private void movePlanetXY(MessageTick tick)
{
PointD pt = OrbitalUtils.CalcPositionFromTick(tick.Tick, _orbitHours, _scPlanet.OrbitKm);
_model.PositionX = pt.X;
_model.PositionY = pt.Y;
}
private void updateShips(MessageTick tick)
{
foreach (ShipController sc in _shipValues)
{
sc.Tick(tick);
}
}
static void AddToSymbolCache(MessageTick tick)
{
Dictionary <string, MessageTick> dict = null;
if (tick.TickType == Platform.Tick.Common.Enums.EnTickType.BID)
{
dict = symbolsCacheBid;
}
else
{
dict = symbolsCacheAsc;
}
if (dict.ContainsKey(tick.Symbol))
{
MessageTick tmp = dict[tick.Symbol];
if (tmp.DateTime < tick.DateTime)
{
dict[tick.Symbol] = tick;
}
}
else
{
dict.Add(tick.Symbol, tick);
//symbolsCache.Add(tick.Symbol, tick, (key, oldValue) => tick);
}
}
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 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 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);
}
}
//private object pilotingCruisingShip(MessageTick tick)
//{
// // new destination
// if (_state.CurrentShipDestinationScId != _memory.CurrentDestinationScId)
// {
// IMessageShipCommandData msd = new MessageShipBasic(ShipCommandEnum.SetDestination, _memory.CurrentDestinationScId);
// MessageShipCommand msc = new MessageShipCommand(msd, tick.Tick, _state.CurrentShipId);
// //ScPlanet curDest = StarChart.GetPlanet(_memory.CurrentDestinationScId);
// //_actorTextOutput.Tell("Agent Piloting Ship towards " + curDest.Name);
// return msc;
// }
// // Am I at my current destination
// if (_state.CurrentShipAtDestination)
// {
// // request docking
// MessageShipCommand msc = new MessageShipCommand(new MessageShipBasic(ShipCommandEnum.Dock,_), tick.Tick, _state.CurrentShipId);
// return msc;
// }
// return null;
//}
//private object pilotingDockedShip(MessageTick tick)
//{
// object msg = null;
// checkMarkets(tick);
// if (checkLeaveShip(tick))
// {
// msg = requestPlanetside(tick);
// }
// else if (checkUndock(tick))
// {
// msg = requestUndock(tick);
// }
// return msg;
//}
// scan the local and system markets and decide if there is an order we want to place / fulfil
private void checkMarkets(MessageTick tick)
{
// do i need to place a place / fulfil a market order, if so leave ship to interact with market
Int64 curPlanet = _state.CurrentShipDockedPlanetScId;
if (checkOverMinimumTimeForMarketCheck(curPlanet, tick.Tick))
{
checkMarketPlaceOrder(tick);
}
}
public void Tick(MessageTick tick)
{
if (_model.ShipState == ShipStateEnum.SpaceAutopilot)
{
// 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;
}
}
public void Tick(MessageTick tick)
{
if (_model.Producing)
{
producingTick(tick);
}
else if (_model.AutoResumeProduction || _model.ProduceNThenStop > 0)
{
requestResources(tick);
}
}
private void checkMarketPlaceOrder(MessageTick tick)
{
// TODO check stock and decide what we need (everywhere) and don't need (at this location)
// get prices at current location for needs
// buy TODO buy any with reasonable price
// get prices at current location for dont needs
// sell TODO sell any at reasonable price
}
private void receiveTick(MessageTick tick)
{
_curTick = tick.Tick;
_solarSystemC.Tick(tick);
foreach (IActorRef agentActor in _actorAgentValues)
{
agentActor.Tell(tick);
}
if (!_subscribedActorAgents.Any())
{
sendSSCompletedMessage();
}
}
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;
}
}
static void Execute(Object listTicks, Object t)
{
if (listTicks is BlockingCollection <MessageTick> )
{
ITicksContainer containerTicks = new TicksDataTableContainer();
DateTime lastSave = DateTime.Now;
BlockingCollection <MessageTick> list = (BlockingCollection <MessageTick>)listTicks;
SaveTicks thread = (SaveTicks)t;
thread.isWorking = true;
while (thread.isWorking)
{
MessageTick messageTick = null;
while (list.TryTake(out messageTick, TimeSpan.FromMilliseconds(10)))
{
containerTicks.AddEntry(messageTick.Symbol, (int)messageTick.Value, messageTick.DecimalValue, messageTick.DateTime, (byte)messageTick.TickType, messageTick.Provider);
AddToSymbolCache(messageTick);
if (((int)(DateTime.Now - lastSave).TotalMilliseconds) >= thread.saveIntervalInMs)
{
// SaveTicks
SaveAndSendTicks(containerTicks, thread.ticksRepository);
containerTicks = new TicksDataTableContainer();
lastSave = DateTime.Now;
}
}
Thread.Sleep(20);
}
if (containerTicks.Count() > 0)
{
SaveAndSendTicks(containerTicks, thread.ticksRepository);
}
thread.isFinished = true;
//Console.WriteLine("FINISHED! Total Save Ticks: " + TotalSavedObjects + "; Total Received Ticks: " + DeserializeTicks.TotalDesObjects);
}
}
// do we need to go planetside?
private bool checkLeaveShip(MessageTick tick)
{
return(false);
}
private bool checkUndock(MessageTick tick)
{
return(true);
}
public void Tick(MessageTick tick)
{
updatePlanets(tick);
updateShips(tick);
}
public void Tick(MessageTick tick)
{
_goapAgent.Tick();
}
public void Tick(MessageTick tick)
{
movePlanetXY(tick);
updateProducers(tick);
}
private void receiveDefaultTick(MessageTick tick)
{
_agentC.Tick(tick);
sendAgentCompletedMessage();
}
private object requestPlanetside(MessageTick tick)
{
throw new NotImplementedException();
}
