internal static void FirstRun(Entity entity) { CargoTransferDB datablob = entity.GetDataBlob <CargoTransferDB>(); double?dv; if (entity.HasDataBlob <OrbitDB>() && datablob.CargoToEntity.HasDataBlob <OrbitDB>()) { dv = CalcDVDifferenceKmPerSecond(entity.GetDataBlob <OrbitDB>(), datablob.CargoToEntity.GetDataBlob <OrbitDB>()); } else { OrbitDB orbitDB; if (entity.HasDataBlob <ColonyInfoDB>()) { orbitDB = entity.GetDataBlob <ColonyInfoDB>().PlanetEntity.GetDataBlob <OrbitDB>(); } else//if (datablob.CargoToEntity.HasDataBlob<ColonyInfoDB>()) { orbitDB = datablob.CargoToEntity.GetDataBlob <ColonyInfoDB>().PlanetEntity.GetDataBlob <OrbitDB>(); } dv = Distance.AuToKm(OrbitMath.MeanOrbitalVelocityInAU(orbitDB)); } if (dv != null) { datablob.TransferRateInKG = CalcTransferRate((double)dv, datablob.CargoFromDB, datablob.CargoToDB); } }
internal static void FirstRun(Entity entity) { CargoTransferDB transferDB = entity.GetDataBlob <CargoTransferDB>(); double dv_mps = CalcDVDifference_m(entity, transferDB.CargoToEntity); var rate = CalcTransferRate(dv_mps, transferDB.CargoFromDB, transferDB.CargoToDB); transferDB.TransferRateInKG = rate; }
public void ProcessEntity(Entity entity, int deltaSeconds) { CargoTransferDB datablob = entity.GetDataBlob <CargoTransferDB>(); OrbitDB orbitDB = entity.GetDataBlob <OrbitDB>(); if (datablob.DistanceBetweenEntitys <= 100)//todo: this is going to have to be based of mass or something, ie being further away from a colony on a planet is ok, but two ships should be close. { for (int i = 0; i < datablob.ItemsLeftToTransfer.Count; i++) { var item = datablob.ItemsLeftToTransfer[i]; ICargoable cargoItem = item.Item1; long amountToXfer = item.Item2; Guid cargoTypeID = cargoItem.CargoTypeID; int itemMassPerUnit = cargoItem.Mass; if (!datablob.CargoToDB.StoredCargoTypes.ContainsKey(cargoTypeID)) { datablob.CargoToDB.StoredCargoTypes.Add(cargoTypeID, new CargoTypeStore()); } var toCargoTypeStore = datablob.CargoToDB.StoredCargoTypes[cargoTypeID]; //reference to the cargoType store we're pushing to. var toCargoItemAndAmount = toCargoTypeStore.ItemsAndAmounts; //reference to dictionary holding the cargo we want to send too var fromCargoTypeStore = datablob.CargoFromDB.StoredCargoTypes[cargoTypeID]; //reference to the cargoType store we're pulling from. var fromCargoItemAndAmount = fromCargoTypeStore.ItemsAndAmounts; //reference to dictionary we want to pull cargo from. long totalweightToTransfer = itemMassPerUnit * amountToXfer; long weightToTransferThisTick = Math.Min(totalweightToTransfer, datablob.TransferRateInKG * deltaSeconds); //only the amount that can be transfered in this timeframe. weightToTransferThisTick = Math.Min(weightToTransferThisTick, toCargoTypeStore.FreeCapacityKg); //check cargo to has enough weight capacity long numberXfered = weightToTransferThisTick / itemMassPerUnit; //get the number of items from the mass transferable numberXfered = Math.Min(numberXfered, fromCargoItemAndAmount[cargoItem.ID]); //check from has enough to send. weightToTransferThisTick = numberXfered * itemMassPerUnit; if (!toCargoItemAndAmount.ContainsKey(cargoItem.ID)) { toCargoItemAndAmount.Add(cargoItem.ID, numberXfered); } else { toCargoItemAndAmount[cargoItem.ID] += numberXfered; } toCargoTypeStore.FreeCapacityKg -= weightToTransferThisTick; fromCargoItemAndAmount[cargoItem.ID] -= numberXfered; fromCargoTypeStore.FreeCapacityKg += weightToTransferThisTick; datablob.ItemsLeftToTransfer[i] = new Tuple <ICargoable, long>(cargoItem, amountToXfer -= numberXfered); } } }
/// <summary> /// Validates and actions the command. /// may eventualy need to return a responce instead of void. /// This creates a CargoTranferDB from the command, which does all the work. /// the command is to create and enqueue a CargoTransferDB. /// </summary> internal override void ActionCommand(Game game) { CargoTransferDB newTransferDB = new CargoTransferDB(); newTransferDB.CargoToEntity = EntityCommanding; newTransferDB.CargoToDB = EntityCommanding.GetDataBlob <CargoStorageDB>(); newTransferDB.CargoFromEntity = loadFromEntity; newTransferDB.CargoFromDB = loadFromEntity.GetDataBlob <CargoStorageDB>(); newTransferDB.TotalAmountToTransfer = TotalAmountToTransfer; newTransferDB.ItemToTranfer = (ICargoable)game.StaticData.FindDataObjectUsingID(ItemToTransfer); EntityCommanding.Manager.SetDataBlob(EntityCommanding.ID, newTransferDB); IsRunning = true; }
public void ProcessEntity(Entity entity, int deltaSeconds) { CargoTransferDB datablob = entity.GetDataBlob <CargoTransferDB>(); if (datablob.DistanceBetweenEntitys <= 100)//todo: this is going to have to be based of mass or something, ie being further away from a colony on a planet is ok, but two ships should be close. { Guid cargoTypeID = datablob.ItemToTranfer.CargoTypeID; int itemMassPerUnit = datablob.ItemToTranfer.Mass; if (!datablob.CargoToDB.StoredCargoTypes.ContainsKey(cargoTypeID)) { datablob.CargoToDB.StoredCargoTypes.Add(cargoTypeID, new CargoTypeStore()); } var toCargoTypeStore = datablob.CargoToDB.StoredCargoTypes[cargoTypeID]; //reference to the cargoType store we're pushing to. var toCargoItemAndAmount = toCargoTypeStore.ItemsAndAmounts; //reference to dictionary holding the cargo we want to send too var fromCargoTypeStore = datablob.CargoFromDB.StoredCargoTypes[cargoTypeID]; //reference to the cargoType store we're pulling from. var fromCargoItemAndAmount = fromCargoTypeStore.ItemsAndAmounts; //reference to dictionary we want to pull cargo from. datablob.TransferRate = 100; //todo set transfer rates on cargostorageDB and get either an average or a math.min. probibly an average. long totalweightToTransfer = itemMassPerUnit * (datablob.AmountTransfered - datablob.TotalAmountToTransfer); long weightToTransferThisTick = Math.Min(totalweightToTransfer, datablob.TransferRate * deltaSeconds); //only the amount that can be transfered in this timeframe. weightToTransferThisTick = Math.Min(weightToTransferThisTick, toCargoTypeStore.FreeCapacity); //check cargo to has enough weight capacity long numberOfItems = weightToTransferThisTick / itemMassPerUnit; //get the number of items from the mass transferable numberOfItems = Math.Min(numberOfItems, fromCargoItemAndAmount[datablob.ItemToTranfer.ID]); //check from has enough to send. weightToTransferThisTick = numberOfItems * itemMassPerUnit; if (!toCargoItemAndAmount.ContainsKey(datablob.ItemToTranfer.ID)) { toCargoItemAndAmount.Add(datablob.ItemToTranfer.ID, numberOfItems); } else { toCargoItemAndAmount[datablob.ItemToTranfer.ID] += numberOfItems; } toCargoTypeStore.FreeCapacity -= weightToTransferThisTick; fromCargoItemAndAmount[datablob.ItemToTranfer.ID] -= numberOfItems; fromCargoTypeStore.FreeCapacity += weightToTransferThisTick; datablob.AmountTransfered += numberOfItems; } }
/// <summary> /// Validates and actions the command. /// may eventualy need to return a responce instead of void. /// This creates a CargoTranferDB from the command, which does all the work. /// the command is to create and enqueue a CargoTransferDB. /// </summary> internal override void ActionCommand(Game game) { if (!IsRunning) { _cargoTransferDB = new CargoTransferDB(); _cargoTransferDB.CargoToEntity = sendToEntity; _cargoTransferDB.CargoToDB = sendToEntity.GetDataBlob <CargoStorageDB>(); _cargoTransferDB.CargoFromEntity = EntityCommanding; _cargoTransferDB.CargoFromDB = EntityCommanding.GetDataBlob <CargoStorageDB>(); _cargoTransferDB.ItemsLeftToTransfer = ItemICargoablesToTransfer; _cargoTransferDB.OrderedToTransfer = ItemICargoablesToTransfer; EntityCommanding.Manager.SetDataBlob(EntityCommanding.ID, _cargoTransferDB); CargoTransferProcessor.FirstRun(EntityCommanding); IsRunning = true; } }
public void ProcessEntity(Entity entity, int deltaSeconds) { CargoTransferDB transferDB = entity.GetDataBlob <CargoTransferDB>(); for (int i = 0; i < transferDB.ItemsLeftToTransfer.Count; i++) { (ICargoable item, long amount)itemsToXfer = transferDB.ItemsLeftToTransfer[i]; ICargoable cargoItem = itemsToXfer.item; long amountToXfer = itemsToXfer.amount; Guid cargoTypeID = cargoItem.CargoTypeID; double itemMassPerUnit = cargoItem.MassPerUnit; if (!transferDB.CargoToDB.TypeStores.ContainsKey(cargoTypeID)) { string errmsg = "This entity cannot store this type of cargo"; StaticRefLib.EventLog.AddGameEntityErrorEvent(entity, errmsg); } var toCargoTypeStore = transferDB.CargoToDB.TypeStores[cargoTypeID]; //reference to the cargoType store we're pushing to. var toCargoItemAndAmount = toCargoTypeStore.CurrentStoreInUnits; //reference to dictionary holding the cargo we want to send too var fromCargoTypeStore = transferDB.CargoFromDB.TypeStores[cargoTypeID]; //reference to the cargoType store we're pulling from. var fromCargoItemAndAmount = fromCargoTypeStore.CurrentStoreInUnits; //reference to dictionary we want to pull cargo from. //the transfer speed is mass based, not unit based. double totalMassToTransfer = itemMassPerUnit * amountToXfer; double massToTransferThisTick = Math.Min(totalMassToTransfer, transferDB.TransferRateInKG * deltaSeconds); //only the amount that can be transfered in this timeframe. //TODO: this wont handle objects that have a larger unit mass than the availible transferRate, //but maybe that makes for a game mechanic int countToTransferThisTick = (int)(massToTransferThisTick / itemMassPerUnit); var amountFrom = transferDB.CargoFromDB.RemoveCargoByUnit(cargoItem, countToTransferThisTick); var amountTo = transferDB.CargoToDB.AddCargoByUnit(cargoItem, countToTransferThisTick); if (amountTo != amountFrom) { throw new Exception("something went wrong here"); } var newAmount = transferDB.ItemsLeftToTransfer[i].amount - amountTo; transferDB.ItemsLeftToTransfer[i] = (cargoItem, newAmount); } }