Merge pull request #1076 from Roeterdink/AllowDepartEarly

Allows request stop, depart early, passing time

Author: cjakeman

Source/Orts.Formats.Msts/SignalConfigurationFile.cs

@@ -582,8 +582,15 @@ public class SignalType
         public int NumClearAhead_ORTS { get; private set; }
         /// <summary>Number of seconds to spend animating a semaphore signal.</summary>
         public float SemaphoreInfo { get; private set; }
+
+        /// <summary> approach control details
         public ApproachControlLimits ApproachControlDetails;
 
+        /// <summary> visibility distance for request stop pick up
+        public float? ReqStopVisDistance;
+        /// <summary> announce distance for request stop set down
+        public float? ReqStopAnnDistance;
+
         /// <summary> Glow value for daytime (optional).</summary>
         public float? DayGlow = null;
         /// <summary> Glow value for nighttime (optional).</summary>
@@ -640,6 +647,8 @@ public SignalType(STFReader stf, bool ortsMode, IDictionary<string, SignalFuncti
                 new STFReader.TokenProcessor("signaldrawstates", ()=>{ DrawStates = ReadDrawStates(stf); }),
                 new STFReader.TokenProcessor("signalaspects", ()=>{ Aspects = ReadAspects(stf); }),
                 new STFReader.TokenProcessor("approachcontrolsettings", ()=>{ ApproachControlDetails = ReadApproachControlDetails(stf); }),
+                new STFReader.TokenProcessor("ortsreqstopvisdistance", ()=>{ReqStopVisDistance = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
+                new STFReader.TokenProcessor("ortsreqstopanndistance", ()=>{ReqStopAnnDistance = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
                 new STFReader.TokenProcessor("signalnumclearahead", ()=>{ numClearAhead = numClearAhead >= -1 ? numClearAhead : stf.ReadIntBlock(null); numdefs++;}),
                 new STFReader.TokenProcessor("semaphoreinfo", ()=>{ SemaphoreInfo = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),
                 new STFReader.TokenProcessor("ortsdayglow", ()=>{ DayGlow = stf.ReadFloatBlock(STFReader.UNITS.None, null); }),

Source/Orts.Formats.Msts/SignalScripts.cs

@@ -113,6 +113,7 @@ public enum SCRExternalFunctions
             NEXT_SIG_HASNORMALSUBTYPE,
             ID_SIG_HASNORMALSUBTYPE,
             SWITCHSTAND,
+            TRAIN_HAS_REQUEST_STOP,
             DEBUG_HEADER,
             DEBUG_OUT,
             RETURN,

Source/Orts.Simulation/Common/Events.cs

@@ -288,6 +288,9 @@ public enum Event
         CruiseControlAlert,
         CruiseControlAlert1,
 
+        // request stop
+        RequestStopAnnounce,
+
         MPCChangePosition,
 
     }
@@ -566,6 +569,8 @@ public static Event From(Source source, int eventID)
                         case 262: return Event.WindowsClosed;
                         case 263: return Event.WindowsOpen;
 
+                        case 270: return Event.RequestStopAnnounce;
+
                         // Cruise Control
                         case 298: return Event.LeverFromZero;
                         case 299: return Event.LeverToZero;

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

@@ -1994,7 +1994,10 @@ public virtual void UpdateStationState(float elapsedClockSeconds, int presentTim
 
             // Depart
             thisStation.Passed = true;
-            Delay = TimeSpan.FromSeconds((presentTime - thisStation.DepartTime) % (24 * 3600));
+            if (thisStation.ArrivalTime >= 0)
+            {
+                Delay = TimeSpan.FromSeconds((presentTime - thisStation.DepartTime) % (24 * 3600));
+            }
             PreviousStop = thisStation.CreateCopy();
 
             if (thisStation.ActualStopType == StationStop.STOPTYPE.STATION_STOP
@@ -2060,7 +2063,6 @@ public virtual void UpdateStationState(float elapsedClockSeconds, int presentTim
                     MovementState = AI_MOVEMENT_STATE.STOPPED_EXISTING;
                     if (TrainType != TRAINTYPE.AI_PLAYERHOSTING) AtStation = false;
                 }
-
                 Delay = TimeSpan.FromSeconds((presentTime - thisStation.DepartTime) % (24 * 3600));
             }
             if (Cars[0] is MSTSLocomotive) Cars[0].SignalEvent(Event.AITrainLeavingStation);

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

@@ -3058,13 +3058,6 @@ public virtual bool PostInit()
             if (IsActualPlayerTrain)
             {
                 SetTrainSpeedLoggingFlag();
-
-
-                // if debug, print out all passing paths
-
-#if DEBUG_DEADLOCK
-                Printout_PassingPaths();
-#endif
             }
 
             return (validPosition);
@@ -13447,6 +13440,7 @@ public bool CreateStationStop(int platformStartID, int arrivalTime, int departTi
                         false,
                         false,
                         false,
+                        false,
                         StationStop.STOPTYPE.STATION_STOP);
 
                 thisStation.arrivalDT = arrivalDT;
@@ -16332,6 +16326,7 @@ public StationStop CalculateStationStop(int platformStartID, int arrivalTime, in
                         false,
                         false,
                         false,
+                        false,
                         StationStop.STOPTYPE.STATION_STOP);
 
                 thisStation.arrivalDT = arrivalDT;
@@ -20832,9 +20827,14 @@ public enum STOPTYPE
             public bool RestrictPlatformToSignal = false;                                         // restrict end of platform to signal position
             public bool ExtendPlatformToSignal = false;                                           // extend end of platform to next signal position
             public bool EndStop = false;                                                          // train terminates at station
+            public bool AllowDepartEarly = false;                                                 // train is allowed to depart early
             public List<int> ConnectionsWaiting = new List<int>();                                // List of trains waiting
             public Dictionary<int, int> ConnectionsAwaited = new Dictionary<int, int>();          // List of awaited trains : key = trainno., value = arr time
             public Dictionary<int, WaitInfo> ConnectionDetails = new Dictionary<int, WaitInfo>(); // Details of connection : key = trainno., value = wait info
+            public RequestStop ReqStopDetails = null;                                             // Request stop details
+            public int PassTime;                                                                  // Passing time (int)
+            public DateTime passDT;                                                               // Passing time (DateTime)
+            public bool PassingOnly;
 
             //================================================================================================//
             //
@@ -20843,9 +20843,9 @@ public enum STOPTYPE
 
             public StationStop(int platformReference, PlatformDetails platformItem, int subrouteIndex, int routeIndex,
                 int tcSectionIndex, int direction, int exitSignal, bool holdSignal, bool noWaitSignal, bool noClaimAllowed, float stopOffset,
-                int arrivalTime, int departTime, bool terminal, int? actualMinStopTime, float? keepClearFront, float? keepClearRear, 
+                int? arrivalTime, int? departTime, bool terminal, int? actualMinStopTime, float? keepClearFront, float? keepClearRear, 
                 bool forcePosition, bool closeupSignal, bool closeup,
-                bool restrictPlatformToSignal, bool extendPlatformToSignal, bool endStop, STOPTYPE actualStopType)
+                bool restrictPlatformToSignal, bool extendPlatformToSignal, bool endStop, bool allowdepartearly, STOPTYPE actualStopType)
             {
                 ActualStopType = actualStopType;
                 PlatformReference = platformReference;
@@ -20861,14 +20861,21 @@ public StationStop(int platformReference, PlatformDetails platformItem, int subr
                 StopOffset = stopOffset;
                 if (actualStopType == STOPTYPE.STATION_STOP)
                 {
-                    ArrivalTime = Math.Max(0, arrivalTime);
-                    DepartTime = Math.Max(0, departTime);
+                    if (arrivalTime.HasValue)
+                    {
+                        ArrivalTime = Math.Max(0, arrivalTime.Value);
+                        DepartTime = Math.Max(0, departTime.Value);
+                    }
+                    else
+                    {
+                        ArrivalTime = DepartTime = -1;
+                    }
                 }
                 else
                 // times may be <0 for waiting point
                 {
-                    ArrivalTime = arrivalTime;
-                    DepartTime = departTime;
+                    ArrivalTime = arrivalTime.Value;
+                    DepartTime = departTime.Value;
                 }
                 ActualArrival = -1;
                 ActualDepart = -1;
@@ -20885,8 +20892,10 @@ public StationStop(int platformReference, PlatformDetails platformItem, int subr
                 RestrictPlatformToSignal = restrictPlatformToSignal;
                 ExtendPlatformToSignal = extendPlatformToSignal;
                 EndStop = endStop;
+                AllowDepartEarly = allowdepartearly;
 
                 CallOnAllowed = false;
+                PassingOnly = false;
             }
 
             //================================================================================================//
@@ -20999,6 +21008,16 @@ public StationStop(BinaryReader inf, Signals signalRef)
                 RestrictPlatformToSignal = inf.ReadBoolean();
                 ExtendPlatformToSignal = inf.ReadBoolean();
                 EndStop = inf.ReadBoolean();
+                AllowDepartEarly = inf.ReadBoolean();
+
+                if (inf.ReadBoolean())
+                {
+                    ReqStopDetails = new RequestStop(inf, signalRef);
+                }
+
+                PassTime = inf.ReadInt32();
+                passDT = new DateTime(inf.ReadInt64());
+                PassingOnly = inf.ReadBoolean();
             }
 
             //================================================================================================//
@@ -21122,6 +21141,21 @@ public void Save(BinaryWriter outf)
                 outf.Write(RestrictPlatformToSignal);
                 outf.Write(ExtendPlatformToSignal);
                 outf.Write(EndStop);
+                outf.Write(AllowDepartEarly);
+
+                if (ReqStopDetails != null)
+                {
+                    outf.Write(true);
+                    ReqStopDetails.Save(outf);
+                }
+                else
+                {
+                    outf.Write(false);
+                }
+
+                outf.Write(PassTime);
+                outf.Write((Int64)passDT.Ticks);
+                outf.Write(PassingOnly);
             }
 
             /// <summary>
@@ -21144,6 +21178,21 @@ public int CalculateDepartTime(int presentTime, Train stoppedTrain)
                 int eightHundredHours = 8 * 3600;
                 int sixteenHundredHours = 16 * 3600;
 
+                int stopTime = 0;
+
+                // allow to depart early if set (timetable mode only, so no need to check for valid schedule)
+                // also allow to depart after boarding time if arrival time is not set
+                if (AllowDepartEarly || ArrivalTime < 0)
+                {
+                    stoppedTrain.ComputeTrainBoardingTime(this, ref stopTime);
+                    ActualDepart = ActualArrival + stopTime;
+
+                    // correct for times around midnight
+                    if (ActualDepart > 24 * 3600) ActualDepart -= 24 * 3600;
+                    if (DepartTime == 0) DepartTime = ActualDepart;
+                    return stopTime;
+                }
+
                 // preset depart to booked time
                 ActualDepart = DepartTime;
 
@@ -21158,7 +21207,7 @@ public int CalculateDepartTime(int presentTime, Train stoppedTrain)
                 }
 
                 // correct stop time for stop around midnight
-                int stopTime = DepartTime - ArrivalTime;
+                stopTime = DepartTime - ArrivalTime;
                 if (DepartTime < eightHundredHours && ArrivalTime > sixteenHundredHours) // stop over midnight
                 {
                     stopTime += (24 * 3600);

Source/Orts.Simulation/Simulation/Signalling/SIGSCRfile.cs

@@ -1440,6 +1440,18 @@ public int SH_function_value(SignalHead thisHead, SignalScripts.SCRScripts.SCRSt
                     return_value = thisHead.id_sig_hasnormalsubtype(parameter1_value, parameter2_value);
                     break;
 
+                // request stop
+
+                case SignalScripts.SCRExternalFunctions.TRAIN_HAS_REQUEST_STOP:
+#if DEBUG_PRINT_PROCESS
+                    if (TDB_debug_ref.Contains(thisHead.TDBIndex) || OBJ_debug_ref.Contains(thisHead.mainSignal.thisRef))
+                    {
+                        dumpfile = String.Concat(dpr_fileLoc, "printproc.txt");
+                    }
+#endif
+                    return_value = thisHead.trainRequestStop(parameter1_value, parameter2_value, dumpfile);
+                    break;
+
                 // switchstand
 
                 case SignalScripts.SCRExternalFunctions.SWITCHSTAND:

Source/Orts.Simulation/Simulation/Signalling/SignalHead.cs

@@ -50,6 +50,9 @@ public class SignalHead
         public float? ApproachControlLimitPositionM;
         public float? ApproachControlLimitSpeedMpS;
 
+        public float? ReqStopVisDistance;       // visibility for request stop for AI trains
+        public float? ReqStopAnnDistance;       // announce distance for request stop for player train
+
         public SignalFunction Function { get; protected set; } = SignalFunction.UNKNOWN;
 
         public int ORTSNormalSubtypeIndex;     // subtype index form sigcfg file
@@ -155,6 +158,11 @@ public void SetSignalType(TrItem[] TrItems, SignalConfigurationFile sigCFG)
                         ApproachControlLimitPositionM = null;
                         ApproachControlLimitSpeedMpS = null;
                     }
+
+                    // request stop visibility
+
+                    ReqStopVisDistance = signalType.ReqStopVisDistance;
+                    ReqStopAnnDistance = signalType.ReqStopAnnDistance;
                 }
                 else
                 {
@@ -313,6 +321,11 @@ public int id_sig_hasnormalsubtype(int sigId, int reqSubtype)
             return 0;
         }
 
+        public int trainRequestStop(int aspect1, int aspect2, string dumpfile)
+        {
+            return mainSignal.trainRequestStop(aspect1, aspect2, dumpfile);
+        }
+
         public int switchstand(int aspect1, int aspect2, string dumpfile)
         {
             return mainSignal.switchstand(aspect1, aspect2, dumpfile);

Source/Orts.Simulation/Simulation/Signalling/SignalObject.cs

@@ -87,6 +87,9 @@ public enum Permission
 
         public List<int> JunctionsPassed = new List<int>();  // Junctions which are passed checking next signal //
 
+        public int? platformRef = null;         // platform reference, used for request stop
+        public float? visDistance = null;       // visibility distance for request stop
+
         public int thisRef;                     // This signal's reference.
         public int direction;                   // Direction facing on track
 
@@ -365,6 +368,30 @@ public void RestoreTrains(List<Train> trains)
                     {
                         enabledTrain = thisSection.CircuitState.TrainReserved;
                     }
+                    else if (thisSection.CircuitState.HasTrainsOccupying())
+                    {
+                        List<Train.TrainRouted> trainList = thisSection.CircuitState.TrainsOccupying();
+                        float? offsetInSection = null;
+
+                        foreach (var thisRouted in trainList)
+                        {
+                            var thisTrain = thisRouted.Train;
+                            var thisOffset = thisTrain.PresentPosition[0].TCOffset;
+                            if (!offsetInSection.HasValue || thisOffset > offsetInSection)
+                            {
+                                offsetInSection = thisOffset;
+                                if (thisTrain.Number == number)
+                                {
+                                    enabledTrain = thisRouted;
+                                    thisTrain.NextSignalObject[0] = this;
+                                }
+                                else
+                                {
+                                    enabledTrain = null;
+                                }
+                            }
+                        }
+                    }
                     else
                     {
                         enabledTrain = null; // reset - train not found
@@ -1251,6 +1278,67 @@ public int switchstand(int aspect1, int aspect2, string dumpfile)
         }
 
 
+        /// <summary>
+        /// trainhasrequeststop : link signal with platform and set state according to request stop pickup requirements
+        /// </summary>
+        public int trainRequestStop(int aspect1, int aspect2, string dumpfile)
+        {
+            int aspect = 0;
+
+            // set platform link if not yet set
+            if (!platformRef.HasValue)
+            {
+                TrackCircuitSection thisSection = signalRef.TrackCircuitList[TCReference];
+                foreach (int pfIndex in thisSection.PlatformIndex)
+                {
+                    PlatformDetails thisPlatform = signalRef.PlatformDetailsList[pfIndex];
+                    if (thisPlatform.TCOffset[0, TCDirection] < TCOffset && TCOffset < thisPlatform.TCOffset[1, TCDirection])
+                    {
+                        platformRef = pfIndex;
+                        continue;
+                    }
+                    else if (thisPlatform.TCOffset[1, TCDirection] < TCOffset && TCOffset < thisPlatform.TCOffset[0, TCDirection])
+                    {
+                        platformRef = pfIndex;
+                        continue;
+                    }
+                }
+            }
+
+            // if enabled, check if related station is next station for train
+
+            if (enabled && platformRef.HasValue)
+            {
+                if (enabledTrain.Train.StationStops != null && enabledTrain.Train.StationStops.Count > 0)
+                {
+                    if (enabledTrain.Train.StationStops[0].PlatformItem.Name == signalRef.PlatformDetailsList[platformRef.Value].Name)
+                    {
+                        if (enabledTrain.Train.StationStops[0].ReqStopDetails != null)
+                        {
+                            foreach (var sighead in SignalHeads)
+                            {
+                                if (sighead.ReqStopVisDistance.HasValue)
+                                {
+                                    enabledTrain.Train.StationStops[0].ReqStopDetails.visDistance = sighead.ReqStopVisDistance.Value;
+                                }
+                                if (sighead.ReqStopAnnDistance.HasValue)
+                                {
+                                    enabledTrain.Train.StationStops[0].ReqStopDetails.annDistance = sighead.ReqStopAnnDistance.Value;
+                                }
+                            }
+
+                            if (enabledTrain.Train.StationStops[0].ReqStopDetails.pickupSet)
+                            {
+                                aspect = 1;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return aspect;
+        }
+
         /// <summary>
         /// route_set : check if required route is set
         /// </summary>