public override void AddTo(BindingManager manager)
{
manager.AddGetter("VESSELNAME", delegate(CPU cpu) { return(cpu.Vessel.vesselName); });
manager.AddSetter("VESSELNAME", delegate(CPU cpu, object value) { cpu.Vessel.vesselName = value.ToString(); });
manager.AddGetter("ALTITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.altitude); });
manager.AddGetter("ALT:RADAR", delegate(CPU cpu) { return((float)cpu.Vessel.heightFromTerrain); });
manager.AddGetter("MISSIONTIME", delegate(CPU cpu) { return((float)cpu.Vessel.missionTime); });
manager.AddGetter("STATUS", delegate(CPU cpu) { return(cpu.Vessel.situation.ToString().Replace("_", " ")); });
manager.AddGetter("APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.ApA); });
manager.AddGetter("PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.PeA); });
manager.AddGetter("ALT:APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.ApA); });
manager.AddGetter("ALT:PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.PeA); });
manager.AddGetter("ETA:APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.timeToAp); });
manager.AddGetter("ETA:PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.timeToPe); });
manager.AddGetter("VELOCITY", delegate(CPU cpu) { return(cpu.Vessel.obt_velocity); });
manager.AddGetter("ANGULARMOMENTUM", delegate(CPU cpu) { return(new Direction(cpu.Vessel.angularMomentum, true)); });
manager.AddGetter("ANGULARVEL", delegate(CPU cpu) { return(new Direction(cpu.Vessel.angularVelocity, true)); });
manager.AddGetter("MASS", delegate(CPU cpu) { return(cpu.Vessel.GetTotalMass()); });
manager.AddGetter("VERTICALSPEED", delegate(CPU cpu) { return((float)cpu.Vessel.verticalSpeed); });
manager.AddGetter("SURFACESPEED", delegate(CPU cpu) { return((float)cpu.Vessel.horizontalSrfSpeed); });
manager.AddGetter("BODY", delegate(CPU cpu) { return(cpu.Vessel.mainBody.bodyName); });
manager.AddGetter("LATITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.latitude); });
manager.AddGetter("LONGITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.longitude); });
manager.AddGetter("UP", delegate(CPU cpu) { return(new Direction(cpu.Vessel.upAxis, false)); });
manager.AddGetter("NODE", delegate(CPU cpu) {
var vessel = cpu.Vessel;
if (!vessel.patchedConicSolver.maneuverNodes.Any())
{
throw new kOSException("No maneuver nodes present!");
}
var up = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;
var fwd = vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(cpu.Vessel.orbit);
var rotRef = Quaternion.LookRotation(fwd, up);
Direction d = new Direction();
d.Rotation = rotRef;
return(d);
});
manager.AddGetter("MAG:NODE", delegate(CPU cpu) {
var vessel = cpu.Vessel;
var orbit = vessel.orbit;
if (!vessel.patchedConicSolver.maneuverNodes.Any())
{
throw new kOSException("No maneuver nodes present!");
}
var mag = vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(orbit).magnitude;
return((float)mag);
});
manager.AddGetter("ETA:NODE", delegate(CPU cpu) {
var vessel = cpu.Vessel;
if (!vessel.patchedConicSolver.maneuverNodes.Any())
{
throw new kOSException("No maneuver nodes present!");
}
var time = vessel.patchedConicSolver.maneuverNodes[0].UT;
var currTime = Planetarium.GetUniversalTime();
return((float)(time - currTime));
});
manager.AddGetter("PROGRADE", delegate(CPU cpu)
{
var vessel = cpu.Vessel;
var up = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;
Direction d = new Direction();
d.Rotation = Quaternion.LookRotation(cpu.Vessel.orbit.GetVel().normalized, up);
return(d);
});
manager.AddGetter("RETROGRADE", delegate(CPU cpu)
{
var vessel = cpu.Vessel;
var up = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;
Direction d = new Direction();
var vesselRoll = cpu.Vessel.GetTransform().eulerAngles.y;
d.Rotation = Quaternion.LookRotation(cpu.Vessel.orbit.GetVel().normalized * -1, up);
return(d);
});
manager.AddGetter("FACING", delegate(CPU cpu)
{
var facing = cpu.Vessel.transform.up;
return(new Direction(new Vector3d(facing.x, facing.y, facing.z).normalized, false));
});
manager.AddGetter("MAXTHRUST", delegate(CPU cpu)
{
return(VesselUtils.GetMaxThrust(cpu.Vessel));
});
manager.AddGetter("AV", delegate(CPU cpu) { return(cpu.Vessel.transform.InverseTransformDirection(cpu.Vessel.rigidbody.angularVelocity)); });
manager.AddGetter("STAGE", delegate(CPU cpu) { return(new StageValues(cpu.Vessel)); });
}
public BodyTarget(String name, ExecutionContext context) : this(VesselUtils.GetBodyByName(name), context)
{
}
private object GetResourceOfCurrentStage(String resourceName)
{
var activeEngines = VesselUtils.GetListOfActivatedEngines(vessel);
return(Utils.ProspectForResource(resourceName, activeEngines));
}
public override void Evaluate()
{
switch (RegexMatch.Groups[1].Value.ToUpper())
{
case "BODIES":
StdOut("");
StdOut("Name Distance");
StdOut("-------------------------------------");
foreach (var body in FlightGlobals.fetch.bodies)
{
StdOut(body.bodyName.PadLeft(14) + " " + Vector3d.Distance(body.position, Vessel.GetWorldPos3D()));
}
StdOut("");
break;
case "TARGETS":
StdOut("");
StdOut("Vessel Name Distance");
StdOut("-------------------------------------");
float commRange = VesselUtils.GetCommRange(Vessel);
foreach (Vessel vessel in FlightGlobals.Vessels)
{
if (vessel != Vessel)
{
var vT = new VesselTarget(vessel, this);
if (vT.IsInRange(commRange))
{
StdOut(vT.target.vesselName.PadRight(24) + " " + vT.GetDistance().ToString("0.0").PadLeft(8));
}
}
}
StdOut("");
break;
case "RESOURCES":
StdOut("");
StdOut("Stage Resource Name Amount");
StdOut("------------------------------------------------");
foreach (Part part in Vessel.Parts)
{
String stageStr = part.inverseStage.ToString();
foreach (PartResource resource in part.Resources)
{
StdOut(part.inverseStage.ToString() + " " + resource.resourceName.PadRight(20) + " " + resource.amount.ToString("0.00").PadLeft(8));
}
}
break;
case "PARTS":
StdOut("------------------------------------------------");
foreach (Part part in Vessel.Parts)
{
StdOut(part.ConstructID + " " + part.partInfo.name);
}
break;
case "ENGINES":
StdOut("------------------------------------------------");
foreach (Part part in VesselUtils.GetListOfActivatedEngines(Vessel))
{
foreach (PartModule module in part.Modules)
{
if (module is ModuleEngines)
{
var engineMod = (ModuleEngines)module;
StdOut(part.uid + " " + part.inverseStage.ToString() + " " + engineMod.moduleName);
}
}
}
break;
}
State = ExecutionState.DONE;
}
public void OnFlyByWire(ref FlightCtrlState c)
{
Expression e = cpu.GetDeepestChildContext().GetLock(propertyName);
if (e != null)
{
Value = e.GetValue();
if (propertyName == "throttle")
{
c.mainThrottle = (float)e.Double();
}
if (propertyName == "wheelthrottle")
{
c.wheelThrottle = (float)Utils.Clamp(e.Double(), -1, 1);
}
if (propertyName == "steering")
{
if (Value is String && ((string)Value).ToUpper() == "KILL")
{
SteeringHelper.KillRotation(c, vessel);
}
else if (Value is Direction)
{
SteeringHelper.SteerShipToward((Direction)Value, c, vessel);
}
else if (Value is Vector)
{
SteeringHelper.SteerShipToward(((Vector)Value).ToDirection(), c, vessel);
}
else if (Value is Node)
{
SteeringHelper.SteerShipToward(((Node)Value).GetBurnVector().ToDirection(), c, vessel);
}
}
if (propertyName == "wheelsteering")
{
float bearing = 0;
if (Value is VesselTarget)
{
bearing = VesselUtils.GetTargetBearing(vessel, ((VesselTarget)Value).target);
}
else if (Value is GeoCoordinates)
{
bearing = ((GeoCoordinates)Value).GetBearing(vessel);
}
else if (Value is double)
{
bearing = (float)(Math.Round((double)Value) - Mathf.Round(FlightGlobals.ship_heading));
}
if (vessel.horizontalSrfSpeed > 0.1f)
{
if (Mathf.Abs(VesselUtils.AngleDelta(VesselUtils.GetHeading(vessel), VesselUtils.GetVelocityHeading(vessel))) <= 90)
{
c.wheelSteer = Mathf.Clamp(bearing / -10, -1, 1);
}
else
{
c.wheelSteer = -Mathf.Clamp(bearing / -10, -1, 1);
}
}
}
if (cpu.GetLock(name) == null)
{
locked = false;
}
}
}
public override object GetSuffix(string suffixName)
{
if (suffixName == "DIRECTION")
{
var vector = (target.GetWorldPos3D() - context.Vessel.GetWorldPos3D());
return(new Direction(vector, false));
}
if (suffixName == "DISTANCE")
{
return((float)GetDistance());
}
if (suffixName == "BEARING")
{
return(VesselUtils.GetTargetBearing(context.Vessel, target));
}
if (suffixName == "HEADING")
{
return(VesselUtils.GetTargetHeading(context.Vessel, target));
}
if (suffixName == "PROGRADE")
{
return(GetPrograde());
}
if (suffixName == "RETROGRADE")
{
return(GetRetrograde());
}
if (suffixName == "MAXTHRUST")
{
return(VesselUtils.GetMaxThrust(target));
}
if (suffixName == "VELOCITY")
{
return(new VesselVelocity(target));
}
if (suffixName == "GEOPOSITION")
{
return(new GeoCoordinates(target));
}
if (suffixName == "LATITUDE")
{
return(VesselUtils.GetVesselLattitude(target));
}
if (suffixName == "LONGITUDE")
{
return(VesselUtils.GetVesselLongitude(target));
}
if (suffixName == "FACING")
{
return(GetFacing());
}
if (suffixName == "UP")
{
return(new Direction(target.upAxis, false));
}
if (suffixName == "NORTH")
{
return(new Direction(VesselUtils.GetNorthVector(target), false));
}
if (suffixName == "BODY")
{
return(target.mainBody.bodyName);
}
if (suffixName == "ANGULARMOMENTUM")
{
return(new Direction(target.angularMomentum, true));
}
if (suffixName == "ANGULARVEL")
{
return(new Direction(target.angularVelocity, true));
}
if (suffixName == "MASS")
{
return(target.GetTotalMass());
}
if (suffixName == "VERTICALSPEED")
{
return(target.verticalSpeed);
}
if (suffixName == "SURFACESPEED")
{
return(target.horizontalSrfSpeed);
}
if (suffixName == "AIRSPEED")
{
return((target.orbit.GetVel() - FlightGlobals.currentMainBody.getRFrmVel(target.GetWorldPos3D())).magnitude); //the velocity of the vessel relative to the air);
}
if (suffixName == "VESSELNAME")
{
return(target.vesselName);
}
if (suffixName == "ALTITUDE")
{
return(target.altitude);
}
if (suffixName == "APOAPSIS")
{
return(target.orbit.ApA);
}
if (suffixName == "PERIAPSIS")
{
return(target.orbit.PeA);
}
if (suffixName == "SENSOR")
{
return(new VesselSensors(target));
}
if (suffixName == "TERMVELOCITY")
{
return(VesselUtils.GetTerminalVelocity(target));
}
if (suffixName == "OBT")
{
return(new OrbitInfo(target.orbit));
}
// Is this a resource?
double dblValue;
if (VesselUtils.TryGetResource(target, suffixName, out dblValue))
{
return(dblValue);
}
return(base.GetSuffix(suffixName));
}
public float GetBearing(Vessel vessel)
{
return(VesselUtils.AngleDelta(VesselUtils.GetHeading(vessel), GetHeadingFromVessel(vessel)));
}
private static bool CheckCommRange(Vessel vessel)
{
return(VesselUtils.GetDistanceToKerbinSurface(vessel) < VesselUtils.GetCommRange(vessel));
}
private void UpdateWheelSteering(ref FlightCtrlState c)
{
float bearing = 0;
if (_value is VesselTarget)
{
bearing = VesselUtils.GetTargetBearing(_shared.Vessel, ((VesselTarget)_value).target);
}
else if (_value is GeoCoordinates)
{
bearing = ((GeoCoordinates)_value).GetBearing(_shared.Vessel);
}
else if (_value is double)
{
bearing = (float)(Math.Round((double)_value) - Mathf.Round(FlightGlobals.ship_heading));
}
if (_shared.Vessel.horizontalSrfSpeed > 0.1f)
{
if (Mathf.Abs(VesselUtils.AngleDelta(VesselUtils.GetHeading(_shared.Vessel), VesselUtils.GetVelocityHeading(_shared.Vessel))) <= 90)
{
c.wheelSteer = Mathf.Clamp(bearing / -10, -1, 1);
}
else
{
c.wheelSteer = -Mathf.Clamp(bearing / -10, -1, 1);
}
}
}
public BodyTarget(String name, Vessel currentVessel) : this(VesselUtils.GetBodyByName(name), currentVessel)
{
}
public override bool CheckRange()
{
return(VesselUtils.GetDistanceToKerbinSurface(vessel) < VesselUtils.GetCommRange(vessel));
}
