//================================================================================================//
//
// Constructor for empty entries
//
public TrackCircuitSection(int INode, Signals thisSignals)
{
signalRef = thisSignals;
Index = INode;
OriginalIndex = -1;
CircuitType = TrackCircuitType.Empty;
for (int iDir = 0; iDir < 2; iDir++)
{
EndIsTrailingJunction[iDir] = false;
EndSignals[iDir] = null;
OffsetLength[iDir] = 0;
}
for (int iDir = 0; iDir < 2; iDir++)
{
for (int pin = 0; pin < 2; pin++)
{
Pins[iDir, pin] = new TrPin();
Pins[iDir, pin].Direction = -1;
Pins[iDir, pin].Link = -1;
ActivePins[iDir, pin] = new TrPin();
ActivePins[iDir, pin].Direction = -1;
ActivePins[iDir, pin].Link = -1;
}
}
CircuitItems = new TrackCircuitItems();
CircuitState = new TrackCircuitState();
}
//================================================================================================//
//
// Get state of single section
//
//================================================================================================//
//
// Get next active link
//
public TrPin GetNextActiveLink(int direction, int lastIndex)
{
// Crossover
if (CircuitType == TrackCircuitSection.TrackCircuitType.Crossover)
{
int inPinIndex = direction == 0 ? 1 : 0;
if (Pins[inPinIndex, 0].Link == lastIndex)
{
return(ActivePins[direction, 0]);
}
else if (Pins[inPinIndex, 1].Link == lastIndex)
{
return(ActivePins[direction, 1]);
}
else
{
TrPin dummyPin = new TrPin();
dummyPin.Direction = -1;
dummyPin.Link = -1;
return(dummyPin);
}
}
// All other sections
if (ActivePins[direction, 0].Link > 0)
{
return(ActivePins[direction, 0]);
}
return(ActivePins[direction, 1]);
}
//================================================================================================//
//
// Get distance between objects
//
public float GetDistanceBetweenObjects(int startSectionIndex, float startOffset, int startDirection,
int endSectionIndex, float endOffset)
{
int thisSectionIndex = startSectionIndex;
int direction = startDirection;
TrackCircuitSection thisSection = signalRef.TrackCircuitList[thisSectionIndex];
float distanceM = 0.0f;
int lastIndex = -2; // set to non-occuring value
while (thisSectionIndex != endSectionIndex && thisSectionIndex > 0)
{
distanceM += thisSection.Length;
TrPin nextLink = thisSection.GetNextActiveLink(direction, lastIndex);
lastIndex = thisSectionIndex;
thisSectionIndex = nextLink.Link;
direction = nextLink.Direction;
if (thisSectionIndex > 0)
{
thisSection = signalRef.TrackCircuitList[thisSectionIndex];
}
}
// use found distance, correct for begin and end offset
if (thisSectionIndex == endSectionIndex)
{
distanceM += endOffset - startOffset;
return(distanceM);
}
return(-1.0f);
}
public List <int> SignalsPassingRoutes; // list of signals reading passed junction //
//================================================================================================//
//
// Constructor
//
public TrackCircuitSection(TrackNode thisNode, int orgINode,
TSectionDatFile tsectiondat, Signals thisSignals)
{
//
// Copy general info
//
signalRef = thisSignals;
Index = orgINode;
OriginalIndex = orgINode;
if (thisNode.TrEndNode)
{
CircuitType = TrackCircuitType.EndOfTrack;
}
else if (thisNode.TrJunctionNode != null)
{
CircuitType = TrackCircuitType.Junction;
}
else
{
CircuitType = TrackCircuitType.Normal;
}
//
// Preset pins, then copy pin info
//
for (int direction = 0; direction < 2; direction++)
{
for (int pin = 0; pin < 2; pin++)
{
Pins[direction, pin] = new TrPin();
Pins[direction, pin].Direction = -1;
Pins[direction, pin].Link = -1;
ActivePins[direction, pin] = new TrPin();
ActivePins[direction, pin].Direction = -1;
ActivePins[direction, pin].Link = -1;
}
}
int PinNo = 0;
for (int pin = 0; pin < Math.Min(thisNode.Inpins, Pins.GetLength(1)); pin++)
{
Pins[0, pin] = thisNode.TrPins[PinNo].Copy();
PinNo++;
}
if (PinNo < thisNode.Inpins)
{
PinNo = (int)thisNode.Inpins;
}
for (int pin = 0; pin < Math.Min(thisNode.Outpins, Pins.GetLength(1)); pin++)
{
Pins[1, pin] = thisNode.TrPins[PinNo].Copy();
PinNo++;
}
//
// preset no end signals
// preset no trailing junction
//
for (int direction = 0; direction < 2; direction++)
{
EndSignals[direction] = null;
EndIsTrailingJunction[direction] = false;
}
//
// Preset length and offset
// If section index not in tsectiondat, set length to 0.
//
float totalLength = 0.0f;
if (thisNode.TrVectorNode != null && thisNode.TrVectorNode.TrVectorSections != null)
{
foreach (TrVectorSection thisSection in thisNode.TrVectorNode.TrVectorSections)
{
float thisLength = 0.0f;
if (tsectiondat.TrackSections.ContainsKey(thisSection.SectionIndex))
{
TrackSection TS = tsectiondat.TrackSections[thisSection.SectionIndex];
if (TS.SectionCurve != null)
{
thisLength =
MathHelper.ToRadians(Math.Abs(TS.SectionCurve.Angle)) *
TS.SectionCurve.Radius;
}
else
{
thisLength = TS.SectionSize.Length;
}
}
totalLength += thisLength;
}
}
Length = totalLength;
for (int direction = 0; direction < 2; direction++)
{
OffsetLength[direction] = 0;
}
//
// set signal list for junctions
//
if (CircuitType == TrackCircuitType.Junction)
{
SignalsPassingRoutes = new List <int>();
}
else
{
SignalsPassingRoutes = null;
}
// for Junction nodes, obtain default route
// set switch to default route
// copy overlap (if set)
if (CircuitType == TrackCircuitType.Junction)
{
uint trackShapeIndex = thisNode.TrJunctionNode.ShapeIndex;
try
{
TrackShape trackShape = tsectiondat.TrackShapes[trackShapeIndex];
JunctionDefaultRoute = (int)trackShape.MainRoute;
Overlap = trackShape.ClearanceDistance;
}
catch (Exception)
{
JunctionDefaultRoute = 0;
Overlap = 0;
}
JunctionLastRoute = JunctionDefaultRoute;
//signalRef.setSwitch(OriginalIndex, JunctionLastRoute, this);
}
//
// Create circuit items
//
CircuitItems = new TrackCircuitItems();
CircuitState = new TrackCircuitState();
}
public void LoadItemsFromMSTS()
{
#if SHOW_STOPWATCH
Stopwatch stopWatch = new Stopwatch();
TimeSpan ts;
string elapsedTime;
if (File.Exists(@"C:\temp\stopwatch.txt"))
{
File.Delete(@"C:\temp\stopwatch.txt");
}
#endif
if (TDB == null ||
TDB.TrackDB == null ||
TDB.TrackDB.TrItemTable == null)
{
return;
}
foreach (GlobalItem item in orRouteConfig.AllItems)
{
if (item.GetType() == typeof(AEBufferItem))
{
mstsItems.buffers.Add((AEBufferItem)item);
}
}
Program.actEditor.DisplayStatusMessage("Start loading Track Nodes ...");
#if SHOW_STOPWATCH
stopWatch.Start();
#endif
nodes = TDB.TrackDB.TrackNodes;
for (int nodeIdx = 0; nodeIdx < nodes.Length; nodeIdx++)
{
if (nodes[nodeIdx] != null)
{
TrackNode currNode = nodes[nodeIdx];
AEBufferItem foundBuffer;
if (currNode.TrEndNode)
{
//Program.actEditor.DisplayStatusMessage("Init data for display... Load End Nodes: " + currNode.Index);
try
{
foundBuffer = (AEBufferItem)orRouteConfig.AllItems.First(x => x.associateNodeIdx == currNode.Index);
foundBuffer.updateNode(currNode);
}
catch (InvalidOperationException)
{
foundBuffer = new AEBufferItem((TrackNode)currNode);
mstsItems.buffers.Add(foundBuffer);
}
#if SHOW_STOPWATCH
ts = stopWatch.Elapsed;
stopWatch.Reset();
// Format and display the TimeSpan value.
elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:000}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds);
File.AppendAllText(@"C:\temp\stopwatch.txt", "One END node: " + elapsedTime + "\n");
stopWatch.Start();
#endif
}
else if (currNode.TrVectorNode != null && currNode.TrVectorNode.TrVectorSections != null)
{
//Program.actEditor.DisplayStatusMessage("Init data for display... Load Vector Nodes: " + currNode.Index);
if (currNode.TrVectorNode.TrVectorSections.Length > 1)
{
AddSegments(currNode);
TrVectorSection section = currNode.TrVectorNode.TrVectorSections[currNode.TrVectorNode.TrVectorSections.Length - 1];
MSTSCoord A = new MSTSCoord(section);
TrPin pin = currNode.TrPins[1];
{
TrackNode connectedNode = nodes[pin.Link];
int direction = DrawUtility.getDirection(currNode, connectedNode);
if (A == connectedNode.getMSTSCoord(direction))
{
continue;
}
AESegment aeSegment = new AESegment(A, connectedNode.getMSTSCoord(direction));
TrackSegment lineSeg = new TrackSegment(aeSegment, currNode, currNode.TrVectorNode.TrVectorSections.Length - 1, direction, TSectionDat);
addTrItems(lineSeg, currNode);
mstsItems.AddSegment(lineSeg);
}
#if SHOW_STOPWATCH
ts = stopWatch.Elapsed;
stopWatch.Reset();
// Format and display the TimeSpan value.
elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:000}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds);
File.AppendAllText(@"C:\temp\stopwatch.txt", "One mult TRACK node: " + elapsedTime + "\n");
stopWatch.Start();
#endif
}
else
{
TrVectorSection s;
s = currNode.TrVectorNode.TrVectorSections[0];
areaRoute.manageTiles(s.TileX, s.TileZ);
foreach (TrPin pin in currNode.TrPins)
{
TrackNode connectedNode = nodes[pin.Link];
int direction = DrawUtility.getDirection(currNode, connectedNode);
if (MSTSCoord.near(currNode.getMSTSCoord(direction), connectedNode.getMSTSCoord(direction)))
{
continue;
}
AESegment aeSegment = new AESegment(currNode.getMSTSCoord(direction), connectedNode.getMSTSCoord(direction));
TrackSegment lineSeg = new TrackSegment(aeSegment, currNode, 0, direction, TSectionDat);
addTrItems(lineSeg, currNode);
mstsItems.AddSegment(lineSeg);
}
#if SHOW_STOPWATCH
ts = stopWatch.Elapsed;
stopWatch.Reset();
// Format and display the TimeSpan value.
elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:000}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds);
File.AppendAllText(@"C:\temp\stopwatch.txt", "One simple TRACK node: " + elapsedTime + "\n");
stopWatch.Start();
#endif
}
}
else if (currNode.TrJunctionNode != null)
{
//Program.actEditor.DisplayStatusMessage("Init data for display... Load Junction Nodes: " + currNode.Index);
mstsItems.switches.Add(new AEJunctionItem(currNode));
areaRoute.manageTiles(currNode.UiD.TileX, currNode.UiD.TileZ);
#if SHOW_STOPWATCH
ts = stopWatch.Elapsed;
stopWatch.Reset();
// Format and display the TimeSpan value.
elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:000}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds);
File.AppendAllText(@"C:\temp\stopwatch.txt", "One JN node: " + elapsedTime + "\n");
stopWatch.Start();
#endif
}
}
}
#if SPA_ADD
var maxsize = maxX - minX > maxX - minX ? maxX - minX : maxX - minX;
maxsize = (int)maxsize / 100 * 100;
if (maxsize < 2000)
{
maxsize = 2000;
}
ZoomFactor = (decimal)maxsize;
#endif
#region AddItem
Program.actEditor.DisplayStatusMessage("Init data for display... Load MSTS Items...");
foreach (var item in TDB.TrackDB.TrItemTable)
{
if (item.ItemType == TrItem.trItemType.trSIGNAL && Signals != null)
{
if (item is SignalItem)
{
#if SHOW_STOPWATCH
Program.actEditor.DisplayStatusMessage("Init data for display... Load Items... Signal");
#endif
SignalItem si = item as SignalItem;
if (si.SigObj >= 0 && si.SigObj < Signals.SignalObjects.Length)
{
AESignalObject s = Signals.SignalObjects[si.SigObj];
if (s.isSignal) // && s.isSignalNormal())
{
mstsItems.AddSignal(new AESignalItem(si, s, TDB));
}
}
}
}
}
#if SHOW_STOPWATCH
ts = stopWatch.Elapsed;
// Format and display the TimeSpan value.
elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:000}",
ts.Hours, ts.Minutes, ts.Seconds,
ts.Milliseconds);
File.AppendAllText(@"C:\temp\stopwatch.txt", "Signals: " + elapsedTime + "\n");
stopWatch.Stop();
#endif
#endregion
}
