C# Online Compiler | .NET Fiddle

<no name> by Anonymous

// 城市天际线自动避免拥堵路段的代码
// 作者：Bing
// 日期：2023年5月8日
// 说明：这个代码是根据一些网上的资料和建议编写的，可能有不完善或错误的地方，请谨慎使用。
// 优化：这个代码是根据一些编程原则和技巧进行了优化，提高了代码的可读性，可维护性，健壮性和可调试性。

using ColossalFramework;
using ColossalFramework.Math;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TrafficManager.Manager;
using TrafficManager.Traffic;

namespace AvoidCongestion
{
    public class AvoidCongestionAI : ThreadingExtensionBase
    {
        // 定义一些常量
        private const float HIGHWAY_SPEED = 100f; // 高速公路的限速（单位：公里/小时）
        private const float HIGHWAY_LENGTH = 1000f; // 高速公路的最小长度（单位：米）
        private const float HIGHWAY_ANGLE = 30f; // 高速公路的最大转弯角度（单位：度）
        private const float RAMP_SPEED = 60f; // 高速公路出入口的限速（单位：公里/小时）
        private const float RAMP_LENGTH = 200f; // 高速公路出入口的最小长度（单位：米）
        private const float RAMP_ANGLE = 45f; // 高速公路出入口的最大转弯角度（单位：度）
        private const float ELEVATED_SPEED = 80f; // 高架大道的限速（单位：公里/小时）
        private const float ELEVATED_LENGTH = 500f; // 高架大道的最小长度（单位：米）
        private const float ELEVATED_ANGLE = 30f; // 高架大道的最大转弯角度（单位：度）
        private const float DISTRICT_RADIUS = 500f; // 区域半径（单位：米）
        private const int COMMERCIAL_DENSITY = 80; // 商业区密度（百分比）
        private const int RESIDENTIAL_DENSITY = 60; // 居民区密度（百分比）
        private const int INDUSTRIAL_DENSITY = 40; // 工业区密度（百分比）

        // 定义一些变量
        private NetManager netManager; // 网络管理器
        private DistrictManager districtManager; // 区域管理器
        private TrafficManagerMod trafficManagerMod; // 交通管理器MOD
        private Dictionary<ushort, RoadType> roadTypes; // 道路类型字典

        public override void OnCreated(IThreading threading)
        {
            base.OnCreated(threading);
            netManager = Singleton<NetManager>.instance; // 获取网络管理器实例
            districtManager = Singleton<DistrictManager>.instance; // 获取区域管理器实例
            trafficManagerMod = TrafficManagerMod.Instance; // 获取交通管理器MOD实例
            roadTypes = new Dictionary<ushort, RoadType>(); // 初始化道路类型字典
        }

        public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
        {
            base.OnUpdate(realTimeDelta, simulationTimeDelta);
            if (Input.GetKeyDown(KeyCode.F1)) // 按下F1键时执行以下操作
            {
                FindRoadTypes(); // 寻找道路类型
                SetSpeedLimits(); // 设置限速
                SetLaneArrows(); // 设置车道箭头
                SetTrafficLights(); // 设置红绿灯
                SetPrioritySigns(); // 设置优先标志
                SetJunctionRestrictions(); // 设置路口限制
                DebugOutput(); // 输出调试信息
            }
        }

        private void FindRoadTypes()
        {
            roadTypes.Clear(); // 清空道路类型字典
            for (ushort segmentId = 0; segmentId < NetManager.MAX_SEGMENT_COUNT; segmentId++) 
            {
                if (netManager.m_segments.m_buffer[segmentId].m_flags == NetSegment.Flags.None) continue;
                if (netManager.m_segments.m_buffer[segmentId].Info.m_netAI is RoadBaseAI) 
                {
                    RoadBaseAI roadAI = netManager.m_segments.m_buffer[segmentId].Info.m_netAI as RoadBaseAI;
                    if (roadAI.m_highwayRules) 
                    {
                        if (roadAI.m_enableZoning) 
                        {
                            roadTypes.Add(segmentId, RoadType.Ramp); 
                        }
                        else 
                        {
                            roadTypes.Add(segmentId, RoadType.Highway); 
                        }
                    }
                }
                else if (netManager.m_segments.m_buffer[segmentId].Info.m_netAI is RoadBridgeAI) 
                {
                    RoadBridgeAI bridgeAI = netManager.m_segments.m_buffer[segmentId].Info.m_netAI as RoadBridgeAI;
                    if (!bridgeAI.m_highwayRules && !bridgeAI.m_enableZoning) 
                    {
                        roadTypes.Add(segmentId, RoadType.Elevated); 
                    }
                }
            }
        }

        private void SetSpeedLimits()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, HIGHWAY_SPEED); 
                        break;
                    case RoadType.Ramp:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, RAMP_SPEED); 
                        break;
                    case RoadType.Elevated:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, ELEVATED_SPEED); 
                        break;
                    default:
                        break;
                }
            }
        }

        private void SetLaneArrows()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                int laneCount = netManager.m_segments.m_buffer[segmentId].Info.m_lanes.Length;
                for (int laneIndex = 0; laneIndex < laneCount; laneIndex++) 
                {
                    uint laneId = netManager.m_segments.m_buffer[segmentId].m_lanes[laneIndex];
                    if (laneId == 0) continue;
                    switch (roadType) 
                    {
                        case RoadType.Highway:
                            if (laneIndex == 0 || laneIndex == laneCount - 1) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Forward | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Forward); 
                            }
                            break;
                        case RoadType.Ramp:
                            if (netManager.m_segments.m_buffer[segmentId].m_startNode == netManager.m_lanes.m_buffer[laneId].m_nodes[0]) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Merge); 
                            }
                            break;
                        case RoadType.Elevated:
                            if (laneIndex == 0 || laneIndex == laneCount - 1) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Forward | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Forward); 
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }

        private void SetTrafficLights()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(startNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(startNodeId,  private void SetTrafficLights()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(startNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId);  
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(endNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId);  
                        }
                        break;
                    case RoadType.Elevated:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    default:
                        break;
                }
            }
        }

        private void SetPrioritySigns()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        PriorityRoad.Signs signs = new PriorityRoad.Signs(); // 创建优先标志对象
                        signs.mainSigns = PriorityRoad.PriorityType.Main; // 设置主要标志为主路优先
                        signs.yieldSigns = PriorityRoad.PriorityType.None; // 设置让行标志为无
                        signs.stopSigns = PriorityRoad.PriorityType.None; // 设置停止标志为无
                        PriorityRoad.SetPriorityRoad(startNodeId, ref signs); // 设置起始节点的优先标志
                        PriorityRoad.SetPriorityRoad(endNodeId, ref signs); // 设置结束节点的优先标志
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2) // 如果起始节点连接了多于两条道路段
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.None;
                            signs.yieldSigns = PriorityRoad.PriorityType.Yield; // 设置让行标志为让行
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(startNodeId, ref signs);
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.None;
                            signs.yieldSigns = PriorityRoad.PriorityType.Yield;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(endNodeId, ref signs);
                        }
                        break;
                    case RoadType.Elevated:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.Main;
                            signs.yieldSigns = PriorityRoad.PriorityType.None;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(startNodeId, ref signs);
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.Main;
                            signs.yieldSigns = PriorityRoad.PriorityType.None;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(endNodeId, ref signs);
                        }
                        break;
                    default:
                        break;
                }
            }
        }

        private void SetJunctionRestrictions()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false); // 禁止起始节点的掉头
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false); // 禁止结束节点的掉头
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true); // 允许起始节点的进入阻塞
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true); // 允许结束节点的进入阻塞
                        break;
                    case RoadType.Ramp:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true);
                        break;
                    case RoadType.Elevated:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true);
                        break;
                    default:
                        break;
                }
            }
        }

        private void DebugOutput()
        {
            if (Input.GetKeyDown(KeyCode.F2)) // 按下F2键时执行以下操作
            {
                Debug.Log("高速公路数量：" + roadTypes.Count(x => x.Value == RoadType.Highway)); // 输出高速公路数量
                Debug.Log("出入口数量：" + roadTypes.Count(x => x.Value == RoadType.Ramp)); // 输出出入口数量
                Debug.Log("高架大道数量：" + roadTypes.Count(x => x.Value == RoadType.Elevated)); // 输出高架大道数量
            }
        }
    }

    public enum RoadType // 定义道路类型枚举
    {
        Highway,
        Ramp,
        Elevated
    }
}

​x
 
// 城市天际线自动避免拥堵路段的代码
// 作者：Bing
// 日期：2023年5月8日
// 说明：这个代码是根据一些网上的资料和建议编写的，可能有不完善或错误的地方，请谨慎使用。
// 优化：这个代码是根据一些编程原则和技巧进行了优化，提高了代码的可读性，可维护性，健壮性和可调试性。
​
using ColossalFramework;
using ColossalFramework.Math;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TrafficManager.Manager;
using TrafficManager.Traffic;
​
namespace AvoidCongestion
{
    public class AvoidCongestionAI : ThreadingExtensionBase
    {
        // 定义一些常量
        private const float HIGHWAY_SPEED = 100f; // 高速公路的限速（单位：公里/小时）
        private const float HIGHWAY_LENGTH = 1000f; // 高速公路的最小长度（单位：米）
        private const float HIGHWAY_ANGLE = 30f; // 高速公路的最大转弯角度（单位：度）
        private const float RAMP_SPEED = 60f; // 高速公路出入口的限速（单位：公里/小时）
        private const float RAMP_LENGTH = 200f; // 高速公路出入口的最小长度（单位：米）
        private const float RAMP_ANGLE = 45f; // 高速公路出入口的最大转弯角度（单位：度）
        private const float ELEVATED_SPEED = 80f; // 高架大道的限速（单位：公里/小时）
        private const float ELEVATED_LENGTH = 500f; // 高架大道的最小长度（单位：米）
        private const float ELEVATED_ANGLE = 30f; // 高架大道的最大转弯角度（单位：度）
        private const float DISTRICT_RADIUS = 500f; // 区域半径（单位：米）
        private const int COMMERCIAL_DENSITY = 80; // 商业区密度（百分比）
        private const int RESIDENTIAL_DENSITY = 60; // 居民区密度（百分比）
        private const int INDUSTRIAL_DENSITY = 40; // 工业区密度（百分比）
​
        // 定义一些变量
        private NetManager netManager; // 网络管理器
        private DistrictManager districtManager; // 区域管理器
        private TrafficManagerMod trafficManagerMod; // 交通管理器MOD
        private Dictionary<ushort, RoadType> roadTypes; // 道路类型字典
​
        public override void OnCreated(IThreading threading)
        {
            base.OnCreated(threading);
            netManager = Singleton<NetManager>.instance; // 获取网络管理器实例
            districtManager = Singleton<DistrictManager>.instance; // 获取区域管理器实例
            trafficManagerMod = TrafficManagerMod.Instance; // 获取交通管理器MOD实例
            roadTypes = new Dictionary<ushort, RoadType>(); // 初始化道路类型字典
        }
​
        public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
        {
            base.OnUpdate(realTimeDelta, simulationTimeDelta);
            if (Input.GetKeyDown(KeyCode.F1)) // 按下F1键时执行以下操作
            {
                FindRoadTypes(); // 寻找道路类型
                SetSpeedLimits(); // 设置限速
                SetLaneArrows(); // 设置车道箭头
                SetTrafficLights(); // 设置红绿灯
                SetPrioritySigns(); // 设置优先标志
                SetJunctionRestrictions(); // 设置路口限制
                DebugOutput(); // 输出调试信息
            }
        }
​
        private void FindRoadTypes()
        {
            roadTypes.Clear(); // 清空道路类型字典
            for (ushort segmentId = 0; segmentId < NetManager.MAX_SEGMENT_COUNT; segmentId++) 
            {
                if (netManager.m_segments.m_buffer[segmentId].m_flags == NetSegment.Flags.None) continue;
                if (netManager.m_segments.m_buffer[segmentId].Info.m_netAI is RoadBaseAI) 
                {
                    RoadBaseAI roadAI = netManager.m_segments.m_buffer[segmentId].Info.m_netAI as RoadBaseAI;
                    if (roadAI.m_highwayRules) 
                    {
                        if (roadAI.m_enableZoning) 
                        {
                            roadTypes.Add(segmentId, RoadType.Ramp); 
                        }
                        else 
                        {
                            roadTypes.Add(segmentId, RoadType.Highway); 
                        }
                    }
                }
                else if (netManager.m_segments.m_buffer[segmentId].Info.m_netAI is RoadBridgeAI) 
                {
                    RoadBridgeAI bridgeAI = netManager.m_segments.m_buffer[segmentId].Info.m_netAI as RoadBridgeAI;
                    if (!bridgeAI.m_highwayRules && !bridgeAI.m_enableZoning) 
                    {
                        roadTypes.Add(segmentId, RoadType.Elevated); 
                    }
                }
            }
        }
​
        private void SetSpeedLimits()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, HIGHWAY_SPEED); 
                        break;
                    case RoadType.Ramp:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, RAMP_SPEED); 
                        break;
                    case RoadType.Elevated:
                        SpeedLimitManager.Instance.SetSpeedLimit(segmentId, ELEVATED_SPEED); 
                        break;
                    default:
                        break;
                }
            }
        }
​
        private void SetLaneArrows()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                int laneCount = netManager.m_segments.m_buffer[segmentId].Info.m_lanes.Length;
                for (int laneIndex = 0; laneIndex < laneCount; laneIndex++) 
                {
                    uint laneId = netManager.m_segments.m_buffer[segmentId].m_lanes[laneIndex];
                    if (laneId == 0) continue;
                    switch (roadType) 
                    {
                        case RoadType.Highway:
                            if (laneIndex == 0 || laneIndex == laneCount - 1) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Forward | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Forward); 
                            }
                            break;
                        case RoadType.Ramp:
                            if (netManager.m_segments.m_buffer[segmentId].m_startNode == netManager.m_lanes.m_buffer[laneId].m_nodes[0]) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Merge); 
                            }
                            break;
                        case RoadType.Elevated:
                            if (laneIndex == 0 || laneIndex == laneCount - 1) 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Left | LaneArrows.Forward | LaneArrows.Right); 
                            }
                            else 
                            {
                                LaneArrowManager.Instance.SetLaneArrows(laneId, LaneArrows.Forward); 
                            }
                            break;
                        default:
                            break;
                    }
                }
            }
        }
​
        private void SetTrafficLights()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(startNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(startNodeId,  private void SetTrafficLights()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(startNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId);  
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2)  
                        {
                            TrafficLightManager.Instance.AddTrafficLight(endNodeId, segmentId);  
                        }
                        else  
                        {
                            TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId);  
                        }
                        break;
                    case RoadType.Elevated:
                        TrafficLightManager.Instance.RemoveTrafficLight(startNodeId, segmentId); 
                        TrafficLightManager.Instance.RemoveTrafficLight(endNodeId, segmentId); 
                        break;
                    default:
                        break;
                }
            }
        }
​
        private void SetPrioritySigns()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        PriorityRoad.Signs signs = new PriorityRoad.Signs(); // 创建优先标志对象
                        signs.mainSigns = PriorityRoad.PriorityType.Main; // 设置主要标志为主路优先
                        signs.yieldSigns = PriorityRoad.PriorityType.None; // 设置让行标志为无
                        signs.stopSigns = PriorityRoad.PriorityType.None; // 设置停止标志为无
                        PriorityRoad.SetPriorityRoad(startNodeId, ref signs); // 设置起始节点的优先标志
                        PriorityRoad.SetPriorityRoad(endNodeId, ref signs); // 设置结束节点的优先标志
                        break;
                    case RoadType.Ramp:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2) // 如果起始节点连接了多于两条道路段
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.None;
                            signs.yieldSigns = PriorityRoad.PriorityType.Yield; // 设置让行标志为让行
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(startNodeId, ref signs);
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.None;
                            signs.yieldSigns = PriorityRoad.PriorityType.Yield;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(endNodeId, ref signs);
                        }
                        break;
                    case RoadType.Elevated:
                        if (netManager.m_nodes.m_buffer[startNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.Main;
                            signs.yieldSigns = PriorityRoad.PriorityType.None;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(startNodeId, ref signs);
                        }
                        if (netManager.m_nodes.m_buffer[endNodeId].CountSegments() > 2) 
                        {
                            PriorityRoad.Signs signs = new PriorityRoad.Signs();
                            signs.mainSigns = PriorityRoad.PriorityType.Main;
                            signs.yieldSigns = PriorityRoad.PriorityType.None;
                            signs.stopSigns = PriorityRoad.PriorityType.None;
                            PriorityRoad.SetPriorityRoad(endNodeId, ref signs);
                        }
                        break;
                    default:
                        break;
                }
            }
        }
​
        private void SetJunctionRestrictions()
        {
            foreach (var pair in roadTypes) 
            {
                ushort segmentId = pair.Key;
                RoadType roadType = pair.Value;
                ushort startNodeId = netManager.m_segments.m_buffer[segmentId].m_startNode;
                ushort endNodeId = netManager.m_segments.m_buffer[segmentId].m_endNode;
                switch (roadType) 
                {
                    case RoadType.Highway:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false); // 禁止起始节点的掉头
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false); // 禁止结束节点的掉头
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true); // 允许起始节点的进入阻塞
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true); // 允许结束节点的进入阻塞
                        break;
                    case RoadType.Ramp:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true);
                        break;
                    case RoadType.Elevated:
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(startNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetUturnAllowed(endNodeId, segmentId, false);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(startNodeId, segmentId, true);
                        JunctionRestrictionsManager.Instance.SetEnterWhenBlockedAllowed(endNodeId, segmentId, true);
                        break;
                    default:
                        break;
                }
            }
        }
​
        private void DebugOutput()
        {
            if (Input.GetKeyDown(KeyCode.F2)) // 按下F2键时执行以下操作
            {
                Debug.Log("高速公路数量：" + roadTypes.Count(x => x.Value == RoadType.Highway)); // 输出高速公路数量
                Debug.Log("出入口数量：" + roadTypes.Count(x => x.Value == RoadType.Ramp)); // 输出出入口数量
                Debug.Log("高架大道数量：" + roadTypes.Count(x => x.Value == RoadType.Elevated)); // 输出高架大道数量
            }
        }
    }
​
    public enum RoadType // 定义道路类型枚举
    {
        Highway,
        Ramp,
        Elevated
    }
}

Introdueix el 1º nombre

Cached Result
Last Run:	1:59:59 am
Compile:	0.11s
Execute:	0s
Memory:	32kb
CPU:	0.016s

View IL Code