private ListValue GetPartServos(PartValue pv)
{
var list = new ListValue();
if (!IRWrapper.APIReady)
{
throw new KOSUnavailableAddonException("IR:PARTSERVOS", "Infernal Robotics");
}
var controlGroups = IRWrapper.IRController.ServoGroups;
if (controlGroups == null)
{
//Control Groups are somehow null, just return the empty list
return(list);
}
foreach (IRWrapper.IControlGroup cg in controlGroups)
{
if (cg.Servos == null || (cg.Vessel != null && cg.Vessel != shared.Vessel))
{
continue;
}
foreach (IRWrapper.IServo s in cg.Servos)
{
if (s.UID == pv.Part.craftID)
{
list.Add(new IRServoWrapper(s, shared));
}
}
}
return(list);
}
public static ListValue PartList(this IShipconstruct vessel, string partType, SharedObjects sharedObj)
{
var list = new ListValue();
var partList = vessel.Parts.ToList();
switch (partType.ToUpper())
{
case "RESOURCES":
list = ResourceValue.PartsToList(partList);
break;
case "PARTS":
list = PartValue.PartsToList(partList, sharedObj);
break;
case "ENGINES":
list = EngineValue.PartsToList(partList, sharedObj);
break;
case "SENSORS":
list = SensorValue.PartsToList(partList, sharedObj);
break;
case "ELEMENTS":
list = ElementValue.PartsToList(partList);
break;
case "DOCKINGPORTS":
list = DockingPortValue.PartsToList(partList, sharedObj);
break;
}
return(list);
}
public PistonValue(ModuleRoboticServoPiston init, SharedObjects shared)
{
servo = init;
this.shared = shared;
part = GetPart();
InitializeSuffixes();
}
public ServoValue(ModuleRoboticRotationServo init, SharedObjects shared)
{
servo = init;
this.shared = shared;
part = GetPart();
InitializeSuffixes();
}
public RotorValue(ModuleRoboticServoRotor init, SharedObjects shared)
{
rotor = init;
this.shared = shared;
part = GetPart();
InitializeSuffixes();
}
public IRServoWrapper(IRWrapper.IServo init, SharedObjects shared)
{
servo = init;
this.shared = shared;
this.partValue = GetPart();
InitializeSuffixes();
}
private ElementValue GetEelement()
{
var elList = shared.KSPPart.vessel.PartList("elements", shared);
var part = new PartValue(shared.KSPPart, shared);
return(elList.Cast <ElementValue>().FirstOrDefault(el => el.Parts.Contains(part)));
}
private void HighlightPart(PartValue partValue)
{
var part = partValue.Part;
part.highlightColor = color.Color;
part.highlightType = Part.HighlightType.AlwaysOn;
part.SetHighlight(enabled, false);
}
private ScalarValue GetPartRunTime(PartValue part)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(part);
if (coreMod != null)
{
return(coreMod.GetOperatingTime());
}
return(-1f);
}
private static BooleanValue RTAntennaHasConnection(PartValue part)
{
bool result = false;
if (RemoteTechHook.IsAvailable(part.Part.vessel.id))
{
result = RemoteTechHook.Instance.AntennaHasConnection(part.Part);
}
return result;
}
private void InvalidateParts()
{
StageValues.stale = true;
rootPart = null;
nextDecoupler = null;
allParts = null;
dockingPorts = null;
decouplers = null;
partCache = null;
}
private BooleanValue GetPartFailed(PartValue part)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(part);
if (coreMod != null)
{
Int32 partFailed = coreMod.GetPartStatus();
return(partFailed > 0);
}
return(false);
}
private TestFlightCore.TestFlightCore GetCoreModule(PartValue part)
{
foreach (var module in part.Part.Modules)
{
if (module is TestFlightCore.TestFlightCore)
{
return(module as TestFlightCore.TestFlightCore);
}
}
return(null);
}
private static BooleanValue RTAntennaHasConnection(PartValue part)
{
bool result = false;
if (RemoteTechHook.IsAvailable(part.Part.vessel.id))
{
result = RemoteTechHook.Instance.AntennaHasConnection(part.Part);
}
return(result);
}
private ScalarValue GetPartMTBF(PartValue part)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(part);
if (coreMod != null)
{
double currentFailRate = coreMod.GetBaseFailureRate();
return(TestFlightAPI.TestFlightUtil.FailureRateToMTBF(currentFailRate, TestFlightUtil.MTBFUnits.SECONDS));
}
return(-1f);
}
private ScalarValue GetPartFailureRate(PartValue part)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(part);
if (coreMod != null)
{
double currentFailRate = coreMod.GetBaseFailureRate();
return(currentFailRate);
}
return(-1f);
}
private ScalarValue GetPartReliability(PartValue part, ScalarValue time)
{
TestFlightCore.TestFlightCore coreMod = GetCoreModule(part);
if (coreMod != null)
{
double currentFailRate = coreMod.GetBaseFailureRate();
return(TestFlightAPI.TestFlightUtil.FailureRateToReliability(currentFailRate, time));
}
return(-1f);
}
private static BooleanValue RTAntennaHasConnection(PartValue part)
{
bool result = false;
// IsAvailable(Id) is only able to return True on loaded vessels, but this
// is a test for a specific PART on a vessel, and individual parts on
// vessels don't exist when the vessel is unloaded anyway.
if (RemoteTechHook.IsAvailable(part.Part.vessel.id))
{
result = RemoteTechHook.Instance.AntennaHasConnection(part.Part);
}
return(result);
}
private void ConstructParts()
{
rootPart = null;
nextDecoupler = null;
allParts = new ListValue <PartValue>();
dockingPorts = new ListValue <DockingPortValue>();
decouplers = new ListValue <DecouplerValue>();
partCache = new Dictionary <global::Part, PartValue>();
ConstructPart(Vessel.rootPart, null, null);
allParts.IsReadOnly = true;
dockingPorts.IsReadOnly = true;
decouplers.IsReadOnly = true;
}
private ScalarValue GetPartRatedBurnTime(PartValue part)
{
foreach (var module in part.Part.Modules)
{
var relMod = module as TestFlightReliabilityBase;
if (relMod != null)
{
double ratedBurnTime = relMod.GetRatedBurnTime();
if (ratedBurnTime > 0)
{
return(ratedBurnTime);
}
}
}
return(-1f);
}
public BoundsValue GetBoundsValue()
{
Direction myFacing = VesselUtils.GetFacing(Vessel);
Quaternion inverseMyFacing = myFacing.Rotation.Inverse();
Vector rootOrigin = Parts[0].GetPosition();
Bounds unionBounds = new Bounds();
for (int pNum = 0; pNum < Parts.Count; ++pNum)
{
PartValue p = Parts[pNum];
Vector partOriginOffsetInVesselBounds = p.GetPosition() - rootOrigin;
Bounds b = p.GetBoundsValue().GetUnityBounds();
Vector partCenter = new Vector(b.center);
// Just like the logic for the part needing all 8 corners of the mesh's bounds,
// this needs all 8 corners of the part bounds:
for (int signX = -1; signX <= 1; signX += 2)
{
for (int signY = -1; signY <= 1; signY += 2)
{
for (int signZ = -1; signZ <= 1; signZ += 2)
{
Vector corner = partCenter + new Vector(signX * b.extents.x, signY * b.extents.y, signZ * b.extents.z);
Vector worldCorner = partOriginOffsetInVesselBounds + p.GetFacing() * corner;
Vector3 vesselCorner = inverseMyFacing * worldCorner.ToVector3();
unionBounds.Encapsulate(vesselCorner);
}
}
}
}
Vector min = new Vector(unionBounds.min);
Vector max = new Vector(unionBounds.max);
// The above operation is expensive and should force the CPU to do a WAIT 0:
Shared.Cpu.YieldProgram(new YieldFinishedNextTick());
return(new BoundsValue(min, max, delegate { return Parts[0].GetPosition(); }, delegate { return VesselUtils.GetFacing(Vessel); }, Shared));
}
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler)
{
if (part.State == PartStates.DEAD || part.transform == null)
{
return;
}
// Modules can be in any order, so to enforce some sort of priority for parts which are multiple types,
// gather all potential modules and then select from those valid.
IEngineStatus engine = null;
ModuleRCS rcs = null;
PartValue separator = null;
ModuleEnviroSensor sensor = null;
foreach (var module in part.Modules)
{
if (module is IEngineStatus)
{
engine = module as IEngineStatus;
}
else if (module is ModuleRCS)
{
rcs = module as ModuleRCS;
}
else if (module is IStageSeparator)
{
var dock = module as ModuleDockingNode;
if (dock != null)
{
var port = new DockingPortValue(Shared, part, parent, decoupler, dock);
separator = port;
dockingPorts.Add(port);
if (!module.StagingEnabled())
{
continue;
}
decoupler = port;
decouplers.Add(decoupler);
}
// ignore anything with staging disabled and continue the search
// this can e.g. be heat shield or some sensor with integrated decoupler
else
{
if (!module.StagingEnabled())
{
continue;
}
if (module is LaunchClamp)
{
separator = decoupler = new LaunchClampValue(Shared, part, parent, decoupler);
}
else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler)
{
separator = decoupler = new DecouplerValue(Shared, part, parent, decoupler);
}
else // ModuleServiceModule ?
{
continue; // rather continue the search
}
decouplers.Add(decoupler);
}
// ignore leftover decouplers
if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage)
{
continue;
}
// check if we just created closer decoupler (see StageValues.CreatePartSet)
if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage)
{
nextDecoupler = decoupler;
}
}
else if (module is ModuleEnviroSensor)
{
sensor = module as ModuleEnviroSensor;
}
}
// Select part value in priority order
PartValue self;
if (engine != null)
{
self = new EngineValue(Shared, part, parent, decoupler);
}
else if (rcs != null)
{
self = new RCSValue(Shared, part, parent, decoupler, rcs);
}
else if (separator != null)
{
self = separator;
}
else if (sensor != null)
{
self = new SensorValue(Shared, part, parent, decoupler, sensor);
}
else
{
self = new PartValue(Shared, part, parent, decoupler);
}
if (rootPart == null)
{
rootPart = self;
}
partCache[part] = self;
allParts.Add(self);
foreach (var child in part.children)
{
ConstructPart(child, self, decoupler);
}
self.Children.IsReadOnly = true;
}
private ElementValue GetEelement()
{
var elList = shared.KSPPart.vessel.PartList("elements", shared);
var part = new PartValue(shared.KSPPart, shared);
return elList.Cast<ElementValue>().FirstOrDefault(el => el.Parts.Contains(part));
}
private void HighlightPart(PartValue partValue)
{
var part = partValue.Part;
part.highlightColor = color.Color;
part.highlightType = Part.HighlightType.AlwaysOn;
part.SetHighlight(enabled, false);
}
private PistonValue GetPiston(PartValue part)
{
return(new PistonValue(part.Part.FindModuleImplementing <ModuleRoboticServoPiston>(), shared));
}
private HingeValue GetHinge(PartValue part)
{
return(new HingeValue(part.Part.FindModuleImplementing <ModuleRoboticServoHinge>(), shared));
}
private ServoValue GetServo(PartValue part)
{
return(new ServoValue(part.Part.FindModuleImplementing <ModuleRoboticRotationServo>(), shared));
}
private RotorValue GetRotor(PartValue part)
{
return(new RotorValue(part.Part.FindModuleImplementing <ModuleRoboticServoRotor>(), shared));
}
private void ConstructPart(global::Part part, PartValue parent, DecouplerValue decoupler)
{
if (part.State == PartStates.DEAD || part.transform == null)
{
return;
}
PartValue self = null;
foreach (var module in part.Modules)
{
var engine = module as IEngineStatus;
if (engine != null)
{
self = new EngineValue(Shared, part, parent, decoupler);
break;
}
if (module is IStageSeparator)
{
var dock = module as ModuleDockingNode;
if (dock != null)
{
var port = new DockingPortValue(Shared, part, parent, decoupler, dock);
self = port;
dockingPorts.Add(port);
if (!module.StagingEnabled())
{
break;
}
decoupler = port;
decouplers.Add(decoupler);
}
else
{
// ignore anything with staging disabled and continue the search
// this can e.g. be heat shield or some sensor with integrated decoupler
if (!module.StagingEnabled())
{
continue;
}
if (module is LaunchClamp)
{
self = decoupler = new LaunchClampValue(Shared, part, parent, decoupler);
}
else if (module is ModuleDecouple || module is ModuleAnchoredDecoupler)
{
self = decoupler = new DecouplerValue(Shared, part, parent, decoupler);
}
else // ModuleServiceModule ?
{
continue; // rather continue the search
}
decouplers.Add(decoupler);
}
// ignore leftover decouplers
if (decoupler == null || decoupler.Part.inverseStage >= StageManager.CurrentStage)
{
break;
}
// check if we just created closer decoupler (see StageValues.CreatePartSet)
if (nextDecoupler == null || decoupler.Part.inverseStage > nextDecoupler.Part.inverseStage)
{
nextDecoupler = decoupler;
}
break;
}
var sensor = module as ModuleEnviroSensor;
if (sensor != null)
{
self = new SensorValue(Shared, part, parent, decoupler, sensor);
break;
}
}
if (self == null)
{
self = new PartValue(Shared, part, parent, decoupler);
}
if (rootPart == null)
{
rootPart = self;
}
partCache[part] = self;
allParts.Add(self);
foreach (var child in part.children)
{
ConstructPart(child, self, decoupler);
}
self.Children.IsReadOnly = true;
}
