Merge pull request #1078 from cesarBLG/steam-locomotive-script

Default PowerSupply script for steam locomotives

Author: cjakeman

Source/Orts.Simulation/Simulation/RollingStocks/MSTSSteamLocomotive.cs

@@ -850,7 +850,7 @@ public MSTSSteamLocomotive(Simulator simulator, string wagFile)
             : base(simulator, wagFile)
         {
             SteamEngines = new SteamEngines(this);
-            PowerSupply = new SteamPowerSupply(this);
+            PowerSupply = new ScriptedSteamPowerSupply(this);
 
             RefillTenderWithFuel();
             RefillTenderWithWater();

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/PowerSupplies/ElectricTrainSupplySwitch.cs

@@ -1,4 +1,4 @@
-// COPYRIGHT 2020 by the Open Rails project.
+// COPYRIGHT 2020 by the Open Rails project.
 // 
 // This file is part of Open Rails.
 // 
@@ -31,16 +31,17 @@ public enum ModeType
             Unfitted, // Locomotive without ETS
             Switch,    // Locomotive with ETS activation via a switch
         }
-        public ModeType Mode { get; protected set; } = ModeType.Automatic;
+        public ModeType Mode { get; protected set; }
 
         // Variables
         readonly MSTSLocomotive Locomotive;
         public bool CommandSwitch { get; protected set; } = false;
         public bool On { get; protected set; } = false;
 
-        public ElectricTrainSupplySwitch(MSTSLocomotive locomotive)
+        public ElectricTrainSupplySwitch(MSTSLocomotive locomotive, ModeType defaultMode = ModeType.Automatic)
         {
             Locomotive = locomotive;
+            Mode = defaultMode;
         }
 
         public virtual void Parse(string lowercasetoken, STFReader stf)

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/PowerSupplies/SteamPowerSupply.cs

@@ -15,8 +15,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Open Rails.  If not, see <http://www.gnu.org/licenses/>.
 
+using System.Diagnostics;
 using System.IO;
 using Orts.Parsers.Msts;
+using ORTS.Common;
 using ORTS.Scripting.Api;
 
 namespace Orts.Simulation.RollingStocks.SubSystems.PowerSupplies
@@ -25,226 +27,103 @@ namespace Orts.Simulation.RollingStocks.SubSystems.PowerSupplies
     /// Basic power supply class for steam locomotives
     /// For electrical systems powered by battery
     /// </summary>
-    public class SteamPowerSupply : ILocomotivePowerSupply
+    public class ScriptedSteamPowerSupply : ScriptedLocomotivePowerSupply
     {
-        public TrainCar Car { get; }
-        public MSTSSteamLocomotive Locomotive => Car as MSTSSteamLocomotive;
-        public PowerSupplyType Type => PowerSupplyType.Steam;
-
-        public Pantographs Pantographs => Locomotive.Pantographs;
-        public Battery Battery { get; protected set; }
-        public BatterySwitch BatterySwitch => Battery.BatterySwitch;
-        public MasterKey MasterKey { get; protected set; }
-        public ElectricTrainSupplySwitch ElectricTrainSupplySwitch => null;
-
-        public PowerSupplyState MainPowerSupplyState
+        public MSTSSteamLocomotive SteamLocomotive => Locomotive as MSTSSteamLocomotive;
+        public override PowerSupplyType Type => PowerSupplyType.Steam;
+        public ScriptedSteamPowerSupply(MSTSSteamLocomotive locomotive) : base(locomotive)
         {
-            get
-            {
-                return PowerSupplyState.PowerOn;
-            }
-            set{}
+            ElectricTrainSupplySwitch = new ElectricTrainSupplySwitch(Locomotive, ElectricTrainSupplySwitch.ModeType.Unfitted);
         }
-
-        public bool MainPowerSupplyOn => true;
-        public bool DynamicBrakeAvailable
+        public override void Initialize()
         {
-            get
-            {
-                return false;
-            }
-            set{}
-        }
-        public float PowerSupplyDynamicBrakePercent { get; set; } = -1;
-        public float MaximumDynamicBrakePowerW { get; set; } = 0;
-        public float MaxThrottlePercent { get; set; } = 100;
-        public float ThrottleReductionPercent { get; set; } = 0;
+            base.Initialize();
 
-        public PowerSupplyState AuxiliaryPowerSupplyState
-        {
-            get
+            if (AbstractScript == null)
             {
-                return PowerSupplyState.PowerOn;
-            }
-            set{}
-        }
+                if (ScriptName != null && ScriptName != "Default")
+                {
+                    Trace.TraceWarning("Skipped custom power supply script, not available for steam locomotives.");
+                }
 
-        public bool AuxiliaryPowerSupplyOn => true;
+                if (ParametersFileName != null)
+                {
+                    ParametersFileName = Path.Combine(Path.Combine(Path.GetDirectoryName(Locomotive.WagFilePath), "Script"), ParametersFileName);
+                }
 
-        public PowerSupplyState LowVoltagePowerSupplyState
-        {
-            get
-            {
-                return Battery.State == PowerSupplyState.PowerOn ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff;
-            }
-            set{}
-        }
+                if (AbstractScript == null)
+                {
+                    AbstractScript = new DefaultSteamPowerSupply();
+                }
 
-        public bool LowVoltagePowerSupplyOn => LowVoltagePowerSupplyState == PowerSupplyState.PowerOn;
+                AssignScriptFunctions();
 
-        public PowerSupplyState BatteryState
-        {
-            get
-            {
-                return Battery.State;
-            }
-            set
-            {
-                Battery.State = value;
+                AbstractScript.AttachToHost(this);
+                AbstractScript.Initialize();
             }
         }
 
-        public bool BatteryOn => BatteryState == PowerSupplyState.PowerOn;
-        public float BatteryVoltageV => BatteryOn ? Battery.VoltageV : 0;
+        public override void Update(float elapsedClockSeconds)
+        {
+            base.Update(elapsedClockSeconds);
 
-        public PowerSupplyState CabPowerSupplyState
+            AbstractScript?.Update(elapsedClockSeconds);
+        }
+    }
+    public class DefaultSteamPowerSupply : LocomotivePowerSupply
+    {
+        public override void Initialize()
         {
-            get
-            {
-                return MasterKey.On ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff;
-            }
-            set{}
         }
 
-        public bool CabPowerSupplyOn => CabPowerSupplyState == PowerSupplyState.PowerOn;
-
-        public PowerSupplyState ElectricTrainSupplyState
+        public override void Update(float elapsedClockSeconds)
         {
-            get
-            {
-                return PowerSupplyState.Unavailable;
-            }
-            set{}
-        }
+            SetCurrentBatteryState(BatterySwitchOn() ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff);
+            SetCurrentLowVoltagePowerSupplyState(BatterySwitchOn() ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff);
+            SetCurrentCabPowerSupplyState(BatterySwitchOn() && MasterKeyOn() ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff);
 
-        public bool ElectricTrainSupplyOn => false;
-        public bool FrontElectricTrainSupplyCableConnected { get => false; set { } }
-        public float ElectricTrainSupplyPowerW => 0f;
+            SetCurrentMainPowerSupplyState(PowerSupplyState.PowerOn);
+            SetCurrentAuxiliaryPowerSupplyState(PowerSupplyState.PowerOn);
 
-        public bool ServiceRetentionButton
-        {
-            get
+            if (ElectricTrainSupplyUnfitted())
             {
-                return false;
+                SetCurrentElectricTrainSupplyState(PowerSupplyState.Unavailable);
             }
-            set{}
-        }
-
-        public bool ServiceRetentionCancellationButton
-        {
-            get
+            else if (CurrentAuxiliaryPowerSupplyState() == PowerSupplyState.PowerOn
+                    && ElectricTrainSupplySwitchOn())
             {
-                return false;
+                SetCurrentElectricTrainSupplyState(PowerSupplyState.PowerOn);
             }
-            set{}
-        }
-
-        public bool ServiceRetentionActive
-        {
-            get
+            else
             {
-                return false;
+                SetCurrentElectricTrainSupplyState(PowerSupplyState.PowerOff);
             }
-            set{}
         }
 
-        public SteamPowerSupply(MSTSSteamLocomotive locomotive)
+        public override void HandleEvent(PowerSupplyEvent evt)
         {
-            Car = locomotive;
-
-            Battery = new Battery(Locomotive);
-            MasterKey = new MasterKey(Locomotive);
-        }
-
-        public virtual void Parse(string lowercasetoken, STFReader stf)
-        {
-            switch (lowercasetoken)
+            switch (evt)
             {
-                case "engine(ortsbattery":
-                    Battery.Parse(lowercasetoken, stf);
+                case PowerSupplyEvent.QuickPowerOn:
+                    SignalEventToBatterySwitch(PowerSupplyEvent.QuickPowerOn);
+                    SignalEventToMasterKey(PowerSupplyEvent.TurnOnMasterKey);
+                    SignalEventToPantograph(PowerSupplyEvent.RaisePantograph, 1);
+                    SignalEventToOtherTrainVehiclesWithId(PowerSupplyEvent.RaisePantograph, 1);
+                    SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOnElectricTrainSupply);
                     break;
-                case "engine(ortsmasterkey(mode":
-                case "engine(ortsmasterkey(delayoff":
-                case "engine(ortsmasterkey(headlightcontrol":
-                    MasterKey.Parse(lowercasetoken, stf);
+
+                case PowerSupplyEvent.QuickPowerOff:
+                    SignalEventToElectricTrainSupplySwitch(PowerSupplyEvent.SwitchOffElectricTrainSupply);
+                    SignalEventToPantographs(PowerSupplyEvent.LowerPantograph);
+                    SignalEventToOtherTrainVehicles(PowerSupplyEvent.LowerPantograph);
+                    SignalEventToMasterKey(PowerSupplyEvent.TurnOffMasterKey);
+                    SignalEventToBatterySwitch(PowerSupplyEvent.QuickPowerOff);
                     break;
-            }
-        }
 
-        public void Copy(IPowerSupply other)
-        {
-            if (other is SteamPowerSupply steamOther)
-            {
-                Battery.Copy(steamOther.Battery);
-                MasterKey.Copy(steamOther.MasterKey);
+                default:
+                    base.HandleEvent(evt);
+                    break;
             }
         }
-
-        public void Initialize()
-        {
-            Battery.Initialize();
-            MasterKey.Initialize();
-        }
-
-        public virtual void InitializeMoving()
-        {
-            Battery.InitializeMoving();
-            MasterKey.InitializeMoving();
-        }
-
-        public void Save(BinaryWriter outf)
-        {
-            Battery.Save(outf);
-            MasterKey.Save(outf);
-        }
-
-        public void Restore(BinaryReader inf)
-        {
-            Battery.Restore(inf);
-            MasterKey.Restore(inf);
-        }
-
-        public void Update(float elapsedClockSeconds)
-        {
-            Battery.State = BatterySwitch.On ? PowerSupplyState.PowerOn : PowerSupplyState.PowerOff;
-        }
-
-        public void HandleEvent(PowerSupplyEvent evt)
-        {
-            BatterySwitch.HandleEvent(evt);
-            MasterKey.HandleEvent(evt);
-        }
-
-        public void HandleEvent(PowerSupplyEvent evt, int id)
-        {
-        }
-
-        public void HandleEventFromTcs(PowerSupplyEvent evt)
-        {
-        }
-
-        public void HandleEventFromTcs(PowerSupplyEvent evt, int id)
-        {
-        }
-
-        public void HandleEventFromTcs(PowerSupplyEvent evt, string message)
-        {
-        }
-
-        public void HandleEventFromLeadLocomotive(PowerSupplyEvent evt)
-        {
-        }
-
-        public void HandleEventFromLeadLocomotive(PowerSupplyEvent evt, int id)
-        {
-        }
-
-        public void HandleEventFromOtherLocomotive(int locoIndex, PowerSupplyEvent evt)
-        {
-        }
-
-        public void HandleEventFromOtherLocomotive(int locoIndex, PowerSupplyEvent evt, int id)
-        {
-        }
     }
 }