private void producingTick(MessageTick tick)
{
if (_model.TickForNextProduction <= tick.Tick)
{
if (_model.Owner != null)
{
MessageProducedResources mpr = new MessageProducedResources(_bp.Produces, _model.Owner);
_planetC.ReceiveProducedResource(mpr);
_model.Producing = false;
//foreach (ResourceQuantity resQ in _bp.Produces)
//{
// _actorTextOutput.Tell(_model.Name + " PRODUCES " + resQ.Quantity + " " + resQ.Type.ToString() + " " + tick.Tick.ToString());
//}
}
if (_model.AutoResumeProduction)
{
requestResources(tick);
}
else
{
_model.Producing = false;
}
}
}
private void receiveEngineRunCommand(MessageEngineRunCommand msg)
{
MessageTick pulse = new MessageTick(0);
if (msg.RunCommand == EngineRunCommand.RunMax && _runState != TickEngineRunState.RunningMax)
{
cancelPulse();
_numberOfIncompleteSS = _subscribedActorSolarSystems.Count();
_runState = TickEngineRunState.RunningMax;
startTicksTimer();
receiveTick(pulse);
}
else if (msg.RunCommand == EngineRunCommand.RunPulse && _runState != TickEngineRunState.Running)
{
_runState = TickEngineRunState.Running;
_runCancel = Context.System.Scheduler.ScheduleTellRepeatedlyCancelable(0, 5, Self, pulse, ActorRefs.Nobody);
startTicksTimer();
receiveTick(pulse);
}
else if (msg.RunCommand == EngineRunCommand.Stop && _runState != TickEngineRunState.Stopped)
{
_runState = TickEngineRunState.Stopped;
cancelPulse();
_secondTimer.Stop();
}
}
private void receiveDefaultTick(MessageTick tick)
{
Object message = _agentC.Tick(tick);
if (message != null)
Sender.Tell(message);
sendAgentCompletedMessage();
}
public void Tick(MessageTick tick)
{
if (_model.Producing)
{
producingTick(tick);
}
else if (_model.AutoResumeProduction || _model.ProduceNThenStop > 0)
{
requestResources(tick);
}
}
private void receiveTick(MessageTick tick)
{
_curTick = tick.Tick;
_solarSystemC.Tick(tick);
foreach(IActorRef agentActor in _actorAgentValues)
{
agentActor.Tell(tick);
}
if (!_subscribedActorAgents.Any())
sendSSCompletedMessage();
}
public void Tick(MessageTick tick)
{
if (_model.ShipState == ShipStateEnum.SpaceCruising && _model.DestinationScId != 0)
{
// move ship towards destination
PointD newPoint = NavigationUtils.GetNewPointForShip(_model.Type.MaxCruisingSpeedKmH, _model.PositionX, _model.PositionY, _destination.PositionX, _destination.PositionY);
_model.PositionX = newPoint.X;
_model.PositionY = newPoint.Y;
if (_model.PositionX == _destination.PositionX && _model.PositionY == _destination.PositionY)
{
// we are at our destination.
MessageAgentDestinationReached msg = new MessageAgentDestinationReached(tick.Tick);
_solarSystemC.SendMessageToAgent(_model.Pilot.AgentId, msg);
}
}
}
private object pilotingShip(MessageTick tick)
{
if (isPilotingShip())
{
if (_model.CurrentShipDestinationScId != _memory.CurrentDestinationScId)
{
IMessageShipCommandData msd = new MessageShipSetDestination(ShipCommandEnum.SetDestination, _memory.CurrentDestinationScId);
MessageShipCommand msc = new MessageShipCommand(msd, tick.Tick, _model.CurrentShipId);
ScPlanet curDest = StarChart.GetPlanet(_memory.CurrentDestinationScId);
//_actorTextOutput.Tell("Agent Piloting Ship towards " + curDest.Name);
return msc;
}
}
return null;
}
private object pilotingDockedShip(MessageTick tick)
{
if (isPilotingShip())
{
setNewDestinationFromDocked();
_currentState = InternalAgentState.PilotingAwaitingUndockingResponse;
//_actorTextOutput.Tell("Agent Requesting Undock from " + _currentShip.DockedPlanet.Name);
return new MessageShipCommand(new MessageShipBasic(ShipCommandEnum.Undock), tick.Tick, _model.CurrentShipId);
}
return null;
}
public void Tick(MessageTick tick)
{
updatePlanets(tick);
updateShips(tick);
}
private void updateShips(MessageTick tick)
{
foreach (ShipController sc in _shipValues)
{
sc.Tick(tick);
}
}
private void updatePlanets(MessageTick tick)
{
foreach (PlanetController pc in _planetValues)
{
pc.Tick(tick);
}
}
private void updateProducers(MessageTick tick)
{
foreach (ProducerController pc in _producerCs)
{
pc.Tick(tick);
}
}
private void receiveTick(MessageTick pulse)
{
_state.CurrentTick++;
MessageTick tick = new MessageTick(_state.CurrentTick);
foreach (IActorRef ssActor in _subscribedActorSolarSystems)
{
ssActor.Tell(tick);
}
}
public void Tick(MessageTick tick)
{
movePlanetXY(tick);
updateProducers(tick);
}
public object Tick(MessageTick tick)
{
object message = null;
switch (_currentState)
{
case InternalAgentState.Planetside:
case InternalAgentState.PilotingAwaitingUndockingResponse:
case InternalAgentState.PilotingAwaitingDockingResponse:
break;
case InternalAgentState.Piloting:
message = pilotingShip(tick);
break;
case InternalAgentState.PilotingDockedShip:
message = pilotingDockedShip(tick);
break;
}
return message;
}
private void requestResources(MessageTick tick)
{
MessageRequestResources msg = new MessageRequestResources(_bp.Consumes, _model.Owner, tick.Tick);
if (_planetC.ReceiveResourceRequest(msg))
{
_model.TickForNextProduction = msg.TickSent + _bp.BaseTicks;
_model.Producing = true;
_model.ProduceNThenStop--;
}
else
{
_model.Producing = false;
}
}
private void movePlanetXY(MessageTick tick)
{
PointD pt = OrbitalUtils.CalcPositionFromTick(tick.Tick, _orbitHours, _scPlanet.OrbitKm);
_model.PositionX = pt.X;
_model.PositionY = pt.Y;
}
