public Encounter(GravityElementsClass gravElements, double startingTrueAnomaly, double endingTrueAnomaly, double timeOfEncounter, OrbitalPOI perigeeIcon)
{
this.gravElements = gravElements;
this.startingTrueAnomaly = startingTrueAnomaly;
this.endingTrueAnomaly = endingTrueAnomaly;
this.timeOfEncounter = timeOfEncounter;
this.perigeeIcon = perigeeIcon;
}
private void updateNode()
{
Vector2 nodePosition = node.getNodePosition();
bool nodeTowardsPerigee = OrbitalHelper.towardsPerigeeOrbit(mouseTrueAnomaly, shipElements.Clockwise);
double nodeSpeed = OrbitalHelper.calculateSpeed(nodePosition, shipElements.SemiMajorAxis, shipElements.Mu, shipElements.OrbitType);
double nodeVelocityAngle = OrbitalHelper.calculateVelocityAngle(nodePosition, shipElements.Eccentricity, shipElements.SemiMajorAxis, mouseTrueAnomaly, shipElements.GlobalRotationAngle, shipElements.Clockwise, nodeTowardsPerigee, shipElements.OrbitType);
Vector2 nodeVelocity = OrbitalHelper.assembleVelocityVector(nodeVelocityAngle, nodeSpeed);
GravityElementsClass newOrbit = calculateInitialOrbitalElements(nodePosition, nodeVelocity + thrustVector, shipElements.massiveBody);
node = new Node(newOrbit, mouseTrueAnomaly, nodePosition);
patchedConics.updatePotentialEncounters(node.getManeuver());
}
public GravityElementsClass getClassVersion()
{
GravityElementsClass returnGravityElements = new GravityElementsClass();
returnGravityElements.velocity = this.velocity;
returnGravityElements.massiveBody = this.massiveBody;
returnGravityElements.gravitationalType = this.gravitationalType;
returnGravityElements.Altitude = this.Altitude;
returnGravityElements.Speed = this.Speed;
returnGravityElements.VelocityAngle = this.VelocityAngle;
returnGravityElements.OrbitType = this.OrbitType;
returnGravityElements.Mu = this.Mu;
returnGravityElements.Position = this.Position;
returnGravityElements.Apogee = this.Apogee;
returnGravityElements.Perigee = this.Perigee;
returnGravityElements.Center = this.Center;
returnGravityElements.AltitudeOfPerigee = this.AltitudeOfPerigee;
returnGravityElements.AngularMomentum = this.AngularMomentum;
returnGravityElements.SemiMajorAxis = this.SemiMajorAxis;
returnGravityElements.SemiLatusRectum = this.SemiLatusRectum;
returnGravityElements.Eccentricity = this.Eccentricity;
returnGravityElements.EccentricityMagnitude = this.EccentricityMagnitude;
returnGravityElements.EccentricAnomaly = this.EccentricAnomaly;
returnGravityElements.TrueAnomaly = this.TrueAnomaly;
returnGravityElements.MeanAnomaly = this.MeanAnomaly;
returnGravityElements.AnomalyAtEpoch = this.AnomalyAtEpoch;
returnGravityElements.MechanicalEnergy = this.MechanicalEnergy;
returnGravityElements.Time = this.Time;
returnGravityElements.TimeStep = this.TimeStep;
returnGravityElements.TimeAtEpoch = this.TimeAtEpoch;
returnGravityElements.Clockwise = this.Clockwise;
returnGravityElements.TowardsPerigee = this.TowardsPerigee;
returnGravityElements.GlobalTransformationVector = this.GlobalTransformationVector;
returnGravityElements.GlobalRotationAngle = this.GlobalRotationAngle;
return(returnGravityElements);
}
public void updatePotentialEncounters(GravityElementsClass newManeuver)
{
foreach (Encounter encounter in encounters.maneuverEncounters)
{
Destroy(encounter.PerigeeIcon.poiIcon);
}
encounters.maneuverEncounters.Clear();
//initial setup
GameObject tempPerigeeIcon = Instantiate(perigeeIcon);
OrbitalPOI perigeePOI = new OrbitalPOI(tempPerigeeIcon, newManeuver.Perigee);
Encounter currentEncounter = new Encounter(newManeuver, newManeuver.TrueAnomaly, double.PositiveInfinity, 0, perigeePOI);
iterations = 0;
predictAnEncounter(currentEncounter, ref encounters.maneuverEncounters);
}
public void copyGravityElementsClass(GravityElementsClass gravElements)
{
this.velocity = gravElements.velocity;
this.massiveBody = gravElements.massiveBody;
this.gravitationalType = gravElements.gravitationalType;
this.altitude = gravElements.Altitude;
this.speed = gravElements.Speed;
this.velocityAngle = gravElements.VelocityAngle;
this.orbitType = gravElements.OrbitType;
this.mu = gravElements.Mu;
this.position = gravElements.Position;
this.apogee = gravElements.Apogee;
this.perigee = gravElements.Perigee;
this.center = gravElements.Center;
this.altitudeOfPerigee = gravElements.AltitudeOfPerigee;
this.angularMomentum = gravElements.AngularMomentum;
this.semiMajorAxis = gravElements.SemiMajorAxis;
this.semiLatusRectum = gravElements.SemiLatusRectum;
this.eccentricity = gravElements.Eccentricity;
this.eccentricityMagnitude = gravElements.EccentricityMagnitude;
this.eccentricAnomaly = gravElements.EccentricAnomaly;
this.trueAnomaly = gravElements.TrueAnomaly;
this.meanAnomaly = gravElements.MeanAnomaly;
this.anomalyAtEpoch = gravElements.AnomalyAtEpoch;
this.mechanicalEnergy = gravElements.MechanicalEnergy;
this.time = gravElements.Time;
this.timeStep = gravElements.TimeStep;
this.timeAtEpoch = gravElements.TimeAtEpoch;
this.clockwise = gravElements.Clockwise;
this.towardsPerigee = gravElements.TowardsPerigee;
this.globalTransformationVector = gravElements.GlobalTransformationVector;
this.globalRotationAngle = gravElements.GlobalRotationAngle;
}
//Finds all encounters within one orbit of the craft
public void updateEncounters()
{
foreach (Encounter encounter in encounters.predictedEncounters)
{
Destroy(encounter.PerigeeIcon.poiIcon);
}
encounters.predictedEncounters.Clear();
//initial setup
GravityElementsClass currentShipsGravityElements = shipElements.getClassVersion();
double startingTrueAnomaly = shipElements.TrueAnomaly;
GameObject tempPerigeeIcon = Instantiate(perigeeIcon);
OrbitalPOI perigeePOI = new OrbitalPOI(tempPerigeeIcon, currentShipsGravityElements.Perigee);
Encounter currentEncounter = new Encounter(currentShipsGravityElements, startingTrueAnomaly, double.PositiveInfinity, 0, perigeePOI);
iterations = 0;
predictAnEncounter(currentEncounter, ref encounters.predictedEncounters);
instantiatePOIs(encounters.predictedEncounters);
}
public void applyThrust(GravityElementsClass newOrbit)
{
gravityElements.copyGravityElementsClass(newOrbit);
shipPatchedConics.updateEncounters();
}
public Node(GravityElementsClass maneuver, double trueAnomaly, Vector2 nodePosition)
{
this.maneuver = maneuver;
this.nodePosition = nodePosition;
this.trueAnomaly = trueAnomaly;
}
//takes in everything relative to the body being orbited
private GravityElementsClass calculateInitialOrbitalElements(Vector2 position, Vector2 velocity, GameObject massiveBody)
{
GravityElementsClass gravityElements = new GravityElementsClass();
gravityElements.massiveBody = massiveBody;
gravityElements.Mu = GlobalElements.GRAV_CONST * gravityElements.MassiveBody.GetComponent <MassiveBodyElements>().mass;
gravityElements.Position = position;
gravityElements.velocity = velocity;
//Calculate Global Tranformation Vector
gravityElements.GlobalTransformationVector = massiveBody.transform.position;
//Calculate eccentricity
gravityElements.Eccentricity = OrbitalHelper.calculateEccentricity(position, velocity, gravityElements.Mu);
//Determine orbit type
gravityElements.OrbitType = OrbitalHelper.determineOrbitType(gravityElements.Eccentricity);
//Calculate Mechanical Energy
gravityElements.MechanicalEnergy = OrbitalHelper.calculateMechanicalEnergy(gravityElements.Position, gravityElements.velocity, gravityElements.Mu, gravityElements.OrbitType);
//Calculate Semi Major Axis
gravityElements.SemiMajorAxis = OrbitalHelper.calculateSemiMajorAxis(gravityElements.MechanicalEnergy, gravityElements.Mu, gravityElements.OrbitType);
//Calculate SemiLatusRectum
gravityElements.SemiLatusRectum = OrbitalHelper.calculateSemiLatusRectum(gravityElements.SemiMajorAxis, gravityElements.Eccentricity, gravityElements.Perigee, gravityElements.OrbitType);
//Calculate Perigee
gravityElements.Perigee = OrbitalHelper.calculatePerigee(gravityElements.SemiMajorAxis, gravityElements.Eccentricity, gravityElements.OrbitType);
//Calculate Apogee
gravityElements.Apogee = OrbitalHelper.calculateApogee(gravityElements.SemiMajorAxis, gravityElements.Eccentricity, gravityElements.OrbitType);
//Calculate Center
gravityElements.Center = OrbitalHelper.calculateCenter(gravityElements.SemiMajorAxis, gravityElements.Perigee, gravityElements.OrbitType);
//Calculate GlobalRotationAngle
gravityElements.GlobalRotationAngle = OrbitalHelper.calculateGlobalRotationAngle(gravityElements.Eccentricity, gravityElements.OrbitType);
//Find orbital directions
gravityElements.Clockwise = OrbitalHelper.clockwiseOrbit(gravityElements.Position, gravityElements.velocity);
gravityElements.TowardsPerigee = OrbitalHelper.towardsPerigeeOrbit(gravityElements.velocity, gravityElements.Eccentricity, gravityElements.OrbitType);
//Calculate trueAnomaly
gravityElements.TrueAnomaly = OrbitalHelper.calculateTrueAnomaly(gravityElements.Eccentricity, gravityElements.Position, gravityElements.TowardsPerigee, gravityElements.Clockwise, gravityElements.OrbitType);
//Calculate Eccentric Anomaly
gravityElements.EccentricAnomaly = OrbitalHelper.calculateEccentricAnomaly(gravityElements.Eccentricity, gravityElements.TrueAnomaly, gravityElements.TowardsPerigee, gravityElements.OrbitType);
//Calculate Anomaly at current epoch
gravityElements.AnomalyAtEpoch = OrbitalHelper.calculateAnomalyAtCurrentEpoch(gravityElements.Eccentricity, gravityElements.EccentricAnomaly, gravityElements.Clockwise, gravityElements.OrbitType);
gravityElements.MeanAnomaly = gravityElements.AnomalyAtEpoch;
//Calculate Angular Momentum
gravityElements.AngularMomentum = OrbitalHelper.calculateAngularMomentum(gravityElements.Eccentricity, gravityElements.Perigee, gravityElements.SemiMajorAxis, gravityElements.SemiLatusRectum,
gravityElements.Mu, gravityElements.OrbitType);
//Calculate time at epoch
gravityElements.TimeAtEpoch = OrbitalHelper.calculateTimeAtEpoch(gravityElements.Eccentricity, gravityElements.EccentricAnomaly, gravityElements.SemiMajorAxis, gravityElements.Mu,
gravityElements.Clockwise, gravityElements.TowardsPerigee, gravityElements.OrbitType);
return(gravityElements);
}
//Takes in the ships current gravity elements according to its last encounter, current massive body elements as they are at tiem 0 and current massivebodyelements as they are at time 0
private void predictAnEncounter(Encounter currentEncounter, ref List <Encounter> encounters)
{
encounters.Add(currentEncounter);
//data sources
MassiveBodyElements currentMassiveBody = currentEncounter.GravElements.massiveBody.GetComponent <MassiveBodyElements>();
GravityElementsClass currentMassiveBodyGravElements = currentEncounter.GravElements.massiveBody.GetComponent <GravityElements>().getClassVersion();
iterations++;
double time = 0;
double currentOrbitalPeriod = calculatePeriod(currentEncounter.GravElements.OrbitType, currentEncounter.GravElements.SemiMajorAxis, currentEncounter.GravElements.Mu);
bool foundNewEncounter = false;
GameObject encounteredMassiveBody = null;
while (time < currentOrbitalPeriod && !foundNewEncounter)
{
time += 0.01;
//have we exited the current soi?
double altitude = currentEncounter.GravElements.calculateLocalPositionAtFutureTime(time).magnitude; //the ships massive body is always at time 0
if (currentMassiveBody.SphereOfInfluence < altitude)
{
foundNewEncounter = true;
encounteredMassiveBody = currentEncounter.GravElements.massiveBody.GetComponent <GravityElements>().massiveBody;
break;
}
//have we entered a new soi?
foreach (GameObject satelite in currentMassiveBody.satelites)
{
double sateliteSphereOfInfluence = satelite.GetComponent <MassiveBodyElements>().SphereOfInfluence;
Vector2 sateliteLocalPosition = satelite.GetComponent <GravityElements>().calculateLocalPositionAtFutureTime(time + currentEncounter.TimeOfEncounter);
Vector2 shipsLocalPosition = currentEncounter.GravElements.calculateLocalPositionAtFutureTime(time);
if (Vector2.Distance(shipsLocalPosition, sateliteLocalPosition) < sateliteSphereOfInfluence)
{
foundNewEncounter = true;
encounteredMassiveBody = satelite;
break;
}
}
if (time > 100) //hyperbolic orbit with infinite periode, this prevents infinite loops
{
break;
}
}
//We have encountered nothing, just a regular eliptical orbit, or a hyperbolic one that's really long
if (encounteredMassiveBody == null)
{
return;
}
//We have encountered a massive body, time to assemble a new encounter
Tuple <Vector2, Vector2> returnInfo;
returnInfo = currentEncounter.GravElements.calculateLocalPositionAndVelocityAtFutureTime(time);
Vector2 shipPredictedLocalPosition = returnInfo.item1;
Vector2 shipPredictedLocalVelocity = returnInfo.item2;
returnInfo = currentMassiveBodyGravElements.calculateGlobalPositionAndVelocityAtFutureTime(time + currentEncounter.TimeOfEncounter);
Vector2 currentMassiveBodyPredictedGlobalPosition = returnInfo.item1;
Vector2 currentMassiveBodyPredictedGlobalVelocity = returnInfo.item2;
returnInfo = encounteredMassiveBody.GetComponent <GravityElements>().calculateGlobalPositionAndVelocityAtFutureTime(time + currentEncounter.TimeOfEncounter);
Vector2 encounteredMassiveBodyPredictedGlobalPosition = returnInfo.item1;
Vector2 encounteredmassiveBodyPredictedGlobalVelocity = returnInfo.item2;
Vector2 shipPositionRelativeToEncounter = (shipPredictedLocalPosition + currentMassiveBodyPredictedGlobalPosition) - encounteredMassiveBodyPredictedGlobalPosition;
Vector2 shipVelocityRelativeToEncounter = (shipPredictedLocalVelocity + currentMassiveBodyPredictedGlobalVelocity) - encounteredmassiveBodyPredictedGlobalVelocity;
GravityElementsClass newShipsGravityElements = calculateInitialOrbitalElements(shipPositionRelativeToEncounter, shipVelocityRelativeToEncounter, encounteredMassiveBody); //massive body is inputed in its state at time 0
//Change the ending true anomaly of the last encounter
double startingTrueAnomaly = newShipsGravityElements.TrueAnomaly;
double endingTrueAnomaly = MiscHelperFuncs.AngleBetweenVector2(currentEncounter.GravElements.Eccentricity, shipPredictedLocalPosition);
encounters[encounters.Count - 1].EndingTrueAnomaly = endingTrueAnomaly;
if (iterations < MAX_ITERATIONS)
{
GameObject tempPerigeeIcon = Instantiate(perigeeIcon);
OrbitalPOI perigeePOI = new OrbitalPOI(tempPerigeeIcon, newShipsGravityElements.Perigee);
Encounter newEncounter = new Encounter(newShipsGravityElements, startingTrueAnomaly, double.PositiveInfinity, time + currentEncounter.TimeOfEncounter, perigeePOI);
predictAnEncounter(newEncounter, ref encounters);
}
}
