reset lane arrows

TLM/TLM/Manager/Impl/LaneArrowManager.cs

@@ -11,6 +11,7 @@ namespace TrafficManager.Manager.Impl {
     using TrafficManager.State;
     using TrafficManager.Util;
     using UnityEngine;
+    using static TrafficManager.Util.Shortcuts;
 
     public class LaneArrowManager
         : AbstractGeometryObservingManager,
@@ -54,7 +55,7 @@ public LaneArrows GetFinalLaneArrows(uint laneId) {
         public bool SetLaneArrows(uint laneId,
                                   LaneArrows flags,
                                   bool overrideHighwayArrows = false) {
-            if (Flags.setLaneArrowFlags(laneId, flags, overrideHighwayArrows)) {
+            if (Flags.SetLaneArrowFlags(laneId, flags, overrideHighwayArrows)) {
                 OnLaneChange(laneId);
                 return true;
             }
@@ -111,6 +112,43 @@ public bool ToggleLaneArrows(uint laneId,
             return false;
         }
 
+        /// <summary>
+        /// Resets lane arrows to their default value for the given segment end.
+        /// </summary>
+        /// <param name="segmentId">segment to reset</param>
+        /// <param name="startNode">determines the segment end to reset. if <c>null</c>
+        /// both ends are reset</param>
+        public void ResetLaneArrows(ushort segmentId, bool? startNode = null) {
+            foreach (var lane in netService.GetSortedLanes(
+                segmentId,
+                ref GetSeg(segmentId),
+                startNode,
+                LANE_TYPES,
+                VEHICLE_TYPES)) {
+                ResetLaneArrows(lane.laneId);
+            }
+        }
+
+        /// <summary>
+        /// Resets lane arrows to their default value for the given lane
+        /// </summary>
+        public void ResetLaneArrows(uint laneId) {
+            if (Flags.ResetLaneArrowFlags(laneId)) {
+                RecalculateFlags(laneId);
+                OnLaneChange(laneId);
+            }
+        }
+
+        private static void RecalculateFlags(uint laneId) {
+            NetLane[] laneBuffer = NetManager.instance.m_lanes.m_buffer;
+            ushort segmentId = laneBuffer[laneId].m_segment;
+            NetAI ai = GetSeg(segmentId).Info.m_netAI;
+#if DEBUGFLAGS
+            Log._Debug($"Flags.RecalculateFlags: Recalculateing lane arrows of segment {segmentId}.");
+#endif
+            ai.UpdateLanes(segmentId, ref GetSeg(segmentId), true);
+        }
+
         private void OnLaneChange(uint laneId) {
             Services.NetService.ProcessLane(
                 laneId,
@@ -126,7 +164,7 @@ private void OnLaneChange(uint laneId) {
         }
 
         protected override void HandleInvalidSegment(ref ExtSegment seg) {
-            Flags.resetSegmentArrowFlags(seg.segmentId);
+            Flags.ResetSegmentArrowFlags(seg.segmentId);
         }
 
         protected override void HandleValidSegment(ref ExtSegment seg) { }

TLM/TLM/Manager/Impl/LaneConnectionManager.cs

@@ -11,6 +11,7 @@ namespace TrafficManager.Manager.Impl {
     using TrafficManager.State.ConfigData;
     using TrafficManager.State;
     using UnityEngine;
+    using static TrafficManager.Util.Shortcuts;
 
     public class LaneConnectionManager
         : AbstractGeometryObservingManager,
@@ -60,6 +61,35 @@ public bool AreLanesConnected(uint sourceLaneId, uint targetLaneId, bool sourceS
                    && connectedLanes.Any(laneId => laneId == targetLaneId);
         }
 
+
+        /// <summary>
+        /// determines whether or not the input lane is heading toward a start node.
+        /// </summary>
+        /// <returns>true if heading toward and start node.</returns>
+        private bool IsHeadingTowardsStartNode(uint sourceLaneId) {
+            NetLane[] laneBuffer = NetManager.instance.m_lanes.m_buffer;
+            ushort segmentId = laneBuffer[sourceLaneId].m_segment;
+            NetSegment segment = GetSeg(segmentId);
+            uint laneId = segment.m_lanes;
+            bool inverted = (segment.m_flags & NetSegment.Flags.Invert) != 0;
+
+            foreach (var laneInfo in segment.Info.m_lanes) {
+                if (laneId == sourceLaneId) {
+                    return (laneInfo.m_direction == NetInfo.Direction.Forward) ^ !inverted;
+                }
+                laneId = laneBuffer[laneId].m_nextLane;
+            }
+            throw new Exception($"Unreachable code. sourceLaneId:{sourceLaneId}, segmentId:{segmentId} ");
+        }
+
+        public bool HasConnections(uint sourceLaneId) {
+            if (!Options.laneConnectorEnabled) {
+                return false;
+            }
+            return HasConnections(sourceLaneId, IsHeadingTowardsStartNode(sourceLaneId));
+        }
+
+
         /// <summary>
         /// Determines if the given lane has outgoing connections
         /// </summary>

TLM/TLM/Manager/Impl/RoutingManager.cs

@@ -2166,7 +2166,7 @@ protected override void HandleInvalidSegment(ref ExtSegment seg) {
                 Log._Debug($"RoutingManager.HandleInvalidSegment({seg.segmentId}) called.");
             }
 
-            Flags.removeHighwayLaneArrowFlagsAtSegment(seg.segmentId);
+            Flags.RemoveHighwayLaneArrowFlagsAtSegment(seg.segmentId);
             ResetRoutingData(seg.segmentId);
         }
 

TLM/TLM/Manager/Impl/SpeedLimitManager.cs

@@ -395,7 +395,7 @@ public void ClearCurrentSpeedLimits(NetInfo info) {
                     continue;
                 }
 
-                Flags.removeLaneSpeedLimit(laneId);
+                Flags.RemoveLaneSpeedLimit(laneId);
             }
         }
 

TLM/TLM/Manager/Impl/TrafficLightManager.cs

@@ -257,7 +257,7 @@ public bool LoadData(string data) {
                         continue;
                     }
 
-                    Flags.setNodeTrafficLight(nodeId, flag > 0);
+                    Flags.SetNodeTrafficLight(nodeId, flag > 0);
                 } catch (Exception e) {
                     // ignore as it's probably bad save data.
                     Log.Error($"Error setting the NodeTrafficLights: " + e.ToString());

TLM/TLM/Manager/Impl/VehicleRestrictionsManager.cs

@@ -378,7 +378,7 @@ internal bool SetAllowedVehicleTypes(ushort segmentId,
             allowedTypes &= GetBaseMask(
                 segmentInfo.m_lanes[laneIndex],
                 VehicleRestrictionsMode.Configured); // ensure default base mask
-            Flags.setLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
+            Flags.SetLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
 
             NotifyStartEndNode(segmentId);
 
@@ -424,7 +424,7 @@ public void AddAllowedType(ushort segmentId,
             allowedTypes &= GetBaseMask(
                 segmentInfo.m_lanes[laneIndex],
                 VehicleRestrictionsMode.Configured); // ensure default base mask
-            Flags.setLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
+            Flags.SetLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
             NotifyStartEndNode(segmentId);
 
             if (OptionsManager.Instance.MayPublishSegmentChanges()) {
@@ -467,7 +467,7 @@ public void RemoveAllowedType(ushort segmentId,
             allowedTypes &= GetBaseMask(
                 segmentInfo.m_lanes[laneIndex],
                 VehicleRestrictionsMode.Configured); // ensure default base mask
-            Flags.setLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
+            Flags.SetLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, allowedTypes);
             NotifyStartEndNode(segmentId);
 
             if (OptionsManager.Instance.MayPublishSegmentChanges()) {
@@ -744,7 +744,7 @@ public void NotifyStartEndNode(ushort segmentId) {
         }
 
         protected override void HandleInvalidSegment(ref ExtSegment seg) {
-            Flags.resetSegmentVehicleRestrictions(seg.segmentId);
+            Flags.ResetSegmentVehicleRestrictions(seg.segmentId);
             ClearCache(seg.segmentId);
         }
 
@@ -773,7 +773,7 @@ public bool LoadData(List<Configuration.LaneVehicleTypes> data) {
                     $"{laneVehicleTypes.vehicleTypes}, masked = {maskedType}");
 #endif
                     if (maskedType != baseMask) {
-                        Flags.setLaneAllowedVehicleTypes(laneVehicleTypes.laneId, maskedType);
+                        Flags.SetLaneAllowedVehicleTypes(laneVehicleTypes.laneId, maskedType);
                     } else {
 #if DEBUGLOAD
                         Log._Debug($"Masked type does not differ from base type. Ignoring.");

TLM/TLM/State/Flags.cs

@@ -1,4 +1,4 @@
-// #define DEBUGFLAGS
+// #define DEBUGFLAGS
 
 namespace TrafficManager.State {
     using ColossalFramework;
@@ -10,6 +10,7 @@ namespace TrafficManager.State {
     using TrafficManager.API.Traffic.Enums;
     using TrafficManager.Manager.Impl;
     using TrafficManager.State.ConfigData;
+    using static TrafficManager.Util.Shortcuts;
 
     [Obsolete]
     public class Flags {
@@ -166,7 +167,7 @@ public static bool MayHaveTrafficLight(ushort nodeId) {
         }
 
         [Obsolete]
-        public static bool setNodeTrafficLight(ushort nodeId, bool flag) {
+        public static bool SetNodeTrafficLight(ushort nodeId, bool flag) {
             if (nodeId <= 0) {
                 return false;
             }
@@ -206,7 +207,7 @@ public static bool setNodeTrafficLight(ushort nodeId, bool flag) {
         [Obsolete]
         [UsedImplicitly]
         // Not used
-        internal static bool isNodeTrafficLight(ushort nodeId) {
+        internal static bool IsNodeTrafficLight(ushort nodeId) {
             if (nodeId <= 0) {
                 return false;
             }
@@ -513,7 +514,7 @@ public static void SetLaneSpeedLimit(uint laneId, float? speedLimit) {
             }
         }
 
-        public static void removeLaneSpeedLimit(uint laneId) {
+        public static void RemoveLaneSpeedLimit(uint laneId) {
             SetLaneSpeedLimit(laneId, null);
         }
 
@@ -614,7 +615,7 @@ public static void SetLaneSpeedLimit(ushort segmentId,
             }
         }
 
-        public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicleTypes) {
+        public static void SetLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicleTypes) {
             if (laneId <= 0) {
                 return;
             }
@@ -642,7 +643,7 @@ public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicl
 
             while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u) {
                 if (curLaneId == laneId) {
-                    setLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, vehicleTypes);
+                    SetLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, vehicleTypes);
                     return;
                 }
 
@@ -651,7 +652,7 @@ public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicl
             }
         }
 
-        public static void setLaneAllowedVehicleTypes(ushort segmentId,
+        public static void SetLaneAllowedVehicleTypes(ushort segmentId,
                                                       uint laneIndex,
                                                       uint laneId,
                                                       ExtVehicleType vehicleTypes)
@@ -696,7 +697,7 @@ public static void setLaneAllowedVehicleTypes(ushort segmentId,
             laneAllowedVehicleTypesArray[segmentId][laneIndex] = vehicleTypes;
         }
 
-        public static void resetSegmentVehicleRestrictions(ushort segmentId) {
+        public static void ResetSegmentVehicleRestrictions(ushort segmentId) {
             if (segmentId <= 0) {
                 return;
             }
@@ -707,7 +708,7 @@ public static void resetSegmentVehicleRestrictions(ushort segmentId) {
             laneAllowedVehicleTypesArray[segmentId] = null;
         }
 
-        public static void resetSegmentArrowFlags(ushort segmentId) {
+        public static void ResetSegmentArrowFlags(ushort segmentId) {
             if (segmentId <= 0) {
                 return;
             }
@@ -732,7 +733,24 @@ public static void resetSegmentArrowFlags(ushort segmentId) {
             }
         }
 
-        public static bool setLaneArrowFlags(uint laneId,
+        /// <summary>
+        /// removes the custom lane arrow flags. requires post recalculation.
+        /// </summary>
+        /// <param name="laneId"></param>
+        /// <returns><c>true</c>on success, <c>false</c> otherwise</returns>
+        public static bool ResetLaneArrowFlags(uint laneId) {
+#if DEBUGFLAGS
+            Log._Debug($"Flags.resetLaneArrowFlags: Resetting lane arrows of lane {laneId}.");
+#endif
+            if (LaneConnectionManager.Instance.HasConnections(laneId)) {
+                return false;
+            }
+
+            laneArrowFlags[laneId] = null;
+            return true;
+        }
+
+        public static bool SetLaneArrowFlags(uint laneId,
                                              LaneArrows flags,
                                              bool overrideHighwayArrows = false) {
 #if DEBUGFLAGS
@@ -1079,7 +1097,7 @@ public static void RemoveLaneArrowFlags(uint laneId) {
             }
         }
 
-        internal static void removeHighwayLaneArrowFlagsAtSegment(ushort segmentId) {
+        internal static void RemoveHighwayLaneArrowFlagsAtSegment(ushort segmentId) {
             NetSegment[] segmentsBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;
 
             if ((segmentsBuffer[segmentId].m_flags &