internal static void AddCargo(CargoStorageDB storeDB, ICargoable item, long amount)
{
if (item is CargoAbleTypeDB)
{
CargoAbleTypeDB cargoItem = (CargoAbleTypeDB)item;
if (cargoItem.MustBeSpecificCargo)
{
if (!storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites.ContainsKey(cargoItem.ID))
{
storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites.Add(cargoItem.ID, new List <Entity>());
}
storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites[cargoItem.ID].Add(cargoItem.OwningEntity);
}
}
if (!storeDB.StoredCargoTypes.ContainsKey(item.CargoTypeID))
{
storeDB.StoredCargoTypes.Add(item.CargoTypeID, new CargoTypeStore());
}
else if (!storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts.ContainsKey(item.ID))
{
storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts.Add(item.ID, 0);
}
storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts[item.ID] += amount;
//FreeCapacity is *MASS*
storeDB.StoredCargoTypes[item.CargoTypeID].FreeCapacityKg -= item.Mass * amount;
}
/// <summary>
/// Checks storage capacity and transferes either the amount or the amount that toCargo is capable of storing.
/// </summary>
/// <param name="fromCargo"></param>
/// <param name="toCargo"></param>
/// <param name="item"></param>
/// <param name="amount"></param>
internal static void TransferCargo(CargoStorageDB fromCargo, CargoStorageDB toCargo, ICargoable item, int amount)
{
Guid cargoTypeID = item.CargoTypeID;
float itemWeight = item.Mass;
Guid itemID = item.ID;
long remainingWeightCapacity = RemainingCapacity(toCargo, cargoTypeID);
long remainingNumCapacity = (long)(remainingWeightCapacity / itemWeight);
float amountWeight = amount * itemWeight;
if (remainingNumCapacity >= amount)
{
//AddToCargo(toCargo, item, amount);
//fromCargo.MinsAndMatsByCargoType[cargoTypeID][itemID] -= amount;
long amountRemoved = SubtractValue(fromCargo, itemID, amount);
AddValue(toCargo, item, amountRemoved);
}
else
{
//AddToCargo(toCargo, item, remainingNumCapacity);
//fromCargo.MinsAndMatsByCargoType[cargoTypeID][itemID] -= remainingNumCapacity;
long amountRemoved = SubtractValue(fromCargo, itemID, remainingNumCapacity);
AddValue(toCargo, item, amountRemoved);
}
}
private static void BatchJobItemComplete(Entity colonyEntity, CargoStorageDB storage, ConstructionJob batchJob, ComponentInfoDB designInfo)
{
var colonyConstruction = colonyEntity.GetDataBlob <ColonyConstructionDB>();
batchJob.NumberCompleted++;
batchJob.PointsLeft = designInfo.BuildPointCost;
batchJob.MineralsRequired = designInfo.MinerialCosts;
batchJob.MineralsRequired = designInfo.MaterialCosts;
batchJob.MineralsRequired = designInfo.ComponentCosts;
var factionInfo = colonyEntity.GetDataBlob <OwnedDB>().ObjectOwner.GetDataBlob <FactionInfoDB>();
Entity designEntity = factionInfo.ComponentDesigns[batchJob.ItemGuid];
Entity specificComponent = ComponentInstanceFactory.NewInstanceFromDesignEntity(designEntity, colonyEntity.GetDataBlob <OwnedDB>().ObjectOwner);
if (batchJob.InstallOn != null)
{
if (batchJob.InstallOn == colonyEntity || StorageSpaceProcessor.HasEntity(storage, colonyEntity))
{
EntityManipulation.AddComponentToEntity(batchJob.InstallOn, specificComponent);
ReCalcProcessor.ReCalcAbilities(batchJob.InstallOn);
}
}
else
{
StorageSpaceProcessor.AddItemToCargo(storage, specificComponent);
}
if (batchJob.NumberCompleted == batchJob.NumberOrdered)
{
colonyConstruction.JobBatchList.Remove(batchJob);
if (batchJob.Auto)
{
colonyConstruction.JobBatchList.Add(batchJob);
}
}
}
/// <summary>
/// must be mins or mats
/// </summary>
/// <param name="fromCargo"></param>
/// <param name="amounts">must be mins or mats</param>
internal static void RemoveResources(CargoStorageDB fromCargo, Dictionary <Guid, int> amounts)
{
foreach (var item in amounts)
{
SubtractValue(fromCargo, item.Key, item.Value);
}
}
public CargoStorageVM(StaticDataStore staticData, CommandReferences cmdRef, CargoStorageDB storeDB)
{
_staticData = staticData;
_storageDatablob = storeDB;
CmdRef = cmdRef;
Update();
}
public static void StartNonNewtTranslation(Entity entity)
{
var moveDB = entity.GetDataBlob <TranslateMoveDB>();
var propulsionDB = entity.GetDataBlob <PropulsionAbilityDB>();
var positionDB = entity.GetDataBlob <PositionDB>();
var maxSpeedMS = propulsionDB.MaximumSpeed_MS;
positionDB.SetParent(null);
Vector3 targetPosMt = Distance.AuToMt(moveDB.TranslateExitPoint_AU);
Vector3 currentPositionMt = Distance.AuToMt(positionDB.AbsolutePosition_AU);
Vector3 postionDelta = currentPositionMt - targetPosMt;
double totalDistance = postionDelta.Length();
double maxKMeters = ShipMovementProcessor.CalcMaxFuelDistance_KM(entity);
double fuelMaxDistanceMt = maxKMeters * 1000;
if (fuelMaxDistanceMt >= totalDistance)
{
var currentVelocityMS = Vector3.Normalise(targetPosMt - currentPositionMt) * maxSpeedMS;
propulsionDB.CurrentVectorMS = currentVelocityMS;
moveDB.CurrentNonNewtonionVectorMS = currentVelocityMS;
moveDB.LastProcessDateTime = entity.Manager.ManagerSubpulses.StarSysDateTime;
CargoStorageDB storedResources = entity.GetDataBlob <CargoStorageDB>();
foreach (var item in propulsionDB.FuelUsePerKM)
{
var fuel = staticData.GetICargoable(item.Key);
StorageSpaceProcessor.RemoveCargo(storedResources, fuel, (long)(item.Value * totalDistance / 1000));
}
}
}
/// <summary>
/// checks if the storage contains all the items and amounts in a given dictionary.
/// note that this will not return true for unique(damaged) items.
/// </summary>
/// <param name="stockpile"></param>
/// <param name="costs"></param>
/// <returns></returns>
public static bool HasRequiredItems(CargoStorageDB stockpile, Dictionary <ICargoable, int> costs)
{
if (costs == null)
{
return(true);
}
else
{
foreach (var costitem in costs)
{
if (costitem.Value > 0)
{
if (stockpile.StoredCargoTypes.ContainsKey(costitem.Key.CargoTypeID) == false)
{
return(false);
}
if (stockpile.StoredCargoTypes[costitem.Key.CargoTypeID].ItemsAndAmounts.ContainsKey(costitem.Key.ID) == false)
{
return(false);
}
}
if (costitem.Value > stockpile.StoredCargoTypes[costitem.Key.CargoTypeID].ItemsAndAmounts[costitem.Key.ID].amount)
{
return(false);
}
}
}
return(true);
}
private static void BatchJobItemComplete(Entity colonyEntity, CargoStorageDB storage, ConstructionJob batchJob, ComponentDesign designInfo)
{
var colonyConstruction = colonyEntity.GetDataBlob <ConstructionDB>();
batchJob.NumberCompleted++;
batchJob.ProductionPointsLeft = designInfo.BuildPointCost;
batchJob.MineralsRequired = designInfo.MineralCosts;
batchJob.MineralsRequired = designInfo.MaterialCosts;
batchJob.MineralsRequired = designInfo.ComponentCosts;
ComponentInstance specificComponent = new ComponentInstance(designInfo);
if (batchJob.InstallOn != null)
{
if (batchJob.InstallOn == colonyEntity || StorageSpaceProcessor.HasEntity(storage, colonyEntity.GetDataBlob <CargoAbleTypeDB>()))
{
EntityManipulation.AddComponentToEntity(batchJob.InstallOn, specificComponent);
ReCalcProcessor.ReCalcAbilities(batchJob.InstallOn);
}
}
else
{
StorageSpaceProcessor.AddCargo(storage, specificComponent, 1);
}
if (batchJob.NumberCompleted == batchJob.NumberOrdered)
{
colonyConstruction.JobBatchList.Remove(batchJob);
if (batchJob.Auto)
{
colonyConstruction.JobBatchList.Add(batchJob);
}
}
}
/// <summary>
/// consumes resources in the stockpile, and updates the dictionary.
/// </summary>
/// <param name="stockpile"></param>
/// <param name="toUse"></param>
private static void ConsumeResources(CargoStorageDB fromCargo, IDictionary <Guid, int> toUse)
{
foreach (KeyValuePair <Guid, int> kvp in toUse.ToArray())
{
ICargoable cargoItem = fromCargo.OwningEntity.Manager.Game.StaticData.GetICargoable(kvp.Key);
Guid cargoTypeID = cargoItem.CargoTypeID;
int amountUsedThisTick = 0;
if (fromCargo.StoredCargoTypes.ContainsKey(cargoTypeID))
{
if (fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts.ContainsKey(cargoItem.ID))
{
if (fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts[cargoItem.ID] >= kvp.Value)
{
amountUsedThisTick = kvp.Value;
}
else
{
amountUsedThisTick = (int)fromCargo.StoredCargoTypes[cargoTypeID].ItemsAndAmounts[cargoItem.ID];
}
}
}
StorageSpaceProcessor.RemoveCargo(fromCargo, cargoItem, amountUsedThisTick);
toUse[kvp.Key] -= amountUsedThisTick;
}
}
/// <summary>
/// TODO: refineing rates should also limit the amount that can be refined for a specific mat each tick.
/// </summary>
internal static void RefineMaterials(Entity colony, Game game)
{
CargoStorageDB stockpiles = colony.GetDataBlob <CargoStorageDB>();
ColonyRefiningDB refiningDB = colony.GetDataBlob <ColonyRefiningDB>();
int RefineryPoints = refiningDB.PointsPerTick;
for (int jobIndex = 0; jobIndex < refiningDB.JobBatchList.Count; jobIndex++)
{
if (RefineryPoints > 0)
{
var job = refiningDB.JobBatchList[jobIndex];
ProcessedMaterialSD material = game.StaticData.ProcessedMaterials[job.ItemGuid];
Dictionary <Guid, int> costs = new Dictionary <Guid, int>(material.RawMineralCosts);
if (material.RefinedMateraialsCosts != null)
{
costs.Concat(new Dictionary <Guid, int>(material.RefinedMateraialsCosts));
}
while (job.NumberCompleted < job.NumberOrdered && job.PointsLeft > 0)
{
if (job.PointsLeft == material.RefineryPointCost)
{
//consume all ingredients for this job on the first point use.
if (StorageSpaceProcessor.HasReqiredItems(stockpiles, costs))
{
StorageSpaceProcessor.RemoveResources(stockpiles, costs);
}
else
{
break;
}
}
//use Refinery points
ushort pointsUsed = (ushort)Math.Min(job.PointsLeft, material.RefineryPointCost);
job.PointsLeft -= pointsUsed;
RefineryPoints -= pointsUsed;
//if job is complete
if (job.PointsLeft == 0)
{
job.NumberCompleted++; //complete job,
StorageSpaceProcessor.AddItemToCargo(stockpiles, material.ID, material.OutputAmount); //and add the product to the stockpile
job.PointsLeft = material.RefineryPointCost; //and reset the points left for the next job in the batch.
}
}
//if the whole batch is completed
if (job.NumberCompleted == job.NumberOrdered)
{
//remove it from the list
refiningDB.JobBatchList.RemoveAt(jobIndex);
if (job.Auto) //but if it's set to auto, re-add it.
{
job.PointsLeft = material.RefineryPointCost;
job.NumberCompleted = 0;
refiningDB.JobBatchList.Add(job);
}
}
}
}
}
public CargoStorageDB(CargoStorageDB cargoDB)
{
CargoCapicity = new PrIwObsDict <Guid, long>(cargoDB.CargoCapicity);
MinsAndMatsByCargoType = new PrIwObsDict <Guid, PrIwObsDict <ICargoable, long> >(cargoDB.MinsAndMatsByCargoType);
StoredEntities = new PrIwObsDict <Guid, PrIwObsDict <Entity, PrIwObsList <Entity> > >(cargoDB.StoredEntities);
ItemToTypeMap = cargoDB.ItemToTypeMap; //note that this is not 'new', the dictionary referenced here is static and should be the same dictionary throughout the game.
}
/// <summary>
/// must be mins or mats DOES NOT CHECK Availiblity
/// will throw normal dictionary exceptions.
/// </summary>
/// <param name="fromCargo"></param>
/// <param name="amounts">must be mins or mats</param>
internal static void RemoveResources(CargoStorageDB fromCargo, Dictionary <ICargoable, int> amounts)
{
foreach (var kvp in amounts)
{
RemoveCargo(fromCargo, kvp.Key, kvp.Value);
}
}
internal static void MineResources(Entity colonyEntity)
{
Dictionary <Guid, int> mineRates = colonyEntity.GetDataBlob <ColonyMinesDB>().MineingRate;
Dictionary <Guid, MineralDepositInfo> planetMinerals = colonyEntity.GetDataBlob <ColonyInfoDB>().PlanetEntity.GetDataBlob <SystemBodyInfoDB>().Minerals;
//Dictionary<Guid, int> colonyMineralStockpile = colonyEntity.GetDataBlob<ColonyInfoDB>().MineralStockpile;
CargoStorageDB stockpile = colonyEntity.GetDataBlob <CargoStorageDB>();
float mineBonuses = 1;//colonyEntity.GetDataBlob<ColonyBonusesDB>().GetBonus(AbilityType.Mine);
foreach (var kvp in mineRates)
{
double accessability = planetMinerals[kvp.Key].Accessibility;
double actualRate = kvp.Value * mineBonuses * accessability;
int mineralsMined = (int)Math.Min(actualRate, planetMinerals[kvp.Key].Amount);
long capacity = StorageSpaceProcessor.RemainingCapacity(stockpile, stockpile.CargoTypeID(kvp.Key));
if (capacity > 0)
{
//colonyMineralStockpile.SafeValueAdd<Guid>(kvp.Key, mineralsMined);
StorageSpaceProcessor.AddItemToCargo(stockpile, kvp.Key, mineralsMined);
MineralDepositInfo mineralDeposit = planetMinerals[kvp.Key];
int newAmount = mineralDeposit.Amount -= mineralsMined;
accessability = Math.Pow((float)mineralDeposit.Amount / mineralDeposit.HalfOriginalAmount, 3) * mineralDeposit.Accessibility;
double newAccess = GMath.Clamp(accessability, 0.1, mineralDeposit.Accessibility);
mineralDeposit.Amount = newAmount;
mineralDeposit.Accessibility = newAccess;
}
}
}
public static long RemainingCapacity(CargoStorageDB cargo, Guid typeID)
{
long capacity = cargo.CargoCapicity[typeID];
long storedWeight = NetWeight(cargo, typeID);
return(capacity - storedWeight);
}
/// <summary>
/// consumes resources in the stockpile, and updates the dictionary.
/// </summary>
/// <param name="stockpile"></param>
/// <param name="toUse"></param>
private static void ConsumeResources(CargoStorageDB stockpile, IDictionary <Guid, int> toUse)
{
foreach (KeyValuePair <Guid, int> kvp in toUse.ToArray())
{
int amountUsedThisTick = (int)StorageSpaceProcessor.SubtractValue(stockpile, kvp.Key, kvp.Value);
toUse[kvp.Key] -= amountUsedThisTick;
}
}
//public static Entity GetEntity(CargoStorageDB cargo, Entity entity)
//{
// var designEntity = entity.GetDataBlob<DesignInfoDB>();
// var cargoableDB = entity.GetDataBlob<CargoAbleTypeDB>();
// if (cargo.StoredEntities.ContainsKey(cargoableDB.CargoTypeID))
// if (cargo.StoredEntities[cargoableDB.CargoTypeID].ContainsKey(designEntity.DesignEntity))
// if (cargo.StoredEntities[cargoableDB.CargoTypeID][designEntity.DesignEntity].Contains(entity))
// return cargo.StoredEntities[cargoableDB.CargoTypeID][designEntity.DesignEntity].Contains(entity);
// return false;
//}
/// <summary>
/// a Dictionary of resources stored of a given cargotype
/// </summary>
/// <param name="typeID">cargo type guid</param>
/// <returns>new dictionary of resources or an empty dictionary</returns>
public static Dictionary <ICargoable, long> GetResourcesOfCargoType(CargoStorageDB fromCargo, Guid typeID)
{
if (fromCargo.MinsAndMatsByCargoType.ContainsKey(typeID))
{
return(new Dictionary <ICargoable, long>(fromCargo.MinsAndMatsByCargoType[typeID].GetInternalDictionary()));
}
return(new Dictionary <ICargoable, long>());
}
public void OnComponentInstallation(Entity parentEntity, ComponentInstance componentInstance)
{
if (!parentEntity.HasDataBlob <CargoStorageDB>())
{
var db = new CargoStorageDB();
parentEntity.SetDataBlob(db);
StorageSpaceProcessor.ReCalcCapacity(parentEntity);
}
}
/// <summary>
/// returns the number of items of a given ICargoable item,
/// Not this will not count unique(damaged) items.
/// </summary>
/// <param name="storeDB"></param>
/// <param name="item"></param>
/// <returns></returns>
public static long GetAmount(CargoStorageDB storeDB, ICargoable item)
{
if (storeDB.StoredCargoTypes.ContainsKey(item.CargoTypeID))
{
if (storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts.ContainsKey(item.ID))
{
return(storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts[item.ID].amount);
}
}
return(0);
}
/// <summary>
/// returns the number of items of a given item guid,
/// Not this will not count unique(damaged) items.
/// </summary>
/// <param name="storeDB"></param>
/// <param name="storeTypeGuid"></param>
/// <param name="itemGuid"></param>
/// <returns></returns>
public static long GetAmount(CargoStorageDB storeDB, Guid storeTypeGuid, Guid itemGuid)
{
if (storeDB.StoredCargoTypes.ContainsKey(storeTypeGuid))
{
if (storeDB.StoredCargoTypes[storeTypeGuid].ItemsAndAmounts.ContainsKey(itemGuid))
{
return(storeDB.StoredCargoTypes[storeTypeGuid].ItemsAndAmounts[itemGuid].amount);
}
}
return(0);
}
internal static bool HasEntity(CargoStorageDB storeDB, CargoAbleTypeDB item)
{
if (storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites.ContainsKey(item.ID))
{
if (storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites[item.ID].Contains(item.OwningEntity))
{
return(true);
}
}
return(false);
}
internal static void ConstructStuff(Entity colony)
{
CargoStorageDB stockpile = colony.GetDataBlob <CargoStorageDB>();
Entity faction;
colony.Manager.FindEntityByGuid(colony.FactionOwner, out faction);
var factionInfo = faction.GetDataBlob <FactionInfoDB>();
var colonyConstruction = colony.GetDataBlob <ConstructionDB>();
var pointRates = new Dictionary <ConstructionType, int>(colonyConstruction.ConstructionRates);
int maxPoints = colonyConstruction.PointsPerTick;
List <ConstructionJob> constructionJobs = colonyConstruction.JobBatchList;
foreach (ConstructionJob batchJob in constructionJobs.ToArray())
{
var designInfo = factionInfo.ComponentDesigns[batchJob.ItemGuid];
ConstructionType conType = batchJob.ConstructionType;
//total number of resources requred for a single job in this batch
int resourcePoints = designInfo.MineralCosts.Sum(item => item.Value);
resourcePoints += designInfo.MaterialCosts.Sum(item => item.Value);
resourcePoints += designInfo.ComponentCosts.Sum(item => item.Value);
while ((pointRates[conType] > 0) && (maxPoints > 0) && (batchJob.NumberCompleted < batchJob.NumberOrdered))
{
//gather availible resorces for this job.
ConsumeResources(stockpile, batchJob.MineralsRequired);
ConsumeResources(stockpile, batchJob.MaterialsRequired);
ConsumeResources(stockpile, batchJob.ComponentsRequired);
int useableResourcePoints = designInfo.MineralCosts.Sum(item => item.Value) - batchJob.MineralsRequired.Sum(item => item.Value);
useableResourcePoints += designInfo.MaterialCosts.Sum(item => item.Value) - batchJob.MaterialsRequired.Sum(item => item.Value);
useableResourcePoints += designInfo.ComponentCosts.Sum(item => item.Value) - batchJob.ComponentsRequired.Sum(item => item.Value);
//how many construction points each resourcepoint is worth.
int pointPerResource = designInfo.BuildPointCost / resourcePoints;
//calculate how many construction points each resource we've got stored for this job is worth
int pointsToUse = Math.Min(pointRates[conType], maxPoints);
pointsToUse = Math.Min(pointsToUse, batchJob.ProductionPointsLeft);
pointsToUse = Math.Min(pointsToUse, useableResourcePoints * pointPerResource);
//construct only enough for the amount of resources we have.
batchJob.ProductionPointsLeft -= pointsToUse;
pointRates[conType] -= pointsToUse;
maxPoints -= pointsToUse;
if (batchJob.ProductionPointsLeft == 0)
{
BatchJobItemComplete(colony, stockpile, batchJob, designInfo);
}
}
}
}
/// <summary>
/// Calculates the transfer rate.
/// </summary>
/// <returns>The transfer rate.</returns>
/// <param name="dvDifferenceKmPerSecond">Dv difference in Km/s</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
public static int CalcTransferRate(double dvDifferenceKmPerSecond, CargoStorageDB from, CargoStorageDB to)
{
//var from = transferDB.CargoFromDB;
//var to = transferDB.CargoToDB;
var fromRange = from.TransferRangeDv;
var toRange = to.TransferRangeDv;
double maxRange;
double maxXferAtMaxRange;
double bestXferRange = Math.Min(from.TransferRangeDv, to.TransferRangeDv);
double maxXferAtBestRange = from.TransferRateInKgHr + to.TransferRateInKgHr;
double transferRate;
if (from.TransferRangeDv > to.TransferRangeDv)
{
maxRange = from.TransferRangeDv;
if (from.TransferRateInKgHr > to.TransferRateInKgHr)
{
maxXferAtMaxRange = from.TransferRateInKgHr;
}
else
{
maxXferAtMaxRange = to.TransferRateInKgHr;
}
}
else
{
maxRange = to.TransferRangeDv;
if (to.TransferRateInKgHr > from.TransferRateInKgHr)
{
maxXferAtMaxRange = to.TransferRateInKgHr;
}
else
{
maxXferAtMaxRange = from.TransferRateInKgHr;
}
}
if (dvDifferenceKmPerSecond < bestXferRange)
{
transferRate = (int)maxXferAtBestRange;
}
else if (dvDifferenceKmPerSecond < maxRange)
{
transferRate = (int)maxXferAtMaxRange;
}
else
{
transferRate = 0;
}
return((int)transferRate);
}
public static CargoCapacityCheckResult GetAvailableSpace(CargoStorageDB storeDB, Guid itemGuid, ICargoDefinitionsLibrary library)
{
var cargoDefinition = library.GetOther(itemGuid);
if (cargoDefinition.Mass == 0)
{
return(new CargoCapacityCheckResult(itemGuid, long.MaxValue, long.MaxValue));
}
return(new CargoCapacityCheckResult(itemGuid,
storeDB.StoredCargoTypes[cargoDefinition.CargoTypeID].FreeCapacityKg / cargoDefinition.Mass,
storeDB.StoredCargoTypes[cargoDefinition.CargoTypeID].FreeCapacityKg));
}
/// <summary>
/// checks the toCargo and stores the item if there is enough space.
/// </summary>
/// <param name="toCargo"></param>
/// <param name="entity"></param>
/// <param name="cargoTypeDB"></param>
/// <param name=""></param>
internal static void AddItemToCargo(CargoStorageDB toCargo, Entity entity)
{
Entity designEntity = entity.GetDataBlob <DesignInfoDB>().DesignEntity;
ICargoable cargoTypeDB = designEntity.GetDataBlob <CargoAbleTypeDB>();
float amountWeight = cargoTypeDB.Mass;
long remainingWeightCapacity = RemainingCapacity(toCargo, cargoTypeDB.CargoTypeID);
int remainingNumCapacity = (int)(remainingWeightCapacity / amountWeight);
if (remainingNumCapacity >= 1)
{
AddToCargo(toCargo, entity, cargoTypeDB);
}
}
/// <summary>
/// a list of entities stored of a given cargotype
/// </summary>
/// <param name="typeID">cargo type guid</param>
/// <returns>new list of Entites or an empty list</returns>
public static List <Entity> GetEntitesOfCargoType(CargoStorageDB fromCargo, Guid typeID)
{
List <Entity> entityList = new List <Entity>();
if (fromCargo.StoredEntities.ContainsKey(typeID))
{
foreach (var kvp in fromCargo.StoredEntities[typeID])
{
entityList.AddRange(kvp.Value.GetInternalList());
}
}
return(entityList);
}
/// <summary>
/// Does not check if cargo or cargotype exsists. will throw normal dictionary exptions if you try.
/// just removes the amount from store and updates the free capacity
/// </summary>
/// <param name="storeDB"></param>
/// <param name="item"></param>
/// <param name="amount"></param>
internal static void RemoveCargo(CargoStorageDB storeDB, ICargoable item, long amount)
{
if (item is CargoAbleTypeDB)
{
CargoAbleTypeDB cargoItem = (CargoAbleTypeDB)item;
if (cargoItem.MustBeSpecificCargo)
{
storeDB.StoredCargoTypes[item.CargoTypeID].SpecificEntites[cargoItem.ID].Remove(cargoItem.OwningEntity);
}
}
storeDB.StoredCargoTypes[item.CargoTypeID].ItemsAndAmounts[item.ID] -= amount;
//FreeCapacity is *MASS*
storeDB.StoredCargoTypes[item.CargoTypeID].FreeCapacityKg += item.Mass * amount;
}
public static long NetWeight(CargoStorageDB cargo, Guid typeID)
{
long net = 0;
if (cargo.MinsAndMatsByCargoType.ContainsKey(typeID))
{
net = StoredWeight(cargo.MinsAndMatsByCargoType, typeID);
}
else if (cargo.StoredEntities.ContainsKey(typeID))
{
net = StoredWeight(cargo.StoredEntities, typeID);
}
return(net);
}
/// <summary>
/// Checks storage capacity and stores either the amount or the amount that toCargo is capable of storing.
/// </summary>
/// <param name="toCargo"></param>
/// <param name="item"></param>
/// <param name="amount"></param>
internal static void AddItemToCargo(CargoStorageDB toCargo, ICargoable item, int amount)
{
long remainingWeightCapacity = RemainingCapacity(toCargo, item.CargoTypeID);
int remainingNumCapacity = (int)(remainingWeightCapacity / item.Mass);
float amountWeight = amount * item.Mass;
if (remainingNumCapacity >= amount)
{
AddValue(toCargo, item, amount);
}
else
{
AddValue(toCargo, item, remainingNumCapacity);
}
}
/// <summary>
/// returns the amount of items for a given item guid.
/// </summary>
/// <param name="fromCargo"></param>
/// <param name="itemID">a min or mat ID</param>
/// <returns></returns>
public static long GetAmountOf(CargoStorageDB fromCargo, Guid itemID)
{
Guid cargoTypeID = fromCargo.ItemToTypeMap[itemID];
ICargoable cargo = fromCargo.OwningEntity.Manager.Game.StaticData.GetICargoable(itemID);
long returnValue = 0;
if (fromCargo.MinsAndMatsByCargoType.ContainsKey(cargoTypeID))
{
if (fromCargo.MinsAndMatsByCargoType[cargoTypeID].ContainsKey(cargo))
{
returnValue = fromCargo.MinsAndMatsByCargoType[cargoTypeID][cargo];
}
}
return(returnValue);
}
internal static void AddItemToCargo(CargoStorageDB toCargo, Guid itemID, long amount)
{
ICargoable item = (ICargoable)toCargo.OwningEntity.Manager.Game.StaticData.FindDataObjectUsingID(itemID);
long remainingWeightCapacity = RemainingCapacity(toCargo, item.CargoTypeID);
long remainingNumCapacity = (long)(remainingWeightCapacity / item.Mass);
float amountWeight = amount / item.Mass;
if (remainingNumCapacity >= amount)
{
AddValue(toCargo, item, amount);
}
else
{
AddValue(toCargo, item, remainingNumCapacity);
}
}
