public static bool toggleLaneArrowFlags(uint laneId, LaneArrows flags) { if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return(false); } if (highwayLaneArrowFlags[laneId] != null) { return(false); // disallow custom lane arrows in highway rule mode } LaneArrows?arrows = laneArrowFlags[laneId]; if (arrows == null) { // read currently defined arrows uint laneFlags = (uint)Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags; laneFlags &= lfr; // filter arrows arrows = (LaneArrows)laneFlags; } arrows ^= flags; laneArrowFlags[laneId] = arrows; applyLaneArrowFlags(laneId, false); return(true); }
public static bool applyLaneArrowFlags(uint laneId, bool check = true) { if (laneId <= 0) { return(true); } uint laneFlags = (uint)Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags; if (check && !mayHaveLaneArrows(laneId)) { return(false); } LaneArrows?hwArrows = highwayLaneArrowFlags[laneId]; LaneArrows?arrows = laneArrowFlags[laneId]; if (hwArrows != null) { laneFlags &= ~lfr; // remove all arrows laneFlags |= (uint)hwArrows; // add highway arrows } else if (arrows != null) { LaneArrows flags = (LaneArrows)arrows; laneFlags &= ~lfr; // remove all arrows laneFlags |= (uint)flags; // add desired arrows } //Log._Debug($"Setting lane flags @ lane {laneId}, seg. {Singleton<NetManager>.instance.m_lanes.m_buffer[laneId].m_segment} to {((NetLane.Flags)laneFlags).ToString()}"); Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags = Convert.ToUInt16(laneFlags); return(true); }
/// <summary> /// remove arrows (user or default) where flag is set. /// 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 RemoveLaneArrows(uint laneId, LaneArrows flags, bool overrideHighwayArrows = false) { LaneArrows flags2 = GetFinalLaneArrows(laneId); return(SetLaneArrows(laneId, ~flags & flags2, overrideHighwayArrows)); }
public bool ToggleLaneArrows(uint laneId, bool startNode, LaneArrows flags, out LaneArrowChangeResult res) { if (Flags.toggleLaneArrowFlags(laneId, startNode, flags, out res)) { OnLaneChange(laneId); return(true); } return(false); }
public bool SetLaneArrows(uint laneId, LaneArrows flags, bool overrideHighwayArrows = false) { if (Flags.setLaneArrowFlags(laneId, flags, overrideHighwayArrows)) { OnLaneChange(laneId); return(true); } return(false); }
public bool ToggleLaneArrows(uint laneId, bool startNode, LaneArrows flags, out LaneArrowChangeResult res) { if (Flags.toggleLaneArrowFlags(laneId, startNode, flags, out res)) { SubscribeToSegmentGeometry(Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_segment); return(true); } return(false); }
public bool SetLaneArrows(uint laneId, LaneArrows flags, bool overrideHighwayArrows = false) { if (Flags.setLaneArrowFlags(laneId, flags, overrideHighwayArrows)) { SubscribeToSegmentGeometry(Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_segment); return(true); } return(false); }
public static void setHighwayLaneArrowFlags(uint laneId, LaneArrows flags) { if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } highwayLaneArrowFlags[laneId] = flags; applyLaneArrowFlags(laneId); }
public static void setHighwayLaneArrowFlags(uint laneId, LaneArrows flags, bool check = true) { if (check && !mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } highwayLaneArrowFlags[laneId] = flags; applyLaneArrowFlags(laneId, false); }
public static void setHighwayLaneArrowFlags(uint laneId, LaneArrows flags, bool check = true) { if (check && !mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } highwayLaneArrowFlags[laneId] = flags; #if DEBUGFLAGS Log._Debug($"Flags.setHighwayLaneArrowFlags: Setting highway arrows of lane {laneId} to {flags}"); #endif applyLaneArrowFlags(laneId, false); }
public static void setLaneArrowFlags(uint laneId, LaneArrows flags) { if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } if (highwayLaneArrowFlags[laneId] != null) { return; // disallow custom lane arrows in highway rule mode } laneArrowFlags[laneId] = flags; applyLaneArrowFlags(laneId, false); }
public static bool ToggleLaneArrowFlags(uint laneId, bool startNode, LaneArrows flags, out SetLaneArrowError res) { if (!CanHaveLaneArrows(laneId)) { RemoveLaneArrowFlags(laneId); res = SetLaneArrowError.Invalid; return(false); } if (highwayLaneArrowFlags[laneId] != null) { res = SetLaneArrowError.HighwayArrows; return(false); // disallow custom lane arrows in highway rule mode } if (LaneConnectionManager.Instance.HasConnections(laneId, startNode)) { // TODO refactor res = SetLaneArrowError.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 = SetLaneArrowError.Success; return(true); } res = SetLaneArrowError.Invalid; return(false); }
public static bool setLaneArrowFlags(uint laneId, LaneArrows flags, bool overrideHighwayArrows = false) { #if DEBUGFLAGS Log._Debug($"Flags.setLaneArrowFlags({laneId}, {flags}, {overrideHighwayArrows}) called"); #endif if (!CanHaveLaneArrows(laneId)) { #if DEBUGFLAGS Log._Debug($"Flags.setLaneArrowFlags({laneId}, {flags}, {overrideHighwayArrows}): " + $"lane must not have lane arrows"); #endif RemoveLaneArrowFlags(laneId); return(false); } if (!overrideHighwayArrows && highwayLaneArrowFlags[laneId] != null) { #if DEBUGFLAGS Log._Debug($"Flags.setLaneArrowFlags({laneId}, {flags}, {overrideHighwayArrows}): " + "highway arrows may not be overridden"); #endif return(false); // disallow custom lane arrows in highway rule mode } if (overrideHighwayArrows) { #if DEBUGFLAGS Log._Debug($"Flags.setLaneArrowFlags({laneId}, {flags}, {overrideHighwayArrows}): " + $"overriding highway arrows"); #endif highwayLaneArrowFlags[laneId] = null; } #if DEBUGFLAGS Log._Debug($"Flags.setLaneArrowFlags({laneId}, {flags}, {overrideHighwayArrows}): setting flags"); #endif laneArrowFlags[laneId] = flags; return(ApplyLaneArrowFlags(laneId, false)); }
public static bool ApplyLaneArrowFlags(uint laneId, bool check = true) { #if DEBUGFLAGS Log._Debug($"Flags.applyLaneArrowFlags({laneId}, {check}) called"); #endif if (laneId <= 0) { return(true); } if (check && !CanHaveLaneArrows(laneId)) { RemoveLaneArrowFlags(laneId); return(false); } LaneArrows?hwArrows = highwayLaneArrowFlags[laneId]; LaneArrows?arrows = laneArrowFlags[laneId]; uint laneFlags = Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags; if (hwArrows != null) { laneFlags &= ~lfr; // remove all arrows laneFlags |= (uint)hwArrows; // add highway arrows } else if (arrows != null) { LaneArrows flags = (LaneArrows)arrows; laneFlags &= ~lfr; // remove all arrows laneFlags |= (uint)flags; // add desired arrows } #if DEBUGFLAGS Log._Debug($"Flags.applyLaneArrowFlags: Setting lane flags of lane {laneId} to " + $"{(NetLane.Flags)laneFlags}"); #endif Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags = Convert.ToUInt16(laneFlags); return(true); }
public static LaneArrows GetFinalLaneArrowFlags(uint laneId, bool check = true) { if (!CanHaveLaneArrows(laneId)) { #if DEBUGFLAGS Log._Debug($"Lane {laneId} may not have lane arrows"); #endif return(LaneArrows.None); } uint ret = 0; LaneArrows?hwArrows = highwayLaneArrowFlags[laneId]; LaneArrows?arrows = laneArrowFlags[laneId]; if (hwArrows != null) { ret &= ~lfr; // remove all arrows ret |= (uint)hwArrows; // add highway arrows } else if (arrows != null) { LaneArrows flags = (LaneArrows)arrows; ret &= ~lfr; // remove all arrows ret |= (uint)flags; // add desired arrows } else { Constants.ServiceFactory.NetService.ProcessLane( laneId, delegate(uint lId, ref NetLane lane) { ret = lane.m_flags; ret &= (uint)LaneArrows.LeftForwardRight; return(true); }); } return((LaneArrows)ret); }
/// <summary> /// Determines if any lane from source segment goes to the target segment /// based on lane arrows and lane connections. public static bool DoesSegmentGoToSegment(ushort sourceSegmentID, ushort targetSegmentID, ushort nodeID) { bool startNode = NetUtil.IsStartNode(sourceSegmentID, nodeID); if (sourceSegmentID == targetSegmentID) { return(TMPE.JunctionRestrictionsManager.IsUturnAllowed(sourceSegmentID, startNode)); } ArrowDirection arrowDir = TMPE.ExtSegmentEndManager.GetDirection(sourceSegmentID, targetSegmentID, nodeID); LaneArrows arrow = ArrowDir2LaneArrows(arrowDir); var sourceLanes = new LaneDataIterator( sourceSegmentID, startNode, TMPE.LaneArrowManager.LaneTypes, TMPE.LaneArrowManager.VehicleTypes); //Log.Debug("DoesSegmentGoToSegment: sourceLanes=" + sourceLanes.ToSTR()); foreach (LaneData sourceLane in sourceLanes) { bool connected; if (TMPE.LaneConnectionManager.HasConnections(sourceLane.LaneID, startNode)) { connected = IsLaneConnectedToSegment(sourceLane.LaneID, targetSegmentID); //Log.Debug($"IsLaneConnectedToSegment({sourceLane},{targetSegmentID}) = {connected}"); } else { LaneArrows arrows = TMPE.LaneArrowManager.GetFinalLaneArrows(sourceLane.LaneID); connected = (arrows & arrow) != 0; } if (connected) { return(true); } } return(false); }
/// <summary> /// Determines if any lane from source segment goes to the target segment /// based on lane arrows and lane connections. public static bool DoesSegmentGoToSegment(ushort sourceSegmentID, ushort targetSegmentID, ushort nodeID) { bool startNode = NetUtil.IsStartNode(sourceSegmentID, nodeID); if (sourceSegmentID == targetSegmentID) { return(JunctionRestrictionsManager.Instance.IsUturnAllowed(sourceSegmentID, startNode)); } ArrowDirection arrowDir = ExtSegmentEndManager.Instance.GetDirection(sourceSegmentID, targetSegmentID, nodeID); LaneArrows arrow = ArrowDir2LaneArrows(arrowDir); var sourceLanes = NetUtil.IterateLanes( sourceSegmentID, startNode, LaneArrowManager.LANE_TYPES, LaneArrowManager.VEHICLE_TYPES); foreach (LaneData sourceLane in sourceLanes) { bool connected; if (LaneConnectionManager.Instance.HasConnections(sourceLane.LaneID, startNode)) { connected = IsLaneConnectedToSegment(sourceLane, targetSegmentID); //Log.Debug($"IsLaneConnectedToSegment({sourceLane},{targetSegmentID}) = {connected}"); } else { LaneArrows arrows = LaneArrowManager.Instance.GetFinalLaneArrows(sourceLane.LaneID); connected = arrows.IsFlagSet(arrow); } if (connected) { return(true); } } return(false); }
public static void toggleLaneArrowFlags(uint laneId, LaneArrows flags) { if (laneId <= 0) return; if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } if (!laneArrowFlags.ContainsKey(laneId)) { // read currently defined arrows uint laneFlags = (uint)Singleton<NetManager>.instance.m_lanes.m_buffer[laneId].m_flags; laneFlags &= lfr; // filter arrows laneArrowFlags[laneId] = (LaneArrows)laneFlags; } laneArrowFlags[laneId] ^= flags; applyLaneArrowFlags(laneId); }
public static void setLaneArrowFlags(uint laneId, LaneArrows flags) { if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return; } if (highwayLaneArrowFlags[laneId] != null) return; // disallow custom lane arrows in highway rule mode laneArrowFlags[laneId] = flags; applyLaneArrowFlags(laneId); }
public static bool toggleLaneArrowFlags(uint laneId, LaneArrows flags) { if (!mayHaveLaneArrows(laneId)) { removeLaneArrowFlags(laneId); return false; } if (highwayLaneArrowFlags[laneId] != null) return false; // disallow custom lane arrows in highway rule mode LaneArrows? arrows = laneArrowFlags[laneId]; if (arrows == null) { // read currently defined arrows uint laneFlags = (uint)Singleton<NetManager>.instance.m_lanes.m_buffer[laneId].m_flags; laneFlags &= lfr; // filter arrows arrows = (LaneArrows)laneFlags; } arrows ^= flags; laneArrowFlags[laneId] = arrows; applyLaneArrowFlags(laneId); return true; }
public void Record() { arrows_ = LaneArrowManager.Instance.GetFinalLaneArrows(LaneId); }