Use IJunctionRestrictionsHook instead of patching

NodeControllerRenewal/Manager/Extensions/SerializableDataExtension.cs

@@ -31,7 +31,7 @@ public override void OnLoadData()
                 SingletonMod<Mod>.Logger.Debug($"Import NC2 data");
 
                 WasImported = true;
-                var state = Backward�ompatibility.Loader.Load<Backward�ompatibility.NCState>(data);
+                var state = BackwardCompatibility.Loader.Load<BackwardCompatibility.NCState>(data);
                 var config = state.ToXml();
                 SetLoadData(config);
             }

NodeControllerRenewal/Manager/SegmentEndData.cs

@@ -765,7 +765,7 @@ public void Render(OverlayData contourData, OverlayData outterData, OverlayData
         {
             var data = SingletonManager<Manager>.Instance[NodeId];
 
-            Render�ontour(contourData);
+            RenderContour(contourData);
             if (data.IsMoveableEnds && IsChangeable)
             {
                 RenderEnd(contourData, LengthXZ(LeftSide.Position - Position) + CircleRadius, 0f);
@@ -788,7 +788,7 @@ public void Render(OverlayData contourData, OverlayData outterData, OverlayData
         }
         public void RenderAlign(OverlayData contourData, OverlayData? leftData = null, OverlayData? rightData = null)
         {
-            Render�ontour(contourData);
+            RenderContour(contourData);
             RenderEnd(contourData);
 
             if (leftData != null)
@@ -813,7 +813,7 @@ public void RenderEnd(OverlayData data, float? leftCut = null, float? rightCut =
             line = line.Cut(startT, 1 - endT);
             line.Render(data);
         }
-        public void Render�ontour(OverlayData data)
+        public void RenderContour(OverlayData data)
         {
             RenderSide(LeftSide, data);
             RenderSide(RightSide, data);

NodeControllerRenewal/Mod.cs

@@ -335,13 +335,12 @@ private void PatchHideCrosswalk(ref bool success)
 
         private void PatchTMPE(ref bool success)
         {
+            var jrHook = TrafficManager.API.Implementations.HookFactory.JunctionRestrictionsHook;
+
+            jrHook.GetConfigurableHook += ExternalModPatches.GetConfigurableHook;
+            jrHook.GetDefaultsHook += ExternalModPatches.GetDefaultsHook;
+
             success &= Patch_TrafficLightManager_CanToggleTrafficLight();
-            success &= Patch_JunctionRestrictionsManager_GetDefaultEnteringBlockedJunctionAllowed();
-            success &= Patch_JunctionRestrictionsManager_GetDefaultPedestrianCrossingAllowed();
-            success &= Patch_JunctionRestrictionsManager_GetDefaultUturnAllowed();
-            success &= Patch_JunctionRestrictionsManager_IsEnteringBlockedJunctionAllowedConfigurable();
-            success &= Patch_JunctionRestrictionsManager_IsPedestrianCrossingAllowedConfigurable();
-            success &= Patch_JunctionRestrictionsManager_IsUturnAllowedConfigurable();
 
             if ((Type.GetType("TrafficManager.TrafficManagerMod") ?? Type.GetType("TrafficManager.Lifecycle.TrafficManagerMod")) is Type tmpeMod)
             {
@@ -360,30 +359,6 @@ private bool Patch_TrafficLightManager_CanToggleTrafficLight()
         {
             return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.CanToggleTrafficLightPrefix), typeof(TrafficLightManager), nameof(TrafficLightManager.CanToggleTrafficLight));
         }
-        private bool Patch_JunctionRestrictionsManager_GetDefaultEnteringBlockedJunctionAllowed()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.GetDefaultEnteringBlockedJunctionAllowedPrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.GetDefaultEnteringBlockedJunctionAllowed));
-        }
-        private bool Patch_JunctionRestrictionsManager_GetDefaultPedestrianCrossingAllowed()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.GetDefaultPedestrianCrossingAllowedPrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.GetDefaultPedestrianCrossingAllowed));
-        }
-        private bool Patch_JunctionRestrictionsManager_GetDefaultUturnAllowed()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.GetDefaultUturnAllowedPrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.GetDefaultUturnAllowed));
-        }
-        private bool Patch_JunctionRestrictionsManager_IsEnteringBlockedJunctionAllowedConfigurable()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.IsEnteringBlockedJunctionAllowedConfigurablePrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.IsEnteringBlockedJunctionAllowedConfigurable));
-        }
-        private bool Patch_JunctionRestrictionsManager_IsPedestrianCrossingAllowedConfigurable()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.IsPedestrianCrossingAllowedConfigurablePrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.IsPedestrianCrossingAllowedConfigurable));
-        }
-        private bool Patch_JunctionRestrictionsManager_IsUturnAllowedConfigurable()
-        {
-            return AddPrefix(typeof(ExternalModPatches), nameof(ExternalModPatches.IsUturnAllowedConfigurablePrefix), typeof(JunctionRestrictionsManager), nameof(JunctionRestrictionsManager.IsUturnAllowedConfigurable));
-        }
 
         #endregion
 

NodeControllerRenewal/NodeControllerRenewal.csproj

@@ -131,7 +131,7 @@
     <Compile Include="Manager\MainRoad.cs" />
     <Compile Include="UI\OptionPanel.cs" />
     <Compile Include="UI\SimpleMessageBox.cs" />
-    <Compile Include="Utilities\BackwardСompatibility.cs" />
+    <Compile Include="Utilities\BackwardCompatibility.cs" />
     <Compile Include="Manager\Extensions\LoadingExtension.cs" />
     <Compile Include="Manager\NodeType.cs" />
     <Compile Include="Manager\SegmentSide.cs" />
@@ -254,7 +254,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_BuildVersioningStyle="None.None.None.Increment" BuildVersion_BuildAction="Both" BuildVersion_StartDate="2000/1/1" BuildVersion_ConfigurationName="Beta Debug" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_UpdateFileVersion="True" />
+      <UserProperties BuildVersion_UpdateFileVersion="True" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_ConfigurationName="Beta Debug" BuildVersion_StartDate="2000/1/1" BuildVersion_BuildAction="Both" BuildVersion_BuildVersioningStyle="None.None.None.Increment" />
     </VisualStudio>
   </ProjectExtensions>
   <PropertyGroup Condition="'$(Configuration)' == 'Stable Release' OR '$(Configuration)' == 'Stable Debug'">

NodeControllerRenewal/Patches/ExternalModPatches.cs

@@ -1,12 +1,52 @@
 using ColossalFramework;
 using ModsCommon;
 using ModsCommon.Utilities;
+using System;
 using TrafficManager.API.Traffic.Enums;
+using static TrafficManager.API.Hook.IJunctionRestrictionsHook;
 
 namespace NodeController.Patches
 {
     public static class ExternalModPatches
     {
+        public static void UpdateFlag(FlagsHookArgs args, JunctionRestrictionsFlags flag, Func<bool?> func)
+        {
+            if (args.Mask.IsFlagSet(flag))
+            {
+                var value = func();
+                if (value.HasValue)
+                    args.Result = args.Result.SetFlags(flag, value.Value);
+            }
+        }
+
+        public static void GetConfigurableHook(FlagsHookArgs args)
+        {
+            ushort nodeID = args.StartNode ? args.SegmentId.GetSegment().m_startNode : args.SegmentId.GetSegment().m_endNode;
+            var node = SingletonManager<Manager>.Instance[nodeID];
+
+            if (node == null)
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowEnterWhenBlocked, () => IsEnteringBlockedJunctionAllowedConfigurable(args.SegmentId, nodeID));
+            else
+            {
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowUTurn, () => IsUturnAllowedConfigurable(node));
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowPedestrianCrossing, () => IsPedestrianCrossingAllowedConfigurable(node));
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowEnterWhenBlocked, () => IsEnteringBlockedJunctionAllowedConfigurable(node));
+            }
+        }
+
+        public static void GetDefaultsHook(FlagsHookArgs args)
+        {
+            ushort nodeID = args.StartNode ? args.SegmentId.GetSegment().m_startNode : args.SegmentId.GetSegment().m_endNode;
+            var node = SingletonManager<Manager>.Instance[nodeID];
+
+            if (node != null)
+            {
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowUTurn, () => IsDefaultUturnAllowed(node));
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowPedestrianCrossing, () => IsDefaultPedestrianCrossingAllowed(node));
+                UpdateFlag(args, JunctionRestrictionsFlags.AllowEnterWhenBlocked, () => IsDefaultEnteringBlockedJunctionAllowed(node));
+            }
+        }
+
         private static bool? IsUturnAllowedConfigurable(NodeData node) => node?.Type switch
         {
             NodeStyleType.Crossing or NodeStyleType.Stretch or NodeStyleType.Middle or NodeStyleType.Bend => false,// always off
@@ -64,52 +104,14 @@ public static bool CanToggleTrafficLightPrefix(ref bool __result, ushort nodeId,
             var nodeData = SingletonManager<Manager>.Instance[nodeId];
             return HandleNullBool(CanHaveTrafficLights(nodeData, out reason), ref __result);
         }
-        public static bool GetDefaultEnteringBlockedJunctionAllowedPrefix(ushort segmentId, bool startNode, ref bool __result)
-        {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            var data = SingletonManager<Manager>.Instance[nodeID];
-            return HandleNullBool(IsDefaultEnteringBlockedJunctionAllowed(data), ref __result);
-        }
-        public static bool GetDefaultPedestrianCrossingAllowedPrefix(ushort segmentId, bool startNode, ref bool __result)
-        {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            NodeData data = SingletonManager<Manager>.Instance[nodeID];
-            return HandleNullBool(IsDefaultPedestrianCrossingAllowed(data), ref __result);
-        }
-        public static bool GetDefaultUturnAllowedPrefix(ushort segmentId, bool startNode, ref bool __result)
-        {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            var data = SingletonManager<Manager>.Instance[nodeID];
-            return HandleNullBool(IsDefaultUturnAllowed(data), ref __result);
-        }
-        public static bool IsEnteringBlockedJunctionAllowedConfigurablePrefix(ushort segmentId, bool startNode, ref bool __result)
-        {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            var data = SingletonManager<Manager>.Instance[nodeID];
-            if (data == null)
-            {
-                var flags = nodeID.GetNode().m_flags;
-                bool oneway = flags.IsFlagSet(NetNode.Flags.OneWayIn) & flags.IsFlagSet(NetNode.Flags.OneWayOut);
-                if (oneway & !segmentId.GetSegment().Info.m_hasPedestrianLanes)
-                {
-                    __result = false;
-                    return false;
-                }
-            }
 
-            return HandleNullBool(IsEnteringBlockedJunctionAllowedConfigurable(data), ref __result);
-        }
-        public static bool IsPedestrianCrossingAllowedConfigurablePrefix(ushort segmentId, bool startNode, ref bool __result)
-        {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            var data = SingletonManager<Manager>.Instance[nodeID];
-            return HandleNullBool(IsPedestrianCrossingAllowedConfigurable(data), ref __result);
-        }
-        public static bool IsUturnAllowedConfigurablePrefix(ushort segmentId, bool startNode, ref bool __result)
+        private static bool? IsEnteringBlockedJunctionAllowedConfigurable(ushort segmentId, ushort nodeID)
         {
-            ushort nodeID = startNode ? segmentId.GetSegment().m_startNode : segmentId.GetSegment().m_endNode;
-            var data = SingletonManager<Manager>.Instance[nodeID];
-            return HandleNullBool(IsUturnAllowedConfigurable(data), ref __result);
+            var flags = nodeID.GetNode().m_flags;
+            bool oneway = flags.IsFlagSet(NetNode.Flags.OneWayIn) & flags.IsFlagSet(NetNode.Flags.OneWayOut);
+            return oneway && !segmentId.GetSegment().Info.m_hasPedestrianLanes
+                ? true
+                : null;
         }
 
         public static bool ShouldHideCrossingPrefix(ushort nodeID, ushort segmentID, ref bool __result)

NodeControllerRenewal/ToolModes/AlignSegmentEnds.cs

@@ -167,7 +167,7 @@ public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
             foreach (var segmentData in Tool.Data.SegmentEndDatas)
             {
                 var defaultColor = new OverlayData(cameraInfo) { Color = segmentData.OverlayColor, RenderLimit = underground };
-                segmentData.RenderСontour(defaultColor);
+                segmentData.RenderContour(defaultColor);
                 segmentData.RenderEnd(defaultColor);
             }
 

NodeControllerRenewal/ToolModes/DragCorner.cs

@@ -50,7 +50,7 @@ public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
             var forbidden = new OverlayData(cameraInfo) { Color = Colors.Red, RenderLimit = underground };
 
             SegmentEnd[Corner].Render(allow, forbidden, allow);
-            SegmentEnd.RenderСontour(new OverlayData(cameraInfo) { Color = SegmentEnd.OverlayColor, RenderLimit = underground });
+            SegmentEnd.RenderContour(new OverlayData(cameraInfo) { Color = SegmentEnd.OverlayColor, RenderLimit = underground });
             SegmentEnd.RenderEnd(new OverlayData(cameraInfo) { Color = SegmentEnd.OverlayColor, RenderLimit = underground });
             SegmentEnd[Corner].RenderCircle(new OverlayData(cameraInfo) { Color = Colors.Yellow, RenderLimit = underground });
         }

NodeControllerRenewal/Utilities/BackwardСompatibility.cs → NodeControllerRenewal/Utilities/BackwardCompatibility.cs

@@ -10,7 +10,7 @@
 using System.Xml.Linq;
 using UnityEngine;
 
-namespace NodeController.BackwardСompatibility
+namespace NodeController.BackwardCompatibility
 {
     public static class Loader
     {