// Restore
public void RestorePresentPosition(BinaryReader inf, Train train)
{
if (null == train)
{
throw new ArgumentNullException(nameof(train));
}
if (null == inf)
{
throw new ArgumentNullException(nameof(inf));
}
TrackNode tn = train.FrontTDBTraveller.TN;
float offset = train.FrontTDBTraveller.TrackNodeOffset;
TrackDirection direction = (TrackDirection)train.FrontTDBTraveller.Direction;
TrackCircuitPosition tempPosition = new TrackCircuitPosition();
tempPosition.SetPosition(tn.TrackCircuitCrossReferences, offset, direction);
TrackCircuitSectionIndex = inf.ReadInt32();
Direction = (TrackDirection)inf.ReadInt32();
Offset = inf.ReadSingle();
RouteListIndex = inf.ReadInt32();
TrackNode = inf.ReadInt32();
DistanceTravelled = inf.ReadSingle();
float offsetDif = Math.Abs(Offset - tempPosition.Offset);
if (TrackCircuitSectionIndex != tempPosition.TrackCircuitSectionIndex ||
(TrackCircuitSectionIndex == tempPosition.TrackCircuitSectionIndex && offsetDif > 5.0f))
{
Trace.TraceWarning("Train {0} restored at different present position : was {1} - {3}, is {2} - {4}",
train.Number, TrackCircuitSectionIndex, tempPosition.TrackCircuitSectionIndex,
Offset, tempPosition.Offset);
}
}
private static int GetDirectionRotation(TrackDirection direction) => direction switch
{
private Sprite GetTrackSprite(Node previousNode, Node node, Node nextNode)
{
TrackDirection previousTrackDir = TrackDirection.None;
if (previousNode != null)
{
previousTrackDir = GetRelativeTrackDirection(node, previousNode);
}
TrackDirection nextTrackDir = TrackDirection.None;
if (nextNode != null)
{
nextTrackDir = GetRelativeTrackDirection(node, nextNode);
}
if (previousTrackDir == TrackDirection.None)
{
if (nextTrackDir == TrackDirection.Up)
{
return(verticalTrack [0]);
}
else if (nextTrackDir == TrackDirection.Down)
{
return(verticalTrack [2]);
}
else if (nextTrackDir == TrackDirection.Left)
{
return(horizontalTrack [2]);
}
else
{
return(horizontalTrack [0]);
}
}
else if (nextTrackDir == TrackDirection.None)
{
if (previousTrackDir == TrackDirection.Up)
{
return(verticalTrack [0]);
}
else if (previousTrackDir == TrackDirection.Down)
{
return(verticalTrack [2]);
}
else if (previousTrackDir == TrackDirection.Left)
{
return(horizontalTrack [2]);
}
else
{
return(horizontalTrack [0]);
}
}
if ((previousTrackDir == TrackDirection.Left && nextTrackDir == TrackDirection.Right) ||
(previousTrackDir == TrackDirection.Right && nextTrackDir == TrackDirection.Left))
{
return(horizontalTrack[1]);
}
else if ((previousTrackDir == TrackDirection.Up && nextTrackDir == TrackDirection.Down) ||
(previousTrackDir == TrackDirection.Down && nextTrackDir == TrackDirection.Up))
{
return(verticalTrack[1]);
}
if (previousTrackDir == TrackDirection.Left && nextTrackDir == TrackDirection.Down)
{
return(trackCorners [3]);
}
else if (previousTrackDir == TrackDirection.Left && nextTrackDir == TrackDirection.Up)
{
return(trackCorners [1]);
}
else if (previousTrackDir == TrackDirection.Right && nextTrackDir == TrackDirection.Down)
{
return(trackCorners [2]);
}
else if (previousTrackDir == TrackDirection.Right && nextTrackDir == TrackDirection.Up)
{
return(trackCorners [0]);
}
if (previousTrackDir == TrackDirection.Down && nextTrackDir == TrackDirection.Left)
{
return(trackCorners [3]);
}
else if (previousTrackDir == TrackDirection.Down && nextTrackDir == TrackDirection.Right)
{
return(trackCorners [2]);
}
else if (previousTrackDir == TrackDirection.Up && nextTrackDir == TrackDirection.Left)
{
return(trackCorners [1]);
}
else if (previousTrackDir == TrackDirection.Up && nextTrackDir == TrackDirection.Right)
{
return(trackCorners [0]);
}
return(horizontalTrack[1]);
}
public static Track Create(string description, TrackDirection direction, DateTime?trackDateOn)
{
return(new Track(description, direction.ToFriendlyString(), trackDateOn));
}
/// <summary>
/// Set the position based on the trackcircuit section.
/// </summary>
/// <param name="trackCircuitCrossReferecenList">List of cross-references from tracknode to trackcircuitsection</param>
/// <param name="offset">Offset along the tracknode</param>
/// <param name="direction">direction along the tracknode (1 is forward)</param>
internal void SetPosition(TrackCircuitCrossReferences trackCircuitCrossReferecenList, float offset, TrackDirection direction)
{
if (null == trackCircuitCrossReferecenList)
{
throw new ArgumentNullException(nameof(trackCircuitCrossReferecenList));
}
int crossRefIndex = trackCircuitCrossReferecenList.GetCrossReferenceIndex(offset, (int)direction);
if (crossRefIndex < 0)
{
return;
}
TrackCircuitSectionCrossReference crossReference = trackCircuitCrossReferecenList[crossRefIndex];
TrackCircuitSectionIndex = crossReference.Index;
Direction = direction;
Offset = offset - crossReference.OffsetLength[(int)direction];
}
public Track(int x, int y, TrackDirection direction)
{
this.Position = new Point(x, y);
this.TrackDirection = direction;
}
public static TrackDefinition Create(string description, string tag, CaptureRule captureRule, TrackDirection direction)
{
return(new TrackDefinition(description, tag, captureRule.ToFriendlyString(), direction.ToFriendlyString()));
}
// Check on deadlock
private protected void CheckDeadlock(TrackCircuitPartialPathRoute route, int number)
{
// clear existing deadlock info
ClearDeadlocks();
// build new deadlock info
foreach (Train otherTrain in simulator.Trains)
{
// check if not AI_Static
if (Simulator.Instance.SignalEnvironment.UseLocationPassingPaths && otherTrain.GetAiMovementState() == AiMovementState.Static)
{
continue;
}
if (otherTrain.Number != number && otherTrain.TrainType != TrainType.Static)
{
TrackCircuitPartialPathRoute otherRoute = otherTrain.ValidRoute[0];
ILookup <int, TrackDirection> otherRouteDict = otherRoute.ConvertRoute();
for (int i = 0; i < route.Count; i++)
{
TrackCircuitRouteElement routeElement = route[i];
TrackCircuitSection section = routeElement.TrackCircuitSection;
TrackDirection sectionDirection = routeElement.Direction;
if (section.CircuitType != TrackCircuitType.Crossover)
{
if (otherRouteDict.Contains(section.Index))
{
TrackDirection otherTrainDirection = otherRouteDict[section.Index].First();
//<CSComment> Right part of OR clause refers to initial placement with trains back-to-back and running away one from the other</CSComment>
if (otherTrainDirection == sectionDirection ||
(PresentPosition[Direction.Backward].TrackCircuitSectionIndex == otherTrain.PresentPosition[Direction.Backward].TrackCircuitSectionIndex && section.Index == PresentPosition[Direction.Backward].TrackCircuitSectionIndex &&
PresentPosition[Direction.Backward].Offset + otherTrain.PresentPosition[Direction.Backward].Offset - 1 > section.Length))
{
i = EndCommonSection(i, route, otherRoute);
}
else
{
if (Simulator.Instance.SignalEnvironment.UseLocationPassingPaths) //new style location based logic
{
if (CheckRealDeadlockLocationBased(route, otherRoute, ref i))
{
int[] endDeadlock = SetDeadlockLocationBased(i, route, otherRoute, otherTrain);
// use end of alternative path if set
i = endDeadlock[1] > 0 ? --endDeadlock[1] : endDeadlock[0];
}
}
else //old style path based logic
{
int[] endDeadlock = SetDeadlockPathBased(i, route, otherRoute, otherTrain);
// use end of alternative path if set - if so, compensate for iElement++
i = endDeadlock[1] > 0 ? --endDeadlock[1] : endDeadlock[0];
}
}
}
}
}
}
}
}
public TrackModel(TrackEnum trackType, TrackDirection trackDirection)
{
TrackType = trackType;
TrackDirection = trackDirection;
}
public static float TrackRotationAngle(this TrackDirection direction) => direction switch
{
public static bool IsThreeWay(this TrackDirection direction) => direction == TrackDirection.RightUpDown || direction == TrackDirection.LeftRightDown || direction == TrackDirection.LeftUpDown || direction == TrackDirection.LeftRightUp;
public void GetConnectedNeighbors(TrackDirection centerDir, TrackDirection leftDir, TrackDirection upDir, TrackDirection rightDir, TrackDirection downDir, bool left, bool up, bool right, bool down)
{
// The real layout evaluates the best direction, so we can't use it. We just want storage
var layout = new TestLayout();
layout.AddTrack(5, 5, centerDir);
layout.AddTrack(4, 5, leftDir);
layout.AddTrack(5, 4, upDir);
layout.AddTrack(6, 5, rightDir);
layout.AddTrack(5, 6, downDir);
var track = layout.GetTrackAt(5, 5);
var neighbors = track.GetConnectedNeighbors();
Assert.Equal(left, neighbors.Left != null);
Assert.Equal(up, neighbors.Up != null);
Assert.Equal(right, neighbors.Right != null);
Assert.Equal(down, neighbors.Down != null);
}
