Merge pull request #638 from kianzarrin/623-reset-lane-arrows

kianzarrin · web-flow · commit 0131e7f9096d · 2020-02-10T03:15:51.000+02:00
Added interface to reset lane arrows back to default. Ignores lanes with outgoing lane connections.

I remove lane flags, call NetAI to recalculate lanes and finally push lane changes.

UI to delete lane arrows : select lane arrow tool -&gt; select segment end -&gt; press Reset all button [hot key is del].
diff --git a/TLM/TLM/Manager/Impl/LaneArrowManager.cs b/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) { }
diff --git a/TLM/TLM/Manager/Impl/LaneConnectionManager.cs b/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>
diff --git a/TLM/TLM/Manager/Impl/RoutingManager.cs b/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);
         }
 
diff --git a/TLM/TLM/Manager/Impl/SpeedLimitManager.cs b/TLM/TLM/Manager/Impl/SpeedLimitManager.cs
@@ -395,7 +395,7 @@ public void ClearCurrentSpeedLimits(NetInfo info) {
                     continue;
                 }
 
-                Flags.removeLaneSpeedLimit(laneId);
+                Flags.RemoveLaneSpeedLimit(laneId);
             }
         }
 
diff --git a/TLM/TLM/Manager/Impl/TrafficLightManager.cs b/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());
diff --git a/TLM/TLM/Manager/Impl/VehicleRestrictionsManager.cs b/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.");
diff --git a/TLM/TLM/State/Flags.cs b/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 &
diff --git a/TLM/TLM/UI/SubTools/LaneArrowTool.cs b/TLM/TLM/UI/SubTools/LaneArrowTool.cs
diff --git a/TLM/TLM/Util/Shortcuts.cs b/TLM/TLM/Util/Shortcuts.cs

Original file line number	Diff line number	Diff line change
`@@ -2166,7 +2166,7 @@ protected override void HandleInvalidSegment(ref ExtSegment seg) {`
`2166`	`2166`	`Log._Debug($"RoutingManager.HandleInvalidSegment({seg.segmentId}) called.");`
`2167`	`2167`	`}`
`2168`	`2168`
`2169`		`- Flags.removeHighwayLaneArrowFlagsAtSegment(seg.segmentId);`
	`2169`	`+ Flags.RemoveHighwayLaneArrowFlagsAtSegment(seg.segmentId);`
`2170`	`2170`	`ResetRoutingData(seg.segmentId);`
`2171`	`2171`	`}`
`2172`	`2172`
Original file line number	Diff line number	Diff line change
`@@ -395,7 +395,7 @@ public void ClearCurrentSpeedLimits(NetInfo info) {`
`395`	`395`	`continue;`
`396`	`396`	`}`
`397`	`397`
`398`		`- Flags.removeLaneSpeedLimit(laneId);`
	`398`	`+ Flags.RemoveLaneSpeedLimit(laneId);`
`399`	`399`	`}`
`400`	`400`	`}`
`401`	`401`
Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ public bool LoadData(string data) {`
`257`	`257`	`continue;`
`258`	`258`	`}`
`259`	`259`
`260`		`- Flags.setNodeTrafficLight(nodeId, flag > 0);`
	`260`	`+ Flags.SetNodeTrafficLight(nodeId, flag > 0);`
`261`	`261`	`} catch (Exception e) {`
`262`	`262`	`// ignore as it's probably bad save data.`
`263`	`263`	`Log.Error($"Error setting the NodeTrafficLights: " + e.ToString());`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// #define DEBUGFLAGS`
	`1`	`+// #define DEBUGFLAGS`
`2`	`2`
`3`	`3`	`namespace TrafficManager.State {`
`4`	`4`	`using ColossalFramework;`
`@@ -10,6 +10,7 @@ namespace TrafficManager.State {`
`10`	`10`	`using TrafficManager.API.Traffic.Enums;`
`11`	`11`	`using TrafficManager.Manager.Impl;`
`12`	`12`	`using TrafficManager.State.ConfigData;`
	`13`	`+ using static TrafficManager.Util.Shortcuts;`
`13`	`14`
`14`	`15`	`[Obsolete]`
`15`	`16`	`public class Flags {`
`@@ -166,7 +167,7 @@ public static bool MayHaveTrafficLight(ushort nodeId) {`
`166`	`167`	`}`
`167`	`168`
`168`	`169`	`[Obsolete]`
`169`		`- public static bool setNodeTrafficLight(ushort nodeId, bool flag) {`
	`170`	`+ public static bool SetNodeTrafficLight(ushort nodeId, bool flag) {`
`170`	`171`	`if (nodeId <= 0) {`
`171`	`172`	`return false;`
`172`	`173`	`}`
`@@ -206,7 +207,7 @@ public static bool setNodeTrafficLight(ushort nodeId, bool flag) {`
`206`	`207`	`[Obsolete]`
`207`	`208`	`[UsedImplicitly]`
`208`	`209`	`// Not used`
`209`		`- internal static bool isNodeTrafficLight(ushort nodeId) {`
	`210`	`+ internal static bool IsNodeTrafficLight(ushort nodeId) {`
`210`	`211`	`if (nodeId <= 0) {`
`211`	`212`	`return false;`
`212`	`213`	`}`
`@@ -513,7 +514,7 @@ public static void SetLaneSpeedLimit(uint laneId, float? speedLimit) {`
`513`	`514`	`}`
`514`	`515`	`}`
`515`	`516`
`516`		`- public static void removeLaneSpeedLimit(uint laneId) {`
	`517`	`+ public static void RemoveLaneSpeedLimit(uint laneId) {`
`517`	`518`	`SetLaneSpeedLimit(laneId, null);`
`518`	`519`	`}`
`519`	`520`
`@@ -614,7 +615,7 @@ public static void SetLaneSpeedLimit(ushort segmentId,`
`614`	`615`	`}`
`615`	`616`	`}`
`616`	`617`
`617`		`- public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicleTypes) {`
	`618`	`+ public static void SetLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicleTypes) {`
`618`	`619`	`if (laneId <= 0) {`
`619`	`620`	`return;`
`620`	`621`	`}`
`@@ -642,7 +643,7 @@ public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicl`
`642`	`643`
`643`	`644`	`while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u) {`
`644`	`645`	`if (curLaneId == laneId) {`
`645`		`- setLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, vehicleTypes);`
	`646`	`+ SetLaneAllowedVehicleTypes(segmentId, laneIndex, laneId, vehicleTypes);`
`646`	`647`	`return;`
`647`	`648`	`}`
`648`	`649`
`@@ -651,7 +652,7 @@ public static void setLaneAllowedVehicleTypes(uint laneId, ExtVehicleType vehicl`
`651`	`652`	`}`
`652`	`653`	`}`
`653`	`654`
`654`		`- public static void setLaneAllowedVehicleTypes(ushort segmentId,`
	`655`	`+ public static void SetLaneAllowedVehicleTypes(ushort segmentId,`
`655`	`656`	`uint laneIndex,`
`656`	`657`	`uint laneId,`
`657`	`658`	`ExtVehicleType vehicleTypes)`
`@@ -696,7 +697,7 @@ public static void setLaneAllowedVehicleTypes(ushort segmentId,`
`696`	`697`	`laneAllowedVehicleTypesArray[segmentId][laneIndex] = vehicleTypes;`
`697`	`698`	`}`
`698`	`699`
`699`		`- public static void resetSegmentVehicleRestrictions(ushort segmentId) {`
	`700`	`+ public static void ResetSegmentVehicleRestrictions(ushort segmentId) {`
`700`	`701`	`if (segmentId <= 0) {`
`701`	`702`	`return;`
`702`	`703`	`}`
`@@ -707,7 +708,7 @@ public static void resetSegmentVehicleRestrictions(ushort segmentId) {`
`707`	`708`	`laneAllowedVehicleTypesArray[segmentId] = null;`
`708`	`709`	`}`
`709`	`710`
`710`		`- public static void resetSegmentArrowFlags(ushort segmentId) {`
	`711`	`+ public static void ResetSegmentArrowFlags(ushort segmentId) {`
`711`	`712`	`if (segmentId <= 0) {`
`712`	`713`	`return;`
`713`	`714`	`}`
`@@ -732,7 +733,24 @@ public static void resetSegmentArrowFlags(ushort segmentId) {`
`732`	`733`	`}`
`733`	`734`	`}`
`734`	`735`
`735`		`- public static bool setLaneArrowFlags(uint laneId,`
	`736`	`+ /// <summary>`
	`737`	`+ /// removes the custom lane arrow flags. requires post recalculation.`
	`738`	`+ /// </summary>`
	`739`	`+ /// <param name="laneId"></param>`
	`740`	`+ /// <returns><c>true</c>on success, <c>false</c> otherwise</returns>`
	`741`	`+ public static bool ResetLaneArrowFlags(uint laneId) {`
	`742`	`+#if DEBUGFLAGS`
	`743`	`+ Log._Debug($"Flags.resetLaneArrowFlags: Resetting lane arrows of lane {laneId}.");`
	`744`	`+#endif`
	`745`	`+ if (LaneConnectionManager.Instance.HasConnections(laneId)) {`
	`746`	`+ return false;`
	`747`	`+ }`
	`748`	`+`
	`749`	`+ laneArrowFlags[laneId] = null;`
	`750`	`+ return true;`
	`751`	`+ }`
	`752`	`+`
	`753`	`+ public static bool SetLaneArrowFlags(uint laneId,`
`736`	`754`	`LaneArrows flags,`
`737`	`755`	`bool overrideHighwayArrows = false) {`
`738`	`756`	`#if DEBUGFLAGS`
`@@ -1079,7 +1097,7 @@ public static void RemoveLaneArrowFlags(uint laneId) {`
`1079`	`1097`	`}`
`1080`	`1098`	`}`
`1081`	`1099`
`1082`		`- internal static void removeHighwayLaneArrowFlagsAtSegment(ushort segmentId) {`
	`1100`	`+ internal static void RemoveHighwayLaneArrowFlagsAtSegment(ushort segmentId) {`
`1083`	`1101`	`NetSegment[] segmentsBuffer = Singleton<NetManager>.instance.m_segments.m_buffer;`
`1084`	`1102`
`1085`	`1103`	`if ((segmentsBuffer[segmentId].m_flags &`