/// <summary> /// separates turning lanes for all segments attached to nodeId, /// </summary> public static void SeparateNode(ushort nodeId, out SetLaneArrow_Result res, bool alternativeMode = true) { NetNode node = Singleton<NetManager>.instance.m_nodes.m_buffer[nodeId]; if (nodeId == 0) { res = SetLaneArrow_Result.Invalid; return; } if ((node.m_flags & NetNode.Flags.Created) == NetNode.Flags.None) { res = SetLaneArrow_Result.Invalid; return; } if (LaneConnectionManager.Instance.HasNodeConnections(nodeId)) { res = SetLaneArrow_Result.LaneConnection; return; } if (Options.highwayRules && ExtNodeManager.JunctionHasHighwayRules(nodeId)) { res = SetLaneArrow_Result.HighwayArrows; return; } res = SetLaneArrow_Result.Success; for (int i = 0; i < 8; i++) { ushort segmentId = Singleton<NetManager>.instance.m_nodes.m_buffer[nodeId].GetSegment(i); if (segmentId == 0) { continue; } SeparateSegmentLanes(segmentId, nodeId, out res, alternativeMode); } Debug.Assert(res == SetLaneArrow_Result.Success); }
/// <summary> /// separates turning lanes for the input segment on the input node. /// <param name="alt2">alternativ mode for two lanes(dedicated near turn)</param> /// <param name="alt3">alternative mode for 3+ lanes(favour forward)</param> /// <param name="altBus">alternative mode for roads with bs lanes(mixed VS separate caluclations)</param> /// </summary> public static void SeparateSegmentLanes( ushort segmentId, ushort nodeId, out SetLaneArrow_Result res, bool alternativeMode = true) { bool alt2 = alternativeMode; // alt mode for 2 lanes bool alt3 = alternativeMode; // alt mode for 3+ lanes bool altBus = alternativeMode; // alt mode if lanes include bus lane[s]. bool hasBusLanes = CountBusLanes(segmentId, nodeId) > 0; LaneArrowManager.Instance.ResetLaneArrows(segmentId, netService.IsStartNode(segmentId, nodeId)); if (!hasBusLanes) { SeparateSegmentLanes( segmentId, nodeId, out res, LaneArrowManager.LANE_TYPES, LaneArrowManager.VEHICLE_TYPES, alt2, alt3); } else { if (altBus) { SeparateSegmentLanes( segmentId, nodeId, out res, LaneArrowManager.LANE_TYPES, LaneArrowManager.VEHICLE_TYPES); } else { SeparateSegmentLanes( segmentId, nodeId, out res, NetInfo.LaneType.Vehicle, LaneArrowManager.VEHICLE_TYPES); SeparateSegmentLanes( segmentId, nodeId, out res, NetInfo.LaneType.TransportVehicle, LaneArrowManager.VEHICLE_TYPES); } } }
/// <summary> /// Toggles a lane arrows (user or default) on and off for the directions where flag is set. /// overrides default settings for the arrows that change. /// default arrows may change as user connects or remove more segments to the junction but /// the user arrows stay the same no matter what. /// </summary> public bool ToggleLaneArrows(uint laneId, bool startNode, LaneArrows flags, out SetLaneArrow_Result res) { if (Flags.ToggleLaneArrowFlags(laneId, startNode, flags, out res)) { OnLaneChange(laneId); return(true); } return(false); }
private static void SeparateSegmentLanes( ushort segmentId, ushort nodeId, out SetLaneArrow_Result res, NetInfo.LaneType laneType, VehicleInfo.VehicleType vehicleType, bool alt2 = false, bool alt3 = false) { res = CanChangeLanes(segmentId, nodeId); if (res != SetLaneArrow_Result.Success) { return; } res = SetLaneArrow_Result.Success; ref NetSegment seg = ref segmentId.ToSegment();
public static bool ToggleLaneArrowFlags(uint laneId, bool startNode, LaneArrows flags, out SetLaneArrow_Result res) { if (!CanHaveLaneArrows(laneId)) { RemoveLaneArrowFlags(laneId); res = SetLaneArrow_Result.Invalid; return(false); } if (highwayLaneArrowFlags[laneId] != null) { res = SetLaneArrow_Result.HighwayArrows; return(false); // disallow custom lane arrows in highway rule mode } if (LaneConnectionManager.Instance.HasConnections(laneId, startNode)) { // TODO refactor res = SetLaneArrow_Result.LaneConnection; return(false); // custom lane connection present } LaneArrows?arrows = laneArrowFlags[laneId]; if (arrows == null) { // read currently defined arrows uint laneFlags = Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags; laneFlags &= lfr; // filter arrows arrows = (LaneArrows)laneFlags; } arrows ^= flags; laneArrowFlags[laneId] = arrows; if (ApplyLaneArrowFlags(laneId, false)) { res = SetLaneArrow_Result.Success; return(true); } res = SetLaneArrow_Result.Invalid; return(false); }
/// <summary> /// If Lane Arrow operation ended with failure, pop up a guide box with an explanation. /// </summary> /// <param name="result">Result coming out of LaneArrowManager function call.</param> internal void InformUserAboutPossibleFailure(SetLaneArrow_Result result) { switch (result) { case SetLaneArrow_Result.HighwayArrows: { MainTool.Guide.Activate("LaneArrowTool_Disabled due to highway rules"); break; } case SetLaneArrow_Result.LaneConnection: { MainTool.Guide.Activate("LaneArrowTool_Disabled due to lane connections"); break; } case SetLaneArrow_Result.Success: MainTool.Guide.Deactivate("LaneArrowTool_Disabled due to highway rules"); MainTool.Guide.Deactivate("LaneArrowTool_Disabled due to lane connections"); break; } }