public void ProcessManager(EntityManager manager, int deltaSeconds)
{
var blobs = manager.GetAllDataBlobsOfType <GenericFiringWeaponsDB>();
//when firing weapons we need to have the parent in the right place.
//orbits don't update every subtick, so we update just this entity for this tick, if it's an orbiting entity.
foreach (var blob in blobs)
{
var entity = blob.OwningEntity; //
if (entity.HasDataBlob <OrbitDB>())
{
var fastBlob = new OrbitUpdateOftenDB(entity.GetDataBlob <OrbitDB>());
entity.RemoveDataBlob <OrbitDB>();
entity.SetDataBlob(fastBlob);
}
List <Entity> targets = new List <Entity>();
for (int i = 0; i < blob.FireControlStates.Length; i++)
{
var tgt = blob.FireControlStates[i].Target;
if (!targets.Contains(tgt))
{
targets.Add(tgt);
}
}
foreach (var tgt in targets)
{
if (tgt.HasDataBlob <OrbitDB>())
{
var fastBlob = new OrbitUpdateOftenDB(tgt.GetDataBlob <OrbitDB>());
tgt.RemoveDataBlob <OrbitDB>();
tgt.SetDataBlob(fastBlob);
}
}
}
foreach (GenericFiringWeaponsDB blob in blobs)
{
ProcessReloadWeapon(blob);
}
foreach (GenericFiringWeaponsDB blob in blobs)
{
ProcessWeaponFire(blob);
}
foreach (var blob in blobs)
{
UpdateReloadState(blob);
}
}
public OrbitDB(OrbitUpdateOftenDB orbit) : base(orbit.Parent)
{
if (orbit.IsStationary)
{
IsStationary = true;
return;
}
SemiMajorAxis = orbit.SemiMajorAxis;
Eccentricity = orbit.Eccentricity;
Inclination = orbit.Inclination;
LongitudeOfAscendingNode = orbit.LongitudeOfAscendingNode;
ArgumentOfPeriapsis = orbit.ArgumentOfPeriapsis;
MeanAnomalyAtEpoch = orbit.MeanAnomalyAtEpoch;
_parentMass = orbit._parentMass;
_myMass = orbit._myMass;
Epoch = orbit.Epoch;
}
public static void UpdateOrbit(OrbitUpdateOftenDB entityOrbitDB, DateTime toDate)
{
PositionDB entityPosition = entityOrbitDB.OwningEntity.GetDataBlob <PositionDB>(PositionTypeIndex);
try
{
Vector3 newPosition = OrbitProcessor.GetPosition_m(entityOrbitDB, toDate);
entityPosition.RelativePosition_m = newPosition;
}
catch (OrbitProcessor.OrbitProcessorException e)
{
var entity = e.Entity;
string name = "Un-Named";
if (entity.HasDataBlob <NameDB>())
{
name = entity.GetDataBlob <NameDB>().OwnersName;
}
//Do NOT fail to the UI. There is NO data-corruption on this exception.
// In this event, we did NOT update our position.
Event evt = new Event(StaticRefLib.CurrentDateTime, "Non Critical Position Exception thrown in OrbitProcessor for EntityItem " + name + " " + entity.Guid + " " + e.Message);
evt.EventType = EventType.Opps;
StaticRefLib.EventLog.AddEvent(evt);
}
}
/// <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>().MassDry;
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 sgp = OrbitMath.CalculateStandardGravityParameterInM3S2(mass_Kg, parentMass_kg);
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_FoRO_m; //how much dv needed to complete the manuver.
Vector3 totalDVFromThrust = new Vector3(0, 0, 0);
if (manuverDV.Length() > 0)
{
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.
totalDVFromThrust = Vector3.Normalise(manuverDV) * deltaVThisStep;
//remove the deltaV we're expending from the max (TODO: Remove fuel from cargo, change mass of ship)
newtonThrust.BurnDeltaV(deltaVThisStep);
//remove the vectorDV from the amount needed to fully complete the manuver.
newtonMoveDB.DeltaVForManuver_FoRO_m -= totalDVFromThrust;
}
//convert prograde to global frame of reference for thrust direction
Vector3 globalCoordDVFromThrust = OrbitMath.ProgradeToParentVector(sgp, totalDVFromThrust,
positionDB.RelativePosition_m,
newtonMoveDB.CurrentVector_ms);
Vector3 totalDV = totalDVFromGrav + globalCoordDVFromThrust;
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>().MassDry;
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_FoRO_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
{
if (entity.HasDataBlob <ProjectileInfoDB>()) //this feels a bit hacky.
{
var newOrbit = OrbitDB.FromKeplerElements(parentEntity, mass_Kg, kE, dateTime);
var fastOrbit = new OrbitUpdateOftenDB(newOrbit);
entity.RemoveDataBlob <NewtonMoveDB>();
entity.SetDataBlob(fastOrbit);
positionDB.SetParent(parentEntity);
var newPos = OrbitProcessor.GetPosition_m(fastOrbit, dateTime);
positionDB.RelativePosition_m = newPos;
}
else
{
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;
}