public StageValues(SharedObjects shared)
        {
            this.shared = shared;
            partSet = new PartSet(partHash);

            InitializeSuffixes();
        }

 public override void Execute(SharedObjects shared)
 {
     double argument = GetDouble(PopValueAssert(shared));
     AssertArgBottomAndConsume(shared);
     double result = Math.Log(argument);
     ReturnValue = result;
 }

 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 OrbitInfo(Orbitable orb, SharedObjects sharedObj)
 {
     orbit = orb.Orbit;
     shared = sharedObj;
     name = orb.GetName();
     InitializeSuffixes();
 }

 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 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 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)
 {
     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 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 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)
        {
            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 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 IRServoWrapper(IRWrapper.IServo init, SharedObjects shared)
 {
     servo = init;
     this.shared = shared;
     this.partValue = GetPart();
     InitializeSuffixes();
 }

        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 object VesselShortcutGetter(SharedObjects shared, string name)
 {
     ISuffixResult suffix = new VesselTarget(shared).GetSuffix(name);
     if (! suffix.HasValue)
         suffix.Invoke(shared.Cpu);
     return suffix.Value;
 }

 public override void Execute(SharedObjects shared)
 {
     if (shared.Cpu != null)
     {
         shared.Cpu.RunProgram(Program);
     }
 }