Basic support for Airports DLC

TLM/SharedAssemblyInfo.cs

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

TLM/TLM/Custom/BuildingSearch/AirplaneStandSearch.cs

@@ -0,0 +1,143 @@
+namespace TrafficManager.Custom.BuildingSearch {
+    using System.Collections.Generic;
+    using CSUtil.Commons;
+    using TrafficManager.API.Traffic.Data;
+    using TrafficManager.Manager.Impl;
+    using TrafficManager.Util.Extensions;
+
+    internal class AirplaneStandSearch {
+        private static Queue<ushort> _queue = new Queue<ushort>();
+
+        private static ThreadProfiler profiler = new ThreadProfiler();
+
+        /// <summary>
+        /// Tries to find better Airplane Stand for Cargo plane traversing segments forward
+        /// starting from vehicle current position
+        /// </summary>
+        /// <param name="extVehicle">ExtVehicle value</param>
+        /// <param name="vehicle">Vanilla vehicle value</param>
+        /// <returns>Building ID of better airplane stand otherwise 0(zero)</returns>
+        internal static ushort FindBetterCargoPlaneStand(ref ExtVehicle extVehicle, ref Vehicle vehicle) {
+            if (vehicle.Info.m_vehicleAI is not CargoPlaneAI) {
+                //passenger planes supported yet
+                return 0;
+            }
+#if DEBUG
+            profiler.BeginStep();
+#endif
+            PathManager.instance.m_pathUnits.m_buffer[vehicle.m_path].GetPosition(
+                vehicle.m_pathPositionIndex >> 1,
+                out PathUnit.Position currentPosition);
+            PathManager.instance.m_pathUnits.m_buffer[vehicle.m_path].GetNextPosition(
+                vehicle.m_pathPositionIndex >> 1,
+                out PathUnit.Position nextPosition);
+
+            ushort nextNodeId = currentPosition.m_segment.ToSegment()
+                                               .GetSharedNode(nextPosition.m_segment);
+            _queue.Clear();
+            _queue.Enqueue(nextNodeId);
+            ushort buildingID = 0;
+            int counter = 0;
+            while (_queue.Count > 0 && buildingID == 0) {
+                ushort currentNodeId = _queue.Dequeue();
+
+                ref NetNode node = ref currentNodeId.ToNode();
+                for (int i = 0; i < 8; i++) {
+                    ushort segmentId = node.GetSegment(i);
+                    if (segmentId == 0 || segmentId == currentPosition.m_segment) {
+                        continue;
+                    }
+
+                    ref NetSegment nextSegment = ref segmentId.ToSegment();
+
+                    if (VehicleRestrictionsManager.Instance.IsRunwayNetInfo(nextSegment.Info)) {
+                        continue;
+                    }
+
+                    bool isNextStartNodeOfNextSegment = nextSegment.m_startNode == currentNodeId;
+                    bool nextSegIsInverted = (nextSegment.m_flags & NetSegment.Flags.Invert) !=
+                                             NetSegment.Flags.None;
+                    NetInfo.Direction nextDir = isNextStartNodeOfNextSegment
+                                                    ? NetInfo.Direction.Forward
+                                                    : NetInfo.Direction.Backward;
+                    NetInfo.Direction forwardDirection = !nextSegIsInverted
+                                                             ? nextDir
+                                                             : NetInfo.InvertDirection(nextDir);
+
+                    // check direction (assuming we work with one-way segments for now)
+                    if ((forwardDirection & NetInfo.Direction.Forward) == 0) {
+                        continue;
+                    }
+
+                    // check segment traffic data to skip congested segments,
+                    // increases threshold when checking further segments - mean speed may increase over time, if not..vehicle will at least move closer :)
+                    if (segmentId != currentPosition.m_segment) {
+                        int dirIndex = TrafficMeasurementManager.Instance.GetDirIndex(
+                            segmentId: segmentId,
+                            dir: NetInfo.Direction.Forward);
+                        SegmentDirTrafficData segmentDirTrafficData =
+                            TrafficMeasurementManager.Instance.SegmentDirTrafficData[dirIndex];
+                        int min = 25 - (counter / 4 * 2);
+                        if (segmentDirTrafficData.meanSpeed / 100 < min) {
+                            continue;
+                        }
+                    }
+
+                    // check if current segment is "End" - airplane stand stop segment contains flag End and one of its nodes also
+                    if ((nextSegment.m_flags & NetSegment.Flags.End) != 0) {
+                        ushort ownerBuildingId = NetSegment.FindOwnerBuilding(segmentId, 32f);
+                        if (ownerBuildingId != 0) {
+                            ref Building building = ref ownerBuildingId.ToBuilding();
+                            // is active and correct vehicle level
+                            if ((building.m_flags & Building.Flags.Active) != 0 &&
+                                building.Info.m_class.m_level == vehicle.Info.m_class.m_level) {
+
+                                if (vehicle.Info.m_vehicleAI.CanSpawnAt(building.m_position)) {
+                                    buildingID = ownerBuildingId;
+                                }
+                            }
+                        }
+                    }
+
+                    // check lane vehicle restrictions
+                    bool allowedDirectionAndVehicleType = false;
+                    uint nextLaneIndex = 0;
+                    NetInfo nextSegmentInfo = nextSegment.Info;
+                    while (nextLaneIndex < nextSegmentInfo.m_lanes.Length) {
+                        NetInfo.Lane nextLaneInfo = nextSegmentInfo.m_lanes[nextLaneIndex];
+
+                        nextLaneIndex++;
+                        if ((nextLaneInfo.m_vehicleType & VehicleInfo.VehicleType.Plane) == 0) {
+                            continue;
+                        }
+
+                        if ((nextLaneInfo.m_finalDirection & forwardDirection) != NetInfo.Direction.None &&
+                            VehicleRestrictionsManager.Instance.MayUseLane(
+                                extVehicle.vehicleType,
+                                segmentId,
+                                (byte)nextLaneIndex,
+                                nextSegmentInfo)) {
+                            allowedDirectionAndVehicleType = true;
+                            break;
+                        }
+                    }
+
+                    if (!allowedDirectionAndVehicleType) {
+                        continue;
+                    }
+
+                    _queue.Enqueue(nextSegment.GetOtherNode(currentNodeId));
+                }
+
+                if (counter++ == 40 /* TODO Configurable node count? */) {
+                    break;
+                }
+            }
+#if DEBUG
+            profiler.EndStep();
+            Log.Info($"[Benchmark(FindBetterCargoPlaneStand)] Time: {(profiler.m_lastStepDuration / 1000f):F2}ms, counter: {counter} b: {buildingID}");
+#endif
+            return buildingID;
+        }
+    }
+}

TLM/TLM/Custom/PathFinding/CustomPathFind.cs

@@ -3998,7 +3998,7 @@ private bool CanUseLane(ushort segmentId,
                 queueItem_.vehicleType == ExtVehicleType.Tram ||
                 queueItem_.vehicleType == ExtVehicleType.Trolleybus ||
                 (laneInfo.m_vehicleType &
-                 (VehicleInfo.VehicleType.Car | VehicleInfo.VehicleType.Train)) ==
+                 (VehicleInfo.VehicleType.Car | VehicleInfo.VehicleType.Train | VehicleInfo.VehicleType.Plane)) ==
                 VehicleInfo.VehicleType.None) {
                 return true;
             }
@@ -4015,7 +4015,21 @@ private bool CanUseLane(ushort segmentId,
                 laneInfo,
                 VehicleRestrictionsMode.Configured);
 
-            return (allowedTypes & queueItem_.vehicleType) != ExtVehicleType.None;
+            bool allowed = (allowedTypes & queueItem_.vehicleType) != ExtVehicleType.None;
+
+            if (allowed && queueItem_.vehicleType == ExtVehicleType.PassengerPlane && queueItem_.vehicleId != 0) {
+                ref ExtVehicle veh = ref ExtVehicleManager.Instance.ExtVehicles[queueItem_.vehicleId];
+                if (veh.passengerPlaneSize.HasValue) {
+                    // allowed size is at least as big as the vehicle size
+                    allowed &= vehicleRestrictionsManager.GetAllowedVehicleSizes(
+                                   segmentId,
+                                   segmentInfo,
+                                   (uint)laneIndex,
+                                   laneInfo).IsFlagSet(veh.passengerPlaneSize.Value);
+                }
+            }
+
+            return allowed;
         }
 #endif
 

TLM/TLM/Manager/Impl/ExtPathManager.cs

@@ -1,7 +1,8 @@
 namespace TrafficManager.Manager.Impl {
     using ColossalFramework;
     using System;
-    using System.Linq;
+    using API.Traffic.Data;
+    using ColossalFramework.Math;
     using State;
     using TrafficManager.API.Manager;
     using TrafficManager.Util;
@@ -448,8 +449,156 @@ bool FindHelper(int i, int j) {
             return pathPosA.m_segment != 0;
         }
 
-        // protected override void InternalPrintDebugInfo() {
-        //     base.InternalPrintDebugInfo();
-        // }
+        /// <summary>
+        /// Try recalculating paths of transported cargo trucks
+        /// </summary>
+        /// <param name="vehicleId">Cargo plane id</param>
+        /// <param name="vehicle">Cargo plane vehicle data</param>
+        /// <param name="extVehicle">Cargo plane ExtVehicle data</param>
+        internal static void RecalculateCargoPlaneCargoTruckPaths(ushort vehicleId, ref Vehicle vehicle, ref ExtVehicle extVehicle) {
+
+            extVehicle.requiresCargoPathRecalculation = false; // reset flag
+
+            VehicleManager instance = VehicleManager.instance;
+            ref Building airplaneStand = ref vehicle.m_targetBuilding.ToBuilding();
+            int firstCargoVehicleId = vehicle.m_firstCargo;
+            int counter = 0;
+            uint maxVehicles = instance.m_vehicles.m_size;
+            while (firstCargoVehicleId != 0)
+            {
+                ref Vehicle v = ref instance.m_vehicles.m_buffer[firstCargoVehicleId];
+                ushort nextCargo = v.m_nextCargo;
+                VehicleInfo info = v.Info;
+                if (v.m_path != 0) {
+                    if (vehicle.m_targetBuilding != 0 && v.m_targetBuilding != 0 && vehicle.m_targetBuilding != v.m_targetBuilding) {
+                            //source building
+                            Randomizer randomizer = new Randomizer(firstCargoVehicleId);
+                            airplaneStand.Info.m_buildingAI.CalculateSpawnPosition(
+                                vehicle.m_targetBuilding,
+                                ref airplaneStand,
+                                ref randomizer,
+                                info,
+                                out Vector3 _,
+                                out Vector3 dir);
+                            //target building
+                            ref Building targetBuilding = ref v.m_targetBuilding.ToBuilding();
+                            BuildingInfo buildingInfo = targetBuilding.Info;
+                            Randomizer randomizer2 = new Randomizer(firstCargoVehicleId);
+                            buildingInfo.m_buildingAI.CalculateUnspawnPosition(
+                                (ushort)firstCargoVehicleId,
+                                ref targetBuilding,
+                                ref randomizer2,
+                                info,
+                                out Vector3 _,
+                                out Vector3 dir2);
+
+                            if (FindPathTransportedCargoTruck(dir, dir2, (ushort)firstCargoVehicleId, ref v)) {
+                                // Log.Info($"FindPathTransportedCargoTruck success, pos: {pos}, dir: {dir}, target: {dir2} first: {firstCargoVehicleId}");
+                            } else {
+                                // Log.Info($"FindPathTransportedCargoTruck failure, pos: {pos}, dir: {dir}, target: {dir2} first: {firstCargoVehicleId}");
+                            }
+                    } else {
+                        // Log.Info($"Skipped recalculation {firstCargoVehicleId}: veh_target: {vehicle.m_targetBuilding}, v_target: {v.m_targetBuilding}");
+                    }
+                } else {
+                    // Log.Info($"Attached Cargo Vehicle: {firstCargoVehicleId} to :{vehicleId} had no path...");
+                }
+
+                firstCargoVehicleId = nextCargo;
+                if (++counter > maxVehicles) {
+                    CODebugBase<LogChannel>.Error(
+                        LogChannel.Core,
+                        $"Invalid list detected! nextCargo: {nextCargo} vehicleId: {vehicleId} vehicleInfo: {vehicle.Info.name} \n" + Environment.StackTrace);
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Slightly modified StartPathFind of CargoTruck
+        /// </summary>
+        /// <param name="startPos">start position</param>
+        /// <param name="endPos">end position</param>
+        /// <param name="vehicleID">vehicle id</param>
+        /// <param name="vehicleData">vehicle data</param>
+        /// <returns>success or fail of swap part of path transported cargo truck</returns>
+        private static bool FindPathTransportedCargoTruck(Vector3 startPos,
+                                          Vector3 endPos,
+                                          ushort vehicleID,
+                                          ref Vehicle vehicleData) {
+            VehicleInfo info = vehicleData.Info;
+            bool allowUnderground = (vehicleData.m_flags & (Vehicle.Flags.Underground | Vehicle.Flags.Transition)) != 0;
+            if (PathManager.FindPathPosition(
+                    startPos,
+                    ItemClass.Service.Road,
+                    NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle,
+                    info.m_vehicleType,
+                    allowUnderground,
+                    requireConnect: false,
+                    32f,
+                    out PathUnit.Position pathPosA,
+                    out PathUnit.Position pathPosB,
+                    out float distanceSqrA,
+                    out float _) &&
+                PathManager.FindPathPosition(
+                    endPos,
+                    ItemClass.Service.Road,
+                    NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle,
+                    info.m_vehicleType,
+                    false,
+                    requireConnect: false,
+                    32f,
+                    out PathUnit.Position pathPosA2,
+                    out PathUnit.Position pathPosB2,
+                    out float distanceSqrA2,
+                    out float _)) {
+
+                if (distanceSqrA < 10f) {
+                    pathPosB = default(PathUnit.Position);
+                }
+
+                if (distanceSqrA2 < 10f) {
+                    pathPosB2 = default(PathUnit.Position);
+                }
+
+                if (Singleton<PathManager>.instance.CreatePath(
+                    out uint unit,
+                    ref Singleton<SimulationManager>.instance.m_randomizer,
+                    Singleton<SimulationManager>.instance.m_currentBuildIndex,
+                    pathPosA,
+                    pathPosB,
+                    pathPosA2,
+                    pathPosB2,
+                    default(PathUnit.Position),
+                    NetInfo.LaneType.Vehicle,
+                    info.m_vehicleType,
+                    20000f,
+                    ((CargoTruckAI)info.m_vehicleAI).m_isHeavyVehicle,
+                    false,
+                    stablePath: false,
+                    skipQueue: false,
+                    randomParking: false,
+                    ignoreFlooded: false,
+                    true)) {
+
+                    // get original path unit and "patch it" to jump to new part of the path
+                    ref PathUnit originalPathUnit = ref PathManager.instance.m_pathUnits.m_buffer[vehicleData.m_path];
+                    int firstIndex = vehicleData.m_pathPositionIndex >> 1;
+                    uint nextOriginalPathUnit = originalPathUnit.m_nextPathUnit;
+                    if (nextOriginalPathUnit != 0) {
+                        // release no longer used, original part of the path (releases all units to the end)
+                        PathManager.instance.ReleasePath(nextOriginalPathUnit);
+                    }
+
+                    originalPathUnit.m_nextPathUnit = unit;
+                    originalPathUnit.m_positionCount = (byte)(firstIndex + 1);
+                    return true;
+                }
+                // Log.Info($"Vehicle: {vehicleID} - CreatePath failed -> pA: {pathPosA} pB: {pathPosB} pA2: {pathPosA2} pB2: {pathPosB2}");
+            }
+
+            // Log.Info($"Vehicle: {vehicleID} - FindPathPosition failed -> pA: {pathPosA} pB: {pathPosB} ");
+            return false;
+        }
     }
 }