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 void setHighwayLaneArrowFlags(uint laneId, LaneArrows flags) {
if (!mayHaveLaneArrows(laneId)) {
removeLaneArrowFlags(laneId);
return;
}
highwayLaneArrowFlags[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);
}
