Merge pull request #1033 from CitiesSkylinesMods/11.5-plus-cherry-picks

Release stable 11.5.1

TLM/SharedAssemblyInfo.cs

@@ -20,4 +20,4 @@
 //      Minor Version
 //      Build Number
 //      Revision
-[assembly: AssemblyVersion("11.5.0.*")]
+[assembly: AssemblyVersion("11.5.1.*")]

TLM/TLM/Manager/Impl/AdvancedParkingManager.cs

@@ -2883,6 +2883,50 @@ bool citizenDebug
                        out parkOffset) != 0;
         }
 
+        public bool VanillaFindParkingSpaceWithoutRestrictions(bool isElectric,
+                                                                ushort homeId,
+                                                                Vector3 refPos,
+                                                                Vector3 searchDir,
+                                                                ushort segment,
+                                                                float width,
+                                                                float length,
+                                                                out Vector3 parkPos,
+                                                                out Quaternion parkRot,
+                                                                out float parkOffset) {
+            if (!CustomPassengerCarAI.FindParkingSpace(isElectric,
+                                                       homeId,
+                                                       refPos,
+                                                       searchDir,
+                                                       segment,
+                                                       width,
+                                                       length,
+                                                       out parkPos,
+                                                       out parkRot,
+                                                       out parkOffset)) {
+                return false;
+            }
+
+            // in vanilla parkOffset is always >= 0 for RoadSideParkingSpace
+            if (Options.parkingRestrictionsEnabled && parkOffset >= 0) {
+                if (Singleton<NetManager>.instance.m_segments.m_buffer[segment].GetClosestLanePosition(
+                        refPos,
+                        NetInfo.LaneType.Parking,
+                        VehicleInfo.VehicleType.Car,
+                        out _,
+                        out _,
+                        out int laneIndex,
+                        out _)) {
+                    NetInfo.Direction direction
+                        = Singleton<NetManager>.instance.m_segments.m_buffer[segment].Info.m_lanes[laneIndex].m_finalDirection;
+                    if (!ParkingRestrictionsManager.Instance.IsParkingAllowed(segment, direction)) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
         public bool GetBuildingInfoViewColor(ushort buildingId,
                                              ref Building buildingData,
                                              ref ExtBuilding extBuilding,

TLM/TLM/Manager/Impl/ExtSegmentEndManager.cs

@@ -12,17 +12,10 @@ public class ExtSegmentEndManager
         : AbstractCustomManager,
           IExtSegmentEndManager
     {
-        public static ExtSegmentEndManager Instance { get; }
-
         static ExtSegmentEndManager() {
             Instance = new ExtSegmentEndManager();
         }
 
-        /// <summary>
-        /// All additional data for segment ends
-        /// </summary>
-        public ExtSegmentEnd[] ExtSegmentEnds { get; }
-
         private ExtSegmentEndManager() {
             ExtSegmentEnds = new ExtSegmentEnd[NetManager.MAX_SEGMENT_COUNT * 2];
             for (uint i = 0; i < NetManager.MAX_SEGMENT_COUNT; ++i) {
@@ -31,6 +24,13 @@ public class ExtSegmentEndManager
             }
         }
 
+        public static ExtSegmentEndManager Instance { get; }
+
+        /// <summary>
+        /// All additional data for segment ends
+        /// </summary>
+        public ExtSegmentEnd[] ExtSegmentEnds { get; }
+
 #if DEBUG
         public string GenerateVehicleChainDebugInfo(ushort segmentId, bool startNode) {
             int index = GetIndex(segmentId, startNode);
@@ -298,23 +298,33 @@ public class ExtSegmentEndManager
         public void CalculateCorners(ushort segmentId, bool startNode) {
             if (!Shortcuts.netService.IsSegmentValid(segmentId))
                 return;
-            ref ExtSegmentEnd segEnd = ref ExtSegmentEnds[GetIndex(segmentId, startNode)];
-            segmentId.ToSegment().CalculateCorner(
-                segmentID: segmentId,
-                heightOffset: true,
-                start: startNode,
-                leftSide: false,
-                cornerPos: out segEnd.RightCorner,
-                cornerDirection: out segEnd.RightCornerDir,
-                smooth: out _);
-            segmentId.ToSegment().CalculateCorner(
-                segmentID: segmentId,
-                heightOffset: true,
-                start: startNode,
-                leftSide: true,
-                cornerPos: out segEnd.LeftCorner,
-                cornerDirection: out segEnd.LeftCornerDir,
-                smooth: out _);
+            if (!segmentId.ToSegment().Info) {
+                Log.Warning($"segment {segmentId} has null info");
+                return;
+            }
+
+            try {
+                ref ExtSegmentEnd segEnd = ref ExtSegmentEnds[GetIndex(segmentId, startNode)];
+                segmentId.ToSegment().CalculateCorner(
+                    segmentID: segmentId,
+                    heightOffset: true,
+                    start: startNode,
+                    leftSide: false,
+                    cornerPos: out segEnd.RightCorner,
+                    cornerDirection: out segEnd.RightCornerDir,
+                    smooth: out _);
+                segmentId.ToSegment().CalculateCorner(
+                    segmentID: segmentId,
+                    heightOffset: true,
+                    start: startNode,
+                    leftSide: true,
+                    cornerPos: out segEnd.LeftCorner,
+                    cornerDirection: out segEnd.LeftCornerDir,
+                    smooth: out _);
+            } catch (Exception e) {
+                Log.Error($"failed calculating corner for segment:{segmentId}, info={segmentId.ToSegment().Info}\n"
+                    + e.Message);
+            }
         }
 
         private void CalculateIncomingOutgoing(ushort segmentId,

TLM/TLM/Manager/Impl/VehicleBehaviorManager.cs

@@ -241,16 +241,16 @@ bool citizenDebug
                 }
 
                 if (!searchedParkingSpace) {
+                    bool isElectric = vehicleInfo.m_class.m_subService != ItemClass.SubService.ResidentialLow;
                     foundParkingSpace =
-                        Constants.ManagerFactory.AdvancedParkingManager.FindParkingSpaceInVicinity(
+                        Constants.ManagerFactory.AdvancedParkingManager.VanillaFindParkingSpaceWithoutRestrictions(
+                            isElectric,
+                            homeID,
                             refPos,
                             searchDir,
-                            vehicleInfo,
-                            homeID,
-                            vehicleID,
-                            GlobalConfig.Instance.ParkingAI.MaxBuildingToPedestrianLaneDistance,
-                            out ExtParkingSpaceLocation parkLoc,
-                            out ushort parkId,
+                            pathPos.m_segment,
+                            vehicleInfo.m_generatedInfo.m_size.x,
+                            vehicleInfo.m_generatedInfo.m_size.z,
                             out parkPos,
                             out parkRot,
                             out parkOffset);

TLM/TLM/State/GlobalConfig.cs

@@ -17,8 +17,8 @@ public class GlobalConfig : GenericObservable<GlobalConfig> {
             get => instance;
             private set {
                 if (value != null && instance != null) {
-                    value.Observers = instance.Observers;
-                    value.ObserverLock = instance.ObserverLock;
+                    value._observers = instance._observers;
+                    value._lock = instance._lock;
                 }
 
                 instance = value;

TLM/TLM/UI/SubTools/JunctionRestrictionsTool.cs

@@ -164,8 +164,12 @@ public JunctionRestrictionsTool(TrafficManagerTool mainTool)
         }
 
         public override void OnSecondaryClickOverlay() {
-            SelectedNodeId = 0;
-            MainTool.RequestOnscreenDisplayUpdate();
+            if (SelectedNodeId != 0) {
+                SelectedNodeId = 0;
+                MainTool.RequestOnscreenDisplayUpdate();
+            } else {
+                MainTool.SetToolMode(ToolMode.None);
+            }
         }
 
         public override void OnActivate() {

TLM/TLM/UI/SubTools/LaneConnectorTool.cs

@@ -553,7 +553,7 @@ public LaneConnectorTool(TrafficManagerTool mainTool)
         /// </summary>
         /// <param name="nodeId"></param>
         /// <param name="mode">determines for which side to connect lanes.</param>
-        /// <returns><c>false</c> if there is only one incomming/outgoing lane, <c>true</c> otherwise</returns>
+        /// <returns><c>true</c> if any lanes were connectde, <c>false</c> otherwise</returns>
         public static bool StayInLane(ushort nodeId, StayInLaneMode mode = StayInLaneMode.None) {
             Log._Debug($"Stay In Lane called node:{nodeId} mode:{mode}");
             LaneConnectionManager.Instance.RemoveLaneConnectionsFromNode(nodeId);
@@ -629,12 +629,12 @@ public LaneConnectorTool(TrafficManagerTool mainTool)
 
             // count relavent source(going toward the junction) lanes and
             // target (going aginst the junction) lanes on each segment.
-            int laneCountMinorSource = minorSegmentId == 0 ? 0 : PriorityRoad.CountLanesTowardJunction(minorSegmentId, nodeId);
-            int laneCountMinorTarget = minorSegmentId == 0 ? 0 : PriorityRoad.CountLanesAgainstJunction(minorSegmentId, nodeId);
-            int laneCountMinor2Source = minorSegment2Id == 0 ? 0 : PriorityRoad.CountLanesTowardJunction(minorSegment2Id, nodeId);
-            int laneCountMinor2Target = minorSegment2Id == 0 ? 0 : PriorityRoad.CountLanesAgainstJunction(minorSegment2Id, nodeId);
-            int laneCountMainSource = PriorityRoad.CountLanesTowardJunction(mainSegmentSourceId, nodeId);
-            int laneCountMainTarget = PriorityRoad.CountLanesAgainstJunction(mainSegmentTargetId, nodeId);
+            int laneCountMinorSource = minorSegmentId == 0 ? 0 : CountLanesTowardJunction(minorSegmentId, nodeId);
+            int laneCountMinorTarget = minorSegmentId == 0 ? 0 : CountLanesAgainstJunction(minorSegmentId, nodeId);
+            int laneCountMinor2Source = minorSegment2Id == 0 ? 0 : CountLanesTowardJunction(minorSegment2Id, nodeId);
+            int laneCountMinor2Target = minorSegment2Id == 0 ? 0 : CountLanesAgainstJunction(minorSegment2Id, nodeId);
+            int laneCountMainSource = CountLanesTowardJunction(mainSegmentSourceId, nodeId);
+            int laneCountMainTarget = CountLanesAgainstJunction(mainSegmentTargetId, nodeId);
             int totalSource = laneCountMinorSource + laneCountMainSource + laneCountMinor2Source;
             int totalTarget = laneCountMinorTarget + laneCountMainTarget + laneCountMinor2Target;
 
@@ -779,6 +779,20 @@ public LaneConnectorTool(TrafficManagerTool mainTool)
             return true;
         }
 
+        private static int CountLanes(ushort segmentId, ushort nodeId, bool toward) {
+            return netService.GetSortedLanes(
+                                segmentId,
+                                ref segmentId.ToSegment(),
+                                netService.IsStartNode(segmentId, nodeId) ^ (!toward),
+                                LaneConnectionManager.LANE_TYPES,
+                                LaneConnectionManager.VEHICLE_TYPES,
+                                true
+                                ).Count;
+        }
+        internal static int CountLanesTowardJunction(ushort segmentId, ushort nodeId) => CountLanes(segmentId, nodeId, true);
+        internal static int CountLanesAgainstJunction(ushort segmentId, ushort nodeId) => CountLanes(segmentId, nodeId, false);
+
+
         public override void OnPrimaryClickOverlay() {
 #if DEBUG
             bool logLaneConn = DebugSwitch.LaneConnections.Get();
@@ -952,6 +966,10 @@ public LaneConnectorTool(TrafficManagerTool mainTool)
                         break;
                     }
             }
+
+            if (GetSelectionMode() == SelectionMode.None) {
+                MainTool.SetToolMode(ToolMode.None);
+            }
         }
 
         public override void OnActivate() {

TLM/TLM/UI/SubTools/ManualTrafficLightsTool.cs

@@ -27,9 +27,13 @@ public ManualTrafficLightsTool(TrafficManagerTool mainTool)
                 return;
             }
 
-            Cleanup();
-            SelectedNodeId = 0;
-            MainTool.RequestOnscreenDisplayUpdate();
+            if (SelectedNodeId != 0) {
+                Cleanup();
+                SelectedNodeId = 0;
+                MainTool.RequestOnscreenDisplayUpdate();
+            } else {
+                MainTool.SetToolMode(ToolMode.None);
+            }
         }
 
         public override void OnPrimaryClickOverlay() {

TLM/TLM/UI/SubTools/ParkingRestrictionsTool.cs

@@ -66,6 +66,10 @@ public ParkingRestrictionsTool(TrafficManagerTool mainTool)
 
         public override void OnPrimaryClickOverlay() { }
 
+        public override void OnSecondaryClickOverlay() {
+            MainTool.SetToolMode(ToolMode.None);
+        }
+
         private void RenderSegmentParkings(RenderManager.CameraInfo cameraInfo) {
             bool allowed = parkingManager.IsParkingAllowed(renderInfo_.SegmentId, renderInfo_.FinalDirection);
             bool pressed = Input.GetMouseButton(0);

TLM/TLM/UI/SubTools/PrioritySigns/PrioritySignsTool.cs

@@ -76,7 +76,7 @@ public PrioritySignsTool(TrafficManagerTool mainTool)
                 if (!isRoundabout) {
                     record_ = PriorityRoad.FixRoad(HoveredSegmentId);
                 }
-                // TODO: benchmark why bulk setup takes a long time. 
+                // TODO: benchmark why bulk setup takes a long time.
                 Log.Info("After FixRoundabout/FixRoad. Before RefreshMassEditOverlay"); // log time for benchmarking.
                 RefreshMassEditOverlay();
                 Log.Info("After RefreshMassEditOverlay."); // log time for benchmarking.
@@ -125,14 +125,18 @@ public PrioritySignsTool(TrafficManagerTool mainTool)
                     massEditMode = PrioritySignsMassEditMode.Min;
                 }
             }
-            
+
             // refresh cache
             if(ControlIsPressed)
                 RefreshMassEditOverlay();
             else
                 RefreshCurrentPriorityNodeIds();
         }
 
+        public override void OnSecondaryClickOverlay() {
+            MainTool.SetToolMode(ToolMode.None);
+        }
+
         public override void OnToolGUI(Event e) { }
 
         /// <summary>