using RailEnterprise.Core.Common;
using RailEnterprise.Core.Data;
using RailEnterprise.Core.Rail;
namespace RailEnterprise.Core.Simulation.Systems;
///
/// Marcia dei treni (guida 8.4) con il segnalamento a blocchi:
/// - percorsi A* fino alla prossima fermata;
/// - autorizzazione al movimento: sezioni di blocco prenotate davanti alla testa; su binario
/// semplice si blocca il verso di tutti gli archi fino al primo punto sicuro (stazione con
/// binario libero, deposito, doppio binario, destinazione), così due treni non si trovano mai
/// faccia a faccia;
/// - fisica: a = (Ft − R)/m con Ft = min(P/v, sforzo di trazione, aderenza) e
/// R = m·g·(attrito + pendenza) + 0,6·v²·cx; frenata costante con anticipo sui limiti;
/// - le risorse si liberano quando la coda le ha superate.
/// Nessuna allocazione nel ciclo per treno: liste del treno riutilizzate.
///
public sealed class TrainSystem : ISimSystem
{
public string Name => "Trains";
private const byte HeldBlock = 0;
private const byte HeldPlatform = 1;
private const byte HeldLock = 2;
private double _dt, _brake, _g, _rolling, _aero, _adhesion, _stallSpeed, _stallSeconds, _margin, _maxTurn, _cosTurn, _gradeThreshold, _fastShare;
private int _ticksPerDay;
public void Step(WorldContext ctx)
{
var w = ctx.World;
var phys = w.Data.Construction.Physics;
_dt = w.Calendar.TrainSecondsPerTick;
_brake = phys.BrakingMs2;
_g = phys.Gravity;
_rolling = phys.RollingResistance;
_aero = phys.AeroCoefficient;
_adhesion = phys.Adhesion * phys.AdhesionFactor;
_stallSpeed = phys.StallSpeedKmh / 3.6;
_stallSeconds = phys.StallSeconds;
_margin = w.Data.Construction.Operations.LookaheadMarginM;
_maxTurn = w.Data.Construction.Operations.MaxTurnDeg;
_ticksPerDay = w.Calendar.TicksPerDay;
_cosTurn = DMath.Cos(_maxTurn * Math.PI / 180);
_gradeThreshold = w.Data.Maintenance.Wear.GradientThreshold;
_fastShare = w.Data.Maintenance.Wear.HighSpeedThreshold;
foreach (var t in w.Trains)
{
if (t.Removed) continue;
switch (t.State)
{
case TrainState.InDepot:
if (WantsToLeaveDepot(w, t)) TryPlanLeg(ctx, t);
break;
case TrainState.Loading:
StationWork.Dwell(ctx, t);
if (t.State == TrainState.Loading && StationWork.ReadyToDepart(ctx, t))
{
StationWork.Depart(ctx, t);
TryPlanLeg(ctx, t);
}
break;
case TrainState.NoRoute:
if ((ctx.Tick + t.Id.Value) % _ticksPerDay == 0) TryPlanLeg(ctx, t);
break;
case TrainState.Waiting:
case TrainState.Moving:
case TrainState.Stalled:
Move(ctx, t);
break;
case TrainState.Broken:
if (t.RescueTick >= 0 && ctx.Tick >= t.RescueTick) Rescue(ctx, t);
break;
}
}
}
private static bool WantsToLeaveDepot(World w, Train t)
{
if (t.InWorkshop) return false;
if (t.MaintenanceDepot.IsValid) return w.Network.Depots[t.MaintenanceDepot.Value].Node != t.AtNode;
if (t.GoingToDepot.IsValid) return w.Network.Depots[t.GoingToDepot.Value].Node != t.AtNode;
return t.Line.IsValid && !w.Lines[t.Line.Value].Removed && w.Lines[t.Line.Value].Stops.Count > 0;
}
// il soccorso è arrivato: il treno riprende la marcia rimorchiato verso il deposito della riparazione
private void Rescue(WorldContext ctx, Train t)
{
FleetMaintenanceSystem.OnRescued(ctx, t);
switch (t.StateBeforeFailure)
{
case TrainState.Loading:
t.State = TrainState.Loading;
t.DwellTicks = 0;
break;
case TrainState.Moving:
case TrainState.Waiting:
case TrainState.Stalled:
if (t.Route.Count > 0 && !t.AtNode.IsValid)
{
t.State = TrainState.Waiting;
t.WaitingSinceTick = ctx.Tick;
t.StallSeconds = 0;
break;
}
t.State = TrainState.Waiting;
TryPlanLeg(ctx, t);
break;
default:
t.State = TrainState.Waiting;
TryPlanLeg(ctx, t);
break;
}
}
// ------------------------------------------------------------------ pianificazione
/// Calcola il percorso verso la prossima destinazione del treno fermo in un nodo.
public void TryPlanLeg(WorldContext ctx, Train t)
{
var w = ctx.World;
var net = w.Network;
// intervento prenotato dal pianificatore: dopo la fermata corrente si va in officina
if (t.MaintenanceDepot.IsValid && !t.InWorkshop && !t.GoingToDepot.IsValid) t.GoingToDepot = t.MaintenanceDepot;
NodeId target;
if (t.GoingToDepot.IsValid) target = net.Depots[t.GoingToDepot.Value].Node;
else if (t.Line.IsValid && !w.Lines[t.Line.Value].Removed && w.Lines[t.Line.Value].Stops.Count > 0)
{
var line = w.Lines[t.Line.Value];
if (t.StopIndex >= line.Stops.Count) t.StopIndex = 0;
target = net.Stations[line.Stops[t.StopIndex].Station.Value].Node;
}
else if (t.HomeDepot.IsValid && net.Depots[t.HomeDepot.Value].Node != t.AtNode) target = net.Depots[t.HomeDepot.Value].Node;
else
{
if (t.AtNode.IsValid && net.Nodes[t.AtNode.Value].Depot.IsValid) t.State = TrainState.InDepot;
return;
}
if (t.AtNode == target)
{
t.Route.Clear();
Arrive(ctx, t, target);
return;
}
var arrived = Pathfinder.IsTurningPoint(net, net.Nodes[t.AtNode.Value]) ? EdgeId.None : t.ArrivedVia;
if (!w.Pathfinder.FindPath(net, t.Owner, t.AtNode, arrived, target, t.MaxSpeedKmh, t.NeedsElectrification, _maxTurn, t.Route))
{
if (t.MaintenanceDepot.IsValid && t.GoingToDepot == t.MaintenanceDepot)
{
// officina irraggiungibile da qui: la prenotazione salta e il treno torna alla linea
FleetMaintenanceSystem.CancelBooking(t);
TryPlanLeg(ctx, t);
return;
}
if (t.State != TrainState.NoRoute)
{
ctx.World.Events.Add(new GameEvent(ctx.Day, EventKind.Train, EventSeverity.Warning,
$"{t.Name}: nessun percorso verso la prossima fermata", EntityKind.Train, t.Id.Value, t.Owner));
}
t.State = TrainState.NoRoute;
return;
}
CutAtReversal(net, t);
// lascia il nodo di partenza: deposito (nessuna risorsa) o stazione (il binario resta tenuto finché la coda non esce)
for (int i = 0; i < t.Held.Count; i++)
{
var h = t.Held[i];
if (h.Kind == HeldPlatform && double.IsNaN(h.LeftAt))
{
h.LeftAt = t.Odometer;
t.Held[i] = h;
}
}
t.RouteIndex = 0;
t.StepPos = 0;
t.Speed = 0;
t.ReservedStep = -1;
t.ReservedBlock = -1;
t.ArrivalPlatform = -1;
t.State = TrainState.Waiting;
t.WaitingSinceTick = ctx.Tick;
t.WaitWarned = false;
t.StallSeconds = 0;
t.AtNode = NodeId.None;
}
///
/// Se il percorso inverte la marcia in un nodo intermedio (stazione, deposito o binario morto),
/// lo tronca lì: il treno vi entra tutto, libera l'arco d'arrivo e riparte nel verso opposto
/// con un nuovo percorso. Senza la sosta il treno terrebbe il verso dell'arco da cui è arrivato
/// mentre chiede quello opposto, bloccando chi lo segue.
///
private void CutAtReversal(RailNetwork net, Train t)
{
for (int k = 0; k < t.Route.Count - 1; k++)
{
var a = t.Route[k];
var b = t.Route[k + 1];
var ea = net.Edges[a.Edge.Value];
var node = a.Forward ? ea.B : ea.A;
var dirIn = -ea.DirectionFrom(node);
var dirOut = net.Edges[b.Edge.Value].DirectionFrom(node);
if (Vec2.Dot(dirIn, dirOut) >= _cosTurn) continue;
t.Route.RemoveRange(k + 1, t.Route.Count - k - 1);
return;
}
}
/// Nodo di destinazione corrente (fermata della linea, deposito o deposito di casa).
private static NodeId TargetNode(World w, Train t)
{
var net = w.Network;
if (t.GoingToDepot.IsValid) return net.Depots[t.GoingToDepot.Value].Node;
if (t.Line.IsValid && !w.Lines[t.Line.Value].Removed && w.Lines[t.Line.Value].Stops.Count > 0)
{
var line = w.Lines[t.Line.Value];
return net.Stations[line.Stops[t.StopIndex % line.Stops.Count].Station.Value].Node;
}
return t.HomeDepot.IsValid ? net.Depots[t.HomeDepot.Value].Node : NodeId.None;
}
// ------------------------------------------------------------------ marcia
private void Move(WorldContext ctx, Train t)
{
var w = ctx.World;
var net = w.Network;
if (t.Route.Count == 0)
{
t.State = TrainState.NoRoute;
return;
}
// 1. estende l'autorizzazione al movimento fino alla distanza di frenata con margine
double needed = t.Speed * t.Speed / (2 * _brake) + t.Speed * _dt * 2 + _margin;
double ma = MaDistance(net, t);
while (ma < needed && TryReserveNext(w, t))
ma = MaDistance(net, t);
// 2. velocità obiettivo: limiti presenti e futuri, fine dell'autorizzazione, fermata
var step = t.Route[t.RouteIndex];
var edge = net.Edges[step.Edge.Value];
// condizione del binario e maltempo sull'area (ADR 0017)
double cond = ConstructionSystem.ConditionFactor(w, edge) * w.WorldEvents.EdgeSpeed(edge);
double limit = Math.Min(t.TopSpeedKmh, LimitAt(edge, step.Forward, t.StepPos) * cond) / 3.6;
double target = Math.Min(limit, Math.Sqrt(2 * _brake * Math.Max(0, ma - 1)));
target = Math.Min(target, LookaheadCap(w, t, needed + 500));
// 3. dinamica
double cargoT = CargoMassT(w, t);
double mass = (t.EmptyMassT + cargoT) * 1000;
double grade = step.Forward ? edge.GradeAt(t.StepPos) : -edge.GradeAt(edge.Length - t.StepPos);
double v = t.Speed;
double resist = mass * _g * (_rolling + grade) + _aero * v * v * t.Cx;
double traction = Math.Min(Math.Min(t.PowerKw * 1000 / Math.Max(v, 1), t.TractiveKn * 1000), _adhesion * t.LocoMassT * 1000 * _g);
double a = (traction - resist) / mass;
double vNew;
if (v < target - 1e-3) vNew = Math.Min(target, v + a * _dt);
else vNew = Math.Max(target, v - _brake * _dt);
if (vNew < 0) vNew = 0;
// stallo: vuole muoversi ma non riesce a vincere la salita
if (target > _stallSpeed && vNew < _stallSpeed && a <= 0)
{
t.StallSeconds += _dt;
if (t.StallSeconds >= _stallSeconds && t.State != TrainState.Stalled)
{
t.State = TrainState.Stalled;
w.Events.Add(new GameEvent(ctx.Day, EventKind.Train, EventSeverity.Critical,
$"{t.Name} non supera la salita del {Math.Abs(grade) * 100:F1}%: aggiungi una locomotiva o cambia tracciato",
EntityKind.Train, t.Id.Value, t.Owner));
}
}
else if (vNew > _stallSpeed)
{
t.StallSeconds = 0;
if (t.State == TrainState.Stalled) t.State = TrainState.Moving;
}
double dist = (v + vNew) / 2 * _dt;
if (dist >= ma)
{
dist = Math.Max(0, ma);
vNew = 0;
}
t.Speed = vNew;
if (t.State != TrainState.Stalled) t.State = vNew > 0.01 || dist > 0.01 ? TrainState.Moving : TrainState.Waiting;
if (t.State == TrainState.Moving) t.WaitingSinceTick = ctx.Tick;
else if (!t.WaitWarned && ctx.Tick - t.WaitingSinceTick > (long)w.Data.Construction.Operations.WaitWarningDays * _ticksPerDay)
{
t.WaitWarned = true;
w.Events.Add(new GameEvent(ctx.Day, EventKind.Train, EventSeverity.Warning,
$"{t.Name} è fermo da {w.Data.Construction.Operations.WaitWarningDays} giorni in attesa di via libera: possibile stallo della rete",
EntityKind.Train, t.Id.Value, t.Owner));
}
// 4. avanzamento lungo il percorso
if (dist > 0) Advance(ctx, t, dist, v, cargoT);
ReleaseBehind(net, t);
}
private void Advance(WorldContext ctx, Train t, double dist, double v, double cargoT)
{
var w = ctx.World;
var net = w.Network;
while (dist > 1e-9)
{
var step = t.Route[t.RouteIndex];
var edge = net.Edges[step.Edge.Value];
double remaining = edge.Length - t.StepPos;
double move = Math.Min(dist, remaining);
double before = t.StepPos;
t.StepPos += move;
t.Odometer += move;
t.KmThisYear += move / 1000;
dist -= move;
// usura: tonnellate × fattori, ripartite sulla frazione d'arco percorsa
double grade = Math.Abs(step.Forward ? edge.GradeAt(before) : edge.GradeAt(edge.Length - before));
// chilometri del giorno per l'usura dei veicoli (sezione 10.1)
double km = move / 1000;
t.DayKm += km;
if (grade > _gradeThreshold) t.DayGradeKm += km;
if (v * 3.6 > _fastShare * t.MaxSpeedKmh) t.DayFastKm += km;
if (t.CapacityT > 0) t.DayLoadKm += km * Math.Min(1, cargoT / t.CapacityT);
double vmaxEdge = Math.Max(1, w.Data.Eras.TrackClasses[edge.TrackClass].SpeedKmh / 3.6);
var tw = w.Data.Construction.TrackWear;
edge.WearToday += (t.EmptyMassT + cargoT) * (move / edge.Length) * (1 + tw.GradientWeight * grade) * (1 + tw.SpeedWeight * v / vmaxEdge);
// sezioni di blocco superate dalla testa
int blockBefore = BlockOf(edge, step.Forward, before);
int blockAfter = BlockOf(edge, step.Forward, Math.Min(t.StepPos, edge.Length - 1e-6));
for (int b = blockBefore; b < blockAfter; b++) MarkLeft(t, HeldBlock, edge.Id.Value, b, step.Forward, t.Odometer);
if (t.StepPos < edge.Length - 1e-6) break;
// la testa lascia l'arco
MarkLeft(t, HeldBlock, edge.Id.Value, LastBlock(edge), step.Forward, t.Odometer);
MarkLeft(t, HeldLock, edge.Id.Value, 0, step.Forward, t.Odometer);
var node = step.Forward ? edge.B : edge.A;
if (t.RouteIndex == t.Route.Count - 1)
{
Arrive(ctx, t, node);
return;
}
// stazione o deposito attraversati (punto sicuro intermedio): come all'arrivo, il treno è tutto
// dentro e l'arco d'arrivo si libera subito; il binario di stazione resta tenuto finché la coda
// non esce. Altrimenti un treno fermo in attesa del tratto successivo terrebbe il verso
// dell'arco da cui è arrivato e chi incrocia in stazione resterebbe bloccato.
var through = net.Nodes[node.Value];
if (through.Station.IsValid || through.Depot.IsValid)
{
if (through.Station.IsValid) MarkLeft(t, HeldPlatform, through.Station.Value, -1, true, t.Odometer);
for (int i = 0; i < t.Held.Count; i++)
{
var h = t.Held[i];
if (double.IsNaN(h.LeftAt) || (h.Kind == HeldPlatform && h.Id == through.Station.Value)) continue;
h.LeftAt -= t.LengthM;
t.Held[i] = h;
}
ReleaseBehind(net, t);
}
t.RouteIndex++;
t.StepPos = 0;
}
}
private static void MarkLeft(Train t, byte kind, int id, int index, bool forward, double odometer)
{
for (int i = 0; i < t.Held.Count; i++)
{
var h = t.Held[i];
if (h.Kind != kind || h.Id != id || !double.IsNaN(h.LeftAt)) continue;
if (kind == HeldBlock && (h.Index != index || h.Forward != forward)) continue;
if (kind == HeldLock && h.Forward != forward) continue;
h.LeftAt = odometer;
t.Held[i] = h;
return;
}
}
/// Libera le risorse superate dalla coda.
private static void ReleaseBehind(RailNetwork net, Train t)
{
for (int i = t.Held.Count - 1; i >= 0; i--)
{
var h = t.Held[i];
if (double.IsNaN(h.LeftAt) || t.Odometer - h.LeftAt < t.LengthM) continue;
Release(net, t, h);
t.Held.RemoveAt(i);
}
}
private static void Release(RailNetwork net, Train t, HeldResource h)
{
switch (h.Kind)
{
case HeldBlock:
{
var e = net.Edges[h.Id];
var blocks = h.Forward ? e.BlocksForward : e.BlocksBackward;
if (h.Index < blocks.Length && blocks[h.Index] == t.Id.Value) blocks[h.Index] = -1;
break;
}
case HeldLock:
{
var e = net.Edges[h.Id];
if (e.LockCount > 0) e.LockCount--;
if (e.LockCount == 0) e.LockDir = -1;
break;
}
default:
{
var s = net.Stations[h.Id];
for (int p = 0; p < s.PlatformTrain.Length; p++)
{
if (s.PlatformTrain[p] == t.Id.Value && (h.Index < 0 || h.Index == p)) s.PlatformTrain[p] = -1;
}
break;
}
}
}
/// Libera immediatamente tutto (treno rimosso o rientrato in deposito).
public static void ReleaseAll(RailNetwork net, Train t)
{
foreach (var h in t.Held) Release(net, t, h);
t.Held.Clear();
}
private void Arrive(WorldContext ctx, Train t, NodeId node)
{
var w = ctx.World;
var net = w.Network;
var n = net.Nodes[node.Value];
// in stazione e in deposito il treno è tutto dentro: le risorse dell'arco d'arrivo si liberano
for (int i = 0; i < t.Held.Count; i++)
{
var h = t.Held[i];
if (h.Kind == HeldPlatform && h.Id == n.Station.Value && n.Station.IsValid) continue;
if (double.IsNaN(h.LeftAt)) h.LeftAt = t.Odometer;
h.LeftAt -= t.LengthM;
t.Held[i] = h;
}
ReleaseBehind(net, t);
if (t.Route.Count > 0) t.ArrivedVia = t.Route[^1].Edge;
t.Route.Clear();
t.RouteIndex = 0;
t.StepPos = 0;
t.Speed = 0;
t.AtNode = node;
t.ReservedStep = -1;
t.ReservedBlock = -1;
if (n.Depot.IsValid && (t.GoingToDepot == n.Depot || (!t.Line.IsValid && t.HomeDepot == n.Depot)))
{
ReleaseAll(net, t);
t.State = TrainState.InDepot;
t.GoingToDepot = DepotId.None;
return;
}
if (n.Station.IsValid)
{
t.Platform = t.ArrivalPlatform;
t.ArrivalPlatform = -1;
if (node != TargetNode(w, t))
{
// sosta tecnica per invertire la marcia: niente carico né scarico
t.State = TrainState.Waiting;
TryPlanLeg(ctx, t);
return;
}
StationWork.Arrive(ctx, t, net.Stations[n.Station.Value]);
return;
}
// nodo qualunque (deposito di passaggio, binario morto): ripianifica
t.State = TrainState.Waiting;
TryPlanLeg(ctx, t);
}
// ------------------------------------------------------------------ prenotazioni
/// Distanza dalla testa alla fine dell'autorizzazione al movimento.
private static double MaDistance(RailNetwork net, Train t)
{
if (t.ReservedStep < t.RouteIndex) return 0;
double dist = 0;
for (int s = t.RouteIndex; s <= t.ReservedStep; s++)
{
var step = t.Route[s];
var e = net.Edges[step.Edge.Value];
double from = s == t.RouteIndex ? t.StepPos : 0;
double to = s == t.ReservedStep ? BlockEnd(e, step.Forward, t.ReservedBlock) : e.Length;
dist += Math.Max(0, to - from);
}
return dist;
}
private bool TryReserveNext(World w, Train t)
{
var net = w.Network;
if (t.ReservedStep >= 0)
{
var cur = t.Route[t.ReservedStep];
var ce = net.Edges[cur.Edge.Value];
if (t.ReservedBlock < LastBlock(ce))
{
// sezione successiva sullo stesso arco
var blocks = cur.Forward ? ce.BlocksForward : ce.BlocksBackward;
int next = t.ReservedBlock + 1;
if (blocks[next] >= 0 && blocks[next] != t.Id.Value) return false;
blocks[next] = t.Id.Value;
t.Held.Add(new HeldResource { Kind = HeldBlock, Id = ce.Id.Value, Index = next, Forward = cur.Forward, LeftAt = double.NaN });
t.ReservedBlock = next;
return true;
}
if (t.ReservedStep >= t.Route.Count - 1) return false; // tutto prenotato fino alla destinazione
}
int s = t.ReservedStep + 1;
return EnterStep(w, t, s);
}
// prenota la prima sezione del passo s; su binario semplice blocca il verso fino a un punto sicuro
private bool EnterStep(World w, Train t, int s)
{
var net = w.Network;
var step = t.Route[s];
var edge = net.Edges[step.Edge.Value];
if (!edge.IsUsable) return false;
var blocks = step.Forward ? edge.BlocksForward : edge.BlocksBackward;
if (blocks[0] >= 0 && blocks[0] != t.Id.Value) return false;
int dir = step.Forward ? 0 : 1;
// catena di archi a binario semplice da bloccare insieme
int last = s;
if (!edge.DoubleTrack)
{
while (last < t.Route.Count - 1 && !IsSafePoint(net, t, last))
{
var ne = net.Edges[t.Route[last + 1].Edge.Value];
if (ne.DoubleTrack) break;
last++;
}
}
// verifica tutto prima di prenotare
for (int k = s; k <= last; k++)
{
var e = net.Edges[t.Route[k].Edge.Value];
if (e.DoubleTrack || HoldsLock(t, e.Id.Value)) continue;
int d = t.Route[k].Forward ? 0 : 1;
if (!e.IsUsable || (e.LockDir >= 0 && e.LockDir != d)) return false;
}
int platform = -1;
StationId platformStation = StationId.None;
var endNode = net.Nodes[(t.Route[last].Forward ? net.Edges[t.Route[last].Edge.Value].B : net.Edges[t.Route[last].Edge.Value].A).Value];
bool chainNeedsPlatform = endNode.Station.IsValid && (last == t.Route.Count - 1 || !edge.DoubleTrack);
if (chainNeedsPlatform && !HoldsPlatform(t, endNode.Station.Value))
{
var st = net.Stations[endNode.Station.Value];
platform = Array.IndexOf(st.PlatformTrain, -1);
if (platform < 0) return false;
platformStation = st.Id;
}
// prenota
for (int k = s; k <= last; k++)
{
var e = net.Edges[t.Route[k].Edge.Value];
if (e.DoubleTrack || HoldsLock(t, e.Id.Value)) continue;
int d = t.Route[k].Forward ? 0 : 1;
e.LockDir = d;
e.LockCount++;
t.Held.Add(new HeldResource { Kind = HeldLock, Id = e.Id.Value, Forward = t.Route[k].Forward, LeftAt = double.NaN });
}
blocks[0] = t.Id.Value;
t.Held.Add(new HeldResource { Kind = HeldBlock, Id = edge.Id.Value, Index = 0, Forward = step.Forward, LeftAt = double.NaN });
if (platformStation.IsValid)
{
var st = net.Stations[platformStation.Value];
st.PlatformTrain[platform] = t.Id.Value;
t.Held.Add(new HeldResource { Kind = HeldPlatform, Id = st.Id.Value, Index = platform, Forward = true, LeftAt = double.NaN });
if (last == t.Route.Count - 1) t.ArrivalPlatform = platform;
}
t.ReservedStep = s;
t.ReservedBlock = 0;
_ = dir;
return true;
}
// punto sicuro alla fine del passo k: stazione o deposito, destinazione, o arco successivo a doppio binario
private static bool IsSafePoint(RailNetwork net, Train t, int k)
{
if (k >= t.Route.Count - 1) return true;
var e = net.Edges[t.Route[k].Edge.Value];
var node = net.Nodes[(t.Route[k].Forward ? e.B : e.A).Value];
if (node.Station.IsValid || node.Depot.IsValid) return true;
return net.Edges[t.Route[k + 1].Edge.Value].DoubleTrack;
}
private static bool HoldsLock(Train t, int edge)
{
foreach (var h in t.Held)
{
if (h.Kind == HeldLock && h.Id == edge && double.IsNaN(h.LeftAt)) return true;
}
return false;
}
private static bool HoldsPlatform(Train t, int station)
{
foreach (var h in t.Held)
{
if (h.Kind == HeldPlatform && h.Id == station && double.IsNaN(h.LeftAt)) return true;
}
return false;
}
// ------------------------------------------------------------------ geometria dei blocchi
/// Indice dell'ultima sezione di blocco dell'arco.
public static int LastBlock(TrackEdge e) => e.Signals.Count;
/// Fine (progressiva nel verso di marcia) della sezione j.
public static double BlockEnd(TrackEdge e, bool forward, int j)
{
int n = e.Signals.Count;
if (j >= n) return e.Length;
return forward ? e.Signals[j] : e.Length - e.Signals[n - 1 - j];
}
/// Sezione che contiene la progressiva pos (nel verso di marcia).
public static int BlockOf(TrackEdge e, bool forward, double pos)
{
int j = 0;
while (j < e.Signals.Count && pos >= BlockEnd(e, forward, j)) j++;
return j;
}
// ------------------------------------------------------------------ limiti e anticipo
private static double LimitAt(TrackEdge e, bool forward, double pos)
{
double s = forward ? pos : e.Length - pos;
return e.SpeedLimitKmh[e.SampleIndex(s)];
}
// velocità massima compatibile con i limiti più bassi entro la distanza di osservazione
private double LookaheadCap(World w, Train t, double horizon)
{
var net = w.Network;
double cap = double.MaxValue;
double dist = 0;
for (int s = t.RouteIndex; s < t.Route.Count && dist < horizon; s++)
{
var step = t.Route[s];
var e = net.Edges[step.Edge.Value];
double cond = ConstructionSystem.ConditionFactor(w, e) * w.WorldEvents.EdgeSpeed(e);
double start = s == t.RouteIndex ? t.StepPos : 0;
int n = e.S.Length;
if (step.Forward)
{
for (int i = e.SampleIndex(start) + 1; i < n - 1; i++)
{
double d = dist + e.S[i] - start;
if (d > horizon) break;
double vl = Math.Min(t.TopSpeedKmh, e.SpeedLimitKmh[i] * cond) / 3.6;
cap = Math.Min(cap, Math.Sqrt(vl * vl + 2 * _brake * Math.Max(0, d)));
}
}
else
{
double sGeo = e.Length - start;
for (int i = e.SampleIndex(sGeo); i > 0; i--)
{
double d = dist + (sGeo - e.S[i]);
if (d > horizon) break;
double vl = Math.Min(t.TopSpeedKmh, e.SpeedLimitKmh[i - 1] * cond) / 3.6;
cap = Math.Min(cap, Math.Sqrt(vl * vl + 2 * _brake * Math.Max(0, d)));
}
}
dist += e.Length - start;
}
// fermata a fine percorso
if (dist < horizon) cap = Math.Min(cap, Math.Sqrt(2 * _brake * Math.Max(0, dist)));
return cap;
}
private static double CargoMassT(World w, Train t)
{
double m = 0;
foreach (var id in t.Vehicles)
{
var v = w.Vehicles[id.Value];
m += v.Load + v.Pax * w.Data.Construction.Physics.PassengerMassT;
}
return m;
}
}