Automatic merge of T1.5.1-1689-g72674c98d and 14 pull requests

- Pull request #900 at b54024b: DMI in 3D cab + two more dials
- Pull request #1030 at d3ae4a2: Refactor settings, in prep for settings exporter
- Pull request #1045 at cc4d53c: Bugfix: Empty Start Time for Explore, and other issues loading from Menu Selection and Content Routes
- Pull request #1052 at 382ea6d: Content Manager: Add axle count, and lowest derail force
- Pull request #1062 at 3b18c48: Train Forces popup Window.
- Pull request #1064 at 53dd604: Add Train Info tab to Help window (F1)
- Pull request #1066 at 62c89c1: Log derailment, using TraceInformation.
- Pull request #892 at 1f5ba4c: Signal Function OPP_SIG_ID_TRAINPATH
- Pull request #1000 at d8d9709: Locomotive operation from control car
- Pull request #1029 at 92c74ef: Superelevation Follow Up Fixes
- Pull request #1065 at 409064d: Fix for PantographToggle sound event
- Pull request #1068 at d6e1f83: Build for online-only documentation files
- Pull request #896 at f1681df: First implementation of https://blueprints.launchpad.net/or/+spec/specific-sounds-for-ai-trains
- Pull request #1067 at 777efaf: Traction and dynamic brake retardation

Author: openrails-bot

Source/Documentation/Manual/physics.rst

@@ -1141,6 +1141,58 @@ with the ``ORTSTractionMotorType ( AC ) `` parameter, to be inserted in the Engi
 section of the ENG file. The use of this motor will have an impact on wheel slip,
 because the wheel speed never exceeds the frequency of the rotating magnetic field.
 
+Traction force retardation
+''''''''''''''''''''''''''
+
+.. index::
+    single: ORTSTractiveForceRampUpRate
+    single: ORTSTractiveForceRampDownRate
+    single: ORTSTractiveForceRampDownToZeroRate
+    single: ORTSDynamicBrakeForceRampUpRate
+    single: ORTSDynamicBrakeForceRampDownRate
+    single: ORTSDynamicBrakeForceRampDownToZeroRate
+    single: ORTSDelayTimeBeforeUpdating
+
+When the driver sets full throttle, the control electronics may not apply the full
+tractive force instantly, but it will instead linearly apply force until reaching
+the target demand. This can be tuned both for traction and dynamic braking by inserting
+``ORTSTractiveForceRampUpRate``, ``ORTSTractiveForceRampDownRate``,
+``ORTSTractiveForceRampDownToZeroRate``, ``ORTSDynamicBrakeForceRampUpRate``,
+``ORTSDynamicBrakeForceRampDownRate`` and ``ORTSDynamicBrakeForceRampDownToZeroRate``
+in the .eng file. The value of each parameter determines the force increase/decrease
+rate in one second.
+
+Example::
+
+  Engine (
+    ORTSTractiveForceRampUpRate ( 50kN )
+    ORTSTractiveForceRampDownRate ( 50kN )
+    ORTSTractiveForceRampDownToZeroRate ( 100kN )
+    ORTSDynamicBrakeForceRampUpRate ( 70kN )
+    ORTSDynamicBrakeForceRampDownRate ( 50kN )
+    ORTSDynamicBrakeForceRampDownToZeroRate ( 50kN )
+  )
+
+Another possibility to avoid sudden variations in tractive force while the driver
+is moving the throttle, is to only update the throttle/brake demand when the lever
+has not been moved for a defined amount of time. This can be implemented using the
+``ORTSDelayTimeBeforeUpdating``, which has to be inserted for the desired
+controller in the ``EngineControllers`` block.
+
+Example::
+
+  Engine (
+    EngineControllers (
+      Throttle ( 0 1 0.1 0
+        NumNotches ( 0 )
+        ORTSDelayTimeBeforeUpdating ( 0.5s )
+      )
+      Brake_Dynamic ( 0 1 0.1 0
+        NumNotches ( 0 )
+        ORTSDelayTimeBeforeUpdating ( 1s )
+      )
+    )
+  )
 
 Steam Locomotives
 -----------------
@@ -2590,6 +2642,10 @@ behave exactly the same way as player controlled ones.
 
 .. _physics-braking:
 
+.. index::
+   single: BrakeSystemType
+   single: BrakeEquipmentType
+
 Open Rails Braking
 ==================
 
@@ -2627,13 +2683,15 @@ graduated release. It will also force graduated release of brakes in triple
 valves. This option should be unchecked, except for compatibility problems
 with old MSTS stock.
 
-The following brake types are implemented in OR:
+The following brake types are implemented in OR. They can be selected using
+the ``Wagon(BrakeSystemType`` parameter:
 
-- Vacuum single
-- Air single-pipe
-- Air twin-pipe
-- EP (Electro-pneumatic)
-- Single-transfer-pipe (air and vacuum)
+- Vacuum single pipe: ``BrakeSystemType ("Vacuum_single_pipe")``
+- Air single-pipe: ``BrakeSystemType ("Air_single_pipe")``
+- Air twin-pipe: ``BrakeSystemType ("Air_twin_pipe")``
+- EP (Electro-pneumatic, twin-pipe): ``BrakeSystemType ("EP")``
+- EP single-pipe: ``BrakeSystemType ("EP_single_pipe")``
+- Single-transfer-pipe (air and vacuum): ``BrakeSystemType ("Air_piped")`` or ``BrakeSystemType ("Vacuum_piped")``
 
 The operation of air single-pipe brakes is described in general below.
 
@@ -2658,17 +2716,19 @@ brake features.
 For EP brakes, two variants are available:
 
 - If ``Wagon(ORTSEPBrakeControlsBrakePipe`` is set to 0 (default situation),
-an electrical wire (application wire) provides simultaneous fast brake application
-along the train. Release time will be fast if standard air brake haven't been applied,
-otherwise air brakes will determine release time. Typically this system is present
-with Train Brake Controllers having an EP-only application section, followed by an
-air application portion which serves as a fallback system.
+  an electrical wire (application wire) provides simultaneous fast brake application
+  along the train. Release time will be fast if standard air brake haven't been applied,
+  otherwise air brakes will determine release time. Typically this system is present
+  with Train Brake Controllers having an EP-only application section, followed by an
+  air application portion which serves as a fallback system, or in combination with a
+  solenoid valve that isolates the triple valve when EP brakes are operational.
+
 - If ``Wagon(ORTSEPBrakeControlsBrakePipe`` is set to 1, brake pipe is charged and discharged
-simultaneously at each car in the train, providing fast and uniform brake application and release.
-The locomotive instructs the cars to "charge" or "discharge" the brake pipe to reach
-a reference pressure. Standard triple valves or distributors will follow brake pipe variations
-actuating the cylinders. This system is sometimes called "UIC EP brake". It is typically the system
-used in high speed trains.
+  simultaneously at each car in the train, providing fast and uniform brake application and release.
+  The locomotive instructs the cars to "charge" or "discharge" the brake pipe to reach
+  a reference pressure. Standard triple valves or distributors will follow brake pipe variations
+  actuating the cylinders. This system is sometimes called "UIC EP brake". It is typically the system
+  used in high speed trains.
 
 .. _physics-brake-controller:
 
@@ -3380,10 +3440,12 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
    single: ORTSBrakeEmergencyTimeFactor
    single: ORTSBrakePipeTimeFactor
    single: ORTSEPBrakeControlsBrakePipe
+   single: ORTSEPBrakeInhibitsTripleValve
    single: ORTSCompressorIsMuControlled
    single: Supply_Reservoir
    single: ORTSSupplyResCapacity
    single: ORTSSupplyResChargingRate
+   single: Emergency_Solenoid_Valve
 
 - ``Wagon(BrakePipeVolume`` -- Volume of car's brake pipe in cubic feet
   (default .5).
@@ -3456,6 +3518,8 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
   by the brake system.
 - ``Wagon(ORTSEPBrakeControlsBrakePipe`` -- Set to 1 for UIC EP brake: brake pipe
   pressure is electrically controlled at every fitted car.
+- ``Wagon(ORTSEPBrakeInhibitsTripleValve`` -- Set to 1 if the car is fitted with a
+  selector valve that ignores brake pipe pressure when EP brakes are operational.
 - ``Wagon(ORTSBrakeRelayValveRatio`` -- Determines the proportionality constant
   between pressure as demanded by the triple valve and brake cylinder pressure.
   This is achieved via a relay valve which sets BC pressure proportionally.
@@ -3534,7 +3598,7 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
 - ``Wagon(ORTSInitialApplicationThreshold`` -- The pressure difference between
   the brake pipe and auxiliary reservoir at which the triple valve will
   change from release to apply (default 1 psi).
-- ``BrakeEquipmentType(Supply_Reservoir`` -- Adds a supply reservoir to the
+- ``Wagon(BrakeEquipmentType(Supply_Reservoir`` -- Adds a supply reservoir to the
   loco or wagon, which will constantly charge to the brake pipe pressure
   or MR pipe (if equipped) pressure. If a supply reservoir is equipped,
   supply res air will be used to pressurize the brake cylinders thru the relay
@@ -3571,6 +3635,10 @@ MaxAuxilaryChargingRate and EmergencyResChargingRate.
   Pipe for twin pipe braking systems (default = Main Reservoir Pressure).
 - ``Engine(ORTSCompressorIsMuControlled`` -- Set to 1 if compressors from
   all locomotives are synchronized.
+- ``Wagon(BrakeEquipmentType(Emergency_Solenoid_Valve`` -- Adds an
+  electrically controlled valve that quickly applies maximum
+  brake cylinder pressure during an emergency braking. Only available if the
+  brake cylinder pressure is controlled using a relay valve.
 
 .. _physics-retainers:
 

Source/Orts.Common/Conversions.cs

@@ -189,7 +189,7 @@ public static class Kg
         /// <summary>Convert from kilograms to UK Tons</summary>
         public static float ToTUK(float kg)       { return kg     * (1.0f / 1016.047f); }
         /// <summary>Convert from kilogram to metric tonnes</summary>
-        public static float ToTonne(float kg)      { return kg    / 1000.0f; }
+        public static float ToTonne(float kg)      { return kg    * (1.0f / 1000.0f); }
         /// <summary>Convert from metrix tonnes to kilogram</summary>
         public static float FromTonne(float tonne) { return tonne * 1000.0f; }
     }

Source/Orts.Parsers.Msts/STFReader.cs

@@ -609,10 +609,11 @@ public float ReadFloat(UNITS validUnits, float? defaultValue)
             // However, some values (mostly "time" ones) may be followed by text. Therefore that approach cannot be used consistently 
             // and has been abandoned. </CJComment> 
 
+            float val;
+            double scale = ParseUnitSuffix(ref item, validUnits);
             if (item.Length == 0) return 0.0f;
             if (item[item.Length - 1] == ',') item = item.TrimEnd(',');
-            double scale = ParseUnitSuffix(ref item, validUnits); // must be after TrimEnd(','), otherwise the unit parsed becomes invalid
-            if (float.TryParse(item, parseNum, parseNFI, out float val)) return (scale == 1) ? val : (float)(scale * val);
+            if (float.TryParse(item, parseNum, parseNFI, out val)) return (scale == 1) ? val : (float)(scale * val);
             STFException.TraceWarning(this, "Cannot parse the constant number " + item);
             if (item == ")") StepBackOneItem();
             return defaultValue.GetValueOrDefault(0);

Source/Orts.Simulation/Simulation/Physics/Train.cs

@@ -4042,7 +4042,7 @@ public virtual void InitializeBrakes()
             if (Simulator.Settings.VerboseConfigurationMessages && LeadLocomotiveIndex >= 0) // Check incompatibilities between brake control valves
             {
                 MSTSLocomotive lead = (MSTSLocomotive)Cars[LeadLocomotiveIndex];
-                if (Cars.Any(x => (x as MSTSWagon).BrakeValve != lead.BrakeValve))
+                if (lead.BrakeSystem is AirSinglePipe leadBrakes && Cars.Any(x => x.BrakeSystem is AirSinglePipe carBrakes && leadBrakes.BrakeValve != carBrakes.BrakeValve))
                 {
                     Trace.TraceInformation("Cars along the train have incompatible brake control valves");
                 }
@@ -4061,13 +4061,33 @@ public void UnconditionalInitializeBrakes()
                 MSTSLocomotive lead = (MSTSLocomotive)Cars[LeadLocomotiveIndex];
                 if (lead.TrainBrakeController != null)
                 {
-                    foreach (var car in Cars)
+                    foreach (MSTSWagon car in Cars)
                     {
-                        if (lead.BrakeSystem.GetType() != car.BrakeSystem.GetType())
+                        if (lead.CarBrakeSystemType != car.CarBrakeSystemType) // Test to see if car brake system is the same as the locomotive
                         {
-                            (car as MSTSWagon).EmergencyReservoirPresent = lead.EmergencyReservoirPresent;
-                            car.BrakeSystem = BrakeSystem.CreateNewLike(lead.BrakeSystem, car);
-                            car.BrakeSystem.InitializeFromCopy(lead.BrakeSystem, false);
+                            // If not, change so that they are compatible
+                            car.CarBrakeSystemType = lead.CarBrakeSystemType;
+                            if (lead.BrakeSystem is VacuumSinglePipe)
+                                car.MSTSBrakeSystem = new VacuumSinglePipe(car);
+                            else if (lead.BrakeSystem is AirTwinPipe)
+                                car.MSTSBrakeSystem = new AirTwinPipe(car);
+                            else if (lead.BrakeSystem is AirSinglePipe leadAir)
+                            {
+                                car.MSTSBrakeSystem = new AirSinglePipe(car);
+                                // if emergency reservoir has been set on lead locomotive then also set on trailing cars
+                                if (leadAir.EmergencyReservoirPresent)
+                                {
+                                    (car.BrakeSystem as AirSinglePipe).EmergencyReservoirPresent = leadAir.EmergencyReservoirPresent;
+                                }
+                            }
+                            else if (lead.BrakeSystem is EPBrakeSystem ep)
+                                car.MSTSBrakeSystem = new EPBrakeSystem(car, ep.TwoPipes);
+                            else if (lead.BrakeSystem is SingleTransferPipe)
+                                car.MSTSBrakeSystem = new SingleTransferPipe(car);
+                            else
+                                throw new Exception("Unknown brake type");
+
+                            car.MSTSBrakeSystem.InitializeFromCopy(lead.BrakeSystem);
                             Trace.TraceInformation("Car and Locomotive Brake System Types Incompatible on Car {0} - Car brakesystem type changed to {1}", car.CarID, car.CarBrakeSystemType);
                         }
                     }

Source/Orts.Simulation/Simulation/RollingStocks/MSTSControlTrailerCar.cs

@@ -263,7 +263,7 @@ public override string GetStatus()
         /// <summary>
         /// This function updates periodically the locomotive's motive force.
         /// </summary>
-        protected override void UpdateTractiveForce(float elapsedClockSeconds, float t, float AbsSpeedMpS, float AbsWheelSpeedMpS)
+        protected override void UpdateTractiveForce(float elapsedClockSeconds)
         {
         }