internal static bool mayHaveLaneArrows(uint laneId, bool?startNode = null)
{
if (laneId <= 0)
{
return(false);
}
NetManager netManager = Singleton <NetManager> .instance;
if (((NetLane.Flags)Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags & (NetLane.Flags.Created | NetLane.Flags.Deleted)) != NetLane.Flags.Created)
{
return(false);
}
ushort segmentId = netManager.m_lanes.m_buffer[laneId].m_segment;
var dir = NetInfo.Direction.Forward;
var dir2 = ((netManager.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection(dir);
var dir3 = TrafficPriority.IsLeftHandDrive() ? NetInfo.InvertDirection(dir2) : dir2;
NetInfo segmentInfo = netManager.m_segments.m_buffer[segmentId].Info;
uint curLaneId = netManager.m_segments.m_buffer[segmentId].m_lanes;
int numLanes = segmentInfo.m_lanes.Length;
int laneIndex = 0;
int wIter = 0;
while (laneIndex < numLanes && curLaneId != 0u)
{
++wIter;
if (wIter >= 20)
{
Log.Error("Too many iterations in Flags.mayHaveLaneArrows!");
break;
}
if (curLaneId == laneId)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
bool isStartNode = laneInfo.m_direction != dir3;
if (startNode != null && isStartNode != startNode)
{
return(false);
}
ushort nodeId = isStartNode ? netManager.m_segments.m_buffer[segmentId].m_startNode : netManager.m_segments.m_buffer[segmentId].m_endNode;
if ((netManager.m_nodes.m_buffer[nodeId].m_flags & (NetNode.Flags.Created | NetNode.Flags.Deleted)) != NetNode.Flags.Created)
{
return(false);
}
return((netManager.m_nodes.m_buffer[nodeId].m_flags & NetNode.Flags.Junction) != NetNode.Flags.None);
}
curLaneId = netManager.m_lanes.m_buffer[curLaneId].m_nextLane;
++laneIndex;
}
return(false);
}
internal static List <object[]> GetSortedVehicleLanes(ushort segmentId, NetInfo info, ushort?nodeId) // TODO refactor together with getSegmentNumVehicleLanes, especially the vehicle type and lane type checks
{
var laneList = new List <object[]>();
NetInfo.Direction?dir = null;
NetInfo.Direction?dir2 = null;
NetInfo.Direction?dir3 = null;
if (nodeId != null)
{
dir = nodeId == Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_startNode ? NetInfo.Direction.Backward : NetInfo.Direction.Forward;
dir2 = ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection((NetInfo.Direction)dir);
dir3 = TrafficPriority.IsLeftHandDrive() ? NetInfo.InvertDirection((NetInfo.Direction)dir2) : dir2;
}
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
uint laneIndex = 0;
while (laneIndex < info.m_lanes.Length && curLaneId != 0u)
{
if ((info.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != NetInfo.LaneType.None &&
(info.m_lanes[laneIndex].m_vehicleType & (VehicleInfo.VehicleType.Car | VehicleInfo.VehicleType.Train)) != VehicleInfo.VehicleType.None &&
(dir2 == null || info.m_lanes[laneIndex].m_finalDirection == dir2))
{
laneList.Add(new object[] { curLaneId, info.m_lanes[laneIndex].m_position, laneIndex });
}
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
laneIndex++;
}
// sort lanes from left to right
laneList.Sort(delegate(object[] x, object[] y) {
if ((float)x[1] == (float)y[1])
{
return(0);
}
if ((dir2 == NetInfo.Direction.Forward) ^ (float)x[1] < (float)y[1])
{
return(1);
}
return(-1);
});
return(laneList);
}
internal static int GetSegmentNumVehicleLanes(ushort segmentId, ushort?nodeId, out int numDirections)
{
var info = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
var num2 = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
var laneIndex = 0;
NetInfo.Direction?dir = null;
NetInfo.Direction?dir2 = null;
NetInfo.Direction?dir3 = null;
numDirections = 0;
HashSet <NetInfo.Direction> directions = new HashSet <NetInfo.Direction>();
if (nodeId != null)
{
dir = (Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_startNode == nodeId) ? NetInfo.Direction.Backward : NetInfo.Direction.Forward;
dir2 = ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? dir : NetInfo.InvertDirection((NetInfo.Direction)dir);
dir3 = TrafficPriority.IsLeftHandDrive() ? NetInfo.InvertDirection((NetInfo.Direction)dir2) : dir2;
}
var numLanes = 0;
while (laneIndex < info.m_lanes.Length && num2 != 0u)
{
if (((info.m_lanes[laneIndex].m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != NetInfo.LaneType.None &&
(info.m_lanes[laneIndex].m_vehicleType & (VehicleInfo.VehicleType.Car | VehicleInfo.VehicleType.Train)) != VehicleInfo.VehicleType.None) &&
(dir3 == null || info.m_lanes[laneIndex].m_direction == dir3))
{
if (!directions.Contains(info.m_lanes[laneIndex].m_direction))
{
directions.Add(info.m_lanes[laneIndex].m_direction);
++numDirections;
}
numLanes++;
}
num2 = Singleton <NetManager> .instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
laneIndex++;
}
return(numLanes);
}
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(out float wait, out float flow)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("TimedTrafficLightsStep.calcWaitFlow");
#endif
#if DEBUGMETRIC
bool debug = timedNode.NodeId == 3201;
#else
bool debug = false;
#endif
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: ***START*** @ node {timedNode.NodeId}");
}
#endif
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// we are the master node. calculate traffic data
foreach (ushort timedNodeId in timedNode.NodeGroup)
{
TrafficLightSimulation sim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
if (slaveTimedNode.NumSteps() <= timedNode.CurrentStep)
{
for (int i = 0; i < slaveTimedNode.NumSteps(); ++i)
{
slaveTimedNode.GetStep(i).invalid = true;
}
continue;
}
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[timedNode.CurrentStep];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var fromSegmentId = e.Key;
var segLights = e.Value;
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd fromSeg = TrafficPriority.GetPrioritySegment(timedNodeId, fromSegmentId);
if (fromSeg == null)
{
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: No priority segment @ seg. {fromSegmentId} found!");
}
#endif
//Log.Warning("stepDone(): prioSeg is null");
//segmentIdsToDelete.Add(fromSegmentId);
continue; // skip invalid segment
}
//bool startPhase = getCurrentFrame() <= startFrame + minTime + 2; // during start phase all vehicles on "green" segments are counted as flowing
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.GetAllowedVehicleTypes(fromSegmentId, timedNode.NodeId);
foreach (KeyValuePair <byte, ExtVehicleType> e2 in segLights.VehicleTypeByLaneIndex)
{
byte laneIndex = e2.Key;
ExtVehicleType vehicleType = e2.Value;
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(laneIndex);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {fromSegmentId}, node {timedNode.NodeId}!");
continue;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Checking lane {laneIndex} @ seg. {fromSegmentId}. Vehicle types: {vehicleType}");
}
#endif
Dictionary <ushort, uint> carsFlowingToSegmentMetric = null;
Dictionary <ushort, uint> allCarsToSegmentMetric = null;
try {
carsFlowingToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(false, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (1): " + ex.ToString());
}
try {
allCarsToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(true, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (2): " + ex.ToString());
}
if (carsFlowingToSegmentMetric == null)
{
continue;
}
// build directions from toSegment to fromSegment
Dictionary <ushort, Direction> directions = new Dictionary <ushort, Direction>();
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
var toSegmentId = f.Key;
SegmentGeometry geometry = SegmentGeometry.Get(fromSegmentId);
Direction dir = geometry.GetDirection(toSegmentId, timedNodeId == geometry.StartNodeId());
directions[toSegmentId] = dir;
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Calculated direction for seg. {fromSegmentId} -> seg. {toSegmentId}: {dir}");
}
#endif
}
// calculate waiting/flowing traffic
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
ushort toSegmentId = f.Key;
uint totalNormCarLength = f.Value;
uint totalFlowingNormCarLength = carsFlowingToSegmentMetric[f.Key];
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Total norm. car length of vehicles on lane {laneIndex} going to seg. {toSegmentId}: {totalNormCarLength}");
}
#endif
bool addToFlow = false;
switch (directions[toSegmentId])
{
case Direction.Turn:
addToFlow = TrafficPriority.IsLeftHandDrive() ? segLight.isRightGreen() : segLight.isLeftGreen();
break;
case Direction.Left:
addToFlow = segLight.isLeftGreen();
break;
case Direction.Right:
addToFlow = segLight.isRightGreen();
break;
case Direction.Forward:
default:
addToFlow = segLight.isForwardGreen();
break;
}
if (addToFlow)
{
++numFlows;
curMeanFlow += totalFlowingNormCarLength;
}
else
{
++numWaits;
curMeanWait += totalNormCarLength;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Vehicles on lane {laneIndex} on seg. {fromSegmentId} going to seg. {toSegmentId} flowing? {addToFlow} curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
#endif
}
}
}
// delete invalid segments from step
/*foreach (int segmentId in segmentIdsToDelete) {
* slaveStep.segmentLightStates.Remove(segmentId);
* }*/
if (slaveStep.segmentLights.Count <= 0)
{
invalid = true;
flow = 0f;
wait = 0f;
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(false);
}
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: ### Calculation completed. numFlows={numFlows}, numWaits={numWaits}, curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
wait = curMeanWait;
flow = curMeanFlow;
#else
if (numFlows > 0)
{
curMeanFlow /= numFlows;
}
if (numWaits > 0)
{
curMeanWait /= numWaits;
}
float fCurMeanFlow = curMeanFlow;
fCurMeanFlow /= waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)curMeanWait;
flow = fCurMeanFlow;
#endif
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(true);
}
private static void GetCustomTrafficLightState(ushort vehicleId, ref Vehicle vehicleData, ushort nodeId, ushort fromSegmentId, ushort toSegmentId, out RoadBaseAI.TrafficLightState vehicleLightState, out RoadBaseAI.TrafficLightState pedestrianLightState, TrafficLightSimulation nodeSim = null)
{
if (nodeSim == null)
{
nodeSim = TrafficLightSimulation.GetNodeSimulation(nodeId);
if (nodeSim == null)
{
Log.Error($"GetCustomTrafficLightState: node traffic light simulation not found at node {nodeId}! Vehicle {vehicleId} comes from segment {fromSegmentId} and goes to node {nodeId}");
throw new ApplicationException($"GetCustomTrafficLightState: node traffic light simulation not found at node {nodeId}! Vehicle {vehicleId} comes from segment {fromSegmentId} and goes to node {nodeId}");
}
}
// get vehicle position
/*VehiclePosition vehiclePos = TrafficPriority.GetVehiclePosition(vehicleId);
* if (!vehiclePos.Valid || vehiclePos.FromSegment != fromSegmentId || vehiclePos.ToNode != nodeId) {
* Log._Debug($"GetTrafficLightState: Recalculating position for vehicle {vehicleId}! FromSegment={vehiclePos.FromSegment} Valid={vehiclePos.Valid}");
* try {
* HandleVehicle(vehicleId, ref Singleton<VehicleManager>.instance.m_vehicles.m_buffer[vehicleId], false, false);
* } catch (Exception e) {
* Log.Error("VehicleAI GetTrafficLightState Error: " + e.ToString());
* }
* }
*
* if (!vehiclePos.Valid || vehiclePos.FromSegment != fromSegmentId || vehiclePos.ToNode != nodeId) {
* Log.Warning($"GetTrafficLightState: Vehicle {vehicleId} is not moving at segment {fromSegmentId} to node {nodeId}! FromSegment={vehiclePos.FromSegment} ToNode={vehiclePos.ToNode} Valid={vehiclePos.Valid}");
* vehicleLightState = RoadBaseAI.TrafficLightState.Red;
* pedestrianLightState = RoadBaseAI.TrafficLightState.Red;
* return;
* }*/
// get vehicle type
ExtVehicleType?vehicleType = CustomVehicleAI.DetermineVehicleTypeFromVehicle(vehicleId, ref vehicleData);
if (vehicleData.Info.m_vehicleType == VehicleInfo.VehicleType.Tram && vehicleType != ExtVehicleType.Tram)
{
Log.Warning($"vehicleType={vehicleType} ({(int)vehicleType}) for Tram");
}
//Log._Debug($"GetCustomTrafficLightState: Vehicle {vehicleId} is a {vehicleType}");
if (vehicleType == null)
{
Log.Warning($"GetTrafficLightState: Could not determine vehicle type of vehicle {vehicleId}!");
vehicleLightState = RoadBaseAI.TrafficLightState.Red;
pedestrianLightState = RoadBaseAI.TrafficLightState.Red;
return;
}
// get responsible traffic light
CustomSegmentLights lights = CustomTrafficLights.GetSegmentLights(nodeId, fromSegmentId);
CustomSegmentLight light = lights == null ? null : lights.GetCustomLight((ExtVehicleType)vehicleType);
if (lights == null || light == null)
{
Log.Warning($"GetTrafficLightState: No custom light for vehicleType {vehicleType} @ node {nodeId}, segment {fromSegmentId} found. lights null? {lights == null} light null? {light == null}");
vehicleLightState = RoadBaseAI.TrafficLightState.Red;
pedestrianLightState = RoadBaseAI.TrafficLightState.Red;
return;
}
SegmentGeometry geometry = CustomRoadAI.GetSegmentGeometry(fromSegmentId);
// get traffic light state from responsible traffic light
if (toSegmentId == fromSegmentId)
{
vehicleLightState = TrafficPriority.IsLeftHandDrive() ? light.GetLightRight() : light.GetLightLeft();
}
else if (geometry.IsLeftSegment(toSegmentId, nodeId))
{
vehicleLightState = light.GetLightLeft();
}
else if (geometry.IsRightSegment(toSegmentId, nodeId))
{
vehicleLightState = light.GetLightRight();
}
else
{
vehicleLightState = light.GetLightMain();
}
// get traffic lights state for pedestrians
pedestrianLightState = (lights.PedestrianLightState != null) ? (RoadBaseAI.TrafficLightState)lights.PedestrianLightState : RoadBaseAI.TrafficLightState.Red;
}