// The list of throttles is ordered under the assumption that you iterate
// over the vessel as follows:
// foreach part in vessel.parts:
// foreach rcsModule in part.Modules.OfType<ModuleRCS>:
// ...
// Note that rotation balancing is not supported at the moment.
public void GetThrottles(Vessel vessel, VesselState state, Vector3 direction,
out double[] throttles, out List <RCSSolver.Thruster> thrustersOut)
{
thrustersOut = callerThrusters;
Vector3 rotation = Vector3.zero;
var rcsBalancer = VesselExtensions.GetMasterMechJeb(vessel).rcsbal;
// Update vessel info if needed.
CheckVessel(vessel, state);
Vector3 dir = direction.normalized;
RCSSolverKey key = new RCSSolverKey(ref dir, rotation);
if (thrusters.Count == 0)
{
throttles = double0;
}
else if (direction == Vector3.zero)
{
throttles = originalThrottles;
}
else if (results.TryGetValue(key, out throttles))
{
cacheHits++;
}
else
{
// This task hasn't been calculated. We'll handle that here.
// Meanwhile, TryGetValue() will have set 'throttles' to null, but
// we'll make it a 0-element array instead to avoid null checks.
cacheMisses++;
throttles = double0;
if (pending.Contains(key))
{
// We've submitted this key before, so we need to check the
// results queue.
while (resultsQueue.Count > 0)
{
SolverResult sr = (SolverResult)resultsQueue.Dequeue();
results[sr.key] = sr.throttles;
pending.Remove(sr.key);
if (sr.key == key)
{
throttles = sr.throttles;
}
}
}
else
{
// This task was neither calculated nor pending, so we've never
// submitted it. Do so!
pending.Add(key);
tasks.Enqueue(new SolverTask(key, dir, rotation));
workEvent.Set();
}
}
// Return a copy of the array to make sure ours isn't modified.
throttles = (double[])throttles.Clone();
}
// Open and close intakes so that they provide the required flow but no
// more.
void OptimizeIntakes(VesselState.ResourceInfo info, double requiredFlow)
{
// The highly imperfect algorithm here is:
// - group intakes by symmetry
// - sort the groups by their size
// - open a group at a time until we have enough airflow
// - close the remaining groups
// TODO: improve the algorithm:
// 1. Take cost-benefit into account. We want to open ram intakes
// before any others, and we probably never want to open
// nacelles. We need more info to know how much thrust we lose
// for losing airflow, versus how much drag we gain for opening
// an intake.
// 2. Take the center of drag into account. We don't need to open
// symmetry groups all at once; we just need the center of drag
// to be in a good place. Symmetry in the SPH also doesn't
// guarantee anything; we could be opening all pairs that are
// above the plane through the center of mass and none below,
// which makes control harder.
// Even just point (1) means we want to solve knapsack.
// Group intakes by symmetry, and collect the information by intake.
var groups = new List<List<ModuleResourceIntake>>();
var groupIds = new Dictionary<ModuleResourceIntake, int>();
var data = new Dictionary<ModuleResourceIntake, VesselState.ResourceInfo.IntakeData>();
foreach (var intakeData in info.intakes)
{
ModuleResourceIntake intake = intakeData.intake;
data[intake] = intakeData;
if (groupIds.ContainsKey(intake)) { continue; }
// Create a group for this symmetry
int grpId = groups.Count;
var intakes = new List<ModuleResourceIntake>();
groups.Add(intakes);
// In DFS order, get all the symmetric parts.
// We can't rely on symmetryCounterparts; see bug #52 by tavert:
// https://github.com/MuMech/MechJeb2/issues/52
var stack = new Stack<Part>();
stack.Push(intake.part);
while(stack.Count > 0) {
var part = stack.Pop();
var partIntake = part.Modules.OfType<ModuleResourceIntake>().FirstOrDefault();
if (partIntake == null || groupIds.ContainsKey(partIntake)) {
continue;
}
groupIds[partIntake] = grpId;
intakes.Add(partIntake);
foreach (var sympart in part.symmetryCounterparts) {
stack.Push(sympart);
}
}
}
// For each group in sorted order, if we need more air, open any
// closed intakes. If we have enough air, close any open intakes.
// OrderBy is stable, so we'll always be opening the same intakes.
double airFlowSoFar = 0;
KSPActionParam param = new KSPActionParam(KSPActionGroup.None,
KSPActionType.Activate);
foreach (var grp in groups.OrderBy(grp => grp.Count))
{
if (airFlowSoFar < requiredFlow)
{
foreach (var intake in grp)
{
double airFlowThisIntake = data[intake].predictedMassFlow;
if (!intake.intakeEnabled)
{
intake.ToggleAction(param);
}
airFlowSoFar += airFlowThisIntake;
}
}
else
{
foreach (var intake in grp)
{
if (intake.intakeEnabled)
{
intake.ToggleAction(param);
}
}
}
}
}
private void CheckVessel(Vessel vessel, VesselState state)
{
bool changed = false;
var rcsBalancer = VesselExtensions.GetMasterMechJeb(vessel).rcsbal;
if (vessel.parts.Count != lastPartCount)
{
lastPartCount = vessel.parts.Count;
changed = true;
}
// Make sure all thrusters are still enabled, because if they're not,
// our calculations will be wrong.
for (int i = 0; i < thrusters.Count; i++)
{
if (!thrusters[i].partModule.isEnabled)
{
changed = true;
break;
}
}
// Likewise, make sure any previously-disabled RCS modules are still
// disabled.
for (int i = 0; i < lastDisabled.Count; i++)
{
var pm = lastDisabled[i];
if (pm.isEnabled)
{
changed = true;
break;
}
}
// See if the CoM has moved too much.
Rigidbody rootPartBody = vessel.rootPart.rigidbody;
if (rootPartBody != null)
{
// But how much is "too much"? Well, it probably has something to do
// with the ship's moment of inertia (MoI). Let's say the distance
// 'd' that the CoM is allowed to shift without a reset is:
//
// d = moi * x + c
//
// where 'moi' is the magnitude of the ship's moment of inertia and
// 'x' and 'c' are tuning parameters to be determined.
//
// Using a few actual KSP ships, I burned RCS fuel (or moved fuel
// from one tank to another) to see how far the CoM could shift
// before the the rotation error on translation became annoying.
// I came up with roughly:
//
// d moi
// 0.005 2.34
// 0.04 11.90
// 0.07 19.96
//
// I then halved each 'd' value, because we'd like to address this
// problem -before- it becomes annoying. Least-squares linear
// regression on the (moi, d/2) pairs gives the following (with
// adjusted R^2 = 0.999966):
//
// moi = 542.268 d + 1.00654
// d = (moi - 1) / 542
//
// So the numbers below have some basis in reality. =)
// Assume MoI magnitude is always >=2.34, since that's all I tested.
comErrorThreshold = (Math.Max(state.MoI.magnitude, 2.34) - 1) / 542;
Vector3 comState = state.CoM;
Vector3 rootPos = state.rootPartPos;
Vector3 com = WorldToVessel(vessel, comState - rootPos);
double thisComErr = (lastCoM - com).magnitude;
maxComError = Math.Max(maxComError, thisComErr);
_comError.value = thisComErr;
if (_comError > comErrorThreshold)
{
lastCoM = com;
changed = true;
}
}
if (!changed)
{
return;
}
// Something about the vessel has changed. We need to reset everything.
lastDisabled.Clear();
// ModuleRCS has no originalThrusterPower attribute, so we have
// to explicitly reset it.
ResetThrusterForces();
// Rebuild the list of thrusters.
var ts = new List <RCSSolver.Thruster>();
for (int index = 0; index < vessel.parts.Count; index++)
{
Part p = vessel.parts[index];
foreach (ModuleRCS pm in p.Modules.OfType <ModuleRCS>())
{
if (!pm.isEnabled)
{
// Keep track of this module so we'll know if it's enabled.
lastDisabled.Add(pm);
}
else if (p.Rigidbody != null && !pm.isJustForShow)
{
Vector3 pos = VesselRelativePos(state.CoM, vessel, p);
// Create a single RCSSolver.Thruster for this part. This
// requires some assumptions about how the game's RCS code will
// drive the individual thrusters (which we can't control).
Vector3[] thrustDirs = new Vector3[pm.thrusterTransforms.Count];
Quaternion rotationQuat = Quaternion.Inverse(vessel.GetTransform().rotation);
for (int i = 0; i < pm.thrusterTransforms.Count; i++)
{
thrustDirs[i] = (rotationQuat * -pm.thrusterTransforms[i].up).normalized;
}
ts.Add(new RCSSolver.Thruster(pos, thrustDirs, p, pm));
}
}
}
callerThrusters.Clear();
originalThrottles = new double[ts.Count];
zeroThrottles = new double[ts.Count];
for (int i = 0; i < ts.Count; i++)
{
originalThrottles[i] = ts[i].originalForce;
zeroThrottles[i] = 0;
callerThrusters.Add(ts[i]);
}
thrusters = ts;
ClearResults();
}
override public void activateAction()
{
base.activateAction();
warping = true;
Orbit orbit = this.scriptModule.orbit;
VesselState vesselState = this.scriptModule.vesselState;
Vessel vessel = FlightGlobals.ActiveVessel;
switch (warpTarget)
{
case WarpTarget.Periapsis:
targetUT = orbit.NextPeriapsisTime(vesselState.time);
break;
case WarpTarget.Apoapsis:
if (orbit.eccentricity < 1)
{
targetUT = orbit.NextApoapsisTime(vesselState.time);
}
break;
case WarpTarget.SoI:
if (orbit.patchEndTransition != Orbit.PatchTransitionType.FINAL)
{
targetUT = orbit.EndUT;
}
break;
case WarpTarget.Node:
if (vessel.patchedConicsUnlocked() && vessel.patchedConicSolver.maneuverNodes.Any())
{
targetUT = vessel.patchedConicSolver.maneuverNodes[0].UT;
}
break;
case WarpTarget.Time:
targetUT = vesselState.time + timeOffset;
break;
case WarpTarget.PhaseAngleT:
if (core.target.NormalTargetExists)
{
Orbit reference;
if (core.target.TargetOrbit.referenceBody == orbit.referenceBody)
{
reference = orbit; // we orbit arround the same body
}
else
{
reference = orbit.referenceBody.orbit;
}
// From Kerbal Alarm Clock
double angleChangePerSec = (360 / core.target.TargetOrbit.period) - (360 / reference.period);
double currentAngle = reference.PhaseAngle(core.target.TargetOrbit, vesselState.time);
double angleDigff = currentAngle - phaseAngle;
if (angleDigff > 0 && angleChangePerSec > 0)
{
angleDigff -= 360;
}
if (angleDigff < 0 && angleChangePerSec < 0)
{
angleDigff += 360;
}
double TimeToTarget = Math.Floor(Math.Abs(angleDigff / angleChangePerSec));
targetUT = vesselState.time + TimeToTarget;
}
break;
case WarpTarget.AtmosphericEntry:
try
{
targetUT = OrbitExtensions.NextTimeOfRadius(vessel.orbit, vesselState.time, vesselState.mainBody.Radius + vesselState.mainBody.RealMaxAtmosphereAltitude());
}
catch
{
warping = false;
}
break;
case WarpTarget.SuicideBurn:
try
{
targetUT = OrbitExtensions.SuicideBurnCountdown(orbit, vesselState, vessel) + vesselState.time;
}
catch
{
warping = false;
}
break;
default:
targetUT = vesselState.time;
break;
}
}
public static double SuicideBurnCountdown(Orbit orbit, VesselState vesselState, Vessel vessel)
{
if (vesselState.mainBody == null) return 0;
if (orbit.PeA > 0) return Double.PositiveInfinity;
double angleFromHorizontal = 90 - Vector3d.Angle(-vessel.srf_velocity, vesselState.up);
angleFromHorizontal = MuUtils.Clamp(angleFromHorizontal, 0, 90);
double sine = Math.Sin(angleFromHorizontal * Math.PI / 180);
double g = vesselState.localg;
double T = vesselState.limitedMaxThrustAccel;
double effectiveDecel = 0.5 * (-2 * g * sine + Math.Sqrt((2 * g * sine) * (2 * g * sine) + 4 * (T * T - g * g)));
double decelTime = vesselState.speedSurface / effectiveDecel;
Vector3d estimatedLandingSite = vesselState.CoM + 0.5 * decelTime * vessel.srf_velocity;
double terrainRadius = vesselState.mainBody.Radius + vesselState.mainBody.TerrainAltitude(estimatedLandingSite);
double impactTime = 0;
try
{
impactTime = orbit.NextTimeOfRadius(vesselState.time, terrainRadius);
}
catch (ArgumentException)
{
return 0;
}
return impactTime - decelTime / 2 - vesselState.time;
}
// The list of throttles is ordered under the assumption that you iterate
// over the vessel as follows:
// foreach part in vessel.parts:
// foreach rcsModule in part.Modules.OfType<ModuleRCS>:
// ...
// Note that rotation balancing is not supported at the moment.
public void GetThrottles(Vessel vessel, VesselState state, Vector3 direction,
out double[] throttles, out List<RCSSolver.Thruster> thrustersOut)
{
thrustersOut = callerThrusters;
Vector3 rotation = Vector3.zero;
var rcsBalancer = VesselExtensions.GetMasterMechJeb(vessel).rcsbal;
// Update vessel info if needed.
CheckVessel(vessel, state);
Vector3 dir = direction.normalized;
RCSSolverKey key = new RCSSolverKey(ref dir, rotation);
if (thrusters.Count == 0)
{
throttles = double0;
}
else if (direction == Vector3.zero)
{
throttles = originalThrottles;
}
else if (results.TryGetValue(key, out throttles))
{
cacheHits++;
}
else
{
// This task hasn't been calculated. We'll handle that here.
// Meanwhile, TryGetValue() will have set 'throttles' to null, but
// we'll make it a 0-element array instead to avoid null checks.
cacheMisses++;
throttles = double0;
if (pending.Contains(key))
{
// We've submitted this key before, so we need to check the
// results queue.
while (resultsQueue.Count > 0)
{
SolverResult sr = (SolverResult)resultsQueue.Dequeue();
results[sr.key] = sr.throttles;
pending.Remove(sr.key);
if (sr.key == key)
{
throttles = sr.throttles;
}
}
}
else
{
// This task was neither calculated nor pending, so we've never
// submitted it. Do so!
pending.Add(key);
tasks.Enqueue(new SolverTask(key, dir, rotation));
workEvent.Set();
}
}
// Return a copy of the array to make sure ours isn't modified.
throttles = (double[])throttles.Clone();
}
private void CheckVessel(Vessel vessel, VesselState state)
{
bool changed = false;
var rcsBalancer = VesselExtensions.GetMasterMechJeb(vessel).rcsbal;
if (vessel.parts.Count != lastPartCount)
{
lastPartCount = vessel.parts.Count;
changed = true;
}
// Make sure all thrusters are still enabled, because if they're not,
// our calculations will be wrong.
for (int i = 0; i < thrusters.Count; i++)
{
if (!thrusters[i].partModule.isEnabled)
{
changed = true;
break;
}
}
// Likewise, make sure any previously-disabled RCS modules are still
// disabled.
foreach (var pm in lastDisabled)
{
if (pm.isEnabled)
{
changed = true;
break;
}
}
// See if the CoM has moved too much.
Rigidbody rootPartBody = vessel.rootPart.rigidbody;
if (rootPartBody != null)
{
// But how much is "too much"? Well, it probably has something to do
// with the ship's moment of inertia (MoI). Let's say the distance
// 'd' that the CoM is allowed to shift without a reset is:
//
// d = moi * x + c
//
// where 'moi' is the magnitude of the ship's moment of inertia and
// 'x' and 'c' are tuning parameters to be determined.
//
// Using a few actual KSP ships, I burned RCS fuel (or moved fuel
// from one tank to another) to see how far the CoM could shift
// before the the rotation error on translation became annoying.
// I came up with roughly:
//
// d moi
// 0.005 2.34
// 0.04 11.90
// 0.07 19.96
//
// I then halved each 'd' value, because we'd like to address this
// problem -before- it becomes annoying. Least-squares linear
// regression on the (moi, d/2) pairs gives the following (with
// adjusted R^2 = 0.999966):
//
// moi = 542.268 d + 1.00654
// d = (moi - 1) / 542
//
// So the numbers below have some basis in reality. =)
// Assume MoI magnitude is always >=2.34, since that's all I tested.
comErrorThreshold = (Math.Max(state.MoI.magnitude, 2.34) - 1) / 542;
Vector3 comState = state.CoM;
Vector3 rootPos = state.rootPartPos;
Vector3 com = WorldToVessel(vessel, comState - rootPos);
double thisComErr = (lastCoM - com).magnitude;
maxComError = Math.Max(maxComError, thisComErr);
_comError.value = thisComErr;
if (_comError > comErrorThreshold)
{
lastCoM = com;
changed = true;
}
}
if (!changed) return;
// Something about the vessel has changed. We need to reset everything.
lastDisabled.Clear();
// ModuleRCS has no originalThrusterPower attribute, so we have
// to explicitly reset it.
ResetThrusterForces();
// Rebuild the list of thrusters.
var ts = new List<RCSSolver.Thruster>();
foreach (Part p in vessel.parts)
{
foreach (ModuleRCS pm in p.Modules.OfType<ModuleRCS>())
{
if (!pm.isEnabled)
{
// Keep track of this module so we'll know if it's enabled.
lastDisabled.Add(pm);
}
else if (p.Rigidbody != null && !pm.isJustForShow)
{
Vector3 pos = VesselRelativePos(state.CoM, vessel, p);
// Create a single RCSSolver.Thruster for this part. This
// requires some assumptions about how the game's RCS code will
// drive the individual thrusters (which we can't control).
Vector3[] thrustDirs = new Vector3[pm.thrusterTransforms.Count];
Quaternion rotationQuat = Quaternion.Inverse(vessel.GetTransform().rotation);
for (int i = 0; i < pm.thrusterTransforms.Count; i++)
{
thrustDirs[i] = (rotationQuat * -pm.thrusterTransforms[i].up).normalized;
}
ts.Add(new RCSSolver.Thruster(pos, thrustDirs, p, pm));
}
}
}
callerThrusters.Clear();
originalThrottles = new double[ts.Count];
zeroThrottles = new double[ts.Count];
for (int i = 0; i < ts.Count; i++)
{
originalThrottles[i] = ts[i].originalForce;
zeroThrottles[i] = 0;
callerThrusters.Add(ts[i]);
}
thrusters = ts;
ClearResults();
}
public void onPartFixedUpdate()
{
if (settingsChanged)
{
saveSettings();
}
if ((part == null))
{
print("F part == null");
return;
}
if ((part.vessel == null))
{
print("F part.vessel == null");
return;
}
if (((part.vessel.rootPart is Decoupler) || (part.vessel.rootPart is RadialDecoupler)) && part.vessel.rootPart.gameObject.layer != 2)
{
print("Disabling collision with decoupler...");
EditorLogic.setPartLayer(part.vessel.rootPart.gameObject, 2);
}
if (part.vessel.orbit.objectType != Orbit.ObjectType.VESSEL)
{
part.vessel.orbit.objectType = Orbit.ObjectType.VESSEL;
}
if (!part.isConnected)
{
List<Part> tmp = new List<Part>(part.vessel.parts);
foreach (Part p in tmp)
{
if ((p is Decoupler) || (p is RadialDecoupler))
{
print("Disabling collision with decoupler...");
EditorLogic.setPartLayer(p.gameObject, 2);
}
}
tmp = new List<Part>(part.vessel.parts);
foreach (Part p in tmp)
{
p.isConnected = true;
if (p.State == PartStates.IDLE)
{
p.force_activate();
}
}
}
if (!allJebs.ContainsKey(part.vessel))
{
allJebs[part.vessel] = new VesselStateKeeper();
allJebs[part.vessel].controller = this;
}
if (!allJebs[part.vessel].jebs.Contains(this))
{
allJebs[part.vessel].jebs.Add(this);
}
if (allJebs[part.vessel].controller == this)
{
allJebs[part.vessel].state.Update(part.vessel);
vesselState = allJebs[part.vessel].state;
foreach (ComputerModule module in modules)
{
module.vesselState = vesselState;
module.onPartFixedUpdate();
}
if (!liftedOff && (FlightGlobals.ActiveVessel == part.vessel) && (Staging.CurrentStage <= Staging.LastStage))
{
foreach (ComputerModule module in modules)
{
module.onLiftOff();
}
liftedOff = true;
}
if (part.vessel != FlightGlobals.ActiveVessel)
{
FlightCtrlState s = new FlightCtrlState();
drive(s);
part.vessel.FeedInputFeed(s);
}
}
}
public void onPartStart()
{
vesselState = new VesselState();
modules.Add(new MechJebModuleSmartASS(this));
modules.Add(new MechJebModuleTranslatron(this));
modules.Add(new MechJebModuleRendezvous(this));
modules.Add(new MechJebModuleSurfaceInfo(this));
modules.Add (new MechJebModuleOrbitInfo(this));
//modules.Add(new MechJebModuleVesselInfo(this));
modules.Add(new MechJebModuleLandingAutopilot(this));
modules.Add(new MechJebModuleAscentAutopilot(this));
modules.Add(new MechJebModuleOrbitOper(this));
//modules.Add(new MechJebModuleOrbitPlane(this));
//modules.Add(new MechJebModuleJoke(this));
//modules.Add(new MechJebModuleAscension(this));
foreach (ComputerModule module in modules)
{
module.onPartStart();
}
}
public ComputerModule(MechJebCore core)
{
this.core = core;
part = core.part;
vesselState = core.vesselState;
}
override public void activateAction()
{
base.activateAction();
Vessel vessel = this.scriptModule.vessel;
VesselState vesselState = this.scriptModule.vesselState;
Orbit orbit = this.scriptModule.orbit;
CelestialBody mainBody = this.scriptModule.mainBody;
const double leadTime = 30;
double closestApproachTime = orbit.NextClosestApproachTime(core.target.TargetOrbit, vesselState.time);
if (actionType == 0) //Align planes
{
double UT;
Vector3d dV;
if (orbit.AscendingNodeExists(core.target.TargetOrbit))
{
dV = OrbitalManeuverCalculator.DeltaVAndTimeToMatchPlanesAscending(orbit, core.target.TargetOrbit, vesselState.time, out UT);
}
else
{
dV = OrbitalManeuverCalculator.DeltaVAndTimeToMatchPlanesDescending(orbit, core.target.TargetOrbit, vesselState.time, out UT);
}
vessel.RemoveAllManeuverNodes();
vessel.PlaceManeuverNode(this.scriptModule.orbit, dV, UT);
}
else if (actionType == 1) //Establish new orbit
{
double phasingOrbitRadius = phasingOrbitAltitude + mainBody.Radius;
vessel.RemoveAllManeuverNodes();
if (orbit.ApR < phasingOrbitRadius)
{
double UT1 = vesselState.time + leadTime;
Vector3d dV1 = OrbitalManeuverCalculator.DeltaVToChangeApoapsis(orbit, UT1, phasingOrbitRadius);
vessel.PlaceManeuverNode(orbit, dV1, UT1);
Orbit transferOrbit = vessel.patchedConicSolver.maneuverNodes[0].nextPatch;
double UT2 = transferOrbit.NextApoapsisTime(UT1);
Vector3d dV2 = OrbitalManeuverCalculator.DeltaVToCircularize(transferOrbit, UT2);
vessel.PlaceManeuverNode(transferOrbit, dV2, UT2);
}
else if (orbit.PeR > phasingOrbitRadius)
{
double UT1 = vesselState.time + leadTime;
Vector3d dV1 = OrbitalManeuverCalculator.DeltaVToChangePeriapsis(orbit, UT1, phasingOrbitRadius);
vessel.PlaceManeuverNode(orbit, dV1, UT1);
Orbit transferOrbit = vessel.patchedConicSolver.maneuverNodes[0].nextPatch;
double UT2 = transferOrbit.NextPeriapsisTime(UT1);
Vector3d dV2 = OrbitalManeuverCalculator.DeltaVToCircularize(transferOrbit, UT2);
vessel.PlaceManeuverNode(transferOrbit, dV2, UT2);
}
else
{
double UT = orbit.NextTimeOfRadius(vesselState.time, phasingOrbitRadius);
Vector3d dV = OrbitalManeuverCalculator.DeltaVToCircularize(orbit, UT);
vessel.PlaceManeuverNode(orbit, dV, UT);
}
}
else if (actionType == 2) //Intercept with Hohmann transfer
{
double UT;
Vector3d dV = OrbitalManeuverCalculator.DeltaVAndTimeForHohmannTransfer(orbit, core.target.TargetOrbit, vesselState.time, out UT);
vessel.RemoveAllManeuverNodes();
vessel.PlaceManeuverNode(orbit, dV, UT);
}
else if (actionType == 3) //Match velocities at closest approach
{
double UT = closestApproachTime;
Vector3d dV = OrbitalManeuverCalculator.DeltaVToMatchVelocities(orbit, UT, core.target.TargetOrbit);
vessel.RemoveAllManeuverNodes();
vessel.PlaceManeuverNode(orbit, dV, UT);
}
else if (actionType == 4) //Get closer
{
double UT = vesselState.time;
double interceptUT = UT + 100;
Vector3d dV = OrbitalManeuverCalculator.DeltaVToInterceptAtTime(orbit, UT, core.target.TargetOrbit, interceptUT, 10);
vessel.RemoveAllManeuverNodes();
vessel.PlaceManeuverNode(orbit, dV, UT);
}
this.endAction();
}
public ComputerModule(MechJebCore core)
{
this.core = core;
part = core.part;
vesselState = core.vesselState;
}
public void onPartStart()
{
vesselState = new VesselState();
Version v = Assembly.GetAssembly(typeof(MechJebCore)).GetName().Version;
version = v.Major.ToString() + "." + v.Minor.ToString() + "." + v.Build.ToString();
modules.Add(new MechJebModuleSmartASS(this));
modules.Add(new MechJebModuleTranslatron(this));
modules.Add(new MechJebModuleOrbitInfo(this));
modules.Add(new MechJebModuleSurfaceInfo(this));
modules.Add(new MechJebModuleVesselInfo(this));
modules.Add(new MechJebModuleLandingAutopilot(this));
modules.Add(new MechJebModuleAscentAutopilot(this));
modules.Add(new MechJebModuleOrbitOper(this));
modules.Add(new MechJebModuleRendezvous(this));
modules.Add(new MechJebModuleILS(this));
modules.Add(new MechJebModuleTablePhase(this));
//modules.Add(new MechJebModuleOrbitPlane(this));
//modules.Add(new MechJebModuleJoke(this));
//modules.Add(new MechJebModuleAscension(this));
autom8 = new MechJebModuleAutom8(this);
modules.Add(autom8);
foreach (ComputerModule module in modules)
{
module.onPartStart();
}
part.Events.Add(new BaseEvent("MechJebLua", MechJebLua));
loadSettings();
}
public void onPartFixedUpdate()
{
if (settingsChanged)
{
saveSettings();
}
if (settingsVersion != settings.version)
{
loadSettings();
}
if ((part == null))
{
print("F part == null");
return;
}
if ((part.vessel == null))
{
print("F part.vessel == null");
return;
}
if (part.vessel.orbit.objectType != Orbit.ObjectType.VESSEL)
{
part.vessel.orbit.objectType = Orbit.ObjectType.VESSEL;
}
if (!part.isConnected)
{
List<Part> tmp = new List<Part>(part.vessel.parts);
foreach (Part p in tmp)
{
p.isConnected = true;
if ((p.State == PartStates.DEACTIVATED) && !(p is Decoupler || p is RadialDecoupler || p is DecouplerGUI))
{
p.force_activate();
}
}
}
if (!allJebs.ContainsKey(part.vessel))
{
allJebs[part.vessel] = new VesselStateKeeper();
allJebs[part.vessel].controller = this;
}
if (!allJebs[part.vessel].jebs.Contains(this))
{
allJebs[part.vessel].jebs.Add(this);
}
if (allJebs[part.vessel].controller == this)
{
allJebs[part.vessel].state.Update(part.vessel);
attitudeError = attitudeActive ? Math.Abs(Vector3d.Angle(attitudeGetReferenceRotation(attitudeReference) * attitudeTarget * Vector3d.forward, vesselState.forward)) : 0; ;
vesselState = allJebs[part.vessel].state;
foreach (ComputerModule module in modules)
{
module.vesselState = vesselState;
module.onPartFixedUpdate();
}
if (!liftedOff && (FlightGlobals.ActiveVessel == part.vessel) && (Staging.CurrentStage <= Staging.lastStage))
{
foreach (ComputerModule module in modules)
{
module.onLiftOff();
}
liftedOff = true;
}
if (part.vessel == FlightGlobals.ActiveVessel)
{
MechJebModuleAutom8.instance = autom8;
}
else
{
FlightCtrlState s = new FlightCtrlState();
drive(s);
part.vessel.FeedInputFeed(s);
}
}
}