public static bool segmentIsIncomingOneWay(int segmentid, ushort nodeID)
{
NetManager instance = Singleton <NetManager> .instance;
var segment = instance.m_segments.m_buffer[segmentid];
var info = segment.Info;
uint num2 = segment.m_lanes;
int num3 = 0;
NetInfo.Direction dir = NetInfo.Direction.Forward;
if (segment.m_startNode == nodeID)
{
dir = NetInfo.Direction.Backward;
}
var dir2 = ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection(dir);
var dir3 = TrafficPriority.leftHandDrive ? NetInfo.InvertDirection(dir2) : dir2;
var isOneWay = true;
while (num3 < info.m_lanes.Length && num2 != 0u)
{
if (info.m_lanes[num3].m_laneType != NetInfo.LaneType.Pedestrian &&
(info.m_lanes[num3].m_direction == dir3))
{
isOneWay = false;
}
num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
num3++;
}
return(isOneWay);
}
public bool SetParkingAllowed(ushort segmentId, NetInfo.Direction finalDir, bool flag)
{
if (!MayHaveParkingRestriction(segmentId))
{
return(false);
}
int dirIndex = GetDirIndex(finalDir);
parkingAllowed[segmentId][dirIndex] = flag;
if (flag && parkingAllowed[segmentId][1 - dirIndex])
{
UnsubscribeFromSegmentGeometry(segmentId);
}
else
{
if (!flag)
{
// force relocation of illegaly parked vehicles
Services.NetService.ProcessSegment(segmentId, delegate(ushort segId, ref NetSegment segment) {
segment.UpdateSegment(segmentId);
return(true);
});
}
SubscribeToSegmentGeometry(segmentId);
}
return(true);
}
internal bool IsOutGoing(ushort segmentId, bool startNode, NetInfo.Lane laneInfo)
{
NetInfo.Direction direction = ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? laneInfo.m_finalDirection : NetInfo.InvertDirection(laneInfo.m_finalDirection);
if (startNode)
{
if ((direction & NetInfo.Direction.Backward) != 0)
{
return(true);
}
if ((direction & NetInfo.Direction.Forward) != 0)
{
return(false);
}
}
else
{
if ((direction & NetInfo.Direction.Forward) != 0)
{
return(true);
}
if ((direction & NetInfo.Direction.Backward) != 0)
{
return(false);
}
}
DebugLog.LogToFileOnly("Error: unknow lane direction");
return(false);
}
public bool SetParkingAllowed(ushort segmentId, NetInfo.Direction finalDir, bool flag)
{
if (!MayHaveParkingRestriction(segmentId))
{
return(false);
}
int dirIndex = GetDirIndex(finalDir);
parkingAllowed[segmentId][dirIndex] = flag;
if (!flag || !parkingAllowed[segmentId][1 - dirIndex])
{
Services.SimulationService.AddAction(
() => {
// force relocation of illegaly parked vehicles
Services.NetService.ProcessSegment(
segmentId,
delegate(ushort segId, ref NetSegment segment) {
segment.UpdateSegment(segmentId);
return(true);
});
});
}
return(true);
}
/// <summary>
/// Determines the average default speed limit for a given NetInfo object in terms of discrete speed limit levels.
/// An in-game speed limit of 2.0 (e.g. on highway) is hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentInfo"></param>
/// <param name="finalDir"></param>
/// <returns></returns>
public ushort GetAverageDefaultCustomSpeedLimit(NetInfo segmentInfo, NetInfo.Direction?finalDir = null)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("SpeedLimitManager.GetAverageDefaultCustomSpeedLimit");
#endif
// calculate the currently set mean speed limit
float meanSpeedLimit = 0f;
uint validLanes = 0;
for (int i = 0; i < segmentInfo.m_lanes.Length; ++i)
{
NetInfo.Direction d = segmentInfo.m_lanes[i].m_finalDirection;
if ((segmentInfo.m_lanes[i].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None || (finalDir != null && d != finalDir))
{
continue;
}
meanSpeedLimit += segmentInfo.m_lanes[i].m_speedLimit;
++validLanes;
}
if (validLanes > 0)
{
meanSpeedLimit /= (float)validLanes;
}
ushort ret = LaneToCustomSpeedLimit(meanSpeedLimit);
#if TRACE
Singleton <CodeProfiler> .instance.Stop("SpeedLimitManager.GetAverageDefaultCustomSpeedLimit");
#endif
return(ret);
}
private int RenderSegmentSideOverlay(
RenderManager.CameraInfo cameraInfo,
ushort segmentId,
NetInfo.Direction finalDirection)
{
int count = 0;
bool pressed = Input.GetMouseButton(0);
Color color = MainTool.GetToolColor(pressed, false);
netService.IterateSegmentLanes(
segmentId,
(uint laneId,
ref NetLane lane,
NetInfo.Lane laneInfo,
ushort _,
ref NetSegment segment,
byte laneIndex) => {
bool render = (laneInfo.m_laneType & SpeedLimitManager.LANE_TYPES) != 0;
render &= (laneInfo.m_vehicleType & SpeedLimitManager.VEHICLE_TYPES) != 0;
render &= laneInfo.m_finalDirection == finalDirection;
if (render)
{
RenderLaneOverlay(cameraInfo, laneId);
count++;
}
return(true);
});
return(count);
}
/// <summary>
/// Determines the average default speed limit for a given NetInfo object in terms of discrete speed limit levels.
/// An in-game speed limit of 2.0 (e.g. on highway) is hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentInfo"></param>
/// <param name="finalDir"></param>
/// <returns></returns>
public ushort GetAverageDefaultCustomSpeedLimit(NetInfo segmentInfo, NetInfo.Direction?finalDir = null)
{
float meanSpeedLimit = 0f;
uint validLanes = 0;
for (int i = 0; i < segmentInfo.m_lanes.Length; ++i)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[i];
NetInfo.Direction d = laneInfo.m_finalDirection;
if (finalDir != null && d != finalDir)
{
continue;
}
if (!MayHaveCustomSpeedLimits(laneInfo))
{
continue;
}
meanSpeedLimit += laneInfo.m_speedLimit;
++validLanes;
}
if (validLanes > 0)
{
meanSpeedLimit /= (float)validLanes;
}
ushort ret = LaneToCustomSpeedLimit(meanSpeedLimit);
return(ret);
}
/// <summary>
/// Determines the average custom speed limit for a given NetInfo object in terms of discrete speed limit levels.
/// An in-game speed limit of 2.0 (e.g. on highway) is hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentInfo"></param>
/// <param name="finalDir"></param>
/// <returns></returns>
public ushort GetAverageCustomSpeedLimit(ushort segmentId, ref NetSegment segment, NetInfo segmentInfo, NetInfo.Direction?finalDir = null)
{
// calculate the currently set mean speed limit
float meanSpeedLimit = 0f;
uint validLanes = 0;
uint curLaneId = segment.m_lanes;
for (uint laneIndex = 0; laneIndex < segmentInfo.m_lanes.Length; ++laneIndex)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
NetInfo.Direction d = laneInfo.m_finalDirection;
if (finalDir != null && d != finalDir)
{
continue;
}
if (!MayHaveCustomSpeedLimits(laneInfo))
{
continue;
}
meanSpeedLimit += GetLockFreeGameSpeedLimit(segmentId, laneIndex, curLaneId, laneInfo);
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
++validLanes;
}
if (validLanes > 0)
{
meanSpeedLimit /= (float)validLanes;
}
return((ushort)Mathf.Round(meanSpeedLimit));
}
bool FindNode(NetSegment segment)
{
uint laneId = segment.m_lanes;
NetInfo info = segment.Info;
int laneCount = info.m_lanes.Length;
int laneIndex = 0;
for (; laneIndex < laneCount && laneId != 0; laneIndex++)
{
if (laneId == m_laneId)
{
break;
}
laneId = NetManager.instance.m_lanes.m_buffer[laneId].m_nextLane;
}
if (laneIndex < laneCount)
{
NetInfo.Direction laneDir = ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? info.m_lanes[laneIndex].m_finalDirection : NetInfo.InvertDirection(info.m_lanes[laneIndex].m_finalDirection);
if ((laneDir & (NetInfo.Direction.Forward | NetInfo.Direction.Avoid)) == NetInfo.Direction.Forward)
{
m_nodeId = segment.m_endNode;
}
else if ((laneDir & (NetInfo.Direction.Backward | NetInfo.Direction.Avoid)) == NetInfo.Direction.Backward)
{
m_nodeId = segment.m_startNode;
}
return(true);
}
return(false);
}
public static bool hasRightLane(ushort nodeID, int segmentID)
{
var instance = Singleton <NetManager> .instance;
var segment = Singleton <NetManager> .instance.m_segments.m_buffer[segmentID];
NetInfo.Direction dir = NetInfo.Direction.Forward;
if (segment.m_startNode == nodeID)
{
dir = NetInfo.Direction.Backward;
}
var dir2 = ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection(dir);
var dir3 = TrafficPriority.leftHandDrive ? NetInfo.InvertDirection(dir2) : dir2;
var info = segment.Info;
var maxValue = 0f;
var num2 = segment.m_lanes;
var num3 = 0;
while (num3 < info.m_lanes.Length && num2 != 0u)
{
var flags = (NetLane.Flags)Singleton <NetManager> .instance.m_lanes.m_buffer[(int)num2].m_flags;
if (info.m_lanes[num3].m_direction == dir3 && (flags & NetLane.Flags.Left) != NetLane.Flags.Right)
{
return(true);
}
num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
num3++;
}
return(false);
}
public float GetAverageDefaultCustomSpeedLimit(NetInfo segmentInfo,
NetInfo.Direction?finalDir = null)
{
var meanSpeedLimit = 0f;
uint validLanes = 0;
foreach (NetInfo.Lane laneInfo in segmentInfo.m_lanes)
{
NetInfo.Direction d = laneInfo.m_finalDirection;
if (finalDir != null && d != finalDir)
{
continue;
}
if (!MayHaveCustomSpeedLimits(laneInfo))
{
continue;
}
meanSpeedLimit += laneInfo.m_speedLimit;
++validLanes;
}
if (validLanes > 0)
{
meanSpeedLimit /= validLanes;
}
return(meanSpeedLimit);
}
private bool PathContainsSegment(uint pathID, ushort segmentID, NetInfo.Direction dir)
{
PathUnit path = this.getPath(pathID);
while (true)
{
// HACK: Dont inlude last segment as it will show vechicles arriving for both directions
for (int i = 0; i < path.m_positionCount - 1; i++)
{
PathUnit.Position p = path.GetPosition(i);
NetSegment segment = netMan.m_segments.m_buffer[(int)p.m_segment];
// Exclude paths with deleted segments
if (PathManager.GetLaneID(p) == 0 || (segment.m_flags & NetSegment.Flags.Deleted) != 0)
{
return(false);
}
if (p.m_segment == segmentID)
{
if (dir == NetInfo.Direction.Both)
{
return(true);
}
NetInfo info = netMan.m_segments.m_buffer[(int)p.m_segment].Info;
NetInfo.Direction laneDir = NetInfo.Direction.None;
if (info.m_lanes.Length > (int)p.m_lane)
{
laneDir = info.m_lanes[(int)p.m_lane].m_finalDirection;
if ((segment.m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
laneDir = NetInfo.InvertDirection(laneDir);
}
}
else
{
Log.error("bad lane count");
}
if (laneDir == dir)
{
return(true);
}
// } else if ((laneDir != NetInfo.Direction.Forward) && (laneDir != NetInfo.Direction.Backward)) {
// Log.debug("laneDir = " + laneDir);
// }
}
}
if (path.m_nextPathUnit == 0)
{
return(false);
}
path = this.getPath(path.m_nextPathUnit);
}
}
internal bool GetLaneEndPoint(ushort segmentId, bool startNode, byte laneIndex, uint?laneId, NetInfo.Lane laneInfo, out bool outgoing, out Vector3?pos)
{
NetManager netManager = Singleton <NetManager> .instance;
pos = null;
outgoing = false;
if ((netManager.m_segments.m_buffer[segmentId].m_flags & (NetSegment.Flags.Created | NetSegment.Flags.Deleted)) != NetSegment.Flags.Created)
{
return(false);
}
if (laneId == null)
{
laneId = FindLaneId(segmentId, laneIndex);
if (laneId == null)
{
return(false);
}
}
if ((netManager.m_lanes.m_buffer[(uint)laneId].m_flags & ((ushort)NetLane.Flags.Created | (ushort)NetLane.Flags.Deleted)) != (ushort)NetLane.Flags.Created)
{
return(false);
}
if (laneInfo == null)
{
if (laneIndex < netManager.m_segments.m_buffer[segmentId].Info.m_lanes.Length)
{
laneInfo = netManager.m_segments.m_buffer[segmentId].Info.m_lanes[laneIndex];
}
else
{
return(false);
}
}
NetInfo.Direction laneDir = ((NetManager.instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? laneInfo.m_finalDirection : NetInfo.InvertDirection(laneInfo.m_finalDirection);
if (startNode)
{
if ((laneDir & (NetInfo.Direction.Backward | NetInfo.Direction.Avoid)) == NetInfo.Direction.Backward)
{
outgoing = true;
}
pos = NetManager.instance.m_lanes.m_buffer[(uint)laneId].m_bezier.a;
}
else
{
if ((laneDir & (NetInfo.Direction.Forward | NetInfo.Direction.Avoid)) == NetInfo.Direction.Forward)
{
outgoing = true;
}
pos = NetManager.instance.m_lanes.m_buffer[(uint)laneId].m_bezier.d;
}
return(true);
}
/// <summary>
/// Sets the speed limit of a given segment and lane direction.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="finalDir"></param>
/// <param name="speedLimit"></param>
/// <returns></returns>
public bool SetSpeedLimit(ushort segmentId, NetInfo.Direction finalDir, ushort speedLimit)
{
if (!MayHaveCustomSpeedLimits(segmentId, ref Singleton <NetManager> .instance.m_segments.m_buffer[segmentId]))
{
return(false);
}
if (!AvailableSpeedLimits.Contains(speedLimit))
{
return(false);
}
NetInfo segmentInfo = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
if (segmentInfo == null)
{
#if DEBUG
Log.Warning($"SpeedLimitManager.SetSpeedLimit: info is null!");
#endif
return(false);
}
if (segmentInfo.m_lanes == null)
{
#if DEBUG
Log.Warning($"SpeedLimitManager.SetSpeedLimit: info.name is null!");
#endif
return(false);
}
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int laneIndex = 0;
while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
NetInfo.Direction d = laneInfo.m_finalDirection;
if (d != finalDir)
{
goto nextIter;
}
if (!MayHaveCustomSpeedLimits(laneInfo))
{
goto nextIter;
}
#if DEBUG
Log._Debug($"SpeedLimitManager: Setting speed limit of lane {curLaneId} to {speedLimit}");
#endif
Flags.setLaneSpeedLimit(curLaneId, speedLimit);
SubscribeToSegmentGeometry(segmentId);
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
return(true);
}
/// <summary>
/// Determines the currently set speed limit for the given segment and lane direction in
/// terms of discrete speed limit levels. An in-game speed limit of 2.0 (e.g. on highway) is
/// hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentId">Interested in this segment</param>
/// <param name="finalDir">Direction</param>
/// <returns>Mean speed limit, average for custom and default lane speeds</returns>
public float GetCustomSpeedLimit(ushort segmentId, NetInfo.Direction finalDir)
{
// calculate the currently set mean speed limit
if (segmentId == 0 ||
(Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags &
NetSegment.Flags.Created) == NetSegment.Flags.None)
{
return(0f);
}
NetInfo segmentInfo =
Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
var laneIndex = 0;
var meanSpeedLimit = 0f;
uint validLanes = 0;
while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
NetInfo.Direction d = laneInfo.m_finalDirection;
if (d != finalDir)
{
goto nextIter;
}
if (!MayHaveCustomSpeedLimits(laneInfo))
{
goto nextIter;
}
float?setSpeedLimit = Flags.GetLaneSpeedLimit(curLaneId);
if (setSpeedLimit != null)
{
meanSpeedLimit += ToGameSpeedLimit(setSpeedLimit.Value); // custom speed limit
}
else
{
meanSpeedLimit += laneInfo.m_speedLimit; // game default
}
++validLanes;
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
if (validLanes > 0)
{
meanSpeedLimit /= validLanes;
}
return(meanSpeedLimit);
}
private void _laneChangePanel()
{
if (TrafficLightTool.SelectedSegment != 0)
{
NetManager instance = Singleton <NetManager> .instance;
var segment = instance.m_segments.m_buffer[TrafficLightTool.SelectedSegment];
var info = segment.Info;
uint num2 = segment.m_lanes;
int num3 = 0;
int offsetIdx = 0;
NetInfo.Direction dir = NetInfo.Direction.Forward;
if (segment.m_startNode == TrafficLightTool.SelectedNode)
{
dir = NetInfo.Direction.Backward;
}
var dir3 = ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection(dir);
while (num3 < info.m_lanes.Length && num2 != 0u)
{
if (info.m_lanes[num3].m_laneType != NetInfo.LaneType.Pedestrian && info.m_lanes[num3].m_direction == dir3)
{
//segmentLights[num3].Show();
//segmentLights[num3].relativePosition = new Vector3(35f, (float)(xPos + (offsetIdx * 40f)));
//segmentLights[num3].text = ((NetLane.Flags)instance.m_lanes.m_buffer[num2].m_flags & ~NetLane.Flags.Created).ToString();
//if (segmentLights[num3].containsMouse)
//{
// if (Input.GetMouseButton(0) && !segmentMouseDown)
// {
// switchLane(num2);
// segmentMouseDown = true;
// if (
// !TrafficPriority.isPrioritySegment(TrafficLightTool.SelectedNode,
// TrafficLightTool.SelectedSegment))
// {
// TrafficPriority.addPrioritySegment(TrafficLightTool.SelectedNode, TrafficLightTool.SelectedSegment, PrioritySegment.PriorityType.None);
// }
// }
//}
offsetIdx++;
}
num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
num3++;
}
}
}
/// <summary>
/// Determines the currently set speed limit for the given segment and lane direction in terms of discrete speed limit levels.
/// An in-game speed limit of 2.0 (e.g. on highway) is hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentId"></param>
/// <param name="finalDir"></param>
/// <returns></returns>
public ushort GetCustomSpeedLimit(ushort segmentId, NetInfo.Direction finalDir)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("SpeedLimitManager.GetCustomSpeedLimit1");
#endif
// calculate the currently set mean speed limit
if (segmentId == 0 || (Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created) == NetSegment.Flags.None)
{
#if TRACE
Singleton <CodeProfiler> .instance.Stop("SpeedLimitManager.GetCustomSpeedLimit1");
#endif
return(0);
}
var segmentInfo = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int laneIndex = 0;
float meanSpeedLimit = 0f;
uint validLanes = 0;
while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u)
{
NetInfo.Direction d = segmentInfo.m_lanes[laneIndex].m_finalDirection;
if ((segmentInfo.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None || d != finalDir)
{
goto nextIter;
}
ushort?setSpeedLimit = Flags.getLaneSpeedLimit(curLaneId);
if (setSpeedLimit != null)
{
meanSpeedLimit += ToGameSpeedLimit((ushort)setSpeedLimit); // custom speed limit
}
else
{
meanSpeedLimit += segmentInfo.m_lanes[laneIndex].m_speedLimit; // game default
}
++validLanes;
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
if (validLanes > 0)
{
meanSpeedLimit /= (float)validLanes;
}
ushort ret = LaneToCustomSpeedLimit(meanSpeedLimit);
#if TRACE
Singleton <CodeProfiler> .instance.Stop("SpeedLimitManager.GetCustomSpeedLimit1");
#endif
return(ret);
}
public static float GetMaxSpeedLimit(ushort segmentID, NetInfo.Direction direction)
{
float ret = -1;
foreach (var lane in NetUtil.IterateSegmentLanes(segmentID))
{
if (lane.IsSpeedLane() && lane.LaneInfo.m_finalDirection == direction)
{
ret = Mathf.Max(ret, lane.GetLaneSpeedLimit());
}
}
return(ret);
}
public bool GetTrafficData(ushort segmentId, NetInfo.Direction dir, out SegmentDirTrafficData trafficData)
{
if (segmentDirTrafficData[segmentId] == null)
{
trafficData = defaultSegmentDirTrafficData;
return(false);
}
else
{
trafficData = segmentDirTrafficData[segmentId][GetDirIndex(dir)];
return(true);
}
}
public int CountLanes(NetInfo.Direction dir)
{
int laneCount = 0;
for (int i = 0; i < currentSegment.Info.m_lanes.Length; i++)
{
if (currentSegment.Info.m_lanes[i].m_laneType == NetInfo.LaneType.Vehicle && currentSegment.Info.m_lanes[i].m_direction == dir)
{
laneCount++;
}
}
return(laneCount);
}
private void RenderRoadParkings(RenderManager.CameraInfo cameraInfo)
{
NetLane[] laneBuffer = NetManager.instance.m_lanes.m_buffer;
bool LaneVisitor(SegmentLaneVisitData data)
{
ushort segmentId = data.SegVisitData.CurSeg.segmentId;
int laneIndex = data.CurLanePos.laneIndex;
NetInfo.Lane laneInfo = segmentId.ToSegment().Info.m_lanes[laneIndex];
NetInfo.Direction finalDirection = laneInfo.m_finalDirection;
if (!data.SegVisitData.Initial)
{
bool reverse =
data.SegVisitData.ViaStartNode ==
data.SegVisitData.ViaInitialStartNode;
bool invert1 = segmentId.ToSegment().m_flags.IsFlagSet(NetSegment.Flags.Invert);
bool invert2 = renderInfo_.SegmentId.ToSegment().m_flags.IsFlagSet(NetSegment.Flags.Invert);
bool invert = invert1 != invert2;
if (reverse ^ invert)
{
finalDirection = NetInfo.InvertDirection(finalDirection);
}
}
if (finalDirection == renderInfo_.FinalDirection)
{
bool pressed = Input.GetMouseButton(0);
Color color = MainTool.GetToolColor(pressed, false);
uint otherLaneId = data.CurLanePos.laneId;
var laneMarker = new SegmentLaneMarker(laneBuffer[otherLaneId].m_bezier);
laneMarker.RenderOverlay(cameraInfo, color, enlarge: pressed);
}
return(true);
}
SegmentLaneTraverser.Traverse(
renderInfo_.SegmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentLaneTraverser.LaneStopCriterion.LaneCount,
SegmentTraverser.SegmentStopCriterion.Junction,
ParkingRestrictionsManager.LANE_TYPES,
ParkingRestrictionsManager.VEHICLE_TYPES,
LaneVisitor);
}
public bool SetParkingAllowed(ushort segmentId, NetInfo.Direction finalDir, bool flag)
{
#if DEBUG
if (DebugSwitch.BasicParkingAILog.Get())
{
if (finalDir != NetInfo.Direction.Forward &&
finalDir != NetInfo.Direction.Backward)
{
Log.Error($"bad parking direction: {finalDir} expected forward or backward");
}
foreach (var lane in segmentId.ToSegment().Info.m_lanes)
{
if (lane.m_laneType.IsFlagSet(NetInfo.LaneType.Parking) &&
lane.m_finalDirection != NetInfo.Direction.Forward &&
lane.m_finalDirection != NetInfo.Direction.Backward)
{
Log.Error($"parking lane with bad m_finalDirection:{lane.m_finalDirection}, expected forward or backward");
}
}
}
#endif
if (!MayHaveParkingRestriction(segmentId))
{
return(false);
}
int dirIndex = GetDirIndex(finalDir);
parkingAllowed[segmentId][dirIndex] = flag;
if (!flag || !parkingAllowed[segmentId][1 - dirIndex])
{
Services.SimulationService.AddAction(
() => {
// force relocation of illegaly parked vehicles
Services.NetService.ProcessSegment(
segmentId,
(ushort segId, ref NetSegment segment) => {
segment.UpdateSegment(segmentId);
return(true);
});
});
}
return(true);
}
private static void UpdateLaneMarker(NetLane.Flags flag, NetInfo.Direction direction, NetSegment segment)
{
NetManager netManager = NetManager.instance;
NetLane currentLane = netManager.m_lanes.m_buffer[segment.m_lanes];
ulong laneID = segment.m_lanes;
for (int i = 0; i < segment.Info.m_lanes.Length; i++)
{
if (segment.Info.m_lanes[i].m_direction == direction && segment.Info.m_lanes[i].m_laneType == NetInfo.LaneType.Vehicle && ((NetLane.Flags)currentLane.m_flags & flag) == flag)
{
NetLane.Flags newFlags = (NetLane.Flags)currentLane.m_flags;
newFlags &= ~flag;
newFlags |= NetLane.Flags.Forward;
netManager.m_lanes.m_buffer[laneID].m_flags = (ushort)newFlags;
}
laneID = currentLane.m_nextLane;
currentLane = netManager.m_lanes.m_buffer[currentLane.m_nextLane];
}
}
internal static void CalculateSegmentCenterByDir(ushort segmentId, Dictionary <NetInfo.Direction, Vector3> segmentCenterByDir)
{
segmentCenterByDir.Clear();
NetInfo segmentInfo = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
Dictionary <NetInfo.Direction, int> numCentersByDir = new Dictionary <NetInfo.Direction, int>();
uint laneIndex = 0;
while (laneIndex < segmentInfo.m_lanes.Length && curLaneId != 0u)
{
if ((segmentInfo.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None)
{
goto nextIter;
}
NetInfo.Direction dir = segmentInfo.m_lanes[laneIndex].m_finalDirection;
Vector3 bezierCenter = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_bezier.Position(0.5f);
if (!segmentCenterByDir.ContainsKey(dir))
{
segmentCenterByDir[dir] = bezierCenter;
numCentersByDir[dir] = 1;
}
else
{
segmentCenterByDir[dir] += bezierCenter;
numCentersByDir[dir]++;
}
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
foreach (KeyValuePair <NetInfo.Direction, int> e in numCentersByDir)
{
segmentCenterByDir[e.Key] /= (float)e.Value;
}
}
public void DirectionSelectButtons(NetSegment currentSegment, NetInfo.Direction dir, float y)
{
float columnOffset = 0f;
uint currentLane = currentSegment.m_lanes;
for (int i = 0; i < currentSegment.Info.m_lanes.Length; i++)
{
if (currentSegment.Info.m_lanes[i].m_laneType == NetInfo.LaneType.Vehicle && currentSegment.Info.m_lanes[i].m_direction == dir)
{
LaneDirectionToggleButton leftToggleButton = this.AddUIComponent <LaneDirectionToggleButton>();
leftToggleButton.DrawButton(currentLane, NetLane.Flags.Left, new Vector3(5f + columnOffset, 5f + y));
LaneDirectionToggleButton forwardToggleButton = this.AddUIComponent <LaneDirectionToggleButton>();
forwardToggleButton.DrawButton(currentLane, NetLane.Flags.Forward, new Vector3(40f + columnOffset, 5f + y));
LaneDirectionToggleButton rightToggleButton = this.AddUIComponent <LaneDirectionToggleButton>();
rightToggleButton.DrawButton(currentLane, NetLane.Flags.Right, new Vector3(75f + columnOffset, 5f + y));
columnOffset += 120f;
}
currentLane = NetManager.instance.m_lanes.m_buffer[currentLane].m_nextLane;
}
}
/// <summary>
/// Sets the speed limit of a given segment and lane direction.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="finalDir"></param>
/// <param name="speedLimit"></param>
/// <returns></returns>
public bool SetSpeedLimit(ushort segmentId, NetInfo.Direction finalDir, ushort speedLimit)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("SpeedLimitManager.SetSpeedLimit");
#endif
if (segmentId == 0 || !AvailableSpeedLimits.Contains(speedLimit) || (Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created) == NetSegment.Flags.None)
{
#if TRACE
Singleton <CodeProfiler> .instance.Stop("SpeedLimitManager.SetSpeedLimit");
#endif
return(false);
}
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int laneIndex = 0;
while (laneIndex < Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes.Length && curLaneId != 0u)
{
NetInfo.Direction d = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes[laneIndex].m_finalDirection;
if ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None || d != finalDir)
{
goto nextIter;
}
#if DEBUG
Log._Debug($"SpeedLimitManager: Setting speed limit of lane {curLaneId} to {speedLimit}");
#endif
Flags.setLaneSpeedLimit(curLaneId, speedLimit);
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
#if TRACE
Singleton <CodeProfiler> .instance.Stop("SpeedLimitManager.SetSpeedLimit");
#endif
return(true);
}
/// <summary>
/// Determines the average default speed limit for a given NetInfo object in terms of discrete speed limit levels.
/// An in-game speed limit of 2.0 (e.g. on highway) is hereby translated into a discrete speed limit value of 100 (km/h).
/// </summary>
/// <param name="segmentInfo"></param>
/// <param name="dir"></param>
/// <returns></returns>
public static ushort GetAverageDefaultCustomSpeedLimit(NetInfo segmentInfo, NetInfo.Direction?dir = null)
{
// calculate the currently set mean speed limit
float meanSpeedLimit = 0f;
uint validLanes = 0;
for (int i = 0; i < segmentInfo.m_lanes.Length; ++i)
{
NetInfo.Direction d = segmentInfo.m_lanes[i].m_direction;
if ((segmentInfo.m_lanes[i].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None || (dir != null && d != dir))
{
continue;
}
meanSpeedLimit += segmentInfo.m_lanes[i].m_speedLimit;
++validLanes;
}
if (validLanes > 0)
{
meanSpeedLimit /= (float)validLanes;
}
return(ToCustomSpeedLimit(meanSpeedLimit));
}
/// <summary>
/// Sets the speed limit of a given segment and lane direction.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="dir"></param>
/// <param name="speedLimit"></param>
/// <returns></returns>
public static bool SetSpeedLimit(ushort segmentId, NetInfo.Direction dir, ushort speedLimit)
{
if (segmentId == 0)
{
return(false);
}
if (!AvailableSpeedLimits.Contains(speedLimit))
{
return(false);
}
if ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created) == NetSegment.Flags.None)
{
return(false);
}
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int laneIndex = 0;
while (laneIndex < Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes.Length && curLaneId != 0u)
{
NetInfo.Direction d = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes[laneIndex].m_direction;
if ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) == NetInfo.LaneType.None || d != dir)
{
goto nextIter;
}
Log._Debug($"SpeedLimitManager: Setting speed limit of lane {curLaneId} to {speedLimit}");
Flags.setLaneSpeedLimit(curLaneId, speedLimit);
nextIter:
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
return(true);
}
private void RenderSegmentsSide(RenderManager.CameraInfo cameraInfo)
{
if (!MultiSegmentMode)
{
RenderSegmentSideOverlay(cameraInfo, renderData_.SegmentId, renderData_.FinalDirection);
}
else
{
SegmentTraverser.Traverse(
renderData_.SegmentId,
SegmentTraverser.TraverseDirection.AnyDirection,
SegmentTraverser.TraverseSide.AnySide,
SegmentTraverser.SegmentStopCriterion.Junction,
data => {
NetInfo.Direction finalDirection = renderData_.FinalDirection;
if (data.IsReversed(renderData_.SegmentId))
{
finalDirection = NetInfo.InvertDirection(finalDirection);
}
RenderSegmentSideOverlay(cameraInfo, data.CurSeg.segmentId, finalDirection);
return(true);
});
}
}
static void Postfix(Vector3 position, ref PathUnit.Position pathPosA, VehicleInfo.VehicleType stopType)
{
NetSegment segment = Singleton <NetManager> .instance.m_segments.m_buffer[pathPosA.m_segment];
int stop = pathPosA.m_lane;
if (stopType == VehicleInfo.VehicleType.Car && stop > 1)
{
segment.GetClosestLanePosition(position, NetInfo.LaneType.Vehicle, stopType, out Vector3 pos, out uint laneID, out int laneindex, out float laneOffset);
NetInfo.Direction dir = segment.Info.m_lanes[laneindex].m_direction;
int stopLane = Array.FindIndex(segment.Info.m_sortedLanes, s => s == stop);
int drivingLane = Array.FindIndex(segment.Info.m_sortedLanes, s => s == laneindex);
if (dir == NetInfo.Direction.Backward && stopLane > drivingLane)
{
pathPosA.m_lane = (byte)segment.Info.m_sortedLanes[drivingLane - 1];
}
else if (dir == NetInfo.Direction.Forward && stopLane < drivingLane)
{
pathPosA.m_lane = (byte)segment.Info.m_sortedLanes[drivingLane + 1];
}
}
}
public LaneRestrictions(uint laneid, int laneNum, NetInfo.Direction dir)
{
this.laneID = laneid;
this.laneNum = laneNum;
this.direction = dir;
}
public LaneRestrictions(uint laneid, int laneNum, NetInfo.Direction dir)
{
LaneId = laneid;
LaneNum = laneNum;
Direction = dir;
}
