/// <summary>
/// PreciseOrbital Velocy in polar coordinates
///
/// </summary>
/// <returns>item1 is speed, item2 angle</returns>
/// <param name="orbit">Orbit.</param>
/// <param name="atDateTime">At date time.</param>
public static (double speed, double angle) InstantaneousOrbitalVelocityPolarCoordinate(OrbitDB orbit, DateTime atDateTime)
{
var position = GetPosition_AU(orbit, atDateTime);
var sma = orbit.SemiMajorAxis;
if (orbit.GravitationalParameter == 0 || sma == 0)
{
return(0, 0); //so we're not returning NaN;
}
var sgp = orbit.GravitationalParameterAU;
double e = orbit.Eccentricity;
double trueAnomaly = GetTrueAnomaly(orbit, atDateTime);
double loAN = Angle.ToRadians(orbit.LongitudeOfAscendingNode);
double aoP = Angle.ToRadians(orbit.ArgumentOfPeriapsis);
double inclination = Angle.ToRadians(orbit.Inclination);
var loP = OrbitMath.GetLongditudeOfPeriapsis(inclination, aoP, loAN);
(double speed, double angle)polar = OrbitMath.InstantaneousOrbitalVelocityPolarCoordinate(sgp, position, sma, e, trueAnomaly);
polar.angle += loP;
return(polar);
}
public static double CalcDVDifference_m(Entity entity1, Entity entity2)
{
double dvDif = 0;
Entity parent;
double parentMass;
double sgp;
double r1;
double r2;
Entity soi1 = Entity.GetSOIParentEntity(entity1);
Entity soi2 = Entity.GetSOIParentEntity(entity2);
if (soi1 == soi2)
{
parent = soi1;
parentMass = parent.GetDataBlob <MassVolumeDB>().MassDry;
sgp = OrbitMath.CalculateStandardGravityParameterInM3S2(0, parentMass);
var state1 = Entity.GetRalitiveState(entity1);
var state2 = Entity.GetRalitiveState(entity2);
r1 = state1.pos.Length();
r2 = state2.pos.Length();
}
else
{
StaticRefLib.EventLog.AddEvent(new Event("Cargo calc failed, entities must have same soi parent"));
return(double.PositiveInfinity);
}
var hohmann = InterceptCalcs.Hohmann(sgp, r1, r2);
return(dvDif = hohmann[0].deltaV.Length() + hohmann[1].deltaV.Length());
}
/// <summary>
/// Creates on Orbit at current location from a given velocity
/// </summary>
/// <returns>The Orbit Does not attach the OrbitDB to the entity!</returns>
/// <param name="parent">Parent. must have massdb</param>
/// <param name="entity">Entity. must have massdb</param>
/// <param name="velocity_m">Velocity in meters.</param>
public static OrbitDB FromVelocity_m(Entity parent, Entity entity, Vector3 velocity_m, DateTime atDateTime)
{
var parentMass = parent.GetDataBlob <MassVolumeDB>().Mass;
var myMass = entity.GetDataBlob <MassVolumeDB>().Mass;
//var epoch1 = parent.Manager.ManagerSubpulses.StarSysDateTime; //getting epoch from here is incorrect as the local datetime doesn't change till after the subpulse.
//var parentPos = OrbitProcessor.GetAbsolutePosition_AU(parent.GetDataBlob<OrbitDB>(), atDateTime); //need to use the parent position at the epoch
var posdb = entity.GetDataBlob <PositionDB>();
posdb.SetParent(parent);
var ralitivePos = posdb.RelativePosition_m;//entity.GetDataBlob<PositionDB>().AbsolutePosition_AU - parentPos;
if (ralitivePos.Length() > OrbitProcessor.GetSOI_m(parent))
{
throw new Exception("Entity not in target SOI");
}
//var sgp = GameConstants.Science.GravitationalConstant * (myMass + parentMass) / 3.347928976e33;
var sgp_m = GMath.StandardGravitationalParameter(myMass + parentMass);
var ke_m = OrbitMath.KeplerFromPositionAndVelocity(sgp_m, ralitivePos, velocity_m, atDateTime);
OrbitDB orbit = new OrbitDB(parent)
{
SemiMajorAxis = ke_m.SemiMajorAxis,
Eccentricity = ke_m.Eccentricity,
Inclination = ke_m.Inclination,
LongitudeOfAscendingNode = ke_m.LoAN,
ArgumentOfPeriapsis = ke_m.AoP,
MeanAnomalyAtEpoch = ke_m.MeanAnomalyAtEpoch,
Epoch = atDateTime,
_parentMass = parentMass,
_myMass = myMass
};
orbit.CalculateExtendedParameters();
var pos = OrbitProcessor.GetPosition_m(orbit, atDateTime);
var d = (pos - ralitivePos).Length();
if (d > 1)
{
var e = new Event(atDateTime, "Positional difference of " + Stringify.Distance(d) + " when creating orbit from velocity");
e.Entity = entity;
e.SystemGuid = entity.Manager.ManagerGuid;
e.EventType = EventType.Opps;
//e.Faction = entity.FactionOwner;
StaticRefLib.EventLog.AddEvent(e);
//other info:
var keta = Angle.ToDegrees(ke_m.TrueAnomalyAtEpoch);
var obta = Angle.ToDegrees(OrbitProcessor.GetTrueAnomaly(orbit, atDateTime));
var tadif = Angle.ToDegrees(Angle.DifferenceBetweenRadians(keta, obta));
var pos1 = OrbitProcessor.GetPosition_m(orbit, atDateTime);
var pos2 = OrbitProcessor.GetPosition_m(orbit, ke_m.TrueAnomalyAtEpoch);
var d2 = (pos1 - pos2).Length();
}
return(orbit);
}
/// <summary>
/// creates an asteroid that will collide with the given entity on the given date.
/// </summary>
/// <param name="starSys"></param>
/// <param name="target"></param>
/// <param name="collisionDate"></param>
/// <returns></returns>
public static Entity CreateAsteroid(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0)
{
//todo rand these a bit.
double radius = Distance.KmToAU(0.5);
double mass;
if (asteroidMass < 0)
{
mass = 1.5e+12; //about 1.5 billion tonne
}
else
{
mass = asteroidMass;
}
var speed = 40000;
Vector3 velocity = new Vector3(speed, 0, 0);
var massVolume = MassVolumeDB.NewFromMassAndRadius_AU(mass, radius);
var planetInfo = new SystemBodyInfoDB();
var name = new NameDB("Ellie");
var AsteroidDmg = new AsteroidDamageDB();
AsteroidDmg.FractureChance = new PercentValue(0.75f);
var dmgPfl = EntityDamageProfileDB.AsteroidDamageProfile(massVolume.Volume_km3, massVolume.Density, massVolume.RadiusInM, 50);
var sensorPfil = new SensorProfileDB();
planetInfo.SupportsPopulations = false;
planetInfo.BodyType = BodyType.Asteroid;
Vector3 targetPos = OrbitProcessor.GetAbsolutePosition_m(target.GetDataBlob <OrbitDB>(), collisionDate);
TimeSpan timeToCollision = collisionDate - StaticRefLib.CurrentDateTime;
var parent = target.GetDataBlob <OrbitDB>().Parent;
var parentMass = parent.GetDataBlob <MassVolumeDB>().Mass;
var myMass = massVolume.Mass;
double sgp = OrbitMath.CalculateStandardGravityParameterInM3S2(myMass, parentMass);
OrbitDB orbit = OrbitDB.FromVector(parent, myMass, parentMass, sgp, targetPos, velocity, collisionDate);
var currentpos = OrbitProcessor.GetAbsolutePosition_AU(orbit, StaticRefLib.CurrentDateTime);
var posDB = new PositionDB(currentpos.X, currentpos.Y, currentpos.Z, parent.Manager.ManagerGuid, parent);
var planetDBs = new List <BaseDataBlob>
{
posDB,
massVolume,
planetInfo,
name,
orbit,
AsteroidDmg,
dmgPfl,
sensorPfil
};
Entity newELE = new Entity(starSys, planetDBs);
return(newELE);
}
/// <summary>
/// This was designed so that fast moving objects will get interpolated a lot more than slow moving objects
/// so fast moving objects shouldn't loose positional acuracy when close to a planet,
/// and slow moving objects won't have processor time wasted on them by calulcating too often.
/// However this seems to be unstable and looses energy, unsure why. currently set it to just itterate/interpolate every second.
/// so currently will be using more time to get through this than neccisary.
/// </summary>
/// <param name="entity">Entity.</param>
/// <param name="deltaSeconds">Delta seconds.</param>
public static void NewtonMove(Entity entity, int deltaSeconds)
{
NewtonMoveDB newtonMoveDB = entity.GetDataBlob <NewtonMoveDB>();
NewtonThrustAbilityDB newtonThrust = entity.GetDataBlob <NewtonThrustAbilityDB>();
PositionDB positionDB = entity.GetDataBlob <PositionDB>();
double mass_Kg = entity.GetDataBlob <MassVolumeDB>().Mass;
double parentMass_kg = newtonMoveDB.ParentMass;
var manager = entity.Manager;
DateTime dateTimeFrom = newtonMoveDB.LastProcessDateTime;
DateTime dateTimeNow = manager.ManagerSubpulses.StarSysDateTime;
DateTime dateTimeFuture = dateTimeNow + TimeSpan.FromSeconds(deltaSeconds);
double deltaT = (dateTimeFuture - dateTimeFrom).TotalSeconds;
double secondsToItterate = deltaT;
while (secondsToItterate > 0)
{
//double timeStep = Math.Max(secondsToItterate / speed_kms, 1);
//timeStep = Math.Min(timeStep, secondsToItterate);
double timeStepInSeconds = 1;//because the above seems unstable and looses energy.
double distanceToParent_m = positionDB.GetDistanceTo_m(newtonMoveDB.SOIParent.GetDataBlob <PositionDB>());
distanceToParent_m = Math.Max(distanceToParent_m, 0.1); //don't let the distance be 0 (once collision is in this will likely never happen anyway)
double gravForce = GameConstants.Science.GravitationalConstant * (mass_Kg * parentMass_kg / Math.Pow(distanceToParent_m, 2));
Vector3 gravForceVector = gravForce * -Vector3.Normalise(positionDB.RelativePosition_m);
Vector3 totalDVFromGrav = (gravForceVector / mass_Kg) * timeStepInSeconds;
double maxAccelFromThrust1 = newtonThrust.ExhaustVelocity * Math.Log(mass_Kg / (mass_Kg - newtonThrust.FuelBurnRate)); //per second
double maxAccelFromThrust = newtonThrust.ThrustInNewtons / mass_Kg; //per second
Vector3 manuverDV = newtonMoveDB.DeltaVForManuver_m; //how much dv needed to complete the manuver.
double dryMass = mass_Kg - newtonThrust.FuelBurnRate * timeStepInSeconds; //how much our ship weighs after a timestep of fuel is used.
//how much dv can we get in this timestep.
double deltaVThisStep = OrbitMath.TsiolkovskyRocketEquation(mass_Kg, dryMass, newtonThrust.ExhaustVelocity);
deltaVThisStep = Math.Min(manuverDV.Length(), deltaVThisStep); //don't use more Dv than what is called for.
deltaVThisStep = Math.Min(newtonThrust.DeltaV, deltaVThisStep); //check we've got the deltaV to spend.
Vector3 totalDVFromThrust = Vector3.Normalise(manuverDV) * deltaVThisStep;
//remove the deltaV we're expending from the max (TODO: Remove fuel from cargo, change mass of ship)
newtonThrust.DeltaV -= deltaVThisStep;
//remove the vectorDV from the amount needed to fully complete the manuver.
newtonMoveDB.DeltaVForManuver_m -= totalDVFromThrust;
Vector3 totalDV = totalDVFromGrav + totalDVFromThrust;
Vector3 newVelocity = totalDV + newtonMoveDB.CurrentVector_ms;
newtonMoveDB.CurrentVector_ms = newVelocity;
Vector3 deltaPos = (newtonMoveDB.CurrentVector_ms + newVelocity) / 2 * timeStepInSeconds;
positionDB.RelativePosition_m += deltaPos;
double sOIRadius = OrbitProcessor.GetSOI_m(newtonMoveDB.SOIParent);
if (positionDB.RelativePosition_m.Length() >= sOIRadius)
{
Entity newParent;
Vector3 parentRalitiveVector;
//if our parent is a regular kepler object (normaly this is the case)
if (newtonMoveDB.SOIParent.HasDataBlob <OrbitDB>())
{
var orbitDB = newtonMoveDB.SOIParent.GetDataBlob <OrbitDB>();
newParent = orbitDB.Parent;
var parentVelocity = OrbitProcessor.InstantaneousOrbitalVelocityVector_m(orbitDB, entity.StarSysDateTime);
parentRalitiveVector = newtonMoveDB.CurrentVector_ms + parentVelocity;
}
else //if (newtonMoveDB.SOIParent.HasDataBlob<NewtonMoveDB>())
{ //this will pretty much never happen.
newParent = newtonMoveDB.SOIParent.GetDataBlob <NewtonMoveDB>().SOIParent;
var parentVelocity = newtonMoveDB.SOIParent.GetDataBlob <NewtonMoveDB>().CurrentVector_ms;
parentRalitiveVector = newtonMoveDB.CurrentVector_ms + parentVelocity;
}
parentMass_kg = newParent.GetDataBlob <MassVolumeDB>().Mass;
Vector3 posRalitiveToNewParent = positionDB.AbsolutePosition_m - newParent.GetDataBlob <PositionDB>().AbsolutePosition_m;
var dateTime = dateTimeNow + TimeSpan.FromSeconds(deltaSeconds - secondsToItterate);
double sgp = GMath.StandardGravitationalParameter(parentMass_kg + mass_Kg);
var kE = OrbitMath.KeplerFromPositionAndVelocity(sgp, posRalitiveToNewParent, parentRalitiveVector, dateTime);
positionDB.SetParent(newParent);
newtonMoveDB.ParentMass = parentMass_kg;
newtonMoveDB.SOIParent = newParent;
newtonMoveDB.CurrentVector_ms = parentRalitiveVector;
}
if (newtonMoveDB.DeltaVForManuver_m.Length() <= 0) //if we've completed the manuver.
{
var dateTime = dateTimeNow + TimeSpan.FromSeconds(deltaSeconds - secondsToItterate);
double sgp = GMath.StandardGravitationalParameter(parentMass_kg + mass_Kg);
KeplerElements kE = OrbitMath.KeplerFromPositionAndVelocity(sgp, positionDB.RelativePosition_m, newtonMoveDB.CurrentVector_ms, dateTime);
var parentEntity = Entity.GetSOIParentEntity(entity, positionDB);
if (kE.Eccentricity < 1) //if we're going to end up in a regular orbit around our new parent
{
var newOrbit = OrbitDB.FromKeplerElements(
parentEntity,
mass_Kg,
kE,
dateTime);
entity.RemoveDataBlob <NewtonMoveDB>();
entity.SetDataBlob(newOrbit);
positionDB.SetParent(parentEntity);
var newPos = OrbitProcessor.GetPosition_m(newOrbit, dateTime);
positionDB.RelativePosition_m = newPos;
}
break;
}
secondsToItterate -= timeStepInSeconds;
}
newtonMoveDB.LastProcessDateTime = dateTimeFuture;
}
internal override void ActionCommand(DateTime atDateTime)
{
if (atDateTime < ActionOnDate)
{
return;
}
if (!IsRunning)
{
IsRunning = true;
_newtonAbilityDB = _entityCommanding.GetDataBlob <NewtonThrustAbilityDB>();
_startDV = _newtonAbilityDB.DeltaV;
_fuelBurnRate = _newtonAbilityDB.FuelBurnRate;
_totalFuel = _newtonAbilityDB.TotalFuel_kg;
var soiParentEntity = Entity.GetSOIParentEntity(_entityCommanding);
_soiParentMass = soiParentEntity.GetDataBlob <MassVolumeDB>().MassDry;
var currentVel = Entity.GetRalitiveFutureVelocity(_entityCommanding, atDateTime);
if (_entityCommanding.HasDataBlob <OrbitDB>())
{
_entityCommanding.RemoveDataBlob <OrbitDB>();
}
if (_entityCommanding.HasDataBlob <OrbitUpdateOftenDB>())
{
_entityCommanding.RemoveDataBlob <OrbitUpdateOftenDB>();
}
if (_entityCommanding.HasDataBlob <NewtonMoveDB>())
{
_newtonMovedb = _entityCommanding.GetDataBlob <NewtonMoveDB>();
}
else
{
_newtonMovedb = new NewtonMoveDB(soiParentEntity, currentVel);
}
_entityCommanding.SetDataBlob(_newtonMovedb);
}
var halfDV = _startDV * 0.5; //lets burn half the dv getting into a good intercept.
var dvUsed = _startDV - _newtonAbilityDB.DeltaV;
var dvToUse = halfDV - dvUsed;
if (dvToUse > 0)
{
(Vector3 Position, Vector3 Velocity)curOurRalState = Entity.GetRalitiveState(_entityCommanding);
(Vector3 Position, Vector3 Velocity)curTgtRalState = Entity.GetRalitiveState(_targetEntity);
var dvRemaining = _newtonAbilityDB.DeltaV;
var tgtVelocity = Entity.GetAbsoluteFutureVelocity(_targetEntity, atDateTime);
//calculate the differencecs in velocity vectors.
Vector3 leadToTgt = (curTgtRalState.Velocity - curOurRalState.Velocity);
//convert the lead to an orbit ralitive (prograde Y) vector.
//var manuverVector = OrbitMath.GlobalToOrbitVector(leadToTgt, curOurRalState.Position, curOurRalState.Velocity);
var burnRate = _newtonAbilityDB.FuelBurnRate;
//var foo = OrbitMath.TsiolkovskyFuelUse(_totalFuel, )
var fuelUse = OrbitMath.TsiolkovskyFuelCost(
_newtonAbilityDB.TotalFuel_kg,
_newtonAbilityDB.ExhaustVelocity,
dvToUse//pretty sure this should be dvToUse, but that's giving me a silent crash.
);
var burnTime = fuelUse / burnRate;
var manuverVector = ManuverVector(dvToUse, burnTime, curOurRalState, curTgtRalState, atDateTime);
_newtonMovedb.DeltaVForManuver_FoRO_m = manuverVector;
_entityCommanding.Manager.ManagerSubpulses.AddEntityInterupt(atDateTime + TimeSpan.FromSeconds(5), nameof(OrderableProcessor), _entityCommanding);
}
else
{
_newtonMovedb.DeltaVForManuver_FoRO_m = new Vector3();
}
}
/// <summary>
/// This was designed so that fast moving objects will get interpolated a lot more than slow moving objects
/// so fast moving objects shouldn't loose positional acuracy when close to a planet,
/// and slow moving objects won't have processor time wasted on them by calulcating too often.
/// However this seems to be unstable and looses energy, unsure why. currently set it to just itterate/interpolate every second.
/// so currently will be using more time to get through this than neccisary.
/// </summary>
/// <param name="entity">Entity.</param>
/// <param name="deltaSeconds">Delta seconds.</param>
public static void NewtonMove(Entity entity, int deltaSeconds)
{
NewtonMoveDB newtonMoveDB = entity.GetDataBlob <NewtonMoveDB>();
PositionDB positionDB = entity.GetDataBlob <PositionDB>();
double Mass_Kg = entity.GetDataBlob <MassVolumeDB>().Mass;
double ParentMass_kg = newtonMoveDB.ParentMass;
var manager = entity.Manager;
DateTime dateTimeFrom = newtonMoveDB.LastProcessDateTime;
DateTime dateTimeNow = manager.ManagerSubpulses.StarSysDateTime;
DateTime dateTimeFuture = dateTimeNow + TimeSpan.FromSeconds(deltaSeconds);
double deltaT = (dateTimeFuture - dateTimeFrom).TotalSeconds;
double secondsToItterate = deltaT;
while (secondsToItterate > 0)
{
double speed_kms = newtonMoveDB.CurrentVector_kms.Length();
//double timeStep = Math.Max(secondsToItterate / speed_kms, 1);
//timeStep = Math.Min(timeStep, secondsToItterate);
double timeStep = 1;//because the above seems unstable and looses energy.
double distanceToParent_m = Distance.AuToMt(positionDB.GetDistanceTo(newtonMoveDB.SOIParent.GetDataBlob <PositionDB>()));
distanceToParent_m = Math.Max(distanceToParent_m, 0.1); //don't let the distance be 0 (once collision is in this will likely never happen anyway)
double gravForce = GameConstants.Science.GravitationalConstant * (Mass_Kg * ParentMass_kg / Math.Pow(distanceToParent_m, 2));
Vector3 gravForceVector = gravForce * -Vector3.Normalise(positionDB.RelativePosition_AU);
double distance = Distance.AuToKm(positionDB.RelativePosition_AU).Length();
Vector3 totalForce = gravForceVector + newtonMoveDB.ThrustVector;
Vector3 acceleration_mps = totalForce / Mass_Kg;
Vector3 newVelocity = (acceleration_mps * timeStep * 0.001) + newtonMoveDB.CurrentVector_kms;
newtonMoveDB.CurrentVector_kms = newVelocity;
Vector3 deltaPos = (newtonMoveDB.CurrentVector_kms + newVelocity) / 2 * timeStep;
//Vector4 deltaPos = newtonMoveDB.CurrentVector_kms * timeStep;
positionDB.RelativePosition_AU += Distance.KmToAU(deltaPos);
double sOIRadius_AU = OrbitProcessor.GetSOI(newtonMoveDB.SOIParent);
if (positionDB.RelativePosition_AU.Length() >= sOIRadius_AU)
{
Entity newParent;
Vector3 parentRalitiveVector;
//if our parent is a regular kepler object (normaly this is the case)
if (newtonMoveDB.SOIParent.HasDataBlob <OrbitDB>())
{
var orbitDB = newtonMoveDB.SOIParent.GetDataBlob <OrbitDB>();
newParent = orbitDB.Parent;
var parentVelocity = OrbitProcessor.InstantaneousOrbitalVelocityVector(orbitDB, entity.Manager.ManagerSubpulses.StarSysDateTime);
parentRalitiveVector = Distance.KmToAU(newtonMoveDB.CurrentVector_kms) + parentVelocity;
var pvlen = Distance.AuToKm(parentVelocity.Length());
var vlen = newtonMoveDB.CurrentVector_kms.Length();
var rvlen = Distance.AuToKm(parentRalitiveVector.Length());
}
else //if (newtonMoveDB.SOIParent.HasDataBlob<NewtonMoveDB>())
{ //this will pretty much never happen.
newParent = newtonMoveDB.SOIParent.GetDataBlob <NewtonMoveDB>().SOIParent;
var parentVelocity = newtonMoveDB.SOIParent.GetDataBlob <NewtonMoveDB>().CurrentVector_kms;
parentRalitiveVector = Distance.KmToAU(newtonMoveDB.CurrentVector_kms + parentVelocity);
}
double newParentMass = newParent.GetDataBlob <MassVolumeDB>().Mass;
double sgp = GameConstants.Science.GravitationalConstant * (newParentMass + Mass_Kg) / 3.347928976e33;
Vector3 posRalitiveToNewParent = positionDB.AbsolutePosition_AU - newParent.GetDataBlob <PositionDB>().AbsolutePosition_AU;
var dateTime = dateTimeNow + TimeSpan.FromSeconds(deltaSeconds - secondsToItterate);
var kE = OrbitMath.KeplerFromPositionAndVelocity(sgp, posRalitiveToNewParent, parentRalitiveVector, dateTime);
if (kE.Eccentricity < 1) //if we're going to end up in a regular orbit around our new parent
{
/*
* var newOrbit = OrbitDB.FromKeplerElements(
* newParent,
* newParentMass,
* Mass_Kg,
* kE,
* dateTime);
*/
var newOrbit = OrbitDB.FromVector(newParent, entity, parentRalitiveVector, dateTime);
entity.RemoveDataBlob <NewtonMoveDB>();
entity.SetDataBlob(newOrbit);
positionDB.SetParent(newParent);
var currentPos = Distance.AuToKm(positionDB.RelativePosition_AU);
var newPos = OrbitProcessor.GetPosition_AU(newOrbit, dateTime);
var newPosKM = Distance.AuToKm(newPos);
positionDB.RelativePosition_AU = newPos;
break;
}
else //else we're in a hyperbolic trajectory around our new parent, so just coninue the newtonion move.
{
positionDB.SetParent(newParent);
newtonMoveDB.ParentMass = newParentMass;
newtonMoveDB.SOIParent = newParent;
}
}
secondsToItterate -= timeStep;
}
newtonMoveDB.LastProcessDateTime = dateTimeFuture;
}
/// <summary>
/// removes fuel and correct amount of DV.
/// </summary>
/// <param name="fuel">in kg</param>
internal void BurnFuel(double fuel)
{
TotalFuel_kg -= fuel;
DeltaV = OrbitMath.TsiolkovskyRocketEquation(TotalFuel_kg, DryMass_kg, ExhaustVelocity);
}
/// <summary>
/// removes deltaV and correct amount of fuel.
/// </summary>
/// <param name="dv"></param>
internal void BurnDeltaV(double dv)
{
DeltaV -= dv;
TotalFuel_kg -= OrbitMath.TsiolkovskyFuelUse(DryMass_kg + TotalFuel_kg, ExhaustVelocity, dv);
}