public override void Execute(SharedObjects shared) { if (shared.Cpu != null) { shared.Cpu.RunProgram(Program); } }
public IRServoWrapper(IRWrapper.IServo init, SharedObjects shared) { servo = init; this.shared = shared; this.partValue = GetPart(); InitializeSuffixes(); }
public StageValues(SharedObjects shared) { this.shared = shared; partSet = new PartSet(partHash); InitializeSuffixes(); }
public override void Execute(SharedObjects shared) { double degrees = GetDouble(shared.Cpu.PopValue()); double radians = DegreesToRadians(degrees); double result = Math.Cos(radians); shared.Cpu.PushStack(result); }
public override void AddTo(SharedObjects shared) { Shared = shared; if (Shared.Vessel == null) { SafeHouse.Logger.LogWarning("FlightControlManager.AddTo Skipped: shared.Vessel== null"); return; } if (Shared.Vessel.rootPart == null) { SafeHouse.Logger.LogWarning("FlightControlManager.AddTo Skipped: shared.Vessel.rootPart == null"); return; } SafeHouse.Logger.Log("FlightControlManager.AddTo " + Shared.Vessel.id); currentVessel = shared.Vessel; ConnectivityManager.AddAutopilotHook(currentVessel, OnFlyByWire); AddNewFlightParam("throttle", Shared); AddNewFlightParam("steering", Shared); AddNewFlightParam("wheelthrottle", Shared); AddNewFlightParam("wheelsteering", Shared); shared.BindingMgr.AddSetter("SASMODE", value => SelectAutopilotMode(value)); shared.BindingMgr.AddGetter("SASMODE", () => GetAutopilotModeName()); shared.BindingMgr.AddSetter("NAVMODE", value => SetNavMode(value)); shared.BindingMgr.AddGetter("NAVMODE", () => GetNavModeName()); }
public override void AddTo(SharedObjects shared) { Shared = shared; if (Shared.Vessel == null) { SafeHouse.Logger.LogWarning("FlightControlManager.AddTo Skipped: shared.Vessel== null"); return; } if (Shared.Vessel.rootPart == null) { SafeHouse.Logger.LogWarning("FlightControlManager.AddTo Skipped: shared.Vessel.rootPart == null"); return; } SafeHouse.Logger.Log("FlightControlManager.AddTo " + Shared.Vessel.id); currentVessel = shared.Vessel; currentVessel.OnPreAutopilotUpdate += OnFlyByWire; AddNewFlightParam("throttle", Shared); AddNewFlightParam("steering", Shared); AddNewFlightParam("wheelthrottle", Shared); AddNewFlightParam("wheelsteering", Shared); shared.BindingMgr.AddSetter("SASMODE", value => SelectAutopilotMode((string)value)); shared.BindingMgr.AddGetter("SASMODE", () => currentVessel.Autopilot.Mode.ToString().ToUpper()); }
public EngineValue(global::Part part, MultiModeEngine engine, SharedObjects sharedObj) : base(part, sharedObj) { MMengine = engine; var moduleEngines = part.Modules.GetModules<ModuleEngines>(); if (moduleEngines.Count == 2) { var modEngine1 = moduleEngines.Where(e => e.engineID == MMengine.primaryEngineID).FirstOrDefault(); if (modEngine1 != null) engine1 = new ModuleEngineAdapter(modEngine1); else throw new KOSException("Attempted to build a MultiModeEngine with no engine matching Primary ID"); var modEngine2 = moduleEngines.Where(e => e.engineID == MMengine.secondaryEngineID).FirstOrDefault(); if (modEngine2 != null) engine2 = new ModuleEngineAdapter(modEngine2); else throw new KOSException("Attempted to build a MultiModeEngine with no engine matching Secondary ID"); } else { throw new KOSException(string.Format("Attempted to build a MultiModeEngine with {0} engine modules defined instead of 2", moduleEngines.Count)); } MultiMode = true; findGimbal(); EngineInitializeSuffixes(); }
public override void Execute(SharedObjects shared) { string bodyName = PopValueAssert(shared).ToString(); AssertArgBottomAndConsume(shared); var result = new BodyTarget(bodyName, shared); ReturnValue = result; }
public static PartModuleFields Construct(PartModule mod, SharedObjects shared) { var moduleGimbal = mod as ModuleGimbal; if (moduleGimbal != null) return new GimbalFields(moduleGimbal, shared); var processor = mod as kOSProcessor; if (processor != null) { return new kOSProcessorFields(processor, shared); } if (mod.moduleName.Equals(RemoteTechAntennaModuleFields.RTAntennaModule)) { return new RemoteTechAntennaModuleFields(mod, shared); } var scienceExperimentFields = ScienceExperimentFieldsFactory.Construct(mod, shared); if (scienceExperimentFields != null) { return scienceExperimentFields; } return new PartModuleFields(mod, shared); }
/// <summary> /// Build a GeoCoordinates from any arbitrary lat/long pair of doubles. /// </summary> /// <param name="sharedObj">to know the current CPU's running vessel</param> /// <param name="lat">latitude</param> /// <param name="lng">longitude</param> public GeoCoordinates(SharedObjects sharedObj, double lat, double lng) { Lat = lat; Lng = lng; Shared = sharedObj; Body = Shared.Vessel.GetOrbit().referenceBody; }
public override void Execute(SharedObjects shared) { AssertArgBottomAndConsume(shared); // no args // ReSharper disable SuggestUseVarKeywordEvident ListValue<WaypointValue> returnList = new ListValue<WaypointValue>(); // ReSharper enable SuggestUseVarKeywordEvident WaypointManager wpm = WaypointManager.Instance(); if (wpm == null) { ReturnValue = returnList; // When no waypoints exist, there isn't even a waypoint manager at all. return; } List<Waypoint> points = wpm.AllWaypoints(); // If the code below gets used in more places it may be worth moving into a factory method // akin to how PartValueFactory makes a ListValue<PartValue> from a List<Part>. // But for now, this is the only place it's done: foreach (Waypoint point in points) returnList.Add(new WaypointValue(point, shared)); ReturnValue = returnList; }
public static SteeringManager DeepCopy(SteeringManager oldInstance, SharedObjects shared) { SteeringManager instance = SteeringManagerProvider.GetInstance(shared); instance.ShowAngularVectors = oldInstance.ShowAngularVectors; instance.ShowFacingVectors = oldInstance.ShowFacingVectors; instance.ShowRCSVectors = oldInstance.ShowRCSVectors; instance.ShowThrustVectors = oldInstance.ShowThrustVectors; instance.ShowSteeringStats = oldInstance.ShowSteeringStats; instance.WriteCSVFiles = oldInstance.WriteCSVFiles; instance.MaxStoppingTime = oldInstance.MaxStoppingTime; instance.pitchPI.Ts = oldInstance.pitchPI.Ts; instance.yawPI.Ts = oldInstance.yawPI.Ts; instance.rollPI.Ts = oldInstance.rollPI.Ts; instance.pitchPI.Loop = PIDLoop.DeepCopy(oldInstance.pitchPI.Loop); instance.yawPI.Loop = PIDLoop.DeepCopy(oldInstance.yawPI.Loop); instance.rollPI.Loop = PIDLoop.DeepCopy(oldInstance.rollPI.Loop); instance.pitchRatePI = PIDLoop.DeepCopy(oldInstance.pitchRatePI); instance.yawRatePI = PIDLoop.DeepCopy(oldInstance.yawRatePI); instance.rollRatePI = PIDLoop.DeepCopy(oldInstance.rollRatePI); instance.PitchTorqueAdjust = oldInstance.PitchTorqueAdjust; instance.PitchTorqueFactor = oldInstance.PitchTorqueFactor; instance.RollTorqueAdjust = oldInstance.RollTorqueAdjust; instance.RollTorqueFactor = oldInstance.RollTorqueFactor; instance.YawTorqueAdjust = oldInstance.YawTorqueAdjust; instance.YawTorqueFactor = oldInstance.YawTorqueFactor; return instance; }
public override void Execute(SharedObjects shared) { double ang2 = GetDouble(shared.Cpu.PopValue()); double ang1 = GetDouble(shared.Cpu.PopValue()); double result = kOS.Utilities.Utils.DegreeFix( ang2 - ang1, -180 ); shared.Cpu.PushStack(result); }
public MessageQueueStructure(MessageQueue messageQueue, SharedObjects sharedObjects) { this.messageQueue = messageQueue; this.sharedObjects = sharedObjects; InitializeSuffixes(); }
public override void Execute(SharedObjects shared) { string listType = shared.Cpu.PopValue().ToString(); ListValue list = new ListValue(); switch (listType) { case "bodies": foreach (var body in FlightGlobals.fetch.bodies) { list.Add(new BodyTarget(body, shared.Vessel)); } break; case "targets": foreach (var vessel in FlightGlobals.Vessels) { if (vessel == shared.Vessel) continue; list.Add(new VesselTarget(vessel, shared.Vessel)); } break; case "resources": case "parts": case "engines": case "sensors": case "elements": list = VesselUtils.PartList(shared.Vessel, listType); break; } shared.Cpu.PushStack(list); }
public override void Execute(SharedObjects shared) { double argument = GetDouble(PopValueAssert(shared)); AssertArgBottomAndConsume(shared); double result = RadiansToDegrees(Math.Atan(argument)); ReturnValue = result; }
public override void AddTo(SharedObjects shared) { _shared = shared; _shared.BindingMgr.AddGetter("LOADDISTANCE", cpu => Vessel.loadDistance ); _shared.BindingMgr.AddSetter("LOADDISTANCE", delegate(CPU cpu, object val) { var distance = (float) val; Vessel.loadDistance = distance; Vessel.unloadDistance = distance - 250; }); _shared.BindingMgr.AddGetter("WARP", cpu => TimeWarp.fetch.current_rate_index); _shared.BindingMgr.AddSetter("WARP", delegate(CPU cpu, object val) { int newRate; if (int.TryParse(val.ToString(), out newRate)) { TimeWarp.SetRate(newRate, false); } }); foreach (var body in FlightGlobals.fetch.bodies) { var cBody = body; _shared.BindingMgr.AddGetter(body.name, cpu => new BodyTarget(cBody, _shared.Vessel)); } }
public override void Execute(SharedObjects shared) { double argument = GetDouble(PopValueAssert(shared)); AssertArgBottomAndConsume(shared); double result = Math.Log(argument); ReturnValue = result; }
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 = AggregateResourceValue.PartsToList(partList, sharedObj); break; case "PARTS": list = PartValueFactory.Construct(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, sharedObj); break; case "DOCKINGPORTS": list = DockingPortValue.PartsToList(partList, sharedObj); break; } return list; }
public override void Execute(SharedObjects shared) { double argument = GetDouble(PopValueAssert(shared)); AssertArgBottomAndConsume(shared); string result = new string((char) argument, 1); ReturnValue = new StringValue(result); }
public override void Execute(SharedObjects shared) { object volumeId = shared.Cpu.PopValue(); string fileName = shared.Cpu.PopValue().ToString(); if (shared.VolumeMgr != null) { Volume volume; if (volumeId != null) { volume = shared.VolumeMgr.GetVolume(volumeId); } else { volume = shared.VolumeMgr.CurrentVolume; } if (volume != null) { if (!volume.DeleteByName(fileName)) { throw new Exception(string.Format("File '{0}' not found", fileName)); } } else { throw new Exception("Volume not found"); } } }
public static PartValue Construct(global::Part part, SharedObjects shared) { foreach (PartModule module in part.Modules) { ModuleEngines mEng = module as ModuleEngines; if (mEng != null) return new EngineValue(part, new ModuleEngineAdapter(mEng), shared); ModuleEnginesFX mEngFX = module as ModuleEnginesFX; if (mEngFX != null) return new EngineValue(part, new ModuleEngineAdapter(mEngFX), shared); ModuleDockingNode mDock = module as ModuleDockingNode; if (mDock != null) return new DockingPortValue(mDock, shared); ModuleEnviroSensor mSense = module as ModuleEnviroSensor; if (mSense != null) return new SensorValue(part, mSense, shared); var gimbalModule = module as ModuleGimbal; if (gimbalModule != null) return new GimbalValue(gimbalModule,shared); } // Fallback if none of the above: then just a normal part: return new PartValue(part, shared); }
public override void Execute(SharedObjects shared) { double x = GetDouble(shared.Cpu.PopValue()); double y = GetDouble(shared.Cpu.PopValue()); double result = RadiansToDegrees(Math.Atan2(y, x)); shared.Cpu.PushStack(result); }
public OrbitInfo( Orbit orb, SharedObjects sharedObj ) { shared = sharedObj; orbit = orb; name = "<unnamed>"; InitializeSuffixes(); }
public object VesselShortcutGetter(SharedObjects shared, string name) { ISuffixResult suffix = new VesselTarget(shared).GetSuffix(name); if (! suffix.HasValue) suffix.Invoke(shared.Cpu); return suffix.Value; }
public OrbitInfo(Orbitable orb, SharedObjects sharedObj) { orbit = orb.Orbit; shared = sharedObj; name = orb.GetName(); InitializeSuffixes(); }
public override void Execute(SharedObjects shared) { var list = new ListValue(); string alarmTypes = PopValueAssert(shared).ToString(); AssertArgBottomAndConsume(shared); if (!KACWrapper.APIReady) { ReturnValue = list; throw new KOSUnavailableAddonException("listAlarms()", "Kerbal Alarm Clock"); } //Get the list of alarms from the KAC Object KACWrapper.KACAPI.KACAlarmList alarms = KACWrapper.KAC.Alarms; foreach (KACWrapper.KACAPI.KACAlarm alarm in alarms) { // if its not my alarm or a general alarm, ignore it if (!string.IsNullOrEmpty(alarm.VesselID) && alarm.VesselID != shared.Vessel.id.ToString()) { continue; } if (alarmTypes.ToUpperInvariant() == "ALL" || alarm.AlarmTime.ToString() == alarmTypes) list.Add(new KACAlarmWrapper(alarm)); } ReturnValue = list; }
public override void AddTo(SharedObjects shared) { _shared = shared; _shared.BindingMgr.AddGetter("SESSIONTIME", cpu => cpu.SessionTime); _shared.BindingMgr.AddGetter("VERSION", cpu => Core.VersionInfo); _shared.BindingMgr.AddGetter("VOLUME:NAME", cpu => _shared.VolumeMgr.CurrentVolume.Name); }
public override void Execute(SharedObjects shared) { double degrees = GetDouble(PopValueAssert(shared)); AssertArgBottomAndConsume(shared); double radians = DegreesToRadians(degrees); double result = Math.Sin(radians); ReturnValue = result; }
public Node(double time, double radialOut, double normal, double prograde, SharedObjects shareObj) : this(shareObj) { this.time = time; this.prograde = prograde; this.radialOut = radialOut; this.normal = normal; }
public GimbalFields(ModuleGimbal gimbal, SharedObjects sharedObj) : base(gimbal, sharedObj) { this.gimbal = gimbal; InitializeGimbalSuffixes(); }
/// <summary> /// Build a GeoCoordinates from any arbitrary lat/long pair of floats. /// </summary> /// <param name="sharedObj">to know the current CPU's running vessel</param> /// <param name="latitude">latitude</param> /// <param name="longitude">longitude</param> public GeoCoordinates(SharedObjects sharedObj, float latitude, float longitude) : this(sharedObj.Vessel.GetOrbit().referenceBody, sharedObj, latitude, longitude) { }
public static string WriteJson(SharedObjects sharedObjects, object input) { return(jsonWriter.Write(new Serializer(sharedObjects).Serialize(input))); }
public override void Execute(SharedObjects shared) { var listValue = new ListValue(); shared.Cpu.PushStack(listValue); }
public BodyTarget(string name, SharedObjects shareObj) : this(VesselUtils.GetBodyByName(name), shareObj) { BodyInitializeSuffixes(); }
internal void AttachTo(SharedObjects shared) { this.shared = shared; this.shared.Window = this; }
public ConnectivityInterpreter(SharedObjects shared) : base(shared) { Shared.UpdateHandler.AddObserver(this); CreateProgressBarSubBuffer(); }
public StageValues(SharedObjects shared) { this.shared = shared; InitializeSuffixes(); }
/// <summary> /// Build a GeoCoordinates from any arbitrary lat/long pair of floats. /// </summary> /// <param name="sharedObj">to know the current CPU's running vessel</param> /// <param name="lat">latitude</param> /// <param name="lng">longitude</param> public GeoCoordinates(SharedObjects sharedObj, float lat, float lng) : this(sharedObj.Vessel.GetOrbit().referenceBody, sharedObj, lat, lng) { }
private void AddNewFlightParam(string name, SharedObjects shared) { flightParameters[name] = new FlightCtrlParam(name, shared); }
public static BodyTarget CreateOrGetExisting(string bodyName, SharedObjects shared) { return(CreateOrGetExisting(VesselUtils.GetBodyByName(bodyName), shared)); }
public void SetSharedObjects(SharedObjects sharedObjects) { Shared = sharedObjects; }
private BodyTarget(CelestialBody body, SharedObjects shareObj) : base(shareObj) { Body = body; BodyInitializeSuffixes(); }
public OrbitInfo(Orbitable orb, SharedObjects sharedObj) : this() { orbit = orb.Orbit; Shared = sharedObj; name = orb.GetName(); }
public Addon(SharedObjects shared) : base(shared) { InitializeSuffixes(); }
/// <summary> /// Do not call! VesselTarget.ConstructPart uses this, would use `friend VesselTarget` if this was C++! /// </summary> internal EngineValue(SharedObjects shared, global::Part part, PartValue parent, DecouplerValue decoupler) : base(shared, part, parent, decoupler) { foreach (var module in part.Modules) { var mme = module as MultiModeEngine; var e = module as ModuleEngines; if (mme != null) { if (Multi == null) { Multi = mme; } else { SafeHouse.Logger.LogWarning("Multiple MultiModeEngine on {0}: {1}", part.name, part.partInfo.title); } } else if (e != null) { if (Engine1 == null) { Engine1 = e; } else if (Engine2 == null) { Engine2 = e; } else { SafeHouse.Logger.LogWarning("Third engine on {0}: {1}", part.name, part.partInfo.title); } } } if (Engine1 == null) { throw new KOSException("Attempted to build an Engine from part with no ModuleEngines on {0}: {1}", part.name, part.partInfo.title); } if (Engine2 == null) { if (Multi != null) { SafeHouse.Logger.LogWarning("MultiModeEngine without second engine on {0}: {1}", part.name, part.partInfo.title); } } else { if (Multi == null) { Engine2 = null; SafeHouse.Logger.LogWarning("Second engine without multi-mode on {0}: {1}", part.name, part.partInfo.title); } else { if (Multi.primaryEngineID == Engine2.engineID) { var tmp = Engine1; Engine1 = Engine2; Engine2 = tmp; } else if (Multi.primaryEngineID != Engine1.engineID) { SafeHouse.Logger.LogWarning("Primary engine ID={0} does not match multi.e1={1} on {2}: {3}", Engine1.engineID, Multi.primaryEngineID, part.name, part.partInfo.title); } if (Multi.secondaryEngineID != Engine2.engineID) { SafeHouse.Logger.LogWarning("Secondary engine ID={0} does not match multi.e2={1} on {2}: {3}", Engine2.engineID, Multi.secondaryEngineID, part.name, part.partInfo.title); } } } // if the part definition includes a ModuleGimbal, create GimbalFields and set HasGimbal to true var gimbalModule = Part.Modules.GetModules <ModuleGimbal>().FirstOrDefault(); if (gimbalModule != null) { Gimbal = new GimbalFields(gimbalModule, Shared); } RegisterInitializer(InitializeSuffixes); }
public override void AddTo(SharedObjects shared) { shared.BindingMgr.AddGetter("KUNIVERSE", () => new KUniverseValue(shared)); shared.BindingMgr.AddGetter("WARPMODE", () => { switch (TimeWarp.WarpMode) { case TimeWarp.Modes.HIGH: return("RAILS"); case TimeWarp.Modes.LOW: return("PHYSICS"); default: throw new ArgumentOutOfRangeException(); } }); shared.BindingMgr.AddSetter("WARPMODE", val => { TimeWarp.Modes toSet; switch (val.ToString().ToUpper()) { case "PHYSICS": toSet = TimeWarp.Modes.LOW; break; case "RAILS": toSet = TimeWarp.Modes.HIGH; break; default: throw new Exception(string.Format("WARPMODE '{0}' is not valid", val)); } TimeWarp.fetch.Mode = toSet; }); shared.BindingMgr.AddGetter("WARP", () => TimeWarp.CurrentRateIndex); shared.BindingMgr.AddSetter("WARP", val => { int newRate; if (int.TryParse(val.ToString(), out newRate)) { switch (TimeWarp.WarpMode) { case TimeWarp.Modes.HIGH: SetWarpRate(newRate, TimeWarp.fetch.warpRates.Length - 1); break; case TimeWarp.Modes.LOW: SetWarpRate(newRate, TimeWarp.fetch.physicsWarpRates.Length - 1); break; default: throw new Exception(string.Format("WARPMODE '{0}' is unknown to kOS, please contact the devs", val)); } } }); shared.BindingMgr.AddGetter("MAPVIEW", () => MapView.MapIsEnabled); shared.BindingMgr.AddSetter("MAPVIEW", val => { if (Convert.ToBoolean(val)) { MapView.EnterMapView(); } else { MapView.ExitMapView(); } }); shared.BindingMgr.AddGetter("CONSTANT", () => new ConstantValue()); foreach (var body in FlightGlobals.fetch.bodies) { var cBody = body; shared.BindingMgr.AddGetter(body.name, () => new BodyTarget(cBody, shared)); } shared.BindingMgr.AddGetter("VERSION", () => Core.VersionInfo); shared.BindingMgr.AddGetter("SOLARPRIMEVECTOR", () => new Vector(Planetarium.right)); shared.BindingMgr.AddGetter("ARCHIVE", () => shared.VolumeMgr.GetVolume(Archive.ArchiveName)); }
public BindingManager(SharedObjects shared) { variables = new Dictionary <string, BoundVariable>(StringComparer.OrdinalIgnoreCase); this.shared = shared; this.shared.BindingMgr = this; }
public TransferManager(SharedObjects shared) { this.shared = shared; transfers = new HashSet <ResourceTransferValue>(); shared.UpdateHandler.AddFixedObserver(this); }
public IInterpreter CreateInterpreter(SharedObjects shared) { return(new RemoteTechInterpreter(shared)); }
public override void Execute(SharedObjects shared) { var constants = new ConstantValue(); shared.Cpu.PushStack(constants); }
public VolumeManager CreateVolumeManager(SharedObjects sharedObjects) { return(new RemoteTechVolumeManager(sharedObjects)); }
public static object ReadJson(SharedObjects sharedObjects, string input) { return(new Serializer(sharedObjects).Deserialize(jsonReader.Read(input))); }
public Interpreter(SharedObjects shared) { Shared = shared; }
public Serializer(SharedObjects sharedObjects) { SharedObjects = sharedObjects; }
void IFlightControlParameter.EnableControl(SharedObjects shared) { controlPartId = shared.KSPPart.flightID; controlShared = shared; Enabled = true; }
void IFlightControlParameter.DisableControl() { controlShared = null; controlPartId = 0; Enabled = false; }
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 = AggregateResourceValue.PartsToList(partList, sharedObj); break; case "PARTS": list = PartValueFactory.Construct(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, sharedObj); break; case "DOCKINGPORTS": list = DockingPortValue.PartsToList(partList, sharedObj); break; case "DECOUPLERS": case "SEPARATORS": list = DecouplerValue.PartsToList(partList, sharedObj); break; } return(list); }
public void AttachTo(SharedObjects sharedObj) { shared = sharedObj; }
public OrbitInfo(Orbit orb, SharedObjects sharedObj) : this() { Shared = sharedObj; orbit = orb; name = "<unnamed>"; }