public void VolumeStorage_BasicChecks()
{
var cookies = SetupCookieTradeGood();
var cookiePile = new VolumeStorageDB();
cookiePile.TypeStores.Add(cookies.CargoTypeID, new TypeStore(100));
var added = cookiePile.AddCargoByUnit(cookies, 99);
var storedCookies = cookiePile.GetUnitsStored(cookies);
var storedCookieMass = cookiePile.GetMassStored(cookies);
var storedCookieVolume = cookiePile.GetVolumeStored(cookies);
Assert.AreEqual(99, added);
Assert.AreEqual(99, storedCookies);
Assert.AreEqual(99, storedCookieMass);
Assert.AreEqual(99, storedCookieVolume);
var addMore = cookiePile.AddCargoByUnit(cookies, 100);
var storedCookies2 = cookiePile.GetUnitsStored(cookies);
var storedCookieMass2 = cookiePile.GetMassStored(cookies);
var storedCookieVolume2 = cookiePile.GetVolumeStored(cookies);
Assert.AreEqual(1, addMore);
Assert.AreEqual(100, storedCookies2);
Assert.AreEqual(100, storedCookieMass2);
Assert.AreEqual(100, storedCookieVolume2);
}
public void OnConstructionComplete(Entity industryEntity, VolumeStorageDB storage, Guid productionLine, IndustryJob batchJob, IConstrucableDesign designInfo)
{
var colonyConstruction = industryEntity.GetDataBlob <IndustryAbilityDB>();
batchJob.NumberCompleted++;
batchJob.ResourcesRequired = designInfo.ResourceCosts;
batchJob.ProductionPointsLeft = designInfo.IndustryPointCosts;
if (batchJob.InstallOn != null)
{
ComponentInstance specificComponent = new ComponentInstance((ComponentDesign)designInfo);
if (batchJob.InstallOn == industryEntity || StorageSpaceProcessor.HasEntity(storage, batchJob.InstallOn.GetDataBlob <CargoAbleTypeDB>()))
{
EntityManipulation.AddComponentToEntity(batchJob.InstallOn, specificComponent);
ReCalcProcessor.ReCalcAbilities(batchJob.InstallOn);
}
}
else
{
storage.AddCargoByUnit((ComponentDesign)designInfo, 1);
//StorageSpaceProcessor.AddCargo(storage, (ComponentDesign)designInfo, 1);
}
if (batchJob.NumberCompleted == batchJob.NumberOrdered)
{
colonyConstruction.ProductionLines[productionLine].Jobs.Remove(batchJob);
if (batchJob.Auto)
{
colonyConstruction.ProductionLines[productionLine].Jobs.Add(batchJob);
}
}
}
public CargoListPannelSimple(StaticDataStore staticData, EntityState entity)
{
_staticData = staticData;
_entityState = entity;
_volStorageDB = entity.Entity.GetDataBlob <VolumeStorageDB>();
_entityState.Entity.Manager.ManagerSubpulses.SystemDateChangedEvent += ManagerSubpulsesOnSystemDateChangedEvent;
Update();
}
public CargoListPannelComplex(StaticDataStore staticData, EntityState entity, Dictionary <Guid, bool> headersOpenDict)
{
_staticData = staticData;
_entityState = entity;
_volStorageDB = entity.Entity.GetDataBlob <VolumeStorageDB>();
HeadersIsOpenDict = headersOpenDict;
Update();
}
internal static void ConsumeResources(VolumeStorageDB fromCargo, ref IDictionary <Guid, int> toUse)
{
foreach (KeyValuePair <Guid, int> kvp in toUse.ToArray())
{
ICargoable cargoItem = StaticRefLib.StaticData.CargoGoods.GetAny(kvp.Key);//fromCargo.OwningEntity.Manager.Game.StaticData.GetICargoable(kvp.Key);
Guid cargoTypeID = cargoItem.CargoTypeID;
int amountUsedThisTick = 0;
if (fromCargo.TypeStores.ContainsKey(cargoTypeID))
{
if (fromCargo.TypeStores[cargoTypeID].CurrentStoreInUnits.ContainsKey(cargoItem.ID))
{
amountUsedThisTick = Math.Min((int)fromCargo.TypeStores[cargoTypeID].CurrentStoreInUnits[cargoItem.ID], kvp.Value);
}
}
if (amountUsedThisTick > 0)
{
int used = fromCargo.RemoveCargoByUnit(cargoItem, amountUsedThisTick);
toUse[kvp.Key] -= used;
}
}
}
public static void LaunchMissile(Entity launchingEntity, Entity targetEntity, double launchForce, OrdnanceDesign missileDesign, int count)
{
var atDatetime = launchingEntity.Manager.StarSysDateTime;
var parentPositionDB = launchingEntity.GetDataBlob <PositionDB>();
Vector3 parentPosition = parentPositionDB.AbsolutePosition_m;
var parentPosRal = parentPositionDB.RelativePosition_m;
var tgtEntityOrbit = targetEntity.GetDataBlob <OrbitDB>();
if (targetEntity.HasDataBlob <OrbitUpdateOftenDB>())
{
tgtEntityOrbit = targetEntity.GetDataBlob <OrbitUpdateOftenDB>();
}
//MissileLauncherAtb launcherAtb;
VolumeStorageDB cargo = launchingEntity.GetDataBlob <VolumeStorageDB>();
int numMis = cargo.TypeStores[missileDesign.CargoTypeID].CurrentStoreInUnits[missileDesign.ID];
if (numMis < 1)
{
return;
}
double launchSpeed = launchForce / missileDesign.MassPerUnit;
double burnTime = ((missileDesign.WetMass - missileDesign.DryMass) / missileDesign.BurnRate) * 0.8; //use 80% of fuel.
double drymass = (missileDesign.WetMass - missileDesign.DryMass) * 0.8; //use 80% of fuel.
double launchManuverDv = OrbitMath.TsiolkovskyRocketEquation(missileDesign.WetMass, drymass, missileDesign.ExaustVelocity);
double totalDV = OrbitMath.TsiolkovskyRocketEquation(missileDesign.WetMass, missileDesign.DryMass, missileDesign.ExaustVelocity);
double speed = launchSpeed + launchManuverDv;
var misslPositionDB = (PositionDB)parentPositionDB.Clone();
Vector3 parentVelocity = Entity.GetRalitiveFutureVelocity(launchingEntity, launchingEntity.StarSysDateTime);
var orderabledb = new OrderableDB();
var newtmovedb = new NewtonMoveDB(misslPositionDB.Parent, parentVelocity);
string defaultName = "Missile";
string factionsName = missileDesign.Name;
if (count > 1)
{
defaultName += " x" + count;
factionsName += " x" + count;
}
List <BaseDataBlob> dataBlobs = new List <BaseDataBlob>();
dataBlobs.Add(new ProjectileInfoDB(launchingEntity.Guid, count));
dataBlobs.Add(new ComponentInstancesDB());
dataBlobs.Add(misslPositionDB);
dataBlobs.Add(MassVolumeDB.NewFromMassAndVolume(missileDesign.WetMass, missileDesign.WetMass));
dataBlobs.Add(new NameDB(defaultName, launchingEntity.FactionOwner, factionsName));
dataBlobs.Add(newtmovedb);
dataBlobs.Add(orderabledb);
var newMissile = Entity.Create(launchingEntity.Manager, launchingEntity.FactionOwner, dataBlobs);
foreach (var tuple in missileDesign.Components)
{
EntityManipulation.AddComponentToEntity(newMissile, tuple.design, tuple.count);
}
var newtdb = newMissile.GetDataBlob <NewtonThrustAbilityDB>();
newtdb.DryMass_kg = missileDesign.MassPerUnit;
newtdb.SetFuel(missileDesign.WetMass - missileDesign.MassPerUnit);
bool directAttack = false;
if (directAttack)
{
/*
* var tgtintercept = OrbitMath.GetInterceptPosition_m(parentPosition, speed, tgtEntityOrbit, atDatetime);
* var tgtEstPos = tgtintercept.position + targetEntity.GetDataBlob<PositionDB>().RelativePosition_m;
*
* var tgtCurPos = Entity.GetPosition_m(targetEntity, atDatetime);
*
* var vectorToTgt = Vector3.Normalise(tgtCurPos - parentPosRal);
*
* //var vectorToTgt = Vector3.Normalise(tgtEstPos - parentPosRal);
* var launcherVector = vectorToTgt * launchSpeed;
*
*
* var launchVelocity = parentVelocity + launcherVector;
* var manuverDV = vectorToTgt * launchManuverDv;
*
* launchVelocity = parentVelocity + launcherVector;
*/
ThrustToTargetCmd.CreateCommand(launchingEntity.FactionOwner, newMissile, launchingEntity.StarSysDateTime, targetEntity);
}
else
{
var launchOrbit = launchingEntity.GetDataBlob <OrbitDB>();
if (launchingEntity.HasDataBlob <OrbitUpdateOftenDB>())
{
launchOrbit = launchingEntity.GetDataBlob <OrbitUpdateOftenDB>();
}
var launchTrueAnomaly = OrbitProcessor.GetTrueAnomaly(launchOrbit, atDatetime);
var targetTrueAnomaly = OrbitProcessor.GetTrueAnomaly(tgtEntityOrbit, atDatetime);
var phaseAngle = targetTrueAnomaly - launchTrueAnomaly;
var manuvers = InterceptCalcs.OrbitPhasingManuvers(launchOrbit, atDatetime, phaseAngle);
var manuverDV = manuvers[0].deltaV;
//newtmovedb.ActionOnDateTime = atDatetime;
//newtmovedb.DeltaVForManuver_FoRO_m = manuverDV;
NewtonThrustCommand.CreateCommand(launchingEntity.FactionOwner, newMissile, atDatetime, manuverDV);
DateTime futureDate = atDatetime + TimeSpan.FromSeconds(manuvers[1].timeInSeconds);
Vector3 futureDV = manuvers[1].deltaV;
NewtonThrustCommand.CreateCommand(launchingEntity.FactionOwner, newMissile, futureDate, futureDV);
//ThrustToTargetCmd.CreateCommand(launchingEntity.FactionOwner, newMissile, futureDate + TimeSpan.FromSeconds(1), targetEntity);
}
cargo.RemoveCargoByUnit(missileDesign, 1); //remove missile from parent.
}
internal static void ConstructStuff(Entity industryEntity)
{
VolumeStorageDB stockpile = industryEntity.GetDataBlob <VolumeStorageDB>();
Entity faction;
industryEntity.Manager.FindEntityByGuid(industryEntity.FactionOwner, out faction);
var factionInfo = faction.GetDataBlob <FactionInfoDB>();
var industryDB = industryEntity.GetDataBlob <IndustryAbilityDB>();
//var pointRates = industryDB.IndustryTypeRates;
//int maxPoints = industryDB.ConstructionPoints;
//List<JobBase> constructionJobs = new List<JobBase>(industryDB.JobBatchList);
foreach (var kvp in industryDB.ProductionLines.ToArray())
{
Guid prodLineID = kvp.Key;
var prodLine = kvp.Value;
var industryPointsRemaining = new Dictionary <Guid, int>(prodLine.IndustryTypeRates);
List <IndustryJob> Joblist = prodLine.Jobs;
float productionPercentage = 1;
for (int i = 0; i < Joblist.Count; i++)
{
IndustryJob batchJob = Joblist[i];
IConstrucableDesign designInfo = factionInfo.IndustryDesigns[batchJob.ItemGuid];
float pointsToUse = industryPointsRemaining[designInfo.IndustryTypeID] * productionPercentage;
//total number of resources requred for a single job in this batch
var resourceSum = designInfo.ResourceCosts.Sum(item => item.Value);
//how many construction points each resourcepoint is worth.
float pointPerResource = (float)designInfo.IndustryPointCosts / resourceSum;
while (
productionPercentage > 0 &&
batchJob.NumberCompleted < batchJob.NumberOrdered &&
pointsToUse > 0)
{
//gather availible resorces for this job.
//right now we take all the resources we can, for an individual item in the batch.
//even if we're taking more than we can use in this turn, we're using/storing it.
IDictionary <Guid, int> resourceCosts = batchJob.ResourcesRequired;
//Note: this is editing batchjob.ResourcesRequired variable.
ConsumeResources(stockpile, ref resourceCosts);
//we calculate the difference between the design resources and the amount of resources we've squirreled away.
// this is the total of the resources that we don't have access to for this item.
int unusableResourceSum = resourceCosts.Sum(item => item.Value);
// this is the total resources that can be used on this item.
int useableResourcePoints = resourceSum - unusableResourceSum;
pointsToUse = Math.Min(industryPointsRemaining[designInfo.IndustryTypeID], batchJob.ProductionPointsLeft);
pointsToUse = Math.Min(pointsToUse, useableResourcePoints * pointPerResource);
var remainingPoints = industryPointsRemaining[designInfo.IndustryTypeID] - pointsToUse;
if (pointsToUse < 0)
{
throw new Exception("Can't have negative production");
}
//construct only enough for the amount of resources we have.
batchJob.ProductionPointsLeft -= (int)Math.Floor(pointsToUse);
productionPercentage -= remainingPoints * productionPercentage;
if (batchJob.ProductionPointsLeft == 0)
{
designInfo.OnConstructionComplete(industryEntity, stockpile, prodLineID, batchJob, designInfo);
}
}
}
}
}