Cleanup: Replace signalObjects by an auto-property

Sharpe49 · Sharpe49 · commit 35ea800370f6 · 2022-08-18T03:16:01.000+02:00
diff --git a/Source/Orts.Simulation/Simulation/Signalling/Signals.cs b/Source/Orts.Simulation/Simulation/Signalling/Signals.cs
@@ -50,7 +50,7 @@ public class Signals
         private TrackSectionsFile tsectiondat;
         private TrackDatabaseFile tdbfile;
 
-        private SignalObject[] signalObjects;
+        public SignalObject[] SignalObjects { get; private set; }
         private List<SignalWorldObject> SignalWorldList = new List<SignalWorldObject>();
         private Dictionary<uint, SignalRefObject> SignalRefList;
         private Dictionary<uint, SignalObject> SignalHeadList;
@@ -162,9 +162,9 @@ public Signals(Simulator simulator, SignalConfigurationFile sigcfg, Cancellation
             }
 
 			var sob = new StringBuilder();
-            for (var isignal = 0; isignal < signalObjects.Length - 1; isignal++)
+            for (var isignal = 0; isignal < SignalObjects.Length - 1; isignal++)
             {
-                var singleSignal = signalObjects[isignal];
+                var singleSignal = SignalObjects[isignal];
                 if (singleSignal == null)
                 {
                     sob.AppendFormat("\nInvalid entry : {0}\n", isignal);
@@ -395,17 +395,6 @@ public void Save(BinaryWriter outf)
 
         }
 
-        /// <summary>
-        /// Gets an array of all the SignalObjects.
-        /// </summary>
-        public SignalObject[] SignalObjects
-        {
-            get
-            {
-                return signalObjects;
-            }
-        }
-
         /// <summary>
         /// Read all world files to get signal flags
         /// </summary>
@@ -579,7 +568,7 @@ public void Update(bool preUpdate)
                 // update required part
                 // in preupdate, process all
 
-                int totalSignal = signalObjects.Length - 1;
+                int totalSignal = SignalObjects.Length - 1;
 
                 int updatestep = (totalSignal / 20) + 1;
                 if (preUpdate)
@@ -589,7 +578,7 @@ public void Update(bool preUpdate)
 
                 for (int icount = updatecount; icount < Math.Min(totalSignal, updatecount + updatestep); icount++)
                 {
-                    SignalObject signal = signalObjects[icount];
+                    SignalObject signal = SignalObjects[icount];
                     if (signal != null && !signal.noupdate) // to cater for orphans, and skip signals which do not require updates
                     {
                         signal.Update();
@@ -634,8 +623,8 @@ private void BuildSignalList(TrItem[] TrItems, TrackNode[] trackNodes, TrackSect
             // set general items and create sections
             if (noSignals > 0)
             {
-                signalObjects = new SignalObject[noSignals];
-                SignalObject.signalObjects = signalObjects;
+                SignalObjects = new SignalObject[noSignals];
+                SignalObject.signalObjects = SignalObjects;
             }
 
             SignalObject.trackNodes = trackNodes;
@@ -703,7 +692,7 @@ private void BuildSignalList(TrItem[] TrItems, TrackNode[] trackNodes, TrackSect
             }
             else
             {
-                signalObjects = new SignalObject[0];
+                SignalObjects = new SignalObject[0];
             }
         }
 
@@ -717,9 +706,9 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)
 
             // Loop through all signals to check on Backfacing heads
 
-            for (int isignal = 0; isignal < signalObjects.Length - 1; isignal++)
+            for (int isignal = 0; isignal < SignalObjects.Length - 1; isignal++)
             {
-                SignalObject singleSignal = signalObjects[isignal];
+                SignalObject singleSignal = SignalObjects[isignal];
                 if (singleSignal != null && singleSignal.isSignal &&
                                 singleSignal.WorldObject != null && singleSignal.WorldObject.Backfacing.Count > 0)
                 {
@@ -862,7 +851,7 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)
                         // revert existing signal to NULL if no heads remain
                         if (singleSignal.SignalHeads.Count <= 0)
                         {
-                            signalObjects[isignal] = null;
+                            SignalObjects[isignal] = null;
                         }
                     }
                 }
@@ -873,7 +862,7 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)
             newindex = foundSignals;
             foreach (SignalObject newSignal in newSignals)
             {
-                signalObjects[newindex] = newSignal;
+                SignalObjects[newindex] = newSignal;
                 newindex++;
             }
 
@@ -1019,15 +1008,15 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe
         {
             validSignal = true;
 
-            signalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);
-            signalObjects[foundSignals].isSignal = true;
-            signalObjects[foundSignals].isSpeedSignal = false;
-            signalObjects[foundSignals].direction = (int)sigItem.Direction;
-            signalObjects[foundSignals].trackNode = trackNode;
-            signalObjects[foundSignals].trRefIndex = nodeIndx;
-            signalObjects[foundSignals].AddHead(nodeIndx, TDBRef, sigItem);
-            signalObjects[foundSignals].thisRef = foundSignals;
-            signalObjects[foundSignals].signalRef = this;
+            SignalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);
+            SignalObjects[foundSignals].isSignal = true;
+            SignalObjects[foundSignals].isSpeedSignal = false;
+            SignalObjects[foundSignals].direction = (int)sigItem.Direction;
+            SignalObjects[foundSignals].trackNode = trackNode;
+            SignalObjects[foundSignals].trRefIndex = nodeIndx;
+            SignalObjects[foundSignals].AddHead(nodeIndx, TDBRef, sigItem);
+            SignalObjects[foundSignals].thisRef = foundSignals;
+            SignalObjects[foundSignals].signalRef = this;
 
             if (tdbfile.TrackDB.TrackNodes[trackNode] == null || tdbfile.TrackDB.TrackNodes[trackNode].TrVectorNode == null)
             {
@@ -1036,13 +1025,13 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe
             }
             else
             {
-                signalObjects[foundSignals].tdbtraveller =
+                SignalObjects[foundSignals].tdbtraveller =
                 new Traveller(tsectiondat, tdbfile.TrackDB.TrackNodes, tdbfile.TrackDB.TrackNodes[trackNode],
                         sigItem.TileX, sigItem.TileZ, sigItem.X, sigItem.Z,
                 (Traveller.TravellerDirection)(1 - sigItem.Direction));
             }
 
-            signalObjects[foundSignals].WorldObject = null;
+            SignalObjects[foundSignals].WorldObject = null;
 
             if (SignalHeadList.ContainsKey((uint)TDBRef))
             {
@@ -1052,11 +1041,11 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe
 
             if (!validSignal)
             {
-                signalObjects[foundSignals] = null;  // reset signal, do not increase signal count
+                SignalObjects[foundSignals] = null;  // reset signal, do not increase signal count
             }
             else
             {
-                SignalHeadList.Add((uint)TDBRef, signalObjects[foundSignals]);
+                SignalHeadList.Add((uint)TDBRef, SignalObjects[foundSignals]);
                 foundSignals++;
             }
 
@@ -1068,43 +1057,43 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe
         /// </summary>
         private int AddSpeed(int trackNode, int nodeIndx, SpeedPostItem speedItem, int TDBRef, TrackSectionsFile tsectiondat, TrackDatabaseFile tdbfile, int ORTSSignalTypeCount)
         {
-            signalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);
-            signalObjects[foundSignals].isSignal = false;
-            signalObjects[foundSignals].isSpeedSignal = false;
-            signalObjects[foundSignals].direction = 0;                  // preset - direction not yet known //
-            signalObjects[foundSignals].trackNode = trackNode;
-            signalObjects[foundSignals].trRefIndex = nodeIndx;
-            signalObjects[foundSignals].AddHead(nodeIndx, TDBRef, speedItem);
-            signalObjects[foundSignals].thisRef = foundSignals;
-            signalObjects[foundSignals].signalRef = this;
-
-            signalObjects[foundSignals].tdbtraveller =
+            SignalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);
+            SignalObjects[foundSignals].isSignal = false;
+            SignalObjects[foundSignals].isSpeedSignal = false;
+            SignalObjects[foundSignals].direction = 0;                  // preset - direction not yet known //
+            SignalObjects[foundSignals].trackNode = trackNode;
+            SignalObjects[foundSignals].trRefIndex = nodeIndx;
+            SignalObjects[foundSignals].AddHead(nodeIndx, TDBRef, speedItem);
+            SignalObjects[foundSignals].thisRef = foundSignals;
+            SignalObjects[foundSignals].signalRef = this;
+
+            SignalObjects[foundSignals].tdbtraveller =
             new Traveller(tsectiondat, tdbfile.TrackDB.TrackNodes, tdbfile.TrackDB.TrackNodes[trackNode],
                     speedItem.TileX, speedItem.TileZ, speedItem.X, speedItem.Z,
-                    (Traveller.TravellerDirection)signalObjects[foundSignals].direction);
+                    (Traveller.TravellerDirection)SignalObjects[foundSignals].direction);
 
-            double delta_angle = signalObjects[foundSignals].tdbtraveller.RotY - ((Math.PI / 2) - speedItem.Angle);
+            double delta_angle = SignalObjects[foundSignals].tdbtraveller.RotY - ((Math.PI / 2) - speedItem.Angle);
             float delta_float = MathHelper.WrapAngle((float)delta_angle);
             if (Math.Abs(delta_float) < (Math.PI / 2))
             {
-                signalObjects[foundSignals].direction = signalObjects[foundSignals].tdbtraveller.Direction == 0 ? 1 : 0;
+                SignalObjects[foundSignals].direction = SignalObjects[foundSignals].tdbtraveller.Direction == 0 ? 1 : 0;
             }
             else
             {
-                signalObjects[foundSignals].direction = (int)signalObjects[foundSignals].tdbtraveller.Direction;
-                signalObjects[foundSignals].tdbtraveller.ReverseDirection();
+                SignalObjects[foundSignals].direction = (int)SignalObjects[foundSignals].tdbtraveller.Direction;
+                SignalObjects[foundSignals].tdbtraveller.ReverseDirection();
             }
 
 #if DEBUG_PRINT
             File.AppendAllText(@"C:\temp\speedpost.txt",
                 string.Format("\nPlaced : at : {0} {1}:{2} {3}; angle - track : {4}:{5}; delta : {6}; dir : {7}\n",
                 speedItem.TileX, speedItem.TileZ, speedItem.X, speedItem.Z,
-                speedItem.Angle, signalObjects[foundSignals].tdbtraveller.RotY,
+                speedItem.Angle, SignalObjects[foundSignals].tdbtraveller.RotY,
                 delta_angle,
-                signalObjects[foundSignals].direction));
+                SignalObjects[foundSignals].direction));
 #endif
 
-            signalObjects[foundSignals].WorldObject = null;
+            SignalObjects[foundSignals].WorldObject = null;
             foundSignals++;
             return foundSignals - 1;
         }
@@ -1134,7 +1123,7 @@ private int AddMilepost(int trackNode, int nodeIndx, SpeedPostItem speedItem, in
         /// </summary>
         private void AddCFG(SignalConfigurationFile sigCFG)
         {
-            foreach (SignalObject signal in signalObjects)
+            foreach (SignalObject signal in SignalObjects)
             {
                 if (signal != null)
                 {
@@ -1152,7 +1141,7 @@ private void AddCFG(SignalConfigurationFile sigCFG)
         private void AddWorldInfo()
         {
             // loop through all signal and all heads
-            foreach (SignalObject signal in signalObjects)
+            foreach (SignalObject signal in SignalObjects)
             {
                 if (signal != null)
                 {
@@ -1196,7 +1185,7 @@ private void AddWorldInfo()
         /// </summary>
         public KeyValuePair<SignalObject, SignalHead>? FindByTrItem(uint trItem)
         {
-            foreach (var signal in signalObjects)
+            foreach (var signal in SignalObjects)
                 if (signal != null)
                     foreach (var head in signal.SignalHeads)
                         if (SignalObject.trackNodes[signal.trackNode].TrVectorNode.TrItemRefs[head.trItemIndex] == (int)trItem)
@@ -1209,7 +1198,7 @@ private void AddWorldInfo()
         /// </summary>
         public void SetNumSignalHeads()
         {
-            foreach (SignalObject thisSignal in signalObjects)
+            foreach (SignalObject thisSignal in SignalObjects)
             {
                 if (thisSignal != null)
                 {
@@ -1696,9 +1685,9 @@ private void CreateTrackCircuits(TrItem[] TrItems, TrackNode[] trackNodes, TSect
 
             // Set default next signal and fixed route information
 
-            for (int iSignal = 0; signalObjects != null && iSignal < signalObjects.Length; iSignal++)
+            for (int iSignal = 0; SignalObjects != null && iSignal < SignalObjects.Length; iSignal++)
             {
-                SignalObject thisSignal = signalObjects[iSignal];
+                SignalObject thisSignal = SignalObjects[iSignal];
                 if (thisSignal != null)
                 {
                     thisSignal.setSignalDefaultNextSignal();

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public class Signals`
`50`	`50`	`private TrackSectionsFile tsectiondat;`
`51`	`51`	`private TrackDatabaseFile tdbfile;`
`52`	`52`
`53`		`- private SignalObject[] signalObjects;`
	`53`	`+ public SignalObject[] SignalObjects { get; private set; }`
`54`	`54`	`private List<SignalWorldObject> SignalWorldList = new List<SignalWorldObject>();`
`55`	`55`	`private Dictionary<uint, SignalRefObject> SignalRefList;`
`56`	`56`	`private Dictionary<uint, SignalObject> SignalHeadList;`
`@@ -162,9 +162,9 @@ public Signals(Simulator simulator, SignalConfigurationFile sigcfg, Cancellation`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`var sob = new StringBuilder();`
`165`		`- for (var isignal = 0; isignal < signalObjects.Length - 1; isignal++)`
	`165`	`+ for (var isignal = 0; isignal < SignalObjects.Length - 1; isignal++)`
`166`	`166`	`{`
`167`		`- var singleSignal = signalObjects[isignal];`
	`167`	`+ var singleSignal = SignalObjects[isignal];`
`168`	`168`	`if (singleSignal == null)`
`169`	`169`	`{`
`170`	`170`	`sob.AppendFormat("\nInvalid entry : {0}\n", isignal);`
`@@ -395,17 +395,6 @@ public void Save(BinaryWriter outf)`
`395`	`395`
`396`	`396`	`}`
`397`	`397`
`398`		`- /// <summary>`
`399`		`- /// Gets an array of all the SignalObjects.`
`400`		`- /// </summary>`
`401`		`- public SignalObject[] SignalObjects`
`402`		`- {`
`403`		`- get`
`404`		`- {`
`405`		`- return signalObjects;`
`406`		`- }`
`407`		`- }`
`408`		`-`
`409`	`398`	`/// <summary>`
`410`	`399`	`/// Read all world files to get signal flags`
`411`	`400`	`/// </summary>`
`@@ -579,7 +568,7 @@ public void Update(bool preUpdate)`
`579`	`568`	`// update required part`
`580`	`569`	`// in preupdate, process all`
`581`	`570`
`582`		`- int totalSignal = signalObjects.Length - 1;`
	`571`	`+ int totalSignal = SignalObjects.Length - 1;`
`583`	`572`
`584`	`573`	`int updatestep = (totalSignal / 20) + 1;`
`585`	`574`	`if (preUpdate)`
`@@ -589,7 +578,7 @@ public void Update(bool preUpdate)`
`589`	`578`
`590`	`579`	`for (int icount = updatecount; icount < Math.Min(totalSignal, updatecount + updatestep); icount++)`
`591`	`580`	`{`
`592`		`- SignalObject signal = signalObjects[icount];`
	`581`	`+ SignalObject signal = SignalObjects[icount];`
`593`	`582`	`if (signal != null && !signal.noupdate) // to cater for orphans, and skip signals which do not require updates`
`594`	`583`	`{`
`595`	`584`	`signal.Update();`
`@@ -634,8 +623,8 @@ private void BuildSignalList(TrItem[] TrItems, TrackNode[] trackNodes, TrackSect`
`634`	`623`	`// set general items and create sections`
`635`	`624`	`if (noSignals > 0)`
`636`	`625`	`{`
`637`		`- signalObjects = new SignalObject[noSignals];`
`638`		`- SignalObject.signalObjects = signalObjects;`
	`626`	`+ SignalObjects = new SignalObject[noSignals];`
	`627`	`+ SignalObject.signalObjects = SignalObjects;`
`639`	`628`	`}`
`640`	`629`
`641`	`630`	`SignalObject.trackNodes = trackNodes;`
`@@ -703,7 +692,7 @@ private void BuildSignalList(TrItem[] TrItems, TrackNode[] trackNodes, TrackSect`
`703`	`692`	`}`
`704`	`693`	`else`
`705`	`694`	`{`
`706`		`- signalObjects = new SignalObject[0];`
	`695`	`+ SignalObjects = new SignalObject[0];`
`707`	`696`	`}`
`708`	`697`	`}`
`709`	`698`
`@@ -717,9 +706,9 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)`
`717`	`706`
`718`	`707`	`// Loop through all signals to check on Backfacing heads`
`719`	`708`
`720`		`- for (int isignal = 0; isignal < signalObjects.Length - 1; isignal++)`
	`709`	`+ for (int isignal = 0; isignal < SignalObjects.Length - 1; isignal++)`
`721`	`710`	`{`
`722`		`- SignalObject singleSignal = signalObjects[isignal];`
	`711`	`+ SignalObject singleSignal = SignalObjects[isignal];`
`723`	`712`	`if (singleSignal != null && singleSignal.isSignal &&`
`724`	`713`	`singleSignal.WorldObject != null && singleSignal.WorldObject.Backfacing.Count > 0)`
`725`	`714`	`{`
`@@ -862,7 +851,7 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)`
`862`	`851`	`// revert existing signal to NULL if no heads remain`
`863`	`852`	`if (singleSignal.SignalHeads.Count <= 0)`
`864`	`853`	`{`
`865`		`- signalObjects[isignal] = null;`
	`854`	`+ SignalObjects[isignal] = null;`
`866`	`855`	`}`
`867`	`856`	`}`
`868`	`857`	`}`
`@@ -873,7 +862,7 @@ private void SplitBackfacing(TrItem[] TrItems, TrackNode[] TrackNodes)`
`873`	`862`	`newindex = foundSignals;`
`874`	`863`	`foreach (SignalObject newSignal in newSignals)`
`875`	`864`	`{`
`876`		`- signalObjects[newindex] = newSignal;`
	`865`	`+ SignalObjects[newindex] = newSignal;`
`877`	`866`	`newindex++;`
`878`	`867`	`}`
`879`	`868`
`@@ -1019,15 +1008,15 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe`
`1019`	`1008`	`{`
`1020`	`1009`	`validSignal = true;`
`1021`	`1010`
`1022`		`- signalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);`
`1023`		`- signalObjects[foundSignals].isSignal = true;`
`1024`		`- signalObjects[foundSignals].isSpeedSignal = false;`
`1025`		`- signalObjects[foundSignals].direction = (int)sigItem.Direction;`
`1026`		`- signalObjects[foundSignals].trackNode = trackNode;`
`1027`		`- signalObjects[foundSignals].trRefIndex = nodeIndx;`
`1028`		`- signalObjects[foundSignals].AddHead(nodeIndx, TDBRef, sigItem);`
`1029`		`- signalObjects[foundSignals].thisRef = foundSignals;`
`1030`		`- signalObjects[foundSignals].signalRef = this;`
	`1011`	`+ SignalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);`
	`1012`	`+ SignalObjects[foundSignals].isSignal = true;`
	`1013`	`+ SignalObjects[foundSignals].isSpeedSignal = false;`
	`1014`	`+ SignalObjects[foundSignals].direction = (int)sigItem.Direction;`
	`1015`	`+ SignalObjects[foundSignals].trackNode = trackNode;`
	`1016`	`+ SignalObjects[foundSignals].trRefIndex = nodeIndx;`
	`1017`	`+ SignalObjects[foundSignals].AddHead(nodeIndx, TDBRef, sigItem);`
	`1018`	`+ SignalObjects[foundSignals].thisRef = foundSignals;`
	`1019`	`+ SignalObjects[foundSignals].signalRef = this;`
`1031`	`1020`
`1032`	`1021`	`if (tdbfile.TrackDB.TrackNodes[trackNode] == null \|\| tdbfile.TrackDB.TrackNodes[trackNode].TrVectorNode == null)`
`1033`	`1022`	`{`
`@@ -1036,13 +1025,13 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe`
`1036`	`1025`	`}`
`1037`	`1026`	`else`
`1038`	`1027`	`{`
`1039`		`- signalObjects[foundSignals].tdbtraveller =`
	`1028`	`+ SignalObjects[foundSignals].tdbtraveller =`
`1040`	`1029`	`new Traveller(tsectiondat, tdbfile.TrackDB.TrackNodes, tdbfile.TrackDB.TrackNodes[trackNode],`
`1041`	`1030`	`sigItem.TileX, sigItem.TileZ, sigItem.X, sigItem.Z,`
`1042`	`1031`	`(Traveller.TravellerDirection)(1 - sigItem.Direction));`
`1043`	`1032`	`}`
`1044`	`1033`
`1045`		`- signalObjects[foundSignals].WorldObject = null;`
	`1034`	`+ SignalObjects[foundSignals].WorldObject = null;`
`1046`	`1035`
`1047`	`1036`	`if (SignalHeadList.ContainsKey((uint)TDBRef))`
`1048`	`1037`	`{`
`@@ -1052,11 +1041,11 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe`
`1052`	`1041`
`1053`	`1042`	`if (!validSignal)`
`1054`	`1043`	`{`
`1055`		`- signalObjects[foundSignals] = null; // reset signal, do not increase signal count`
	`1044`	`+ SignalObjects[foundSignals] = null; // reset signal, do not increase signal count`
`1056`	`1045`	`}`
`1057`	`1046`	`else`
`1058`	`1047`	`{`
`1059`		`- SignalHeadList.Add((uint)TDBRef, signalObjects[foundSignals]);`
	`1048`	`+ SignalHeadList.Add((uint)TDBRef, SignalObjects[foundSignals]);`
`1060`	`1049`	`foundSignals++;`
`1061`	`1050`	`}`
`1062`	`1051`
`@@ -1068,43 +1057,43 @@ private int AddSignal(int trackNode, int nodeIndx, SignalItem sigItem, int TDBRe`
`1068`	`1057`	`/// </summary>`
`1069`	`1058`	`private int AddSpeed(int trackNode, int nodeIndx, SpeedPostItem speedItem, int TDBRef, TrackSectionsFile tsectiondat, TrackDatabaseFile tdbfile, int ORTSSignalTypeCount)`
`1070`	`1059`	`{`
`1071`		`- signalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);`
`1072`		`- signalObjects[foundSignals].isSignal = false;`
`1073`		`- signalObjects[foundSignals].isSpeedSignal = false;`
`1074`		`- signalObjects[foundSignals].direction = 0; // preset - direction not yet known //`
`1075`		`- signalObjects[foundSignals].trackNode = trackNode;`
`1076`		`- signalObjects[foundSignals].trRefIndex = nodeIndx;`
`1077`		`- signalObjects[foundSignals].AddHead(nodeIndx, TDBRef, speedItem);`
`1078`		`- signalObjects[foundSignals].thisRef = foundSignals;`
`1079`		`- signalObjects[foundSignals].signalRef = this;`
`1080`		`-`
`1081`		`- signalObjects[foundSignals].tdbtraveller =`
	`1060`	`+ SignalObjects[foundSignals] = new SignalObject(ORTSSignalTypeCount);`
	`1061`	`+ SignalObjects[foundSignals].isSignal = false;`
	`1062`	`+ SignalObjects[foundSignals].isSpeedSignal = false;`
	`1063`	`+ SignalObjects[foundSignals].direction = 0; // preset - direction not yet known //`
	`1064`	`+ SignalObjects[foundSignals].trackNode = trackNode;`
	`1065`	`+ SignalObjects[foundSignals].trRefIndex = nodeIndx;`
	`1066`	`+ SignalObjects[foundSignals].AddHead(nodeIndx, TDBRef, speedItem);`
	`1067`	`+ SignalObjects[foundSignals].thisRef = foundSignals;`
	`1068`	`+ SignalObjects[foundSignals].signalRef = this;`
	`1069`	`+`
	`1070`	`+ SignalObjects[foundSignals].tdbtraveller =`
`1082`	`1071`	`new Traveller(tsectiondat, tdbfile.TrackDB.TrackNodes, tdbfile.TrackDB.TrackNodes[trackNode],`
`1083`	`1072`	`speedItem.TileX, speedItem.TileZ, speedItem.X, speedItem.Z,`
`1084`		`- (Traveller.TravellerDirection)signalObjects[foundSignals].direction);`
	`1073`	`+ (Traveller.TravellerDirection)SignalObjects[foundSignals].direction);`
`1085`	`1074`
`1086`		`- double delta_angle = signalObjects[foundSignals].tdbtraveller.RotY - ((Math.PI / 2) - speedItem.Angle);`
	`1075`	`+ double delta_angle = SignalObjects[foundSignals].tdbtraveller.RotY - ((Math.PI / 2) - speedItem.Angle);`
`1087`	`1076`	`float delta_float = MathHelper.WrapAngle((float)delta_angle);`
`1088`	`1077`	`if (Math.Abs(delta_float) < (Math.PI / 2))`
`1089`	`1078`	`{`
`1090`		`- signalObjects[foundSignals].direction = signalObjects[foundSignals].tdbtraveller.Direction == 0 ? 1 : 0;`
	`1079`	`+ SignalObjects[foundSignals].direction = SignalObjects[foundSignals].tdbtraveller.Direction == 0 ? 1 : 0;`
`1091`	`1080`	`}`
`1092`	`1081`	`else`
`1093`	`1082`	`{`
`1094`		`- signalObjects[foundSignals].direction = (int)signalObjects[foundSignals].tdbtraveller.Direction;`
`1095`		`- signalObjects[foundSignals].tdbtraveller.ReverseDirection();`
	`1083`	`+ SignalObjects[foundSignals].direction = (int)SignalObjects[foundSignals].tdbtraveller.Direction;`
	`1084`	`+ SignalObjects[foundSignals].tdbtraveller.ReverseDirection();`
`1096`	`1085`	`}`
`1097`	`1086`
`1098`	`1087`	`#if DEBUG_PRINT`
`1099`	`1088`	`File.AppendAllText(@"C:\temp\speedpost.txt",`
`1100`	`1089`	`string.Format("\nPlaced : at : {0} {1}:{2} {3}; angle - track : {4}:{5}; delta : {6}; dir : {7}\n",`
`1101`	`1090`	`speedItem.TileX, speedItem.TileZ, speedItem.X, speedItem.Z,`
`1102`		`- speedItem.Angle, signalObjects[foundSignals].tdbtraveller.RotY,`
	`1091`	`+ speedItem.Angle, SignalObjects[foundSignals].tdbtraveller.RotY,`
`1103`	`1092`	`delta_angle,`
`1104`		`- signalObjects[foundSignals].direction));`
	`1093`	`+ SignalObjects[foundSignals].direction));`
`1105`	`1094`	`#endif`
`1106`	`1095`
`1107`		`- signalObjects[foundSignals].WorldObject = null;`
	`1096`	`+ SignalObjects[foundSignals].WorldObject = null;`
`1108`	`1097`	`foundSignals++;`
`1109`	`1098`	`return foundSignals - 1;`
`1110`	`1099`	`}`
`@@ -1134,7 +1123,7 @@ private int AddMilepost(int trackNode, int nodeIndx, SpeedPostItem speedItem, in`
`1134`	`1123`	`/// </summary>`
`1135`	`1124`	`private void AddCFG(SignalConfigurationFile sigCFG)`
`1136`	`1125`	`{`
`1137`		`- foreach (SignalObject signal in signalObjects)`
	`1126`	`+ foreach (SignalObject signal in SignalObjects)`
`1138`	`1127`	`{`
`1139`	`1128`	`if (signal != null)`
`1140`	`1129`	`{`
`@@ -1152,7 +1141,7 @@ private void AddCFG(SignalConfigurationFile sigCFG)`
`1152`	`1141`	`private void AddWorldInfo()`
`1153`	`1142`	`{`
`1154`	`1143`	`// loop through all signal and all heads`
`1155`		`- foreach (SignalObject signal in signalObjects)`
	`1144`	`+ foreach (SignalObject signal in SignalObjects)`
`1156`	`1145`	`{`
`1157`	`1146`	`if (signal != null)`
`1158`	`1147`	`{`
`@@ -1196,7 +1185,7 @@ private void AddWorldInfo()`
`1196`	`1185`	`/// </summary>`
`1197`	`1186`	`public KeyValuePair<SignalObject, SignalHead>? FindByTrItem(uint trItem)`
`1198`	`1187`	`{`
`1199`		`- foreach (var signal in signalObjects)`
	`1188`	`+ foreach (var signal in SignalObjects)`
`1200`	`1189`	`if (signal != null)`
`1201`	`1190`	`foreach (var head in signal.SignalHeads)`
`1202`	`1191`	`if (SignalObject.trackNodes[signal.trackNode].TrVectorNode.TrItemRefs[head.trItemIndex] == (int)trItem)`
`@@ -1209,7 +1198,7 @@ private void AddWorldInfo()`
`1209`	`1198`	`/// </summary>`
`1210`	`1199`	`public void SetNumSignalHeads()`
`1211`	`1200`	`{`
`1212`		`- foreach (SignalObject thisSignal in signalObjects)`
	`1201`	`+ foreach (SignalObject thisSignal in SignalObjects)`
`1213`	`1202`	`{`
`1214`	`1203`	`if (thisSignal != null)`
`1215`	`1204`	`{`
`@@ -1696,9 +1685,9 @@ private void CreateTrackCircuits(TrItem[] TrItems, TrackNode[] trackNodes, TSect`
`1696`	`1685`
`1697`	`1686`	`// Set default next signal and fixed route information`
`1698`	`1687`
`1699`		`- for (int iSignal = 0; signalObjects != null && iSignal < signalObjects.Length; iSignal++)`
	`1688`	`+ for (int iSignal = 0; SignalObjects != null && iSignal < SignalObjects.Length; iSignal++)`
`1700`	`1689`	`{`
`1701`		`- SignalObject thisSignal = signalObjects[iSignal];`
	`1690`	`+ SignalObject thisSignal = SignalObjects[iSignal];`
`1702`	`1691`	`if (thisSignal != null)`
`1703`	`1692`	`{`
`1704`	`1693`	`thisSignal.setSignalDefaultNextSignal();`