public override void Execute(SharedObjects shared)
{
string vesselName = shared.Cpu.PopValue().ToString();
VesselTarget result = new VesselTarget(VesselUtils.GetVesselByName(vesselName, shared.Vessel), shared.Vessel);
shared.Cpu.PushStack(result);
}
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 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 Guid GetTargetGuid(object target)
{
if (target is String)
{
String targetString = (String)target;
if (targetString.Equals(NoTargetString, StringComparison.InvariantCultureIgnoreCase))
{
return(new Guid(NoTargetGuid));
}
else if (targetString.Equals(ActiveVesselString, StringComparison.InvariantCultureIgnoreCase))
{
return(new Guid(ActiveVesselGuid));
}
else if (targetString.Equals(MissionControlString, StringComparison.InvariantCultureIgnoreCase))
{
return(new Guid(MissionControlGuid));
}
else
{
var body = FlightGlobals.Bodies.Where(b => b.bodyName.Equals(targetString, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
if (body != null)
{
return(CelestialBodyGuid(body));
}
else
{
var vessel = FlightGlobals.Vessels.Where(v => v.vesselName.Equals(targetString, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
if (vessel != null)
{
if (partModule.vessel.id.Equals(vessel.id))
{
throw new KOSInvalidFieldValueException("Current vessel can't be the target");
}
return(vessel.id);
}
}
}
}
else if (target is BodyTarget)
{
BodyTarget targetBody = (BodyTarget)target;
return(CelestialBodyGuid(targetBody.Body));
}
else if (target is VesselTarget)
{
VesselTarget targetVessel = (VesselTarget)target;
if (partModule.vessel.id.Equals(targetVessel.Vessel.id))
{
throw new KOSInvalidFieldValueException("Current vessel can't be the target");
}
return(targetVessel.Vessel.id);
}
throw new KOSInvalidFieldValueException("'" + NoTargetString + "', '" + ActiveVesselString + "', '" + MissionControlString +
"', Body or Vessel expected");
}
private void RecoverVessel(VesselTarget vessel)
{
if (!vessel.Vessel.IsRecoverable)
{
throw new kOS.Safe.Exceptions.KOSException("Vessel is not recoverable");
}
VesselRecovery.Recover(vessel.Vessel);
}
public void ThrowIfNotCPUVessel()
{
VesselTarget vt = GetVessel();
if (vt.Vessel.id != shared.Vessel.id)
{
throw new KOSWrongCPUVesselException();
}
}
public override void Execute(SharedObjects shared)
{
string vesselName = PopValueAssert(shared).ToString();
AssertArgBottomAndConsume(shared);
var result = new VesselTarget(VesselUtils.GetVesselByName(vesselName, shared.Vessel), shared);
ReturnValue = result;
}
public object VesselShortcutGetter(SharedObjects shared, string name)
{
ISuffixResult suffix = new VesselTarget(shared).GetSuffix(name);
if (!suffix.HasValue)
{
suffix.Invoke(shared.Cpu);
}
return(suffix.Value);
}
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);
}
private static ScalarValue RTGetDelay(VesselTarget tgtVessel)
{
double waitTotal = 0;
if (RemoteTechHook.IsAvailable())
{
waitTotal = RemoteTechHook.Instance.GetShortestSignalDelay(tgtVessel.Vessel.id);
}
return(Double.IsPositiveInfinity(waitTotal) ? -1 : waitTotal);
}
private static double RTGetKSCDelay(VesselTarget tgtVessel)
{
double waitTotal = 0;
if (RemoteTechHook.IsAvailable(tgtVessel.Vessel.id) && tgtVessel.Vessel.GetVesselCrew().Count == 0)
{
waitTotal = RemoteTechHook.Instance.GetSignalDelayToKSC(tgtVessel.Vessel.id);
}
return(waitTotal);
}
private static ScalarValue RTGetKSCDelay(VesselTarget tgtVessel)
{
double waitTotal = 0;
if (RemoteTechHook.IsAvailable() && tgtVessel.Vessel.GetVesselCrew().Count == 0)
{
waitTotal = RemoteTechHook.Instance.GetSignalDelayToKSC(tgtVessel.Vessel.id);
}
return(Double.IsPositiveInfinity(waitTotal) ? -1 : waitTotal);
}
public Structure GetVesselTarget()
{
Vessel vessel = GetVessel();
if (vessel == null)
{
return(new BooleanValue(false));
}
return(VesselTarget.CreateOrGetExisting(vessel, shared));
}
private static BooleanValue RTHasConnection(VesselTarget tgtVessel)
{
bool result = false;
if (RemoteTechHook.IsAvailable(tgtVessel.Vessel.id))
{
result = RemoteTechHook.Instance.HasAnyConnection(tgtVessel.Vessel.id);
}
return(result);
}
private static bool RTHasLocalControl(VesselTarget tgtVessel)
{
bool result = false;
if (RemoteTechHook.IsAvailable(tgtVessel.Vessel.id))
{
result = RemoteTechHook.Instance.HasLocalControl(tgtVessel.Vessel.id);
}
return(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);
}
private static bool RTHasKSCConnection(VesselTarget tgtVessel)
{
bool result = false;
if (RemoteTechHook.IsAvailable(tgtVessel.Vessel.id))
{
result = RemoteTechHook.Instance.HasConnectionToKSC(tgtVessel.Vessel.id);
}
return(result);
}
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);
}
//private void Engage(VesselTarget vessel)
//{
// predictors.Add(new KeyValuePair<Guid, Class1>(vessel.Vessel.id, new Class1(vessel.Vessel)));
// isEngaged = true;
//}
//private void Disengage(VesselTarget vessel)
//{
// predictors.Find(kv => kv.Key == vessel.Vessel.id).Value.StopThread();
// predictors.Remove(new KeyValuePair<Guid, Class1>(vessel.Vessel.id, new Class1(vessel.Vessel)));
// isEngaged = false;
//}
public Vector3?GetImpactPosition(VesselTarget vessel)
{
Class1 pr = new Class1(vessel.Vessel);
pr.ComputeTrajectory(vessel.Vessel, DescentProfile.fetch);
foreach (Patch patch in pr.Patches)
{
if (patch.ImpactPosition != null)
{
return(patch.ImpactPosition);
}
}
return(null);
}
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);
}
private GeoCoordinates ImpactPos(VesselTarget vessel)
{
//Class1 pr = new Class1(vessel.Vessel);
//if(!isEngaged)
// throw new KOSException("please use engage");
CelestialBody body = vessel.Vessel.orbit.referenceBody;
Vector3? impactVect = GetImpactPosition(vessel);
if (impactVect != null)
{
var worldImpactPos = (Vector3d)impactVect + body.position;
var lat = body.GetLatitude(worldImpactPos);
var lng = DegreeFix(body.GetLongitude(worldImpactPos), -180);
return(new GeoCoordinates(vessel.Shared, lat, lng));
}
throw new KOSException("Impact position is null");
}
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)
{
var vT = new VesselTarget(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.");
}
}
