Speed Limits tool full rewrite/refactor; Render overlay refactor

TLM/.editorconfig

@@ -35,11 +35,11 @@ resharper_add_imports_to_deepest_scope=true
 resharper_align_linq_query=true
 resharper_align_multiline_argument=true
 resharper_align_multiline_calls_chain=true
-resharper_align_multiline_expression=true
+resharper_align_multiline_expression=false
 resharper_align_multiline_extends_list=true
 resharper_align_multiline_for_stmt=true
 resharper_align_multiline_parameter=true
-resharper_align_multiple_declaration=true
+resharper_align_multiple_declaration=false
 resharper_align_multline_type_parameter_constrains=true
 resharper_align_multline_type_parameter_list=true
 resharper_autodetect_indent_settings=true

TLM/TLM/Constants.cs

@@ -15,17 +15,6 @@ public static class Constants {
         /// </summary>
         public static readonly bool[] ALL_BOOL = { false, true };
 
-        /// <summary>
-        /// Conversion rate from km/h to game speed (also exists in TrafficManager.API.Constants)
-        /// </summary>
-        public const float SPEED_TO_KMPH = 50.0f; // 1.0f equals 50 km/h
-
-        /// <summary>
-        /// Conversion rate from MPH to game speed (also exists in TrafficManager.API.Constants)
-        /// </summary>
-        [UsedImplicitly]
-        public const float SPEED_TO_MPH = 32.06f; // 50 km/h converted to mph
-
         public static float ByteToFloat(byte b) {
             return b * BYTE_TO_FLOAT_SCALE;
         }
@@ -41,5 +30,11 @@ public static class Constants {
         }
 
         public static IManagerFactory ManagerFactory => Manager.Impl.ManagerFactory.Instance;
+
+        /// <summary>Size for clickable signs used in overlays. Larger than readonly signs.</summary>
+        public const float OVERLAY_INTERACTIVE_SIGN_SIZE = 6.0f;
+
+        /// <summary>Size for readonly signs used in overlays.</summary>
+        public const float OVERLAY_READONLY_SIGN_SIZE = 3.8f;
     }
 }

TLM/TLM/Custom/PathFinding/CustomPathFind.cs

@@ -147,7 +147,7 @@ private struct BufferItem {
         }
 
         // stock fields
-        public ThreadProfiler m_pathfindProfiler;
+        // public ThreadProfiler m_pathfindProfiler;
         private object bufferLock_;
         private int bufferMinPos_;
         private int bufferMaxPos_;

TLM/TLM/Manager/Impl/OptionsManager.cs

@@ -232,7 +232,7 @@ public class OptionsManager
 
             index = LoadBool(index, OptionsMassEditTab.PriorityRoad_CrossMainR);
             index = LoadBool(index, OptionsMassEditTab.PriorityRoad_AllowLeftTurns);
-            index = LoadBool(index, OptionsMassEditTab.PriorityRoad_EnterBlockedYeild);
+            index = LoadBool(index, OptionsMassEditTab.PriorityRoad_EnterBlockedYield);
             index = LoadBool(index, OptionsMassEditTab.PriorityRoad_StopAtEntry);
 
             index = LoadBool(index, OptionsMassEditTab.RoundAboutQuickFix_KeepClearYieldR);
@@ -297,7 +297,7 @@ public class OptionsManager
 
                 (byte)(OptionsMassEditTab.PriorityRoad_CrossMainR.Save()),
                 (byte)(OptionsMassEditTab.PriorityRoad_AllowLeftTurns.Save()),
-                (byte)(OptionsMassEditTab.PriorityRoad_EnterBlockedYeild.Save()),
+                (byte)(OptionsMassEditTab.PriorityRoad_EnterBlockedYield.Save()),
                 (byte)(OptionsMassEditTab.PriorityRoad_StopAtEntry.Save()),
 
                 (byte)(OptionsMassEditTab.RoundAboutQuickFix_KeepClearYieldR.Save()),

TLM/TLM/State/ConfigData/Main.cs

@@ -14,13 +14,15 @@ public class Main {
         public int MainMenuButtonY = 10;
         public bool MainMenuButtonPosLocked = false;
 
-        /// <summary>
-        /// Main menu position
-        /// </summary>
+        /// <summary>Main menu position.</summary>
         public int MainMenuX = MainMenuWindow.DEFAULT_MENU_X;
         public int MainMenuY = MainMenuWindow.DEFAULT_MENU_Y;
         public bool MainMenuPosLocked = false;
 
+        /// <summary>Speed Limits tool window position.</summary>
+        public int SpeedLimitsWindowX = 0;
+        public int SpeedLimitsWindowY = 0;
+
         /// <summary>
         /// Already displayed tutorial messages
         /// </summary>
@@ -74,7 +76,7 @@ public class Main {
         /// <summary>
         /// Selected theme for road signs when MPH is active.
         /// </summary>
-        public MphSignStyle MphRoadSignStyle = MphSignStyle.SquareUS;
+        public SpeedLimitSignTheme MphRoadSignStyle = SpeedLimitSignTheme.RectangularUS;
 
         public void AddDisplayedTutorialMessage(string messageKey) {
             HashSet<string> newMessages = DisplayedTutorialMessages != null

TLM/TLM/State/Flags.cs

@@ -7,6 +7,7 @@ namespace TrafficManager.State {
     using System.Collections.Generic;
     using System.Threading;
     using System;
+    using TrafficManager.API.Traffic.Data;
     using TrafficManager.API.Traffic.Enums;
     using TrafficManager.Manager.Impl;
     using TrafficManager.State.ConfigData;
@@ -485,7 +486,7 @@ public class Flags {
                     (NetSegment.Flags.Created | NetSegment.Flags.Deleted)) == NetSegment.Flags.Created;
         }
 
-        public static void SetLaneSpeedLimit(uint laneId, float? speedLimit) {
+        public static void SetLaneSpeedLimit(uint laneId, SetSpeedLimitAction action) {
             if (!CheckLane(laneId)) {
                 return;
             }
@@ -497,7 +498,7 @@ public class Flags {
 
             while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u) {
                 if (curLaneId == laneId) {
-                    SetLaneSpeedLimit(segmentId, laneIndex, laneId, speedLimit);
+                    SetLaneSpeedLimit(segmentId, laneIndex, laneId, action);
                     return;
                 }
 
@@ -507,28 +508,32 @@ public class Flags {
         }
 
         public static void RemoveLaneSpeedLimit(uint laneId) {
-            SetLaneSpeedLimit(laneId, null);
+            SetLaneSpeedLimit(laneId, SetSpeedLimitAction.Default());
         }
 
         public static void SetLaneSpeedLimit(ushort segmentId,
                                              uint laneIndex,
                                              uint laneId,
-                                             float? speedLimit) {
+                                             SetSpeedLimitAction action) {
             if (segmentId <= 0 || laneId <= 0) {
                 return;
             }
 
-            if ((Singleton<NetManager>.instance.m_segments.m_buffer[segmentId].m_flags &
+            NetSegment[] segmentsBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;
+
+            if ((segmentsBuffer[segmentId].m_flags &
                  (NetSegment.Flags.Created | NetSegment.Flags.Deleted)) != NetSegment.Flags.Created) {
                 return;
             }
 
-            if (((NetLane.Flags)Singleton<NetManager>.instance.m_lanes.m_buffer[laneId].m_flags &
+            NetLane[] lanesBuffer = Singleton<NetManager>.instance.m_lanes.m_buffer;
+
+            if (((NetLane.Flags)lanesBuffer[laneId].m_flags &
                  (NetLane.Flags.Created | NetLane.Flags.Deleted)) != NetLane.Flags.Created) {
                 return;
             }
 
-            NetInfo segmentInfo = Singleton<NetManager>.instance.m_segments.m_buffer[segmentId].Info;
+            NetInfo segmentInfo = segmentsBuffer[segmentId].Info;
 
             if (laneIndex >= segmentInfo.m_lanes.Length) {
                 return;
@@ -541,33 +546,41 @@ public class Flags {
                     $"Flags.setLaneSpeedLimit: setting speed limit of lane index {laneIndex} @ seg. " +
                     $"{segmentId} to {speedLimit}");
 #endif
-                if (speedLimit == null) {
-                    laneSpeedLimit.Remove(laneId);
+                switch (action.Type) {
+                    case SetSpeedLimitAction.ValueType.Default: {
+                        laneSpeedLimit.Remove(laneId);
 
-                    if (laneSpeedLimitArray[segmentId] == null) {
-                        return;
-                    }
+                        if (laneSpeedLimitArray[segmentId] == null) {
+                            return;
+                        }
 
-                    if (laneIndex >= laneSpeedLimitArray[segmentId].Length) {
-                        return;
-                    }
+                        if (laneIndex >= laneSpeedLimitArray[segmentId].Length) {
+                            return;
+                        }
 
-                    laneSpeedLimitArray[segmentId][laneIndex] = null;
-                } else {
-                    laneSpeedLimit[laneId] = speedLimit.Value;
-
-                    // save speed limit into the fast-access array.
-                    // (1) ensure that the array is defined and large enough
-                    if (laneSpeedLimitArray[segmentId] == null) {
-                        laneSpeedLimitArray[segmentId] = new float?[segmentInfo.m_lanes.Length];
-                    } else if (laneSpeedLimitArray[segmentId].Length < segmentInfo.m_lanes.Length) {
-                        float?[] oldArray = laneSpeedLimitArray[segmentId];
-                        laneSpeedLimitArray[segmentId] = new float?[segmentInfo.m_lanes.Length];
-                        Array.Copy(oldArray, laneSpeedLimitArray[segmentId], oldArray.Length);
+                        laneSpeedLimitArray[segmentId][laneIndex] = null;
+                        break;
+                    }
+                    case SetSpeedLimitAction.ValueType.Unlimited:
+                    case SetSpeedLimitAction.ValueType.SetSpeed: {
+                        laneSpeedLimit[laneId] = action.Value.GetKmph();
+
+                        // save speed limit into the fast-access array.
+                        // (1) ensure that the array is defined and large enough
+                        if (laneSpeedLimitArray[segmentId] == null) {
+                            laneSpeedLimitArray[segmentId] = new float?[segmentInfo.m_lanes.Length];
+                        } else if (laneSpeedLimitArray[segmentId].Length < segmentInfo.m_lanes.Length) {
+                            float?[] oldArray = laneSpeedLimitArray[segmentId];
+                            laneSpeedLimitArray[segmentId] = new float?[segmentInfo.m_lanes.Length];
+                            Array.Copy(sourceArray: oldArray,
+                                       destinationArray: laneSpeedLimitArray[segmentId],
+                                       length: oldArray.Length);
+                        }
+
+                        // (2) insert the custom speed limit
+                        laneSpeedLimitArray[segmentId][laneIndex] = action.Value.GetKmph();
+                        break;
                     }
-
-                    // (2) insert the custom speed limit
-                    laneSpeedLimitArray[segmentId][laneIndex] = speedLimit;
                 }
             }
             finally {
@@ -862,15 +875,16 @@ public class Flags {
             return false;
         }
 
-        public static float? GetLaneSpeedLimit(uint laneId) {
+        public static SpeedValue? GetLaneSpeedLimit(uint laneId) {
             try {
                 Monitor.Enter(laneSpeedLimitLock);
 
-                if (laneId <= 0 || !laneSpeedLimit.TryGetValue(laneId, out float speedLimit)) {
+                if (laneId <= 0 || !laneSpeedLimit.TryGetValue(laneId, out float kmphOverride)) {
                     return null;
                 }
 
-                return speedLimit;
+                // assumption: speed limit is stored in km/h
+                return SpeedValue.FromKmph(kmphOverride);
             }
             finally {
                 Monitor.Exit(laneSpeedLimitLock);

TLM/TLM/State/GetSpeedLimitResult.cs

@@ -0,0 +1,44 @@
+namespace TrafficManager {
+    using System.Runtime.CompilerServices;
+    using TrafficManager.API.Traffic.Data;
+
+    public struct GetSpeedLimitResult {
+        public enum ResultType {
+            /// <summary>The speed limit had an override.</summary>
+            OverrideExists,
+
+            /// <summary>There was no override possible.</summary>
+            NotAvailable,
+        }
+
+        public ResultType Type;
+
+        /// <summary>Valid only if Type=='Value'.</summary>
+        public SpeedValue? OverrideValue;
+
+        public SpeedValue DefaultValue;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetSpeedLimitResult"/> struct
+        /// from maybe an override value (nullable SpeedValue) and a
+        /// default speedlimit value for that lane type.
+        /// </summary>
+        /// <param name="value">Nullable override value.</param>
+        /// <param name="defaultValue">Default speed value.</param>
+        public GetSpeedLimitResult(SpeedValue? value, SpeedValue defaultValue) {
+            Type = ResultType.OverrideExists;
+            OverrideValue = value;
+            DefaultValue = defaultValue;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetSpeedLimitResult"/> struct
+        /// as error state (no override possible).
+        /// </summary>
+        public GetSpeedLimitResult(ResultType _ignored) {
+            Type = ResultType.NotAvailable;
+            OverrideValue = null;
+            DefaultValue = new SpeedValue(0f);
+        }
+    }
+}

TLM/TLM/State/OptionsTabs/OptionsGeneralTab.cs

@@ -306,13 +306,13 @@ public static class OptionsGeneralTab {
             }
 
             // The UI order is: US, UK, German
-            var newStyle = MphSignStyle.RoundGerman;
+            var newStyle = SpeedLimitSignTheme.RoundGerman;
             switch (newRoadSignStyle) {
                 case 1:
-                    newStyle = MphSignStyle.RoundUK;
+                    newStyle = SpeedLimitSignTheme.RoundUK;
                     break;
                 case 0:
-                    newStyle = MphSignStyle.SquareUS;
+                    newStyle = SpeedLimitSignTheme.RectangularUS;
                     break;
             }
 

TLM/TLM/State/OptionsTabs/OptionsMassEditTab.cs

@@ -72,7 +72,7 @@ public static class OptionsMassEditTab {
                 Tooltip = "Priority roads.Tooltip:Allow far turns",
             };
 
-        public static CheckboxOption PriorityRoad_EnterBlockedYeild =
+        public static CheckboxOption PriorityRoad_EnterBlockedYield =
             new CheckboxOption("PriorityRoad_EnterBlockedYeild") {
                 Label = "Priority roads.Option:Enter blocked yield road",
         };
@@ -106,7 +106,7 @@ public static void MakeSettings_MassEdit(ExtUITabstrip tabStrip, int tabIndex)
             UIHelperBase priorityRoadGroup = panelHelper.AddGroup(T("MassEdit.Group.Priority roads"));
             PriorityRoad_CrossMainR.AddUI(priorityRoadGroup);
             PriorityRoad_AllowLeftTurns.AddUI(priorityRoadGroup);
-            PriorityRoad_EnterBlockedYeild.AddUI(priorityRoadGroup);
+            PriorityRoad_EnterBlockedYield.AddUI(priorityRoadGroup);
             PriorityRoad_StopAtEntry.AddUI(priorityRoadGroup);
         }