public TrainPathData(Timetable tt, ITrain train) : base(tt)
{
var path = train.GetPath().ToArray();
var arrDeps = train.GetArrDepsUnsorted();
Entries = Init(path, (s, r) =>
{
arrDeps.TryGetValue(s, out var ardp);
return(new TrainPathEntry(s, ardp, r));
});
PathEntries = Entries.OfType <TrainPathEntry>().ToArray();
}
private IEnumerable <Station> GetSortedStations(ITrain train)
{
var path = train.GetPath();
var arrdeps = train.GetArrDepsUnsorted();
foreach (var sta in path)
{
if (arrdeps[sta].HasMinOneTimeSet)
{
yield return(sta);
}
}
}
/// <summary>
/// Get the direction the train passes through this station.
/// </summary>
/// <remarks>This direction may differ from train to train (at the same station) and from station to station (with the same train).</remarks>
/// <returns>If null, the train does not pass through this station.</returns>
public TrainDirection?GetTrainDirectionAtStation(ITrain train, Station sta)
{
var stasAfter = GetStationsInDir(TrainDirection.ti, sta);
var stasBefore = GetStationsInDir(TrainDirection.ta, sta);
var path = train.GetPath();
if (!path.Contains(sta))
{
return(null);
}
var ardeps = train.GetArrDepsUnsorted();
var isStopping = ardeps[sta].HasMinOneTimeSet;
Station?nextStopStation = path.Where(s => stasAfter.Contains(s)).FirstOrDefault(s => ardeps[s].HasMinOneTimeSet);
Station?lastStopStation = null;
if (nextStopStation == null || !isStopping)
{
lastStopStation = path.Where(s => stasBefore.Contains(s)).FirstOrDefault(s => ardeps[s].HasMinOneTimeSet);
}
// We have a stop at this station, use time difference between first/last and current.
if (isStopping)
{
if (nextStopStation == null)
{
if (lastStopStation == null)
{
return(null);
}
var lastStopTime = ardeps[lastStopStation].LastSetTime;
return(lastStopTime < ardeps[sta].FirstSetTime ? TrainDirection.ti : TrainDirection.ta);
}
var nextStopTime = ardeps[nextStopStation].FirstSetTime;
return(nextStopTime > ardeps[sta].LastSetTime ? TrainDirection.ti : TrainDirection.ta);
}
if (lastStopStation == null || nextStopStation == null)
{
return(null); // We are (proven!) not running over this station.
}
// Passthrough, use difference between first and last
return(ardeps[nextStopStation].FirstSetTime > ardeps[lastStopStation].LastSetTime ? TrainDirection.ti : TrainDirection.ta);
}
public IStation[] GetStations(ITrain train)
{
List <IStation> points = new List <IStation>();
var fstations = train.GetPath().Where(s => filterable.LoadStationRules(tt).All(r => !r.Matches(s))); // Filter
points.AddRange(fstations);
var p = attrs?.Points ?? new List <BfplPoint>();
for (int i = 0; i < points.Count; i++)
{
var sta0 = points[i];
if (sta0 == points.Last())
{
break; // Hier ist die Strecke zuende
}
var sta1 = points[i + 1];
int route = Timetable.LINEAR_ROUTE_ID;
if (tt.Type == TimetableType.Network)
{
var routes = sta0.Routes.Where(r => sta1.Routes.Contains(r)).ToArray();
if (routes.Length > 1 || routes.Length == 0)
{
throw new Exception(T._("Zwei benachbarte Stationen sollten nicht mehr als eine/keine Route gemeinsam haben! Zusammengefallene Routen sind vorhanden und werden nicht unterstützt."));
}
route = routes[0];
}
var maxPos = Math.Max(sta0.Positions.GetPosition(route).Value, sta1.Positions.GetPosition(route).Value);
var minPos = Math.Min(sta0.Positions.GetPosition(route).Value, sta1.Positions.GetPosition(route).Value);
var p1 = tt.Type == TimetableType.Network ? p.Where(po => po.Routes.Contains(route)) : p;
var pointsBetween = p1.Where(po => po.Positions.GetPosition(route) > minPos && po.Positions.GetPosition(route) < maxPos).ToArray();
points.InsertRange(points.IndexOf(sta0) + 1, pointsBetween);
i += pointsBetween.Length;
}
return(points.ToArray());
}
/// <inheritdoc /> public List <Station> GetPath() => baseTrain.GetPath();
private string BuildPath(ITrain t)
{
var path = t.GetPath();
return(path.FirstOrDefault()?.SName + " - " + path.LastOrDefault()?.SName);
}
