public ExtVehicleType GetDefaultAllowedVehicleTypes(NetInfo.Lane laneInfo, VehicleRestrictionsMode busLaneMode)
{
ExtVehicleType ret = ExtVehicleType.None;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Bicycle) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Bicycle;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Tram) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Tram;
if (busLaneMode == VehicleRestrictionsMode.Restricted ||
(busLaneMode == VehicleRestrictionsMode.Configured && Options.banRegularTrafficOnBusLanes)) {
if ((laneInfo.m_laneType & NetInfo.LaneType.TransportVehicle) != NetInfo.LaneType.None)
ret |= ExtVehicleType.RoadPublicTransport | ExtVehicleType.Service | ExtVehicleType.Emergency;
else if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Car) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.RoadVehicle;
} else {
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Car) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.RoadVehicle;
}
if ((laneInfo.m_vehicleType & (VehicleInfo.VehicleType.Train | VehicleInfo.VehicleType.Metro | VehicleInfo.VehicleType.Monorail)) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.RailVehicle;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Ship) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Ship;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Plane) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Plane;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Ferry) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Ferry;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Blimp) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.Blimp;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.CableCar) != VehicleInfo.VehicleType.None)
ret |= ExtVehicleType.CableCar;
return ret;
}
/// <summary>
/// Determines the maximum allowed set of vehicles (the base mask) for a given lane
/// </summary>
/// <param name="laneInfo"></param>
/// <returns></returns>
public ExtVehicleType GetBaseMask(uint laneId, VehicleRestrictionsMode includeBusLanes)
{
if (((NetLane.Flags)Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags & NetLane.Flags.Created) == NetLane.Flags.None)
{
return(ExtVehicleType.None);
}
ushort segmentId = Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_segment;
if ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created) == NetSegment.Flags.None)
{
return(ExtVehicleType.None);
}
NetInfo segmentInfo = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int numLanes = segmentInfo.m_lanes.Length;
uint laneIndex = 0;
while (laneIndex < numLanes && curLaneId != 0u)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if (curLaneId == laneId)
{
return(GetBaseMask(laneInfo, includeBusLanes));
}
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
++laneIndex;
}
return(ExtVehicleType.None);
}
/// <summary>
/// Determines the default set of allowed vehicle types for a given lane.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="segmentInfo"></param>
/// <param name="laneIndex"></param>
/// <param name="laneInfo"></param>
/// <returns></returns>
internal ExtVehicleType GetDefaultAllowedVehicleTypes(uint laneId, VehicleRestrictionsMode busLaneMode)
{
if (((NetLane.Flags)Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_flags & NetLane.Flags.Created) == NetLane.Flags.None)
{
return(ExtVehicleType.None);
}
ushort segmentId = Singleton <NetManager> .instance.m_lanes.m_buffer[laneId].m_segment;
if ((Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created) == NetSegment.Flags.None)
{
return(ExtVehicleType.None);
}
NetInfo segmentInfo = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].Info;
uint curLaneId = Singleton <NetManager> .instance.m_segments.m_buffer[segmentId].m_lanes;
int numLanes = segmentInfo.m_lanes.Length;
uint laneIndex = 0;
while (laneIndex < numLanes && curLaneId != 0u)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if (curLaneId == laneId)
{
return(GetDefaultAllowedVehicleTypes(segmentId, segmentInfo, laneIndex, laneInfo, busLaneMode));
}
curLaneId = Singleton <NetManager> .instance.m_lanes.m_buffer[curLaneId].m_nextLane;
++laneIndex;
}
return(ExtVehicleType.None);
}
public HashSet <ExtVehicleType> GetAllowedVehicleTypesAsSet(
ushort segmentId,
ushort nodeId,
VehicleRestrictionsMode busLaneMode)
{
var ret = new HashSet <ExtVehicleType>(
GetAllowedVehicleTypesAsDict(segmentId, nodeId, busLaneMode).Values);
return(ret);
}
/// <summary>
/// Determines the allowed vehicle types that may approach the given node from the given segment (lane-wise).
/// </summary>
/// <param name="segmentId"></param>
/// <param name="nodeId"></param>
/// <returns></returns>
public IDictionary <byte, ExtVehicleType> GetAllowedVehicleTypesAsDict(
ushort segmentId,
ushort nodeId,
VehicleRestrictionsMode busLaneMode)
{
IDictionary <byte, ExtVehicleType> ret = new Dictionary <byte, ExtVehicleType>();
NetManager netManager = Singleton <NetManager> .instance;
if (segmentId == 0)
{
return(ret);
}
ref NetSegment netSegment = ref segmentId.ToSegment();
// TODO optimize method (don't depend on collections!)
public ExtVehicleType GetAllowedVehicleTypes(ushort segmentId,
ushort nodeId,
VehicleRestrictionsMode busLaneMode)
{
var ret = ExtVehicleType.None;
foreach (ExtVehicleType vehicleType in GetAllowedVehicleTypesAsSet(
segmentId,
nodeId,
busLaneMode))
{
ret |= vehicleType;
}
return(ret);
}
/// <summary>
/// Determines the allowed vehicle types for the given segment and lane.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="laneIndex"></param>
/// <param name="segmentInfo"></param>
/// <param name="laneInfo"></param>
/// <returns></returns>
public ExtVehicleType GetAllowedVehicleTypes(ushort segmentId,
NetInfo segmentInfo,
uint laneIndex,
NetInfo.Lane laneInfo,
VehicleRestrictionsMode busLaneMode)
{
ExtVehicleType?[] fastArray = Flags.laneAllowedVehicleTypesArray[segmentId];
if (fastArray != null && fastArray.Length > laneIndex && fastArray[laneIndex] != null)
{
return((ExtVehicleType)fastArray[laneIndex]);
}
return(GetDefaultAllowedVehicleTypes(
segmentId,
segmentInfo,
laneIndex,
laneInfo,
busLaneMode));
}
/// <summary>
/// Determines the default set of allowed vehicle types for a given segment and lane.
/// </summary>
/// <param name="segmentId"></param>
/// <param name="segmentInfo"></param>
/// <param name="laneIndex"></param>
/// <param name="laneInfo"></param>
/// <returns></returns>
public ExtVehicleType GetDefaultAllowedVehicleTypes(
ushort segmentId,
NetInfo segmentInfo,
uint laneIndex,
NetInfo.Lane laneInfo,
VehicleRestrictionsMode busLaneMode)
{
// manage cached default vehicle types
if (defaultVehicleTypeCache == null)
{
defaultVehicleTypeCache = new ExtVehicleType?[NetManager.MAX_SEGMENT_COUNT][][];
}
ExtVehicleType?[] cachedDefaultTypes = null;
int cacheIndex = (int)busLaneMode;
if (defaultVehicleTypeCache[segmentId] != null)
{
cachedDefaultTypes = defaultVehicleTypeCache[segmentId][cacheIndex];
}
if (cachedDefaultTypes == null ||
cachedDefaultTypes.Length != segmentInfo.m_lanes.Length)
{
ExtVehicleType?[][] segmentCache = new ExtVehicleType?[3][];
segmentCache[0] = new ExtVehicleType?[segmentInfo.m_lanes.Length];
segmentCache[1] = new ExtVehicleType?[segmentInfo.m_lanes.Length];
segmentCache[2] = new ExtVehicleType?[segmentInfo.m_lanes.Length];
defaultVehicleTypeCache[segmentId] = segmentCache;
cachedDefaultTypes = segmentCache[cacheIndex];
}
ExtVehicleType?defaultVehicleType = cachedDefaultTypes[laneIndex];
if (defaultVehicleType == null)
{
defaultVehicleType = GetDefaultAllowedVehicleTypes(laneInfo, busLaneMode);
cachedDefaultTypes[laneIndex] = defaultVehicleType;
}
return((ExtVehicleType)defaultVehicleType);
}
/// <summary>
/// Determines the allowed vehicle types that may approach the given node from the given segment (lane-wise).
/// </summary>
/// <param name="segmentId"></param>
/// <param name="nodeId"></param>
/// <returns></returns>
public IDictionary <byte, ExtVehicleType> GetAllowedVehicleTypesAsDict(
ushort segmentId,
ushort nodeId,
VehicleRestrictionsMode busLaneMode)
{
IDictionary <byte, ExtVehicleType> ret = new TinyDictionary <byte, ExtVehicleType>();
NetManager netManager = Singleton <NetManager> .instance;
if (segmentId == 0 ||
(netManager.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Created)
== NetSegment.Flags.None ||
nodeId == 0 ||
(netManager.m_nodes.m_buffer[nodeId].m_flags & NetNode.Flags.Created)
== NetNode.Flags.None)
{
return(ret);
}
const NetInfo.Direction DIR = NetInfo.Direction.Forward;
NetInfo.Direction dir2 =
((netManager.m_segments.m_buffer[segmentId].m_flags & NetSegment.Flags.Invert)
== NetSegment.Flags.None)
? DIR
: NetInfo.InvertDirection(DIR);
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;
uint laneIndex = 0;
while (laneIndex < numLanes && curLaneId != 0u)
{
NetInfo.Lane laneInfo = segmentInfo.m_lanes[laneIndex];
if (laneInfo.m_laneType == NetInfo.LaneType.Vehicle ||
laneInfo.m_laneType == NetInfo.LaneType.TransportVehicle)
{
if ((laneInfo.m_vehicleType & VEHICLE_TYPES) != VehicleInfo.VehicleType.None)
{
ushort toNodeId =
(laneInfo.m_finalDirection & dir2) != NetInfo.Direction.None
? netManager.m_segments.m_buffer[segmentId].m_endNode
: netManager.m_segments.m_buffer[segmentId].m_startNode;
if ((laneInfo.m_finalDirection & NetInfo.Direction.Both) ==
NetInfo.Direction.Both || toNodeId == nodeId)
{
ExtVehicleType vehicleTypes = GetAllowedVehicleTypes(
segmentId,
segmentInfo,
laneIndex,
laneInfo,
busLaneMode);
ret[(byte)laneIndex] = vehicleTypes;
}
}
}
curLaneId = netManager.m_lanes.m_buffer[curLaneId].m_nextLane;
++laneIndex;
}
return(ret);
}
/// <summary>
/// Determines the maximum allowed set of vehicles (the base mask) for a given lane
/// </summary>
/// <param name="laneInfo"></param>
/// <returns></returns>
public ExtVehicleType GetBaseMask(NetInfo.Lane laneInfo,
VehicleRestrictionsMode includeBusLanes)
{
return(GetDefaultAllowedVehicleTypes(laneInfo, includeBusLanes));
}
public ExtVehicleType GetDefaultAllowedVehicleTypes(NetInfo.Lane laneInfo,
VehicleRestrictionsMode busLaneMode)
{
var ret = ExtVehicleType.None;
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Bicycle) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Bicycle;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Tram) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Tram;
}
switch (busLaneMode)
{
case VehicleRestrictionsMode.Restricted:
case VehicleRestrictionsMode.Configured when Options.banRegularTrafficOnBusLanes: {
if ((laneInfo.m_laneType & NetInfo.LaneType.TransportVehicle) !=
NetInfo.LaneType.None)
{
ret |= ExtVehicleType.RoadPublicTransport
| ExtVehicleType.Service
| ExtVehicleType.Emergency;
}
else if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Car) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.RoadVehicle;
}
break;
}
default: {
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Car) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.RoadVehicle;
}
break;
}
}
// TODO: Mapping from VehicleInfo.VehicleType to bit flags can be improved by a lookup table
if ((laneInfo.m_vehicleType & (VehicleInfo.VehicleType.Train |
VehicleInfo.VehicleType.Metro |
VehicleInfo.VehicleType.Monorail)) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.RailVehicle;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Ship) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Ship;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Plane) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Plane;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Ferry) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Ferry;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.Blimp) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.Blimp;
}
if ((laneInfo.m_vehicleType & VehicleInfo.VehicleType.CableCar) !=
VehicleInfo.VehicleType.None)
{
ret |= ExtVehicleType.CableCar;
}
return(ret);
}
public ExtVehicleType GetAllowedVehicleTypes(ushort segmentId, ushort nodeId, VehicleRestrictionsMode busLaneMode)
{
// TODO optimize method (don't depend on collections!)
ExtVehicleType ret = ExtVehicleType.None;
foreach (ExtVehicleType vehicleType in GetAllowedVehicleTypesAsSet(segmentId, nodeId, busLaneMode)) {
ret |= vehicleType;
}
return ret;
}
