Merge pull request #9 from odwales20/master

Steam loco support and speed lookahead

Author: odwales20

.gitignore

@@ -2,3 +2,9 @@
 /.claude
 /PORTING_NOTES.md
 /SESSION_RESUME.md
+$staging/Resources/audio/wrongway.wav
+$staging/Resources/audio/trainend.wav
+$staging/Resources/audio/stoptrain.wav
+$staging/Resources/audio/set.wav
+$staging/Resources/audio/on.wav
+$staging/Resources/audio/off.wav

DVRouteManager.dll

@@ -67,6 +67,40 @@ private float GetTrackSpeedLimit(RailTrack track)
             return limit;
         }
 
+        /// <summary>
+        /// Returns the most restrictive speed limit within braking distance ahead on the route.
+        /// Lookahead = v²/0.8 + 50 m (assumes ~0.4 m/s² deceleration), capped at 1500 m.
+        /// Falls back to current track's limit if path not available.
+        /// </summary>
+        private float GetLookaheadSpeedLimit(RailTrack currentTrack, float currentSpeedKmh)
+        {
+            float currentLimit = GetTrackSpeedLimit(currentTrack);
+
+            var path = RouteTracker?.Route?.Path;
+            if (path == null) return currentLimit;
+
+            int startIdx = path.IndexOf(currentTrack);
+            if (startIdx < 0) return currentLimit;
+
+            // Match the game's sign placement: UpcomingSpeedDown signs appear ~speed*2 m
+            // before the speed change. We use speed*3 to give a small safety margin on top.
+            float lookaheadM = Mathf.Max(currentSpeedKmh * 3f, 100f);
+
+            float minLimit = currentLimit;
+            float distAhead = 0f;
+
+            for (int i = startIdx + 1; i < path.Count && distAhead < lookaheadM; i++)
+            {
+                var t = path[i];
+                if (t == null) break;
+                float limit = GetTrackSpeedLimit(t);
+                if (limit < minLimit) minLimit = limit;
+                distAhead += (float)t.LogicTrack().length;
+            }
+
+            return minLimit;
+        }
+
         /// <summary>
         /// Computes the speed limit for a track using the exact same method the game uses
         /// to place speed-limit signs: BezierArcApproximation finds the minimum curve radius,
@@ -257,12 +291,12 @@ private IEnumerator AICoroutine()
                     }
                     else
                     {
-                        TargetSpeed = GetTrackSpeedLimit(trainCar.Bogies[0].track);
+                        TargetSpeed = GetLookaheadSpeedLimit(trainCar.Bogies[0].track, speed);
                     }
                 }
                 else if (RouteTracker.TrackState == RouteTracker.TrackingState.OnStart)
                 {
-                    TargetSpeed = GetTrackSpeedLimit(trainCar.Bogies[0].track);
+                    TargetSpeed = GetLookaheadSpeedLimit(trainCar.Bogies[0].track, speed);
                 }
                 else if (RouteTracker.TrackState == RouteTracker.TrackingState.StopTrainAfterSwitch)
                 {
@@ -289,7 +323,7 @@ private IEnumerator AICoroutine()
                     {
                         yield return Module.StartCoroutine(Reverse());
                         shouldreverse = false;
-                        TargetSpeed = GetTrackSpeedLimit(trainCar.Bogies[0].track);
+                        TargetSpeed = GetLookaheadSpeedLimit(trainCar.Bogies[0].track, speed);
                     }
                 }
 

DVRouteManager/LocoAI.cs

@@ -1,10 +1,12 @@
 using CommandTerminal;
 using DV.HUD;
 using DV.Simulation.Cars;
+using DV.Simulation.Controllers;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
@@ -42,6 +44,29 @@ public class LocoCruiseControl : IDisposable
         private InteriorControlsManager    _interiorControls;
         private bool                       _isDM3;
 
+        // ── Steam (S060 / S282) state ────────────────────────────────────────
+        private bool                       _isSteam;
+        private BaseControlsOverrider      _steamOverrider;
+
+        // Smoothed control positions
+        private float _steamRegulator      = 0f;
+        private float _steamCutoff         = 0.5f;
+        private float _steamBrakeTarget    = 0f;
+
+        // Pulse-braking state
+        private bool  _steamPulseBraking   = false;
+        private float _steamPulseTimer     = 0f;
+        private bool  _steamPulseHigh      = false;
+
+        // Averaged steam-chest pressure (sampled every 0.1 s, window = 10)
+        private readonly Queue<float> _steamPressureSamples = new Queue<float>();
+        private float _steamPressureTimer = 0f;
+
+        // Reflection cache for simFlow.TryGetPort
+        private SimController _steamSimCtrl;
+        private MethodInfo    _tryGetPortMI;
+        private PropertyInfo  _portValueProp;
+
         // ────────────────────────────────────────────────────────────────────
 
         public LocoCruiseControl(ILocomotiveRemoteControl remoteControl, TrainCar car = null)
@@ -54,6 +79,11 @@ public LocoCruiseControl(ILocomotiveRemoteControl remoteControl, TrainCar car =
                 _isDM3        = car.carLivery?.parentType?.id == LOCO_DM3;
                 _indicators   = car.GetComponentInChildren<LocoIndicatorReader>();
                 // Interior controls loaded lazily (may be null until player enters cab)
+
+                string locoId = car.carLivery?.parentType?.id ?? "";
+                _isSteam = locoId.Contains("S060") || locoId.Contains("S282");
+                if (_isSteam)
+                    _steamOverrider = car.SimController?.controlsOverrider;
             }
         }
 
@@ -77,6 +107,10 @@ public bool StartCruiseControl(float targetSpeed)
         //https://en.wikipedia.org/wiki/PID_controller
         protected float MaintainSpeed(float targetAcceleration, float dt, float speed, float acceleration)
         {
+            // Steam locos use direct regulator/cutoff/brake control, not the PID
+            if (_isSteam)
+                return MaintainSpeedSteam(dt, speed);
+
             if (remoteControl.GetReverserSymbol() == "N")
             {
                 running = false;
@@ -220,6 +254,199 @@ private InteriorControlsManager GetInteriorControls()
             return _interiorControls;
         }
 
+        // ── Steam loco controller ────────────────────────────────────────────
+        // Mirrors the algorithm from SteamCruiseControl mod's CruiseControlAI:
+        //   - Direct absolute Set() on regulator, cutoff, brake (no PID)
+        //   - Pressure-aware cutoff: reduce steam admission as chest pressure rises
+        //   - Pulse braking: on 2.5 s / off 1.5 s cycle when overspeeding
+        private float MaintainSpeedSteam(float dt, float speed)
+        {
+            if (_steamOverrider == null) return 0f;
+
+            bool forward  = TargetSpeed >= 0f;
+            float absTarget = Mathf.Abs(TargetSpeed);
+            float absSpeed  = Mathf.Abs(speed);
+
+            float pressure    = GetSteamChestPressure();
+            float avgPressure = UpdateSteamPressureAvg(pressure, dt);
+
+            // ── Full stop ────────────────────────────────────────────────────
+            if (absTarget < Mathf.Epsilon)
+            {
+                _steamPulseBraking = false;
+                SteamSetBrake(1f);
+                SteamSetRegulatorSmooth(0f);
+                SteamSetCutoffSmooth(0.5f, dt);
+                return 0f;
+            }
+
+            float speedDiff = absSpeed - absTarget; // positive → too fast
+
+            if (speedDiff > 0.1f)
+            {
+                // ── Pulse braking ─────────────────────────────────────────────
+                if (!_steamPulseBraking)
+                {
+                    _steamPulseBraking = true;
+                    _steamPulseHigh    = true;
+                    _steamPulseTimer   = 0f;
+                }
+
+                _steamPulseTimer += dt;
+                float overshootFactor = Mathf.Clamp01(speedDiff / 5f);
+
+                const float PULSE_HIGH_DURATION = 2.5f;
+                const float PULSE_LOW_DURATION  = 1.5f;
+
+                if (_steamPulseHigh)
+                {
+                    if (_steamPulseTimer >= PULSE_HIGH_DURATION)
+                    { _steamPulseHigh = false; _steamPulseTimer = 0f; }
+                }
+                else
+                {
+                    if (_steamPulseTimer >= PULSE_LOW_DURATION)
+                    { _steamPulseHigh = true; _steamPulseTimer = 0f; }
+                }
+
+                float brakeVal = _steamPulseHigh ? Mathf.Lerp(0.7f, 1f, overshootFactor) : 0f;
+                SteamSetBrake(brakeVal);
+                SteamSetRegulatorSmooth(0f);
+                // Cutoff to neutral while braking — avoids steam fighting brakes
+                SteamSetCutoffSmooth(forward ? 0.5f : 0.49f, dt);
+            }
+            else
+            {
+                // ── Not braking ───────────────────────────────────────────────
+                _steamPulseBraking = false;
+                _steamPulseHigh    = false;
+                SteamSetBrake(0f);
+
+                if (absSpeed < absTarget - 0.1f)
+                {
+                    // ── Accelerating ──────────────────────────────────────────
+                    float targetRegulator, targetCutoff;
+
+                    if (absSpeed < 10f)
+                    {
+                        // Gentle start — ramp up regulator, full cutoff
+                        targetRegulator = 0.1f + 0.9f * (absSpeed / 10f);
+                        targetCutoff    = forward ? 1f : 0f;
+                    }
+                    else if (absSpeed < 20f)
+                    {
+                        // Full regulator, full cutoff until up to speed
+                        targetRegulator = 1f;
+                        targetCutoff    = forward ? 1f : 0f;
+                    }
+                    else if (avgPressure < 5f)
+                    {
+                        // Low chest pressure: wide-open cutoff to admit more steam
+                        targetRegulator = 1f;
+                        targetCutoff    = forward ? 0.35f : 0.15f;
+                    }
+                    else if (avgPressure < 8f)
+                    {
+                        targetRegulator = 1f;
+                        targetCutoff    = forward
+                            ? (0.4f + 0.1f * (avgPressure - 5f) / 3f)
+                            : 0.25f;
+                    }
+                    else if (avgPressure < 12f)
+                    {
+                        targetRegulator = 1f;
+                        float t = (avgPressure - 8f) / 4f;
+                        targetCutoff    = forward ? (0.55f + 0.25f * t) : 0.35f;
+                    }
+                    else
+                    {
+                        // Good pressure: efficient cutoff (~75%)
+                        targetRegulator = 1f;
+                        targetCutoff    = forward ? 0.75f : 0.25f;
+                    }
+
+                    SteamSetRegulatorSmooth(targetRegulator);
+                    SteamSetCutoffSmooth(targetCutoff, dt);
+                }
+                else
+                {
+                    // ── Coasting at target speed ──────────────────────────────
+                    // Keep tiny regulator so steam flows (engine sound + steam heat)
+                    SteamSetRegulatorSmooth(0.1f);
+                    SteamSetCutoffSmooth(0.5f, dt);
+                }
+            }
+
+            return 0f;
+        }
+
+        private void SteamSetRegulatorSmooth(float target)
+        {
+            _steamRegulator = Mathf.Lerp(_steamRegulator, target, 0.15f);
+            _steamOverrider?.Throttle?.Set(_steamRegulator);
+        }
+
+        // cutoff 0 = full reverse, 0.5 = neutral, 1 = full forward
+        private void SteamSetCutoffSmooth(float target, float dt)
+        {
+            float delta = target - _steamCutoff;
+            if (Mathf.Abs(delta) > 0.005f)
+                _steamCutoff += delta * 0.15f * dt;
+            else
+                _steamCutoff = target;
+
+            _steamOverrider?.Reverser?.Set(_steamCutoff);
+        }
+
+        private void SteamSetBrake(float value)
+        {
+            _steamBrakeTarget = value;
+            _steamOverrider?.Brake?.Set(value);
+        }
+
+        private float UpdateSteamPressureAvg(float currentPressure, float dt)
+        {
+            _steamPressureTimer += dt;
+            if (_steamPressureTimer >= 0.1f)
+            {
+                _steamPressureSamples.Enqueue(currentPressure);
+                _steamPressureTimer = 0f;
+                while (_steamPressureSamples.Count > 10)
+                    _steamPressureSamples.Dequeue();
+            }
+
+            if (_steamPressureSamples.Count == 0) return currentPressure;
+
+            float sum = 0f;
+            foreach (float s in _steamPressureSamples) sum += s;
+            return sum / _steamPressureSamples.Count;
+        }
+
+        private float GetSteamChestPressure()
+        {
+            try
+            {
+                if (_steamSimCtrl == null)
+                    _steamSimCtrl = trainCar?.GetComponentInChildren<SimController>();
+                if (_steamSimCtrl?.simFlow == null) return 8f;
+
+                if (_tryGetPortMI == null)
+                    _tryGetPortMI = _steamSimCtrl.simFlow.GetType()
+                        .GetMethod("TryGetPort", BindingFlags.Instance | BindingFlags.Public);
+                if (_tryGetPortMI == null) return 8f;
+
+                var args = new object[] { "steamEngine.STEAM_CHEST_PRESSURE", null, true };
+                if (!(bool)_tryGetPortMI.Invoke(_steamSimCtrl.simFlow, args) || args[1] == null)
+                    return 8f;
+
+                if (_portValueProp == null)
+                    _portValueProp = args[1].GetType().GetProperty("Value");
+
+                return _portValueProp != null ? (float)_portValueProp.GetValue(args[1]) - 1f : 8f;
+            }
+            catch { return 8f; }
+        }
+
         // ────────────────────────────────────────────────────────────────────
 
         public void Stop()

DVRouteManager/LocoCruiseControl.cs

@@ -33,5 +33,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.4.0.0")]
-[assembly: AssemblyFileVersion("0.4.0.0")]
+[assembly: AssemblyVersion("0.3.4.0")]
+[assembly: AssemblyFileVersion("0.3.4.0")]

DVRouteManager/Properties/AssemblyInfo.cs

@@ -332,11 +332,11 @@ public RailTrack GetPrevTrack(RailTrack currentTrack)
 
         public async Task<Route> FindOppositeRoute()
         {
-            List<TrackTransition> trackTransitions = new List<TrackTransition>();
-
-            trackTransitions.Add(new TrackTransition() { track = FirstTrack, nextTrack = SecondTrack });
-
-            return await Route.FindRoute(FirstTrack.LogicTrack(), LastTrack.LogicTrack(), Module.settings.ReversingStrategy, Trainset, trackTransitions);
+            // Route from the original destination back to the original start.
+            // The old approach banned FirstTrack→SecondTrack and re-ran the same
+            // start→end, which forced the pathfinder around an alternate loop
+            // instead of simply reversing the path.
+            return await Route.FindRoute(LastTrack.LogicTrack(), FirstTrack.LogicTrack(), Module.settings.ReversingStrategy, Trainset);
         }
 
         public async static Task<Route> FindRoute(Track begin, Track end, ReversingStrategy reversingStrategy, Trainset trainset, List<TrackTransition> trackTransitions = null)