Merge pull request #1074 from Roeterdink/Gradient

Gradient for AI trains in timetables

Author: cjakeman

Source/Orts.Simulation/Simulation/AIs/AITrain.cs

@@ -3658,7 +3658,7 @@ public void AdjustControlsThrottleOff()
             }
         }
 
-        public void AdjustControlsAccelMore(float reqAccelMpSS, float timeS, int stepSize)
+        public virtual void AdjustControlsAccelMore(float reqAccelMpSS, float timeS, int stepSize)
         {
             if (AITrainBrakePercent > 0)
             {

Source/Orts.Simulation/Simulation/Timetables/ProcessTimetable.cs

@@ -2160,6 +2160,61 @@ public void ProcessSpeedInfo(string speedInfo, float actSpeedConv)
                                 }
                                 break;
 
+                            case "gradient":
+                                foreach (TTTrainCommands.TTTrainComQualifiers thisComValue in thisCommand.CommandQualifiers)
+                                {
+                                    switch (thisComValue.QualifierName)
+                                    {
+                                        case "perc":
+                                            try
+                                            {
+                                                float gradPerc = Convert.ToSingle(thisComValue.QualifierValues[0]);
+                                                if (gradPerc <= 0 || gradPerc > 25)
+                                                {
+                                                    Trace.TraceInformation("Train {0} : invalid value for gradient percent in speed setting : {1} \n",
+                                                    TTTrain.Name, gradPerc);
+                                                }
+                                                else
+                                                {
+                                                    TTTrain.SpeedSettings.gradPerc = gradPerc;
+                                                }
+                                            }
+                                            catch
+                                            {
+                                                Trace.TraceInformation("Train {0} : invalid value for gradient percent in speed setting : {1} \n",
+                                                TTTrain.Name, thisComValue.QualifierValues[0]);
+                                            }
+                                            break;
+
+                                        case "speed":
+                                            try
+                                            {
+                                                float gradSpeed = Convert.ToSingle(thisComValue.QualifierValues[0]);
+                                                TTTrain.SpeedSettings.gradMinSpeed = gradSpeed;
+                                            }
+                                            catch
+                                            {
+                                                Trace.TraceInformation("Train {0} : invalid value for gradient min speed in speed setting : {1} \n",
+                                                TTTrain.Name, thisComValue.QualifierValues[0]);
+                                            }
+                                            break;
+
+                                        default:
+                                            Trace.TraceInformation("Invalid qualifier in gradient speed command : {0} for train : {1}", thisComValue.QualifierName, TTTrain.Name);
+                                            break;
+                                    }
+                                }
+
+                                if (TTTrain.SpeedSettings.gradPerc.HasValue && TTTrain.SpeedSettings.gradMinSpeed.HasValue)
+                                {
+                                    TTTrain.SpeedSettings.gradient = true;
+                                }
+                                else
+                                {
+                                    Trace.TraceInformation("Train {0} : incomplete definition for gradient\n", TTTrain.Name);
+                                }
+                                break;
+
                             default:
                                 Trace.TraceInformation("Invalid token in speed command : {0} for train : {1}", thisCommand.CommandToken, TTTrain.Name);
                                 break;

Source/Orts.Simulation/Simulation/Timetables/TTTrain.cs

@@ -183,6 +183,9 @@ public struct SpeedValues
             public float routeSpeedMpS;        // Route defined max speed
             public float consistSpeedMpS;      // Consist defined max speed
             public bool restrictedSet;         // Special speed has been set
+            public bool gradient;              // gradient definition has been set
+            public float? gradPerc;            // gradient percentage
+            public float? gradMinSpeed;        // gradient minimum speed
         }
 
         public DelayedStartValues DelayedStartSettings = new DelayedStartValues();
@@ -261,6 +264,9 @@ public TTTrain(Simulator simulator)
             SpeedSettings.detachSpeedMpS = null;
             SpeedSettings.movingtableSpeedMpS = null;
             SpeedSettings.restrictedSet = false;
+            SpeedSettings.gradient = false;
+            SpeedSettings.gradPerc = null;
+            SpeedSettings.gradMinSpeed = null;
         }
 
         //================================================================================================//
@@ -530,9 +536,18 @@ public TTTrain(Simulator simulator, BinaryReader inf, AI airef)
                 attachSpeedMpS = inf.ReadBoolean() ? inf.ReadSingle() : (float?)null,
                 detachSpeedMpS = inf.ReadBoolean() ? inf.ReadSingle() : (float?)null,
                 movingtableSpeedMpS = inf.ReadBoolean() ? inf.ReadSingle() : (float?)null,
-                restrictedSet = inf.ReadBoolean()
+                restrictedSet = inf.ReadBoolean(),
+                gradient = inf.ReadBoolean(),
+                gradPerc = null,
+                gradMinSpeed = null
             };
 
+            if (SpeedSettings.gradient)
+            {
+                SpeedSettings.gradPerc = inf.ReadSingle();
+                SpeedSettings.gradMinSpeed = inf.ReadSingle();
+            }
+
             DriverOnlyOperation = inf.ReadBoolean();
             ForceReversal = inf.ReadBoolean();
 
@@ -843,6 +858,13 @@ public override void Save(BinaryWriter outf)
                 outf.Write(SpeedSettings.movingtableSpeedMpS.Value);
             }
             outf.Write(SpeedSettings.restrictedSet);
+            outf.Write(SpeedSettings.gradient);
+            if (SpeedSettings.gradient)
+            {
+                outf.Write(SpeedSettings.gradPerc.Value);
+                outf.Write(SpeedSettings.gradMinSpeed.Value);
+            }
+
             outf.Write(DriverOnlyOperation);
             outf.Write(ForceReversal);
             outf.Write(Briefing);
@@ -5911,6 +5933,70 @@ public override void StartMoving(AI_START_MOVEMENT reason)
 #endif
         }
 
+        //================================================================================================//
+        /// <summary>
+        /// Train control routine for full acceleration
+        /// Overrride for AITrain.cs
+        /// </summary>
+
+        public override void AdjustControlsAccelMore(float reqAccelMpSS, float timeS, int stepSize)
+        {
+            if (AITrainBrakePercent > 0)
+            {
+                AdjustControlsBrakeOff();
+            }
+
+            if (AITrainThrottlePercent < 100)
+            {
+                AITrainThrottlePercent += stepSize;
+                if (AITrainThrottlePercent > 100)
+                    AITrainThrottlePercent = 100;
+            }
+            else if (LastSpeedMpS == 0 || (((SpeedMpS - LastSpeedMpS) / timeS) < 0.5f * MaxAccelMpSS))
+            {
+                bool forceaccreq = true;
+
+                // test for train on gradient
+                if (SpeedSettings.gradient)
+                {
+                    bool ongrad = false;
+                    foreach (TrainCar car in Cars)
+                    {
+                        if (car.CurrentElevationPercent > SpeedSettings.gradPerc)
+                        {
+                            ongrad = true;
+                            continue;
+                        }
+                    }
+                    if (ongrad && SpeedMpS > SpeedSettings.gradMinSpeed)
+                    {
+                        forceaccreq = false;
+                    }
+                }
+
+                // forced acc is required
+                if (forceaccreq)
+                {
+                    float ds = timeS * (reqAccelMpSS);
+                    SpeedMpS = LastSpeedMpS + ds;
+                    foreach (TrainCar car in Cars)
+                    {
+                        //TODO: next code line has been modified to flip trainset physics in order to get viewing direction coincident with loco direction when using rear cab.
+                        // To achieve the same result with other means, without flipping trainset physics, the line should be changed as follows:
+                        //  car.SpeedMpS = car.Flipped ? -SpeedMpS : SpeedMpS;
+                        car.SpeedMpS = car.Flipped ^ (car.IsDriveable && car.Train.IsActualPlayerTrain && ((MSTSLocomotive)car).UsingRearCab) ? -SpeedMpS : SpeedMpS;
+                    }
+
+                    if (CheckTrain)
+                    {
+                        File.AppendAllText(@"C:\temp\checktrain.txt", "Forced speed increase : was " + LastSpeedMpS + " - now " + SpeedMpS + "\n");
+                    }
+                }
+            }
+
+            SetPercentsFromTrainToTrainset();
+        }
+
         //================================================================================================//
         /// <summary>
         /// Calculate initial position