private void ProcessItem(CustomPathFind.BufferItem item, ushort nodeID, ref NetNode node, byte connectOffset, bool isMiddle)
{
NetManager instance = Singleton<NetManager>.instance;
bool flag = false;
bool flag2 = false;
int num = 0;
NetInfo info = instance.m_segments.m_buffer[(int)item.m_position.m_segment].Info;
if ((int)item.m_position.m_lane < info.m_lanes.Length)
{
NetInfo.Lane lane = info.m_lanes[(int)item.m_position.m_lane];
flag = (lane.m_laneType == NetInfo.LaneType.Pedestrian);
flag2 = (lane.m_laneType == NetInfo.LaneType.Vehicle && lane.m_vehicleType == VehicleInfo.VehicleType.Bicycle);
if ((byte)(lane.m_finalDirection & NetInfo.Direction.Forward) != 0)
{
num = lane.m_similarLaneIndex;
}
else
{
num = lane.m_similarLaneCount - lane.m_similarLaneIndex - 1;
}
}
if (isMiddle)
{
for (int i = 0; i < 8; i++)
{
ushort segment = node.GetSegment(i);
if (segment != 0)
{
this.ProcessItem(item, nodeID, segment, ref instance.m_segments.m_buffer[(int)segment], ref num, connectOffset, !flag, flag);
}
}
}
else if (flag)
{
ushort segment2 = item.m_position.m_segment;
int lane2 = (int)item.m_position.m_lane;
if (node.Info.m_class.m_service != ItemClass.Service.Beautification)
{
bool flag3 = (node.m_flags & (NetNode.Flags.End | NetNode.Flags.Bend | NetNode.Flags.Junction)) != NetNode.Flags.None;
int laneIndex;
int laneIndex2;
uint num2;
uint num3;
instance.m_segments.m_buffer[(int)segment2].GetLeftAndRightLanes(nodeID, NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, lane2, out laneIndex, out laneIndex2, out num2, out num3);
ushort num4 = segment2;
ushort num5 = segment2;
if (num2 == 0u || num3 == 0u)
{
ushort leftSegment;
ushort rightSegment;
instance.m_segments.m_buffer[(int)segment2].GetLeftAndRightSegments(nodeID, out leftSegment, out rightSegment);
int num6 = 0;
while (leftSegment != 0 && leftSegment != segment2 && num2 == 0u)
{
int num7;
int num8;
uint num9;
uint num10;
instance.m_segments.m_buffer[(int)leftSegment].GetLeftAndRightLanes(nodeID, NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, -1, out num7, out num8, out num9, out num10);
if (num10 != 0u)
{
num4 = leftSegment;
laneIndex = num8;
num2 = num10;
}
else
{
leftSegment = instance.m_segments.m_buffer[(int)leftSegment].GetLeftSegment(nodeID);
}
if (++num6 == 8)
{
break;
}
}
num6 = 0;
while (rightSegment != 0 && rightSegment != segment2 && num3 == 0u)
{
int num11;
int num12;
uint num13;
uint num14;
instance.m_segments.m_buffer[(int)rightSegment].GetLeftAndRightLanes(nodeID, NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, -1, out num11, out num12, out num13, out num14);
if (num13 != 0u)
{
num5 = rightSegment;
laneIndex2 = num11;
num3 = num13;
}
else
{
rightSegment = instance.m_segments.m_buffer[(int)rightSegment].GetRightSegment(nodeID);
}
if (++num6 == 8)
{
break;
}
}
}
if (num2 != 0u && (num4 != segment2 || flag3))
{
this.ProcessItem(item, nodeID, num4, ref instance.m_segments.m_buffer[(int)num4], connectOffset, laneIndex, num2);
}
if (num3 != 0u && num3 != num2 && (num5 != segment2 || flag3))
{
this.ProcessItem(item, nodeID, num5, ref instance.m_segments.m_buffer[(int)num5], connectOffset, laneIndex2, num3);
}
int laneIndex3;
uint lane3;
if ((this.m_vehicleTypes & VehicleInfo.VehicleType.Bicycle) != VehicleInfo.VehicleType.None && instance.m_segments.m_buffer[(int)segment2].GetClosestLane((int)item.m_position.m_lane, NetInfo.LaneType.Vehicle, VehicleInfo.VehicleType.Bicycle, out laneIndex3, out lane3))
{
this.ProcessItem(item, nodeID, segment2, ref instance.m_segments.m_buffer[(int)segment2], connectOffset, laneIndex3, lane3);
}
}
else
{
for (int j = 0; j < 8; j++)
{
ushort segment3 = node.GetSegment(j);
if (segment3 != 0 && segment3 != segment2)
{
this.ProcessItem(item, nodeID, segment3, ref instance.m_segments.m_buffer[(int)segment3], ref num, connectOffset, false, true);
}
}
}
NetInfo.LaneType laneType = this.m_laneTypes & ~NetInfo.LaneType.Pedestrian;
VehicleInfo.VehicleType vehicleType = this.m_vehicleTypes & ~VehicleInfo.VehicleType.Bicycle;
if ((item.m_lanesUsed & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != 0)
{
laneType &= ~(NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle);
}
int num15;
uint lane4;
if (laneType != NetInfo.LaneType.None && vehicleType != VehicleInfo.VehicleType.None && instance.m_segments.m_buffer[(int)segment2].GetClosestLane(lane2, laneType, vehicleType, out num15, out lane4))
{
NetInfo.Lane lane5 = info.m_lanes[num15];
byte connectOffset2;
if ((instance.m_segments.m_buffer[(int)segment2].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None == ((byte)(lane5.m_finalDirection & NetInfo.Direction.Backward) != 0))
{
connectOffset2 = 1;
}
else
{
connectOffset2 = 254;
}
this.ProcessItem(item, nodeID, segment2, ref instance.m_segments.m_buffer[(int)segment2], connectOffset2, num15, lane4);
}
}
else
{
bool flag4 = (node.m_flags & (NetNode.Flags.End | NetNode.Flags.OneWayOut)) != NetNode.Flags.None;
bool flag5 = (byte)(this.m_laneTypes & NetInfo.LaneType.Pedestrian) != 0;
bool enablePedestrian = false;
byte connectOffset3 = 0;
if (flag5)
{
if (flag2)
{
connectOffset3 = connectOffset;
enablePedestrian = (node.Info.m_class.m_service == ItemClass.Service.Beautification);
}
else if (this.m_vehicleLane != 0u)
{
if (this.m_vehicleLane != item.m_laneID)
{
flag5 = false;
}
else
{
connectOffset3 = this.m_vehicleOffset;
}
}
else if (this.m_stablePath)
{
connectOffset3 = 128;
}
else
{
connectOffset3 = (byte)this.m_pathRandomizer.UInt32(1u, 254u);
}
}
ushort num16 = instance.m_segments.m_buffer[(int)item.m_position.m_segment].GetRightSegment(nodeID);
for (int k = 0; k < 8; k++)
{
if (num16 == 0 || num16 == item.m_position.m_segment)
{
break;
}
if (this.ProcessItem(item, nodeID, num16, ref instance.m_segments.m_buffer[(int)num16], ref num, connectOffset, true, enablePedestrian))
{
flag4 = true;
}
num16 = instance.m_segments.m_buffer[(int)num16].GetRightSegment(nodeID);
}
if (flag4)
{
num16 = item.m_position.m_segment;
this.ProcessItem(item, nodeID, num16, ref instance.m_segments.m_buffer[(int)num16], ref num, connectOffset, true, false);
}
if (flag5)
{
num16 = item.m_position.m_segment;
int laneIndex4;
uint lane6;
if (instance.m_segments.m_buffer[(int)num16].GetClosestLane((int)item.m_position.m_lane, NetInfo.LaneType.Pedestrian, this.m_vehicleTypes, out laneIndex4, out lane6))
{
this.ProcessItem(item, nodeID, num16, ref instance.m_segments.m_buffer[(int)num16], connectOffset3, laneIndex4, lane6);
}
}
}
if (node.m_lane != 0u)
{
bool targetDisabled = (node.m_flags & NetNode.Flags.Disabled) != NetNode.Flags.None;
ushort segment4 = instance.m_lanes.m_buffer[(int)((UIntPtr)node.m_lane)].m_segment;
if (segment4 != 0 && segment4 != item.m_position.m_segment)
{
this.ProcessItem(item, nodeID, targetDisabled, segment4, ref instance.m_segments.m_buffer[(int)segment4], node.m_lane, node.m_laneOffset, connectOffset);
}
}
}
private void AddBufferItem(CustomPathFind.BufferItem item, PathUnit.Position target)
{
uint num = this.m_laneLocation[(int)((UIntPtr)item.m_laneID)];
uint num2 = num >> 16;
int num3 = (int)(num & 65535u);
int num6;
if (num2 == this.m_pathFindIndex)
{
if (item.m_comparisonValue >= this.m_buffer[num3].m_comparisonValue)
{
return;
}
int num4 = num3 >> 6;
int num5 = num3 & -64;
if (num4 < this.m_bufferMinPos || (num4 == this.m_bufferMinPos && num5 < this.m_bufferMin[num4]))
{
return;
}
num6 = Mathf.Max(Mathf.RoundToInt(item.m_comparisonValue * 1024f), this.m_bufferMinPos);
if (num6 == num4)
{
this.m_buffer[num3] = item;
this.m_laneTarget[(int)((UIntPtr)item.m_laneID)] = target;
return;
}
int num7 = num4 << 6 | this.m_bufferMax[num4]--;
CustomPathFind.BufferItem bufferItem = this.m_buffer[num7];
this.m_laneLocation[(int)((UIntPtr)bufferItem.m_laneID)] = num;
this.m_buffer[num3] = bufferItem;
}
else
{
num6 = Mathf.Max(Mathf.RoundToInt(item.m_comparisonValue * 1024f), this.m_bufferMinPos);
}
if (num6 >= 1024)
{
return;
}
while (this.m_bufferMax[num6] == 63)
{
num6++;
if (num6 == 1024)
{
return;
}
}
if (num6 > this.m_bufferMaxPos)
{
this.m_bufferMaxPos = num6;
}
num3 = (num6 << 6 | ++this.m_bufferMax[num6]);
this.m_buffer[num3] = item;
this.m_laneLocation[(int)((UIntPtr)item.m_laneID)] = (this.m_pathFindIndex << 16 | (uint)num3);
this.m_laneTarget[(int)((UIntPtr)item.m_laneID)] = target;
}
private bool ProcessItem(CustomPathFind.BufferItem item, ushort targetNode, ushort segmentID, ref NetSegment segment, ref int currentTargetIndex, byte connectOffset, bool enableVehicle, bool enablePedestrian)
{
bool result = false;
if ((segment.m_flags & (NetSegment.Flags.PathFailed | NetSegment.Flags.Flooded)) != NetSegment.Flags.None)
{
return result;
}
NetManager instance = Singleton<NetManager>.instance;
NetInfo info = segment.Info;
NetInfo info2 = instance.m_segments.m_buffer[(int)item.m_position.m_segment].Info;
int num = info.m_lanes.Length;
uint num2 = segment.m_lanes;
NetInfo.Direction direction = (targetNode != segment.m_startNode) ? NetInfo.Direction.Forward : NetInfo.Direction.Backward;
NetInfo.Direction direction2 = ((segment.m_flags & NetSegment.Flags.Invert) == NetSegment.Flags.None) ? direction : NetInfo.InvertDirection(direction);
float num3 = 0.01f - Mathf.Min(info.m_maxTurnAngleCos, info2.m_maxTurnAngleCos);
if (num3 < 1f)
{
Vector3 vector;
if (targetNode == instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_startNode)
{
vector = instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_startDirection;
}
else
{
vector = instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_endDirection;
}
Vector3 vector2;
if ((byte)(direction & NetInfo.Direction.Forward) != 0)
{
vector2 = segment.m_endDirection;
}
else
{
vector2 = segment.m_startDirection;
}
float num4 = vector.x * vector2.x + vector.z * vector2.z;
if (num4 >= num3)
{
return result;
}
}
float num5 = 1f;
float num6 = 1f;
NetInfo.LaneType laneType = NetInfo.LaneType.None;
VehicleInfo.VehicleType vehicleType = VehicleInfo.VehicleType.None;
if ((int)item.m_position.m_lane < info2.m_lanes.Length)
{
NetInfo.Lane lane = info2.m_lanes[(int)item.m_position.m_lane];
laneType = lane.m_laneType;
vehicleType = lane.m_vehicleType;
num5 = lane.m_speedLimit;
num6 = this.CalculateLaneSpeed(connectOffset, item.m_position.m_offset, ref instance.m_segments.m_buffer[(int)item.m_position.m_segment], lane);
}
float num7 = instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_averageLength;
if (!this.m_stablePath)
{
Randomizer randomizer = new Randomizer(this.m_pathFindIndex << 16 | (uint)item.m_position.m_segment);
num7 *= (float)(randomizer.Int32(900, 1000 + (int)(instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_trafficDensity * 10)) + this.m_pathRandomizer.Int32(20u)) * 0.001f;
}
if (this.m_isHeavyVehicle && (instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_flags & NetSegment.Flags.HeavyBan) != NetSegment.Flags.None)
{
num7 *= 10f;
}
if (this.m_transportVehicle && laneType == NetInfo.LaneType.TransportVehicle)
{
num7 *= 0.95f;
}
if ((laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != 0)
{
laneType = (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle);
}
float num8 = (float)Mathf.Abs((int)(connectOffset - item.m_position.m_offset)) * 0.003921569f * num7;
float num9 = item.m_methodDistance + num8;
float num10 = item.m_comparisonValue + num8 / (num6 * this.m_maxLength);
Vector3 b = instance.m_lanes.m_buffer[(int)((UIntPtr)item.m_laneID)].CalculatePosition((float)connectOffset * 0.003921569f);
int num11 = currentTargetIndex;
bool flag = (instance.m_nodes.m_buffer[(int)targetNode].m_flags & NetNode.Flags.Transition) != NetNode.Flags.None;
NetInfo.LaneType laneType2 = this.m_laneTypes;
VehicleInfo.VehicleType vehicleType2 = this.m_vehicleTypes;
if (!enableVehicle)
{
vehicleType2 &= VehicleInfo.VehicleType.Bicycle;
if (vehicleType2 == VehicleInfo.VehicleType.None)
{
laneType2 &= ~(NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle);
}
}
if (!enablePedestrian)
{
laneType2 &= ~NetInfo.LaneType.Pedestrian;
}
int num12 = 0;
while (num12 < num && num2 != 0u)
{
NetInfo.Lane lane2 = info.m_lanes[num12];
if ((byte)(lane2.m_finalDirection & direction2) != 0 && (!m_obeyTMLanes || CSL_Traffic.RoadManager.CheckLaneConnection(num2, item.m_laneID, targetNode)))
{
if (lane2.CheckType(laneType2, vehicleType2) && (segmentID != item.m_position.m_segment || num12 != (int)item.m_position.m_lane) && (byte)(lane2.m_finalDirection & direction2) != 0)
{
Vector3 a;
if ((byte)(direction & NetInfo.Direction.Forward) != 0)
{
a = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_bezier.d;
}
else
{
a = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_bezier.a;
}
float num13 = Vector3.Distance(a, b);
if (flag)
{
num13 *= 2f;
}
/* ----- Congestion Changes ----- */
// Checks if the lane has space for a vehicle of length 5. If not, increase its cost to avoid it.
if (!instance.m_lanes.m_buffer[num2].CheckSpace(m_minLaneSpace)) // the length used here can be tweaked for different results. Haven't had time to test it yet
{
num13 *= m_congestionCostFactor; // the factor of cost increase can also be tweaked to achieve different results
}
/* ------------------------------ */
float num14 = num13 / ((num5 + lane2.m_speedLimit) * 0.5f * this.m_maxLength);
CustomPathFind.BufferItem item2;
item2.m_position.m_segment = segmentID;
item2.m_position.m_lane = (byte)num12;
item2.m_position.m_offset = (byte)(((direction & NetInfo.Direction.Forward) == 0) ? 0 : 255);
if ((lane2.m_laneType & laneType) == 0)
{
item2.m_methodDistance = 0f;
}
else
{
item2.m_methodDistance = num9 + num13;
}
if (lane2.m_laneType != NetInfo.LaneType.Pedestrian || item2.m_methodDistance < 1000f)
{
item2.m_comparisonValue = num10 + num14;
if (num2 == this.m_startLaneA)
{
float num15 = this.CalculateLaneSpeed(this.m_startOffsetA, item2.m_position.m_offset, ref segment, lane2);
float num16 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetA)) * 0.003921569f;
item2.m_comparisonValue += num16 * segment.m_averageLength / (num15 * this.m_maxLength);
}
if (num2 == this.m_startLaneB)
{
float num17 = this.CalculateLaneSpeed(this.m_startOffsetB, item2.m_position.m_offset, ref segment, lane2);
float num18 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetB)) * 0.003921569f;
item2.m_comparisonValue += num18 * segment.m_averageLength / (num17 * this.m_maxLength);
}
if (!this.m_ignoreBlocked && (segment.m_flags & NetSegment.Flags.Blocked) != NetSegment.Flags.None && (lane2.m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != 0)
{
item2.m_comparisonValue += 0.1f;
result = true;
}
item2.m_direction = direction;
item2.m_lanesUsed = (item.m_lanesUsed | lane2.m_laneType);
item2.m_laneID = num2;
if ((lane2.m_laneType & laneType) != 0 && lane2.m_vehicleType == vehicleType)
{
int firstTarget = (int)instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_firstTarget;
int lastTarget = (int)instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_lastTarget;
if (currentTargetIndex < firstTarget || currentTargetIndex >= lastTarget)
{
item2.m_comparisonValue += Mathf.Max(1f, num13 * 3f - 3f) / ((num5 + lane2.m_speedLimit) * 0.5f * this.m_maxLength);
}
if (!this.m_transportVehicle && lane2.m_laneType == NetInfo.LaneType.TransportVehicle)
{
item2.m_comparisonValue += 20f / ((num5 + lane2.m_speedLimit) * 0.5f * this.m_maxLength);
}
}
this.AddBufferItem(item2, item.m_position);
}
}
}
else if ((lane2.m_laneType & laneType) != 0 && lane2.m_vehicleType == vehicleType)
{
num11++;
}
num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
num12++;
}
currentTargetIndex = num11;
return result;
}
private void ProcessItem(CustomPathFind.BufferItem item, ushort targetNode, ushort segmentID, ref NetSegment segment, byte connectOffset, int laneIndex, uint lane)
{
if ((segment.m_flags & (NetSegment.Flags.PathFailed | NetSegment.Flags.Flooded)) != NetSegment.Flags.None)
{
return;
}
NetManager instance = Singleton<NetManager>.instance;
NetInfo info = segment.Info;
NetInfo info2 = instance.m_segments.m_buffer[(int)item.m_position.m_segment].Info;
int num = info.m_lanes.Length;
float num2;
byte offset;
if (segmentID == item.m_position.m_segment)
{
Vector3 b = instance.m_lanes.m_buffer[(int)((UIntPtr)item.m_laneID)].CalculatePosition((float)connectOffset * 0.003921569f);
Vector3 a = instance.m_lanes.m_buffer[(int)((UIntPtr)lane)].CalculatePosition((float)connectOffset * 0.003921569f);
num2 = Vector3.Distance(a, b);
offset = connectOffset;
}
else
{
NetInfo.Direction direction = (targetNode != segment.m_startNode) ? NetInfo.Direction.Forward : NetInfo.Direction.Backward;
Vector3 b2 = instance.m_lanes.m_buffer[(int)((UIntPtr)item.m_laneID)].CalculatePosition((float)connectOffset * 0.003921569f);
Vector3 a2;
if ((byte)(direction & NetInfo.Direction.Forward) != 0)
{
a2 = instance.m_lanes.m_buffer[(int)((UIntPtr)lane)].m_bezier.d;
}
else
{
a2 = instance.m_lanes.m_buffer[(int)((UIntPtr)lane)].m_bezier.a;
}
num2 = Vector3.Distance(a2, b2);
offset = (byte)(((direction & NetInfo.Direction.Forward) == 0) ? 0 : 255);
}
float num3 = 1f;
float num4 = 1f;
NetInfo.LaneType laneType = NetInfo.LaneType.None;
if ((int)item.m_position.m_lane < info2.m_lanes.Length)
{
NetInfo.Lane lane2 = info2.m_lanes[(int)item.m_position.m_lane];
num3 = lane2.m_speedLimit;
laneType = lane2.m_laneType;
if ((laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != 0)
{
laneType = (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle);
}
num4 = this.CalculateLaneSpeed(connectOffset, item.m_position.m_offset, ref instance.m_segments.m_buffer[(int)item.m_position.m_segment], lane2);
}
float averageLength = instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_averageLength;
float num5 = (float)Mathf.Abs((int)(connectOffset - item.m_position.m_offset)) * 0.003921569f * averageLength;
float num6 = item.m_methodDistance + num5;
float num7 = item.m_comparisonValue + num5 / (num4 * this.m_maxLength);
if (laneIndex < num)
{
NetInfo.Lane lane3 = info.m_lanes[laneIndex];
CustomPathFind.BufferItem item2;
item2.m_position.m_segment = segmentID;
item2.m_position.m_lane = (byte)laneIndex;
item2.m_position.m_offset = offset;
if ((lane3.m_laneType & laneType) == 0)
{
item2.m_methodDistance = 0f;
}
else
{
if (item.m_methodDistance == 0f)
{
num7 += 100f / (0.25f * this.m_maxLength);
}
item2.m_methodDistance = num6 + num2;
}
if (lane3.m_laneType != NetInfo.LaneType.Pedestrian || item2.m_methodDistance < 1000f)
{
item2.m_comparisonValue = num7 + num2 / ((num3 + lane3.m_speedLimit) * 0.25f * this.m_maxLength);
if (lane == this.m_startLaneA)
{
float num8 = this.CalculateLaneSpeed(this.m_startOffsetA, item2.m_position.m_offset, ref segment, lane3);
float num9 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetA)) * 0.003921569f;
item2.m_comparisonValue += num9 * segment.m_averageLength / (num8 * this.m_maxLength);
}
if (lane == this.m_startLaneB)
{
float num10 = this.CalculateLaneSpeed(this.m_startOffsetB, item2.m_position.m_offset, ref segment, lane3);
float num11 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetB)) * 0.003921569f;
item2.m_comparisonValue += num11 * segment.m_averageLength / (num10 * this.m_maxLength);
}
if ((segment.m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
item2.m_direction = NetInfo.InvertDirection(lane3.m_finalDirection);
}
else
{
item2.m_direction = lane3.m_finalDirection;
}
item2.m_laneID = lane;
item2.m_lanesUsed = (item.m_lanesUsed | lane3.m_laneType);
this.AddBufferItem(item2, item.m_position);
}
}
}
private void ProcessItem(CustomPathFind.BufferItem item, ushort targetNode, bool targetDisabled, ushort segmentID, ref NetSegment segment, uint lane, byte offset, byte connectOffset)
{
if ((segment.m_flags & (NetSegment.Flags.PathFailed | NetSegment.Flags.Flooded)) != NetSegment.Flags.None)
{
return;
}
NetManager instance = Singleton<NetManager>.instance;
if (targetDisabled && ((instance.m_nodes.m_buffer[(int)segment.m_startNode].m_flags | instance.m_nodes.m_buffer[(int)segment.m_endNode].m_flags) & NetNode.Flags.Disabled) == NetNode.Flags.None)
{
return;
}
NetInfo info = segment.Info;
NetInfo info2 = instance.m_segments.m_buffer[(int)item.m_position.m_segment].Info;
int num = info.m_lanes.Length;
uint num2 = segment.m_lanes;
float num3 = 1f;
float num4 = 1f;
NetInfo.LaneType laneType = NetInfo.LaneType.None;
if ((int)item.m_position.m_lane < info2.m_lanes.Length)
{
NetInfo.Lane lane2 = info2.m_lanes[(int)item.m_position.m_lane];
num3 = lane2.m_speedLimit;
laneType = lane2.m_laneType;
if ((laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle)) != 0)
{
laneType = (NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle);
}
num4 = this.CalculateLaneSpeed(connectOffset, item.m_position.m_offset, ref instance.m_segments.m_buffer[(int)item.m_position.m_segment], lane2);
}
float averageLength = instance.m_segments.m_buffer[(int)item.m_position.m_segment].m_averageLength;
float num5 = (float)Mathf.Abs((int)(connectOffset - item.m_position.m_offset)) * 0.003921569f * averageLength;
float num6 = item.m_methodDistance + num5;
float num7 = item.m_comparisonValue + num5 / (num4 * this.m_maxLength);
Vector3 b = instance.m_lanes.m_buffer[(int)((UIntPtr)item.m_laneID)].CalculatePosition((float)connectOffset * 0.003921569f);
int num8 = 0;
while (num8 < num && num2 != 0u)
{
if (lane == num2)
{
NetInfo.Lane lane3 = info.m_lanes[num8];
if (lane3.CheckType(this.m_laneTypes, this.m_vehicleTypes))
{
Vector3 a = instance.m_lanes.m_buffer[(int)((UIntPtr)lane)].CalculatePosition((float)offset * 0.003921569f);
float num9 = Vector3.Distance(a, b);
CustomPathFind.BufferItem item2;
item2.m_position.m_segment = segmentID;
item2.m_position.m_lane = (byte)num8;
item2.m_position.m_offset = offset;
if ((lane3.m_laneType & laneType) == 0)
{
item2.m_methodDistance = 0f;
}
else
{
item2.m_methodDistance = num6 + num9;
}
if (lane3.m_laneType != NetInfo.LaneType.Pedestrian || item2.m_methodDistance < 1000f)
{
item2.m_comparisonValue = num7 + num9 / ((num3 + lane3.m_speedLimit) * 0.5f * this.m_maxLength);
if (lane == this.m_startLaneA)
{
float num10 = this.CalculateLaneSpeed(this.m_startOffsetA, item2.m_position.m_offset, ref segment, lane3);
float num11 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetA)) * 0.003921569f;
item2.m_comparisonValue += num11 * segment.m_averageLength / (num10 * this.m_maxLength);
}
if (lane == this.m_startLaneB)
{
float num12 = this.CalculateLaneSpeed(this.m_startOffsetB, item2.m_position.m_offset, ref segment, lane3);
float num13 = (float)Mathf.Abs((int)(item2.m_position.m_offset - this.m_startOffsetB)) * 0.003921569f;
item2.m_comparisonValue += num13 * segment.m_averageLength / (num12 * this.m_maxLength);
}
if ((segment.m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
item2.m_direction = NetInfo.InvertDirection(lane3.m_finalDirection);
}
else
{
item2.m_direction = lane3.m_finalDirection;
}
item2.m_laneID = lane;
item2.m_lanesUsed = (item.m_lanesUsed | lane3.m_laneType);
this.AddBufferItem(item2, item.m_position);
}
}
return;
}
num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)num2)].m_nextLane;
num8++;
}
}
