Refactor detection of WheelAxlesLoaded, remove fake axles from calculations where appropriate

Author: SteelFill

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/CruiseControl.cs

@@ -432,7 +432,7 @@ private void ComputeNumberOfAxles()
                 SelectedNumberOfAxles = 0;
                 foreach (TrainCar tc in Locomotive.Train.Cars)
                 {
-                    SelectedNumberOfAxles += tc.WheelAxles.Count;
+                    SelectedNumberOfAxles += tc.WheelAxles.Sum(w => w.Fake ? 0 : 1);
                 }
             }
         }

Source/Orts.Simulation/Simulation/RollingStocks/TrainCar.cs

@@ -911,9 +911,11 @@ public virtual void Update(float elapsedClockSeconds)
             // Initialize RigidWheelBaseM in first loop if not defined in ENG file, then ignore
             if (RigidWheelBaseM == 0 && !RigidWheelBaseInitialised)   // Calculate default values if no value in Wag File
             {
-                float Axles = WheelAxles.Count;
-                float Bogies = Parts.Count - 1;
-                float BogieSize = Axles / Bogies;
+                int Axles = WheelAxles.Sum(w => w.Fake ? 0 : 1); // Only consider real axles
+                int Bogies = Parts.Sum(p => p.Bogie ? 1 : 0);
+                int BogieSize = Axles;
+                if (Bogies > 0)
+                    BogieSize = (int)(WheelAxles.Sum(w => !w.Fake && w.Part.Bogie ? 1 : 0) / Bogies); // Only consider axles attached to bogies
 
                 RigidWheelBaseM = 1.6764f;       // Set a default in case no option is found - assume a standard 4 wheel (2 axle) bogie - wheel base - 5' 6" (1.6764m)
 
@@ -2804,16 +2806,20 @@ public void SetUpWheels()
             // No parts means no bogies (always?), so make sure we've got Parts[0] for the car itself.
             if (Parts.Count == 0)
                 Parts.Add(new TrainCarPart(Vector3.Zero, 0));
-            // No axles but we have bogies.
-            if (WheelAxles.Count == 0 && Parts.Count > 1)
-            {
-                // Fake the axles by pretending each bogie has 1 axle.
+            // Determine how many parts are considered bogies (used to calculate position of the car)
+            int bogieCount = 0;
+            foreach (TrainCarPart p in Parts)
+                if (p.Bogie == true)
+                    bogieCount++;
+            // No axles but we have bogies. Each bogie needs axles to function correctly
+            if (WheelAxles.Count == 0 && bogieCount > 0)
+            {
+                // Add a fake axle to each bogie, a second fake axle will be added later if needed
                 for (int i = 1; i < Parts.Count; i++)
-                    WheelAxles.Add(new WheelAxle(Parts[i].OffsetM, i, Parts[i].iMatrix));
-                Trace.TraceInformation("Wheel axle data faked based on {1} bogies for {0}", WagFilePath, Parts.Count - 1);
+                    if (Parts[i].Bogie == true)
+                        WheelAxles.Add(new WheelAxle(Parts[i].OffsetM, i, Parts[i].iMatrix, true));
+                Trace.TraceInformation("Wheel axle data faked based on {1} bogies for {0}", WagFilePath, bogieCount);
             }
-            bool articFront = !WheelAxles.Any(a => a.OffsetM.Z < 0);
-            bool articRear = !WheelAxles.Any(a => a.OffsetM.Z > 0);
             // Validate the axles' assigned bogies and count up the axles on each bogie.
             if (WheelAxles.Count > 0)
             {
@@ -2833,10 +2839,6 @@ public void SetUpWheels()
                     w.Part = Parts[w.BogieIndex];
                     w.Part.SumWgt++;
                 }
-
-                // Make sure the axles are sorted by OffsetM along the car.
-                // Attempting to sort car w/o WheelAxles will resort to an error.
-                WheelAxles.Sort(WheelAxles[0]);
             }
 
             //fix bogies with only one wheel set:
@@ -2856,7 +2858,7 @@ public void SetUpWheels()
                         {
                             if (w.OffsetM.Z.AlmostEqual(Parts[i].OffsetM.Z, 0.6f))
                             {
-                                var w1 = new WheelAxle(new Vector3(w.OffsetM.X, w.OffsetM.Y, w.OffsetM.Z - 0.5f), w.BogieIndex, i);
+                                var w1 = new WheelAxle(new Vector3(w.OffsetM.X, w.OffsetM.Y, w.OffsetM.Z - 0.5f), w.BogieIndex, i, true);
                                 w1.Part = Parts[w1.BogieIndex]; //create virtual wheel
                                 w1.Part.SumWgt++;
                                 WheelAxles.Add(w1);
@@ -2869,34 +2871,29 @@ public void SetUpWheels()
                 }
             }
 
-            // Count up the number of bogies (parts) with at least 2 axles.
+            // Check how many parts can drive the position of the car itself
+            // Each part needs at least 2 components (sum of weights > 1.5) for position calculation to work
             for (var i = 1; i < Parts.Count; i++)
                 if (Parts[i].SumWgt > 1.5)
                     Parts[0].SumWgt++;
 
-            // This check is for the single axle/bogie issue.
-            // Check SumWgt using Parts[0].SumWgt.
-            // Certain locomotives do not test well when using Part.SumWgt versus Parts[0].SumWgt.
-            // Make sure test using Parts[0] is performed after the above for loop.
+            // Check if articulation is desired on this car, as this requires different handling
+            bool articFront = (FrontArticulation == 1 || (FrontArticulation == -1 && !WheelAxles.Any(a => a.OffsetM.Z < 0)));
+            bool articRear = (RearArticulation == 1 || (RearArticulation == -1 && !WheelAxles.Any(a => a.OffsetM.Z > 0)));
+
+            // If car has insufficient bogies and it's not because of articulation, attempt to avoid position calculation errors
+            // Detach wheels from the last bogie, and instead attach to the main part, which should allow calculations to work properly
             if (!articFront && !articRear && (Parts[0].SumWgt < 1.5))
             {
-                foreach (var w in WheelAxles)
+                foreach (WheelAxle w in WheelAxles)
                 {
                     if (w.BogieIndex >= Parts.Count - 1)
                     {
                         w.BogieIndex = 0;
                         w.Part = Parts[w.BogieIndex];
-
                     }
                 }
             }
-            // Using WheelAxles.Count test to control WheelAxlesLoaded flag.
-            if (WheelAxles.Count >= 2) // Some cars only have two axles.
-            {
-                WheelAxles.Sort(WheelAxles[0]);
-                WheelAxlesLoaded = true;
-            }
-
 
 #if DEBUG_WHEELS
             Console.WriteLine(WagFilePath);
@@ -2907,43 +2904,49 @@ public void SetUpWheels()
             foreach (var p in Parts)
                 Console.WriteLine("  part:  matrix {1,5:F0}  offset {0,10:F4}  weight {2,5:F0}", p.OffsetM, p.iMatrix, p.SumWgt);
 #endif
-            // Decided to control what is sent to SetUpWheelsArticulation()by using
-            // WheelAxlesLoaded as a flag.  This way, wagons that have to be processed are included
-            // and the rest left out.
-
-            // Force articulation if stock is configured as such
-            // Otherwise, use default behavior which gives articulation if there are no axles forward/rearward on the model,
-            // disables articulation on engines, and only allows articulation with 3 or fewer axles, but not 1 axle
-            bool articulatedFront = (FrontArticulation == 1 ||
-                (FrontArticulation == -1 && !WheelAxles.Any(a => a.OffsetM.Z < 0) && WagonType != WagonTypes.Engine && WheelAxles.Count != 1 && WheelAxles.Count <= 3));
-            bool articulatedRear = (RearArticulation == 1 ||
-                (RearArticulation == -1 && !WheelAxles.Any(a => a.OffsetM.Z > 0) && WagonType != WagonTypes.Engine && WheelAxles.Count != 1 && WheelAxles.Count <= 3));
-
-            if (articulatedFront || articulatedRear)
-            {
+            // Add fake axle(s) to train car for articulation when desired
+            // Adding fake axles automatically is only allowed on non-engines with 0, 2, or 3 axles
+            // These limitations prevent various incompatibilities with existing content
+            bool allowAutoArticulate = WagonType != WagonTypes.Engine && WheelAxles.Count != 1 && WheelAxles.Count <= 3;
+            articFront &= !(FrontArticulation == -1 && !allowAutoArticulate);
+            articRear &= !(RearArticulation == -1 && !allowAutoArticulate);
+
+            if (articFront || articRear)
+                SetUpWheelsArticulation(articFront, articRear);
+
+            // Other calculations require axles to be sorted based on their Z-offset
+            WheelAxles.Sort(WheelAxles[0]);
+
+            // After all processing is complete, check if the car can have its position calculated
+            // using the position of the axles, which is indicated by the 'WheelAxlesLoaded' flag.
+            // The train car must have at least 2 position references. These references can be either
+            // an axle or a bogie, but each bogie itself needs 2 position references.
+            int[] posReferences = new int[Parts.Count];
+            // Count the number of axles associated with each part (including main object)
+            foreach (WheelAxle w in WheelAxles)
+                posReferences[w.BogieIndex]++;
+            // Add a position reference to the main object for each bogie itself with at least 2 position references
+            for (int i = 1; i < Parts.Count; i++)
+                if (posReferences[i] >= 2) 
+                    posReferences[0]++;
+            // Car has a suitable arrangement of axles for position calculation if the main object has at least 2 position references
+            if (posReferences[0] >= 2) 
                 WheelAxlesLoaded = true;
-                SetUpWheelsArticulation(articulatedFront, articulatedRear);
-            }
         } // end SetUpWheels()
 
         protected void SetUpWheelsArticulation(bool front, bool rear)
         {
-            // If there are no forward wheels, this car is articulated (joined
+            // If there are no forward axles, this car is articulated (joined
             // to the car in front) at the front. Likewise for the rear.
-            // Original process originally used caused too many issues.
-            // The original process did include the below process of just using WheelAxles.Add
-            //  if the initial test did not work.  Since the below process is working without issues the
-            //  original process was stripped down to what is below
-            if (front || rear)
-            {
-                if (front)
-                    WheelAxles.Add(new WheelAxle(new Vector3(0.0f, BogiePivotHeightM, -CarLengthM / 2.0f), 0, 0) { Part = Parts[0] });
+            // This will cause the car to move incorrectly, so to produce the
+            // expected motion, a fake axle is added at the articulated end(s)
+            // of the car, attached to the car itself. This will drive the positioning
+            // of the car as expected.
+            if (front)
+                WheelAxles.Add(new WheelAxle(new Vector3(0.0f, BogiePivotHeightM, -CarLengthM / 2.0f), 0, 0, true) { Part = Parts[0] });
 
-                if (rear)
-                    WheelAxles.Add(new WheelAxle(new Vector3(0.0f, BogiePivotHeightM, CarLengthM / 2.0f), 0, 0) { Part = Parts[0] });
-
-                WheelAxles.Sort(WheelAxles[0]);
-            }
+            if (rear)
+                WheelAxles.Add(new WheelAxle(new Vector3(0.0f, BogiePivotHeightM, CarLengthM / 2.0f), 0, 0, true) { Part = Parts[0] });
 
 
 #if DEBUG_WHEELS
@@ -3718,14 +3721,16 @@ public void UpdateGravity(Matrix orientation)
     public class WheelAxle : IComparer<WheelAxle>
     {
         public Vector3 OffsetM;   // Offset from the bogie center
-        public int BogieIndex;
-        public int BogieMatrix;
-        public TrainCarPart Part;
-        public WheelAxle(Vector3 offset, int bogie, int parentMatrix)
+        public int BogieIndex;    // Index in the Parts list of the bogie this is attached to
+        public int BogieMatrix;   // Index in the matrix hierarchy of the bogie this is attached to
+        public TrainCarPart Part; // Reference to the object for the bogie this is attached to
+        public bool Fake;         // True for axles that aren't present in the 3D model
+        public WheelAxle(Vector3 offset, int bogie, int parentMatrix, bool fake = false)
         {
             OffsetM = offset;
             BogieIndex = bogie;
             BogieMatrix = parentMatrix;
+            Fake = fake;
         }
         public int Compare(WheelAxle a, WheelAxle b)
         {

Source/RunActivity/Viewer3D/Popups/HUDWindow.cs

@@ -608,53 +608,66 @@ static string GetCarWhyteLikeNotation(TrainCar car)
 
                 foreach (var axle in car.WheelAxles)
                 {
-                    if (!axle.Part.Bogie) // if not a bogie then check for the number of axles.
+                    // Do not consider fake axles
+                    if (!axle.Fake)
                     {
-                        if (currentBogie != axle.BogieIndex && currentCount != 0)
+                        if (!axle.Part.Bogie) // if not a bogie then check for the number of axles.
                         {
-                            whyte.Add(currentCount.ToString());
-                            currentBogie = axle.BogieIndex;
-                            currentCount = 0;
-                        }
+                            if (currentBogie != axle.BogieIndex)
+                            {
+                                if (currentCount != 0)
+                                {
+                                    whyte.Add(currentCount.ToString());
+                                    currentCount = 0;
+                                }
+                                currentBogie = axle.BogieIndex;
+                            }
 
-                        if (steamloco.SteamEngines[i].AuxiliarySteamEngineType != SteamEngine.AuxiliarySteamEngineTypes.Booster)
+                            if (steamloco.SteamEngines[i].AuxiliarySteamEngineType != SteamEngine.AuxiliarySteamEngineTypes.Booster)
+                            {
+                                currentCount += 2;
+                                axlesCount += 1;
+
+                                if (axlesCount >= steamloco.SteamEngines[i].AttachedAxle.NumWheelsetAxles)
+                                {
+                                    if (currentCount != 0)
+                                    {
+                                        whyte.Add(currentCount.ToString());
+                                        currentCount = 0;
+                                    }
+                                    currentBogie = axle.BogieIndex;
+                                    axlesCount = 0;
+                                    i = i + 1;
+                                }
+                            }
+                        }
+                        else if (axle.Part.Bogie) // this is a bogie
                         {
-                            currentCount += 2;
-                            axlesCount += 1;
+                            if (PreviousAxlePart)
+                            {
+                                currentBogie = axle.BogieIndex;
+                            }
 
-                            if (axlesCount >= steamloco.SteamEngines[i].AttachedAxle.NumWheelsetAxles && currentCount != 0)
+                            if (currentBogie != axle.BogieIndex)
                             {
-                                whyte.Add(currentCount.ToString());
+                                if (currentCount != 0)
+                                {
+                                    whyte.Add(currentCount.ToString());
+                                    currentCount = 0;
+                                }
                                 currentBogie = axle.BogieIndex;
-                                currentCount = 0;
-                                axlesCount = 0;
-                                i = i + 1;
                             }
+                            currentCount += 2;
                         }
-                    }
-                    else if (axle.Part.Bogie) // this is a bogie
-                    {
-                        if ( PreviousAxlePart)
+
+                        if (axle.Part.Bogie)
                         {
-                            currentBogie = axle.BogieIndex;
+                            PreviousAxlePart = true;
                         }
-
-                        if (currentBogie != axle.BogieIndex && currentCount != 0)
+                        else
                         {
-                            whyte.Add(currentCount.ToString());
-                            currentBogie = axle.BogieIndex;
-                            currentCount = 0;
+                            PreviousAxlePart = false;
                         }
-                        currentCount += 2;
-                    }
-
-                    if (axle.Part.Bogie)
-                    {
-                        PreviousAxlePart = true;
-                    }
-                    else
-                    {
-                        PreviousAxlePart = false;
                     }
                 }
 
@@ -665,13 +678,20 @@ static string GetCarWhyteLikeNotation(TrainCar car)
             {
                 foreach (var axle in car.WheelAxles)
                 {
-                    if (currentBogie != axle.BogieIndex && currentCount != 0)
+                    // Do not consider fake axles
+                    if (!axle.Fake)
                     {
-                        whyte.Add(currentCount.ToString());
-                        currentBogie = axle.BogieIndex;
-                        currentCount = 0;
+                        if (currentBogie != axle.BogieIndex)
+                        {
+                            if (currentCount != 0)
+                            {
+                                whyte.Add(currentCount.ToString());
+                                currentCount = 0;
+                            }
+                            currentBogie = axle.BogieIndex;
+                        }
+                        currentCount += 2;
                     }
-                    currentCount += 2;
                 }
                 whyte.Add(currentCount.ToString());
                 return String.Join("-", whyte.ToArray());