public static ListValue PartsToList(IEnumerable <global::Part> parts, SharedObjects sharedObj)
{
var toReturn = new ListValue();
var vessel = VesselTarget.CreateOrGetExisting(sharedObj);
foreach (var part in parts)
{
foreach (PartModule module in part.Modules)
{
if (!(module is IStageSeparator))
{
continue;
}
var dockingNode = module as ModuleDockingNode;
if (dockingNode != null && !dockingNode.stagingEnabled)
{
continue;
}
if (module is ModuleDecouple || module is ModuleAnchoredDecoupler ||
module is LaunchClamp)
{
toReturn.Add(vessel[part]);
}
}
}
return(toReturn);
}
private void PartInitializeSuffixes()
{
AddSuffix("CONTROLFROM", new NoArgsVoidSuffix(ControlFrom));
AddSuffix("NAME", new Suffix <StringValue>(() => Part.name));
AddSuffix("FUELCROSSFEED", new Suffix <BooleanValue>(() => Part.fuelCrossFeed));
AddSuffix("TITLE", new Suffix <StringValue>(() => Part.partInfo.title));
AddSuffix("STAGE", new Suffix <ScalarValue>(() => Part.inverseStage));
AddSuffix("CID", new Suffix <StringValue>(() => Part.craftID.ToString()));
AddSuffix("UID", new Suffix <StringValue>(() => Part.flightID.ToString()));
AddSuffix("ROTATION", new Suffix <Direction>(() => new Direction(Part.transform.rotation)));
AddSuffix("POSITION", new Suffix <Vector>(() => GetPosition()));
AddSuffix("TAG", new SetSuffix <StringValue>(GetTagName, SetTagName));
AddSuffix("FACING", new Suffix <Direction>(() => GetFacing()));
AddSuffix("BOUNDS", new Suffix <BoundsValue>(GetBoundsValue));
AddSuffix("RESOURCES", new Suffix <ListValue>(() => GatherResources(Part)));
AddSuffix("TARGETABLE", new Suffix <BooleanValue>(() => Part.Modules.OfType <ITargetable>().Any()));
AddSuffix("SHIP", new Suffix <VesselTarget>(() => VesselTarget.CreateOrGetExisting(Part.vessel, Shared)));
AddSuffix("HASMODULE", new OneArgsSuffix <BooleanValue, StringValue>(HasModule));
AddSuffix("GETMODULE", new OneArgsSuffix <PartModuleFields, StringValue>(GetModule));
AddSuffix("GETMODULEBYINDEX", new OneArgsSuffix <PartModuleFields, ScalarValue>(GetModuleIndex));
AddSuffix(new[] { "MODULES", "ALLMODULES" }, new Suffix <ListValue>(GetAllModules, "A List of all the modules' names on this part"));
AddSuffix("PARENT", new Suffix <Structure>(() => ParentValue, "The parent part of this part"));
AddSuffix(new[] { "DECOUPLER", "SEPARATOR" }, new Suffix <Structure>(() => DecouplerValue, "The part that will decouple/separate this part when activated"));
AddSuffix(new[] { "DECOUPLEDIN", "SEPARATEDIN" }, new Suffix <ScalarValue>(() => DecoupledIn));
AddSuffix("HASPARENT", new Suffix <BooleanValue>(() => Part.parent != null, "Tells you if this part has a parent, is used to avoid null exception from PARENT"));
AddSuffix("CHILDREN", new Suffix <ListValue <PartValue> >(() => PartValueFactory.ConstructGeneric(Part.children, Shared), "A LIST() of the children parts of this part"));
AddSuffix("DRYMASS", new Suffix <ScalarValue>(() => Part.GetDryMass(), "The Part's mass when empty"));
AddSuffix("MASS", new Suffix <ScalarValue>(() => Part.CalculateCurrentMass(), "The Part's current mass"));
AddSuffix("WETMASS", new Suffix <ScalarValue>(() => Part.GetWetMass(), "The Part's mass when full"));
AddSuffix("HASPHYSICS", new Suffix <BooleanValue>(() => Part.HasPhysics(), "Is this a strange 'massless' part"));
}
public override void Execute(SharedObjects shared)
{
string listType = PopValueAssert(shared).ToString();
var list = new ListValue();
switch (listType)
{
case "bodies":
foreach (CelestialBody cBody in FlightGlobals.fetch.bodies)
{
list.Add(BodyTarget.CreateOrGetExisting(cBody, shared));
}
break;
case "targets":
foreach (var vessel in FlightGlobals.Vessels)
{
if (vessel == shared.Vessel)
{
continue;
}
list.Add(VesselTarget.CreateOrGetExisting(vessel, shared));
}
break;
case "resources":
case "parts":
case "engines":
case "sensors":
case "elements":
case "dockingports":
list = shared.Vessel.PartList(listType, shared);
break;
case "files":
list = ListValue.CreateList(shared.VolumeMgr.CurrentDirectory.ListAsLexicon().Values.ToList());
break;
case "volumes":
list = ListValue.CreateList(shared.VolumeMgr.Volumes.Values.ToList());
break;
case "processors":
list = ListValue.CreateList(shared.ProcessorMgr.processors.Values.ToList().Select(processor => PartModuleFieldsFactory.Construct(processor, shared)));
break;
case "fonts":
foreach (Font f in Resources.FindObjectsOfTypeAll <Font>())
{
list.Add(new StringValue(f.name));
}
break;
default:
throw new ArgumentOutOfRangeException();
}
AssertArgBottomAndConsume(shared);
ReturnValue = list;
}
public override void Execute(SharedObjects shared)
{
string vesselName = PopValueAssert(shared).ToString();
AssertArgBottomAndConsume(shared);
var result = VesselTarget.CreateOrGetExisting(VesselUtils.GetVesselByName(vesselName, shared.Vessel), shared);
ReturnValue = result;
}
private PartValue GetPart()
{
var p = servo.HostPart;
if (!p)
{
shared.Logger.LogError("Cannot find Infernal Robotics part with UID: " + servo.UID);
}
return(p != null?VesselTarget.CreateOrGetExisting(shared)[p] : null);
}
public Structure GetVesselTarget()
{
Vessel vessel = GetVessel();
if (vessel == null)
{
return(new BooleanValue(false));
}
return(VesselTarget.CreateOrGetExisting(vessel, shared));
}
public void SendToSwitchVesselNotifyees(Vessel fromVes, Vessel toVes)
{
UniqueSetValue <UserDelegate> notifyees = GetSwitchVesselNotifyees();
foreach (UserDelegate del in notifyees)
{
if (UserDelgateIsAcceptable(del))
{
Shared.Cpu.AddTrigger(del, VesselTarget.CreateOrGetExisting(fromVes, Shared), VesselTarget.CreateOrGetExisting(toVes, Shared));
}
}
}
public VesselTarget GetVessel()
{
if (IRWrapper.APIReady)
{
//IF IR version is 0.21.4 or below IR API may return null, but it also means that IR API only returns groups for ActiveVessel
//so returning the ActiveVessel should work
return(cg.Vessel != null?VesselTarget.CreateOrGetExisting(cg.Vessel, shared) : VesselTarget.CreateOrGetExisting(FlightGlobals.ActiveVessel, shared));
}
else
{
return(VesselTarget.CreateOrGetExisting(shared.Vessel, shared)); //user should not be able to get here anyway, but to avoid null will return shared.Vessel
}
}
public static ListValue PartsToList(IEnumerable <global::Part> parts, SharedObjects sharedObj)
{
var toReturn = new ListValue();
var vessel = VesselTarget.CreateOrGetExisting(sharedObj);
foreach (var part in parts)
{
if (part.Modules.Contains <ModuleEnviroSensor>())
{
toReturn.Add(vessel[part]);
}
}
return(toReturn);
}
public void PushMessage(Structure content)
{
if (content is MessageStructure)
{
MessageStructure m = content as MessageStructure;
messageQueue.Push(m.Message);
}
else
{
double sentAt = Planetarium.GetUniversalTime();
messageQueue.Push(Message.Create(content, sentAt, sentAt, VesselTarget.CreateOrGetExisting(sharedObjects.Vessel, sharedObjects),
sharedObjects.Processor.Tag));
}
}
protected new Structure GetKSPFieldValue(StringValue suffixName)
{
if (Equals(suffixName, new StringValue(RTTargetField)))
{
var api = RemoteTechHook.Instance;
Guid guid = api.GetAntennaTarget(partModule.part);
if (guid.Equals(api.GetNoTargetGuid()))
{
return(new StringValue(NoTargetString));
}
else if (guid.Equals(api.GetActiveVesselGuid()))
{
return(new StringValue(ActiveVesselString));
}
else
{
IEnumerable <string> groundStations = api.GetGroundStations();
foreach (var groundStation in groundStations)
{
if (guid.Equals(api.GetGroundStationGuid(groundStation)))
{
return(new StringValue(groundStation));
}
}
}
foreach (var body in FlightGlobals.Bodies)
{
if (api.GetCelestialBodyGuid(body).Equals(guid))
{
return(BodyTarget.CreateOrGetExisting(body, shared));
}
}
foreach (var vessel in FlightGlobals.Vessels)
{
if (vessel.id.Equals(guid))
{
return(VesselTarget.CreateOrGetExisting(vessel, shared));
}
}
// just print the guid if we can't figure out what it is
return(new StringValue(guid.ToString()));
}
return(base.GetKSPFieldValue(suffixName));
}
public override void AddTo(SharedObjects shared)
{
shared.BindingMgr.AddGetter("ALT", () => new VesselAlt(shared));
shared.BindingMgr.AddGetter("ANGULARVELOCITY", () => shared.Vessel.transform.InverseTransformDirection(shared.Vessel.GetComponent <Rigidbody>().angularVelocity));
shared.BindingMgr.AddGetter("ENCOUNTER", () => VesselUtils.TryGetEncounter(shared.Vessel, shared));
shared.BindingMgr.AddGetter("ETA", () => new VesselEta(shared));
shared.BindingMgr.AddGetter("MISSIONTIME", () => shared.Vessel.missionTime);
shared.BindingMgr.AddGetter(new [] { "OBT", "ORBIT" }, () => new OrbitInfo(shared.Vessel.orbit, shared));
// Note: "TIME" is both a bound variable AND a built-in function now.
// While it would be cleaner to make it JUST a built -in function,
// the bound variable had to be retained for backward compatibility with scripts
// that call TIME without parentheses:
shared.BindingMgr.AddGetter("TIME", () => new TimeSpan(Planetarium.GetUniversalTime()));
shared.BindingMgr.AddGetter("ACTIVESHIP", () => VesselTarget.CreateOrGetExisting(FlightGlobals.ActiveVessel, shared));
shared.BindingMgr.AddGetter("STATUS", () => shared.Vessel.situation.ToString());
shared.BindingMgr.AddGetter("STAGE", () => shared.VesselTarget.StageValues);
shared.BindingMgr.AddSetter("SHIPNAME", value => shared.Vessel.vesselName = value.ToString());
shared.BindingMgr.AddGetter("STEERINGMANAGER", () => (SteeringManager)kOSVesselModule.GetInstance(shared.Vessel).GetFlightControlParameter("steering"));
shared.BindingMgr.AddGetter("NEXTNODE", () =>
{
var vessel = shared.Vessel;
if (vessel.patchedConicSolver == null)
{
throw new KOSSituationallyInvalidException(
"A KSP limitation makes it impossible to access the maneuver nodes of this vessel at this time. " +
"(perhaps it's not the active vessel?)");
}
if (vessel.patchedConicSolver.maneuverNodes.Count == 0)
{
throw new KOSSituationallyInvalidException("No maneuver nodes present!");
}
return(Node.FromExisting(vessel, vessel.patchedConicSolver.maneuverNodes[0], shared));
});
shared.BindingMgr.AddGetter("HASNODE", () =>
{
var vessel = shared.Vessel;
if (vessel.patchedConicSolver == null)
{
return(false); // Since there is no solver, there can be no node.
}
return(vessel.patchedConicSolver.maneuverNodes.Count > 0);
});
shared.BindingMgr.AddGetter("ALLNODES", () => GetAllNodes(shared));
}
protected override BooleanValue SendMessage(Structure content)
{
if (!Connected)
{
return(false);
}
MessageQueueStructure queue = InterVesselManager.Instance.GetQueue(vessel, shared);
double sentAt = Planetarium.GetUniversalTime();
double receivedAt = sentAt + Delay;
queue.Push(Message.Create(content, sentAt, receivedAt, VesselTarget.CreateOrGetExisting(shared), shared.Processor.Tag));
return(true);
}
public static ListValue PartsToList(IEnumerable <global::Part> parts, SharedObjects sharedObj)
{
var toReturn = new ListValue();
var vessel = VesselTarget.CreateOrGetExisting(sharedObj);
foreach (var part in parts)
{
foreach (var module in part.Modules)
{
if (module is IEngineStatus)
{
toReturn.Add(vessel[part]);
}
}
}
return(toReturn);
}
private kList GetTargetList(SharedObjects shared)
{
var list = new kList();
list.AddColumn("Vessel Name", 25, ColumnAlignment.Left);
list.AddColumn("Distance", 12, ColumnAlignment.Right, "0.0");
foreach (Vessel vessel in FlightGlobals.Vessels)
{
if (vessel == shared.Vessel)
{
continue;
}
var vT = VesselTarget.CreateOrGetExisting(vessel, shared);
list.AddItem(vT.Vessel.vesselName, vT.GetDistance());
}
return(list);
}
private Structure GetCameraTarget()
{
var cam = FlightCamera.fetch;
switch (cam.targetMode)
{
case FlightCamera.TargetMode.Vessel:
return(VesselTarget.CreateOrGetExisting(cam.vesselTarget, shared));
case FlightCamera.TargetMode.Part:
return(Suffixed.Part.PartValueFactory.Construct(cam.partTarget, shared));
case FlightCamera.TargetMode.Transform:
throw new KOSException("Flight camera has target set to transform. This is currently not supported.");
case FlightCamera.TargetMode.None:
default:
throw new KOSException("Flight camera has no target set. This should not ever happen, unless KSP changes their API.");
}
}
public override void Update()
{
base.Update();
if (ship == null)
{
ship = VesselTarget.CreateOrGetExisting(sharedObj);
ship.LinkCount++;
}
else if (ship.Vessel == null)
{
ship.LinkCount--;
ship = VesselTarget.CreateOrGetExisting(sharedObj);
ship.LinkCount++;
}
else if (!ship.Vessel.id.Equals(sharedObj.Vessel.id))
{
ship.LinkCount--;
ship = VesselTarget.CreateOrGetExisting(sharedObj);
ship.LinkCount++;
}
}
public PartValue GetPartner()
{
var otherNode = module.otherNode;
if (otherNode == null)
{
return(null);
}
var otherVessel = VesselTarget.CreateOrGetExisting(otherNode.vessel, Shared);
foreach (var part in otherVessel.Parts)
{
if (part.Part == otherNode.part)
{
return(part);
}
}
throw new Safe.Exceptions.KOSException("The docking port indicated that it was connected to another docking port, but that port could not be found. Tried to find: " + otherNode.GetModuleDisplayName());
}
public override void AddTo(SharedObjects shared)
{
sharedObj = shared;
shared.BindingMgr.AddGetter("CORE", () => new Core((kOSProcessor)shared.Processor, shared));
shared.BindingMgr.AddGetter("SHIP", () => ship);
// These are now considered shortcuts to SHIP:suffix
foreach (var scName in VesselTarget.ShortCuttableShipSuffixes)
{
shared.BindingMgr.AddGetter(scName, () => VesselShortcutGetter(scName));
}
shared.BindingMgr.AddSetter("TARGET", val =>
{
if (shared.Vessel != FlightGlobals.ActiveVessel)
{
throw new kOS.Safe.Exceptions.KOSSituationallyInvalidException("TARGET can only be set for the Active Vessel");
}
var targetable = val as IKOSTargetable;
if (targetable != null)
{
VesselUtils.SetTarget(targetable, shared.Vessel);
return;
}
if (!string.IsNullOrEmpty(val.ToString().Trim()))
{
var body = VesselUtils.GetBodyByName(val.ToString());
if (body != null)
{
VesselUtils.SetTarget(body, shared.Vessel);
return;
}
var vessel = VesselUtils.GetVesselByName(val.ToString(), shared.Vessel);
if (vessel != null)
{
VesselUtils.SetTarget(vessel, shared.Vessel);
return;
}
}
//Target not found, if we have a target we clear it
VesselUtils.UnsetTarget();
});
shared.BindingMgr.AddGetter("TARGET", () =>
{
var target = (shared.Vessel == FlightGlobals.ActiveVessel) ? FlightGlobals.fetch.VesselTarget : shared.Vessel.targetObject;
var vessel = target as Vessel;
if (vessel != null)
{
return(VesselTarget.CreateOrGetExisting(vessel, shared));
}
var body = target as CelestialBody;
if (body != null)
{
return(BodyTarget.CreateOrGetExisting(body, shared));
}
var dockingNode = target as ModuleDockingNode;
if (dockingNode != null)
{
return(VesselTarget.CreateOrGetExisting(dockingNode.vessel, shared)[dockingNode.part]);
}
throw new kOS.Safe.Exceptions.KOSSituationallyInvalidException("No TARGET is selected");
});
shared.BindingMgr.AddGetter("HASTARGET", () =>
{
// the ship has a target if the object does not equal null.
return((shared.Vessel == FlightGlobals.ActiveVessel ?
FlightGlobals.fetch.VesselTarget : shared.Vessel.targetObject) != null);
});
}
public void Send(Structure content)
{
double sentAt = Planetarium.GetUniversalTime();
Messages.Push(Message.Create(content, sentAt, sentAt, VesselTarget.CreateOrGetExisting(shared), Tag));
}
public static PartValue Construct(global::Part part, SharedObjects shared)
{
return(VesselTarget.CreateOrGetExisting(part.vessel, shared)[part]);
}
private PartValue GetPart()
{
var p = servo.part;
return(p != null?VesselTarget.CreateOrGetExisting(shared)[p] : null);
}
public void SendToSwitchVesselNotifyees(Vessel fromVes, Vessel toVes)
{
UniqueSetValue <UserDelegate> notifyees = GetSwitchVesselNotifyees();
foreach (UserDelegate del in notifyees)
{
if (UserDelgateIsAcceptable(del))
{
Shared.Cpu.AddTrigger(del, InterruptPriority.CallbackOnce, Shared.Cpu.NextTriggerInstanceId, false, VesselTarget.CreateOrGetExisting(fromVes, Shared), VesselTarget.CreateOrGetExisting(toVes, Shared));
}
}
}
private BooleanValue SendImmediate(VesselTarget target, Structure content)
{
double sentAt = Planetarium.GetUniversalTime();
double receivedAt = sentAt;
Message message = Message.Create(content, sentAt, receivedAt, VesselTarget.CreateOrGetExisting(shared), shared.Processor.Tag);
MessageQueueStructure queue = InterVesselManager.Instance.GetQueue(target.Vessel, shared);
queue.Push(message);
return(true);
}
protected override Structure Destination()
{
return(VesselTarget.CreateOrGetExisting(vessel, shared));
}
public Vector GetPosition()
{
Vector3d positionError = VesselTarget.CreateOrGetExisting(Part.vessel, Shared).GetPositionError();
return(new Vector(Part.transform.position - Shared.Vessel.CoMD + positionError));
}