internal ExtVehicleType?DetermineVehicleType(ushort vehicleId, ref Vehicle vehicleData)
{
if ((vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0)
{
VehicleStates[vehicleId].VehicleType = ExtVehicleType.Emergency;
return(ExtVehicleType.Emergency);
}
VehicleAI ai = vehicleData.Info.m_vehicleAI;
ExtVehicleType?ret = DetermineVehicleTypeFromAIType(ai, false);
if (ret != null)
{
VehicleStates[vehicleId].VehicleType = (ExtVehicleType)ret;
if ((ExtVehicleType)ret == ExtVehicleType.CargoTruck)
{
VehicleStates[vehicleId].HeavyVehicle = ((CargoTruckAI)ai).m_isHeavyVehicle;
}
}
else
{
VehicleStates[vehicleId].VehicleType = ExtVehicleType.None;
VehicleStates[vehicleId].HeavyVehicle = false;
#if DEBUG
if (GlobalConfig.Instance.DebugSwitches[4])
{
Log._Debug($"Could not determine vehicle type of {vehicleId}. Info={vehicleData.Info?.name}");
}
#endif
}
return(ret);
}
void CheckRoadSpeed()
{
Road current = gameManager.speedLimitController.IsInsideRoadBoundaries(player.transform.position.z);
if (current != null && gameManager.activeRoadIndex != gameManager.speedLimitController.activeIndex)
{
// show UI (inside road bounds)
ToggleUI(true);
// store current road index on list
gameManager.activeRoadIndex = gameManager.speedLimitController.activeIndex;
// store road speed
//TODO: maybe change this index and speed to a Road object. Makes more sense
gameManager.speedLimitController.currentRoadSpeed = current.speedlimit;
// change new road speed
speedLimitUI.text = VehicleAI.GetCurrentSpeedIndicator((int)current.speedlimit);
}
else if (current == null)
{
// Hide UI (outisde a road)
ToggleUI(false);
}
}
public static bool Prefix(VehicleAI __instance,
ushort vehicleID,
ref Vehicle vehicleData,
PathUnit.Position nextPosition,
PathUnit.Position position,
uint laneID,
byte offset,
PathUnit.Position prevPos,
uint prevLaneID,
byte prevOffset,
int index,
out Vector3 pos,
out Vector3 dir,
out float maxSpeed)
{
VehicleAICommons.CustomCalculateSegmentPosition(
__instance,
vehicleID,
ref vehicleData,
position,
laneID,
offset,
out pos,
out dir,
out maxSpeed);
return(false);
}
void OnTriggerEnter(Collider col)
{
// simulates click on a car
if (col.gameObject.CompareTag(Constants.TagVehicle))
{
gameObject.SetActive(false);
VehicleAI vehicle = col.gameObject.GetComponent <VehicleAI>();
bool isVehicleOnCurrentRoad = gameManager.speedLimitController.IsVehicleOnCurrentRoad(col.gameObject.transform.position.z);
if (isVehicleOnCurrentRoad)
{
if (vehicle.GetCurrentSpeed() > (float)gameManager.speedLimitController.currentRoadSpeed)
{
vehicle.SetCurrentSpeed(gameManager.speedLimitController.currentRoadSpeed);
gameManager.scoreController.AddScoreVehicleHit();
//Debug.Log("WIN POINTS because vehicle speed = " + vehicle.GetCurrentSpeed() + " and road is " + 0 + gameManager.speedLimitController.currentRoadSpeed);
}
else
{
gameManager.scoreController.SubScoreVehicleHit();
//Debug.Log("LOSE POINTS because vehicle speed = " + vehicle.GetCurrentSpeed() + " and road is " + 0 + gameManager.speedLimitController.currentRoadSpeed);
}
}
}
}
public void SetVehicleCapacity(string assetName, int newCapacity)
{
VehicleInfo vehicle = PrefabCollection <VehicleInfo> .FindLoaded(assetName);
if (vehicle != null && !VehicleUtils.IsTrailer(vehicle))
{
Dictionary <string, MutableTuple <float, int> > assetsCapacitiesPercentagePerTrailer = GetCapacityRelative(vehicle);
int capacityUsed = 0;
foreach (KeyValuePair <string, MutableTuple <float, int> > entry in assetsCapacitiesPercentagePerTrailer)
{
SafeGetAsset(entry.Key).Capacity = Mathf.RoundToInt(newCapacity <= 0 ? -1f : entry.Value.First *newCapacity);
capacityUsed += SafeGetAsset(entry.Key).Capacity *entry.Value.Second;
}
if (newCapacity > 0 && capacityUsed != newCapacity)
{
SafeGetAsset(assetsCapacitiesPercentagePerTrailer.Keys.ElementAt(0)).Capacity += (newCapacity - capacityUsed) / assetsCapacitiesPercentagePerTrailer[assetsCapacitiesPercentagePerTrailer.Keys.ElementAt(0)].Second;
}
foreach (string entry in assetsCapacitiesPercentagePerTrailer.Keys)
{
VehicleAI vai = PrefabCollection <VehicleInfo> .FindLoaded(entry).m_vehicleAI;
SetVehicleCapacity(vai, SafeGetAsset(entry).Capacity);
}
SimulationManager.instance.StartCoroutine(TLMVehicleUtils.UpdateCapacityUnitsFromTSD());
}
}
public static void CustomCalculateTargetSpeed(VehicleAI instance,
ushort vehicleId,
ref Vehicle vehicleData,
PathUnit.Position position,
uint laneId,
NetInfo info,
out float maxSpeed)
{
if (info.m_lanes != null && info.m_lanes.Length > position.m_lane)
{
float laneSpeedLimit = Options.customSpeedLimitsEnabled
? SpeedLimitManager.Instance.GetLockFreeGameSpeedLimit(
position.m_segment,
position.m_lane,
laneId,
info.m_lanes[position.m_lane])
: info.m_lanes[position.m_lane].m_speedLimit; // NON-STOCK CODE
maxSpeed = CalculateTargetSpeed(
instance,
vehicleId,
ref vehicleData,
laneSpeedLimit,
_netManager.m_lanes.m_buffer[laneId].m_curve);
}
else
{
maxSpeed = CalculateTargetSpeed(instance, vehicleId, ref vehicleData, 1f, 0f);
}
}
//// TODO: set correct values on vehicles for realistic speeds
//void SetRealisitcSpeeds(VehicleInfo vehicle, bool activate)
//{
// float accelerationMultiplier;
// float maxSpeedMultiplier;
// switch (vehicle.name)
// {
// case "Ambulance":
// accelerationMultiplier = 0.2f;
// //vehicle.m_braking *= 0.3f;
// //vehicle.m_turning *= 0.25f;
// maxSpeedMultiplier = 0.5f;
// break;
// case "Bus":
// case "Fire Truck":
// case "Garbage Truck":
// accelerationMultiplier = 0.15f;
// //vehicle.m_braking *= 0.25f;
// //vehicle.m_turning *= 0.2f;
// maxSpeedMultiplier = 0.5f;
// break;
// case "Hearse":
// case "Police Car":
// accelerationMultiplier = 0.25f;
// //vehicle.m_braking *= 0.35f;
// //vehicle.m_turning *= 0.3f;
// maxSpeedMultiplier = 0.5f;
// break;
// default:
// accelerationMultiplier = 0.25f;
// //vehicle.m_braking *= 0.35f;
// //vehicle.m_turning *= 0.3f;
// maxSpeedMultiplier = 0.5f;
// break;
// }
// if (!activate)
// {
// accelerationMultiplier = 1f / accelerationMultiplier;
// maxSpeedMultiplier = 1f / maxSpeedMultiplier;
// }
// vehicle.m_acceleration *= accelerationMultiplier;
// vehicle.m_maxSpeed *= maxSpeedMultiplier;
//}
void CopyVehicleAIAttributes <T>(VehicleAI from, T to)
{
foreach (FieldInfo fi in typeof(T).BaseType.GetFields())
{
fi.SetValue(to, fi.GetValue(from));
}
}
private static bool IsAICustom(VehicleAI ai)
{
Type type = ai.GetType();
return((type != typeof(AmbulanceAI) ||
type != typeof(BusAI) ||
type != typeof(CargoTruckAI) ||
type != typeof(FireTruckAI) ||
type != typeof(GarbageTruckAI) ||
type != typeof(HearseAI) ||
type != typeof(PassengerCarAI) ||
type != typeof(PoliceCarAI)) ||
type != typeof(TaxiAI) ||
type != typeof(TramAI) ||
type != typeof(MaintenanceTruckAI) ||
type != typeof(WaterTruckAI) ||
type != typeof(ParkMaintenanceVehicleAI) ||
type != typeof(SnowTruckAI) ||
type != typeof(CableCarAI) ||
type != typeof(TrolleybusAI) ||
type != typeof(PassengerFerryAI) ||
type != typeof(PassengerBlimpAI) ||
type != typeof(PostVanAI) ||
type != typeof(PassengerHelicopterAI));
}
async Task SpawnVehicle()
{
GameObject g = Instantiate(VehiclePrefab, GetRandomPos(transform.GetChild(0).position), transform.GetChild(0).rotation);
var vtypes = new List <string> {
"busnew", "sedan", "muscle"
};
await g.GetComponent <ModObject>().Create(vtypes[Random.Range(0, vtypes.Count)]);
g.GetComponent <ModObject>().AttachPart("Wheel");
g.GetComponent <ModObject>().AttachPart("PaintBlack");
g.GetComponent <ModObject>().AttachPart("StickerWhite");
g.GetComponent <ModObject>().AttachPart("NormalHeight");
g.GetComponent <ModObject>().AttachPart("PoliceLights");
g.GetComponent <ModObject>().AttachPart("50v8");
g.GetComponent <ModObject>().AttachPart("Police");
g.GetComponentInChildren <Rigidbody>().velocity = GetComponentInChildren <Rigidbody>().velocity *1.3f;
g.GetComponentInChildren <Rigidbody>().angularVelocity = Vector3.zero;
VehicleAI a = g.GetComponent <VehicleAI>();
a.target = transform;
GameObject bar = Instantiate(HPBarPrefab, canvas.transform);
bar.GetComponent <HPBar>().vehicle = a.GetComponent <Vehicle>();
bar.GetComponent <HPBar>().camera = Camera.main;
a.target = transform.GetChild(0);
SpawnedVehicles.Add(a);
}
private static void SetTicketPrice(ItemClass.SubService subService, VehicleAI ai, int ticketPrice)
{
if (subService == ItemClass.SubService.PublicTransportBus && (UnityEngine.Object)(ai as BusAI) != (UnityEngine.Object)null)
{
(ai as BusAI).m_ticketPrice = ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportMetro && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
(ai as PassengerTrainAI).m_ticketPrice = ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportTrain && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
(ai as PassengerTrainAI).m_ticketPrice = ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportShip && (UnityEngine.Object)(ai as PassengerShipAI) != (UnityEngine.Object)null)
{
(ai as PassengerShipAI).m_ticketPrice = ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportPlane && (UnityEngine.Object)(ai as PassengerPlaneAI) != (UnityEngine.Object)null)
{
(ai as PassengerPlaneAI).m_ticketPrice = ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportTaxi && (UnityEngine.Object)(ai as TaxiAI) != (UnityEngine.Object)null)
{
(ai as TaxiAI).m_pricePerKilometer = ticketPrice;
}
else
{
if (subService != ItemClass.SubService.PublicTransportTram || !((UnityEngine.Object)(ai as TramAI) != (UnityEngine.Object)null))
{
return;
}
(ai as TramAI).m_ticketPrice = ticketPrice;
}
}
internal static ExtVehicleType?DetermineVehicleType(ushort vehicleId, ref Vehicle vehicleData)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("VehicleStateManager.DetermineVehicleType");
#endif
if ((vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0)
{
#if TRACE
Singleton <CodeProfiler> .instance.Stop("VehicleStateManager.DetermineVehicleType");
#endif
VehicleStates[vehicleId].VehicleType = ExtVehicleType.Emergency;
return(ExtVehicleType.Emergency);
}
VehicleAI ai = vehicleData.Info.m_vehicleAI;
#if TRACE
Singleton <CodeProfiler> .instance.Start("VehicleStateManager.DetermineVehicleTypeFromAIType");
#endif
ExtVehicleType?ret = DetermineVehicleTypeFromAIType(ai, false);
#if TRACE
Singleton <CodeProfiler> .instance.Stop("VehicleStateManager.DetermineVehicleTypeFromAIType");
#endif
VehicleStates[vehicleId].VehicleType = ret != null ? (ExtVehicleType)ret : ExtVehicleType.None;
#if TRACE
Singleton <CodeProfiler> .instance.Stop("VehicleStateManager.DetermineVehicleType");
#endif
return(ret);
}
private static int GetTicketPrice(ItemClass.SubService subService, VehicleAI ai)
{
int num = 0;
if (subService == ItemClass.SubService.PublicTransportBus && (UnityEngine.Object)(ai as BusAI) != (UnityEngine.Object)null)
{
num = (ai as BusAI).m_ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportMetro && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerTrainAI).m_ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportTrain && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerTrainAI).m_ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportShip && (UnityEngine.Object)(ai as PassengerShipAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerShipAI).m_ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportPlane && (UnityEngine.Object)(ai as PassengerPlaneAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerPlaneAI).m_ticketPrice;
}
else if (subService == ItemClass.SubService.PublicTransportTaxi && (UnityEngine.Object)(ai as TaxiAI) != (UnityEngine.Object)null)
{
num = (ai as TaxiAI).m_pricePerKilometer;
}
else if (subService == ItemClass.SubService.PublicTransportTram && (UnityEngine.Object)(ai as TramAI) != (UnityEngine.Object)null)
{
num = (ai as TramAI).m_ticketPrice;
}
return(num);
}
public static int GetMaintenanceCost(ItemClass.SubService subService, VehicleAI ai)
{
int num = 0;
if (subService == ItemClass.SubService.PublicTransportBus && (UnityEngine.Object)(ai as BusAI) != (UnityEngine.Object)null)
{
num = (ai as BusAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
else if (subService == ItemClass.SubService.PublicTransportMetro && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerTrainAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
else if (subService == ItemClass.SubService.PublicTransportTrain && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerTrainAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
else if (subService == ItemClass.SubService.PublicTransportShip && (UnityEngine.Object)(ai as PassengerShipAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerShipAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
else if (subService == ItemClass.SubService.PublicTransportPlane && (UnityEngine.Object)(ai as PassengerPlaneAI) != (UnityEngine.Object)null)
{
num = (ai as PassengerPlaneAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
else if (subService == ItemClass.SubService.PublicTransportTram && (UnityEngine.Object)(ai as TramAI) != (UnityEngine.Object)null)
{
num = (ai as TramAI).m_transportInfo.m_maintenanceCostPerVehicle;
}
return(num);
}
private static void SetCapacity(ItemClass.SubService subService, VehicleAI ai, int capacity)
{
if (subService == ItemClass.SubService.PublicTransportBus && (UnityEngine.Object)(ai as BusAI) != (UnityEngine.Object)null)
{
(ai as BusAI).m_passengerCapacity = capacity;
}
else if (subService == ItemClass.SubService.PublicTransportMetro && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
(ai as PassengerTrainAI).m_passengerCapacity = capacity;
}
else if (subService == ItemClass.SubService.PublicTransportTrain && (UnityEngine.Object)(ai as PassengerTrainAI) != (UnityEngine.Object)null)
{
(ai as PassengerTrainAI).m_passengerCapacity = capacity;
}
else if (subService == ItemClass.SubService.PublicTransportShip && (UnityEngine.Object)(ai as PassengerShipAI) != (UnityEngine.Object)null)
{
(ai as PassengerShipAI).m_passengerCapacity = capacity;
}
else if (subService == ItemClass.SubService.PublicTransportPlane && (UnityEngine.Object)(ai as PassengerPlaneAI) != (UnityEngine.Object)null)
{
(ai as PassengerPlaneAI).m_passengerCapacity = capacity;
}
else if (subService == ItemClass.SubService.PublicTransportTaxi && (UnityEngine.Object)(ai as TaxiAI) != (UnityEngine.Object)null)
{
(ai as TaxiAI).m_travelCapacity = capacity;
}
else
{
if (subService != ItemClass.SubService.PublicTransportTram || !((UnityEngine.Object)(ai as TramAI) != (UnityEngine.Object)null))
{
return;
}
(ai as TramAI).m_passengerCapacity = capacity;
}
}
private void InitCapacitiesInAssets()
{
var keys = AssetConfigurations.Keys.ToList();
foreach (string entry in keys)
{
try
{
VehicleInfo info = PrefabCollection <VehicleInfo> .FindLoaded(entry);
if (info != null)
{
VehicleAI ai = info.m_vehicleAI;
UpdateDefaultCapacity(ai);
SetVehicleCapacity(ai, SafeGetAsset(entry).Capacity);
}
else
{
AssetConfigurations.Remove(entry);
}
}
catch (Exception e)
{
LogUtils.DoErrorLog($"ERROR LOADING ASSET CONFIG: {e}=> {e.Message}\n{e.StackTrace}");
}
}
SimulationManager.instance.StartCoroutine(TLMVehicleUtils.UpdateCapacityUnitsFromTSD());
}
private static int GetUnitsCapacity(VehicleAI vehicleAI)
{
VehicleAI vehicleAI2 = vehicleAI as AmbulanceAI;
if (vehicleAI2 != null)
{
return(((AmbulanceAI)vehicleAI2).m_patientCapacity + ((AmbulanceAI)vehicleAI2).m_paramedicCount);
}
vehicleAI2 = (vehicleAI as BusAI);
if (vehicleAI2 != null)
{
return(((BusAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as HearseAI);
if (vehicleAI2 != null)
{
return(((HearseAI)vehicleAI2).m_corpseCapacity + ((HearseAI)vehicleAI2).m_driverCount);
}
vehicleAI2 = (vehicleAI as PassengerPlaneAI);
if (vehicleAI2 != null)
{
return(((PassengerPlaneAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as PassengerShipAI);
if (vehicleAI2 != null)
{
return(((PassengerShipAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as PassengerTrainAI);
if (vehicleAI2 != null)
{
return(((PassengerTrainAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as TramAI);
if (vehicleAI2 != null)
{
return(((TramAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as CableCarAI);
if (vehicleAI2 != null)
{
return(((CableCarAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as PassengerFerryAI);
if (vehicleAI2 != null)
{
return(((PassengerFerryAI)vehicleAI2).m_passengerCapacity);
}
vehicleAI2 = (vehicleAI as PassengerBlimpAI);
if (vehicleAI2 != null)
{
return(((PassengerBlimpAI)vehicleAI2).m_passengerCapacity);
}
return(-1);
}
private static int GetUnitsCapacity(VehicleAI vehicleAI)
{
VehicleAI ai;
ai = vehicleAI as AmbulanceAI;
if (ai != null)
{
return(((AmbulanceAI)ai).m_patientCapacity + ((AmbulanceAI)ai).m_paramedicCount);
}
ai = vehicleAI as BusAI;
if (ai != null)
{
return(((BusAI)ai).m_passengerCapacity);
}
/*ai = prefab.m_vehicleAI as FireTruckAI;
* if (ai != null) return ((FireTruckAI)ai).m_firemanCount;*/
ai = vehicleAI as HearseAI;
if (ai != null)
{
return(((HearseAI)ai).m_corpseCapacity + ((HearseAI)ai).m_driverCount);
}
ai = vehicleAI as PassengerPlaneAI;
if (ai != null)
{
return(((PassengerPlaneAI)ai).m_passengerCapacity);
}
ai = vehicleAI as PassengerShipAI;
if (ai != null)
{
return(((PassengerShipAI)ai).m_passengerCapacity);
}
ai = vehicleAI as PassengerTrainAI;
if (ai != null)
{
return(((PassengerTrainAI)ai).m_passengerCapacity);
}
ai = vehicleAI as TramAI;
if (ai != null)
{
return(((TramAI)ai).m_passengerCapacity);
}
/*ai = prefab.m_vehicleAI as PoliceCarAI;
* if (ai != null) return ((PoliceCarAI)ai).m_policeCount;*/
return(-1);
}
private static bool IsAICustom(VehicleAI ai)
{
Type type = ai.GetType();
return(type != typeof(AmbulanceAI) ||
type != typeof(BusAI) ||
type != typeof(CargoTruckAI) ||
type != typeof(FireTruckAI) ||
type != typeof(GarbageTruckAI) ||
type != typeof(HearseAI) ||
type != typeof(PassengerCarAI) ||
type != typeof(PoliceCarAI));
}
/*
* Spawns a random enemy
*/
void SpawnEnemy(float roadZ)
{
//TODO: Generate random enemy
// generates random side position
float enemyX = 0;
float enemyZ = 0;
// chooses what enemy to spawn
int enemyType = Random.Range(0, 3);
GameObject vehicle = pfVehicles[0];
if (enemyType == 0)
{
vehicle = pfPoliceCar;
}
if (enemyType == 1)
{
vehicle = pfAmbulance;
}
if (enemyType == 2)
{
vehicle = pfVehicles[Random.Range(0, pfVehicles.Count)];
}
// defines a direction (left or right) and sets the lane position
VehicleDirection direction = (VehicleDirection)Random.Range(0, 2);
switch (direction)
{
case VehicleDirection.Left:
enemyX = settings.GameRightBoundary;
enemyZ = roadZ + (2 * Constants.PathSizeZ + 1) + Constants.PathSizeZ / 2;
break;
case VehicleDirection.Right:
enemyX = settings.GameLeftBoundary;
enemyZ = roadZ + Constants.PathSizeZ + Constants.PathSizeZ / 2;
break;
}
Vector3 enemyPosition = new Vector3(enemyX, 2, enemyZ);
// instantiates enemy at position
GameObject enemy = InstantiateSceneObject(vehicle, enemyPosition);
VehicleAI model = enemy.GetComponent <VehicleAI>();
model.SetDirection(direction);
model.Go();
}
public static void CustomCalculateSegmentPosition(VehicleAI instance,
ushort vehicleId,
ref Vehicle vehicleData,
PathUnit.Position position,
uint laneId,
byte offset,
out Vector3 pos,
out Vector3 dir,
out float maxSpeed)
{
_netManager.m_lanes.m_buffer[laneId].CalculatePositionAndDirection(Constants.ByteToFloat(offset), out pos, out dir);
NetInfo info = _netManager.m_segments.m_buffer[position.m_segment].Info;
CustomCalculateTargetSpeed(instance, vehicleId, ref vehicleData, position, laneId, info, out maxSpeed);
}
static void SimulationStep(VehicleAI _this, ushort vehicleID, ref Vehicle data, Vector3 physicsLodRefPos)
{
try
{
_this.SimulationStep(vehicleID, ref data, physicsLodRefPos);
}
catch (Exception e)
{
string info = $"An exception occured during VehicleAI simulation step.\nAsset: {_this.m_info.name}" +
$"\nVehicleID: {vehicleID}\nType: {_this.GetType().Name}\nSeverity: High";
HealkitException e2 = new HealkitException(info, e);
e2.m_uniqueData = _this.m_info.name;
e2.m_supperessMsg = "Suppress similar exceptions caused by this asset";
UIView.ForwardException(e2);
}
}
internal static ExtVehicleType?DetermineVehicleTypeFromVehicle(ushort vehicleId, ref Vehicle vehicleData)
{
if ((vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0)
{
return(ExtVehicleType.Emergency);
}
/*else {
* VehiclePosition vehiclePos = TrafficPriority.GetVehiclePosition(vehicleId);
* if (vehiclePos != null && vehiclePos.Valid && vehiclePos.VehicleType != ExtVehicleType.Emergency)
* return vehiclePos.VehicleType;
* }*/
VehicleAI ai = vehicleData.Info.m_vehicleAI;
return(DetermineVehicleTypeFromAIType(ai, (vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0));
}
private void vehicleHover(UIComponent component, UIMouseEventParameter eventParam)
{
bool oldVal = component.GetComponentInChildren <DraggableVehicleInfo>().isDragging;
bool newVal = (eventParam.buttons & UIMouseButton.Left) != UIMouseButton.None;
component.GetComponentInChildren <DraggableVehicleInfo>().isDragging = newVal;
if (oldVal != newVal && newVal == false)
{
TLMUtils.doLog("onVehicleDrop! {0}", component.name);
DraggableVehicleInfo dvi = eventParam.source.parent.GetComponentInChildren <DraggableVehicleInfo>();
UIView view = GameObject.FindObjectOfType <UIView>();
UIHitInfo[] hits = view.RaycastAll(eventParam.ray);
DroppableStationInfo dsi = null;
UIComponent res = null;
int idxRes = -1;
for (int i = hits.Length - 1; i >= 0; i--)
{
UIHitInfo hit = hits[i];
DroppableStationInfo[] dsiList = hit.component.GetComponentsInChildren <DroppableStationInfo>();
if (dsiList.Length == 0)
{
dsiList = hit.component.parent.GetComponentsInChildren <DroppableStationInfo>();
}
if (dsiList.Length == 1)
{
dsi = dsiList[0];
res = hit.component;
idxRes = i;
break;
}
}
if (dvi == null || dsi == null)
{
TLMUtils.doLog("Drag Drop falhou! {0}", eventParam.source.name);
return;
}
else
{
TLMUtils.doLog("Drag Funcionou! {0}/{1} ({2}-{3})", eventParam.source.name, dsi.gameObject.name, res.gameObject.name, idxRes);
VehicleAI ai = (VehicleAI)Singleton <VehicleManager> .instance.m_vehicles.m_buffer[dvi.vehicleId].Info.GetAI();
ai.SetTarget(dvi.vehicleId, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[dvi.vehicleId], dsi.nodeId);
}
}
}
void Start()
{
if (!rb)
{
rb = GetComponent <Rigidbody>();
}
if (!inputs)
{
inputs = GetComponent <VehicleAI>();
}
rb.centerOfMass = new Vector3(0, rb.centerOfMass.y + centerOfMassYOffset, (frontAxle.offset.x + rearAxle.offset.x) / 2);
foreach (Slider s in GetComponentsInChildren <Slider>())
{
s.maxValue = HP;
}
}
public void AfterRenderExtraStuff(VehicleAI thiz, ushort vehicleID, ref Vehicle vehicleData, RenderManager.CameraInfo cameraInfo, InstanceID id, Vector3 position, Quaternion rotation, Vector4 tyrePosition, Vector4 lightState, Vector3 scale, Vector3 swayPosition, bool underground, bool overground)
{
if (thiz.m_info == null || thiz.m_info.m_vehicleAI == null || thiz.m_info.m_subMeshes == null)
{
return;
}
GetTargetDescriptor(thiz.m_info.name, out _, out LayoutDescriptorVehicleXml targetDescriptor);
if (targetDescriptor != null)
{
Vehicle.Flags flags = VehicleManager.instance.m_vehicles.m_buffer[vehicleID].m_flags;
Matrix4x4 vehicleMatrix = thiz.m_info.m_vehicleAI.CalculateBodyMatrix(flags, ref position, ref rotation, ref scale, ref swayPosition);
MaterialPropertyBlock materialBlock = VehicleManager.instance.m_materialBlock;
materialBlock.Clear();
RenderDescriptor(ref vehicleData, cameraInfo, vehicleID, position, vehicleMatrix, ref targetDescriptor);
}
}
private void DetermineVehicleType(ref ExtVehicle extVehicle, ref Vehicle vehicleData)
{
VehicleAI ai = vehicleData.Info.m_vehicleAI;
if ((vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0)
{
extVehicle.vehicleType = ExtVehicleType.Emergency;
}
else
{
ExtVehicleType?type = DetermineVehicleTypeFromAIType(
extVehicle.vehicleId,
ai,
false);
if (type != null)
{
extVehicle.vehicleType = (ExtVehicleType)type;
}
else
{
extVehicle.vehicleType = ExtVehicleType.None;
}
}
if (extVehicle.vehicleType == ExtVehicleType.CargoTruck)
{
extVehicle.heavyVehicle = ((CargoTruckAI)ai).m_isHeavyVehicle;
}
else
{
extVehicle.heavyVehicle = false;
}
#if DEBUG
if (DebugSwitch.VehicleLinkingToSegmentEnd.Get())
{
Log._Debug(
$"ExtVehicleManager.DetermineVehicleType({extVehicle.vehicleId}): " +
$"vehicleType={extVehicle.vehicleType}, heavyVehicle={extVehicle.heavyVehicle}. " +
$"Info={vehicleData.Info?.name}");
}
#endif
}
/*
* Spawns a random enemy
*/
void SpawnEnemy()
{
if (normalVehicles.Count > 0 && emergencyVehicles.Count > 0)
{
GameObject vehicle = normalVehicles[0];
LaneDirection laneDirection = null;
// diferentiate between avenue or normal road
if (avenue)
{
Lane lane = (Lane)Random.Range(2, 6);
laneDirection = GetVehicleStartPointOnLane(lane);
}
else
{
Lane lane = (Lane)Random.Range(0, 2);
laneDirection = GetVehicleStartPointOnLane(lane);
}
// generates emergency vehicle
if (Random.value < Constants.ProbabilityLow)
{
vehicle = emergencyVehicles[Random.Range(0, emergencyVehicles.Count)];
}
else // generates normal vehicle
{
vehicle = normalVehicles[Random.Range(0, normalVehicles.Count)];
}
// instantiates enemy at position
GameObject enemy = InstantiateSceneObject(vehicle, laneDirection.startPosition);
// saves new enemy on the list
vehiclesOnLanes.Add(enemy);
// sets the direction and orders to go
VehicleAI model = enemy.GetComponent <VehicleAI>();
model.SetDirection(laneDirection.direction);
model.Go();
}
}
public static void CustomCalculateSegmentPosition(VehicleAI instance,
ushort vehicleId,
ref Vehicle vehicleData,
PathUnit.Position position,
uint laneId,
byte offset,
out Vector3 pos,
out Vector3 dir,
out float maxSpeed)
{
laneId.ToLane().CalculatePositionAndDirection(Constants.ByteToFloat(offset), out pos, out dir);
CustomCalculateTargetSpeed(
instance,
vehicleId,
ref vehicleData,
position,
laneId,
position.m_segment.ToSegment().Info,
out maxSpeed);
}
public void OnReleased()
{
var keys = AssetConfigurations.Keys.ToList();
foreach (string entry in keys)
{
try
{
VehicleInfo info = PrefabCollection <VehicleInfo> .FindLoaded(entry);
if (info != null)
{
VehicleAI ai = info.m_vehicleAI;
SetVehicleCapacity(ai, 0);
}
}
catch (Exception e)
{
LogUtils.DoErrorLog($"ERROR ROLLING BACK ASSET CONFIG: {e}=> {e.Message}\n{e.StackTrace}");
}
}
}
private void DetermineVehicleType(ref Vehicle vehicleData)
{
VehicleAI ai = vehicleData.Info.m_vehicleAI;
if ((vehicleData.m_flags & Vehicle.Flags.Emergency2) != 0)
{
vehicleType = ExtVehicleType.Emergency;
}
else
{
ExtVehicleType?type = DetermineVehicleTypeFromAIType(ai, false);
if (type != null)
{
vehicleType = (ExtVehicleType)type;
}
else
{
vehicleType = ExtVehicleType.None;
}
}
if (vehicleType == ExtVehicleType.CargoTruck)
{
heavyVehicle = ((CargoTruckAI)ai).m_isHeavyVehicle;
}
else
{
heavyVehicle = false;
}
#if DEBUG
if (GlobalConfig.Instance.Debug.Switches[9])
{
Log._Debug($"VehicleState.DetermineVehicleType({vehicleId}): vehicleType={vehicleType}, heavyVehicle={heavyVehicle}. Info={vehicleData.Info?.name}");
}
#endif
}
internal static ExtVehicleType? DetermineVehicleTypeFromAIType(VehicleAI ai, bool emergencyOnDuty) {
switch (ai.m_info.m_vehicleType) {
case VehicleInfo.VehicleType.Bicycle:
return ExtVehicleType.Bicycle;
case VehicleInfo.VehicleType.Car:
if (ai is PassengerCarAI)
return ExtVehicleType.PassengerCar;
if (ai is AmbulanceAI || ai is FireTruckAI || ai is PoliceCarAI) {
if (emergencyOnDuty)
return ExtVehicleType.Emergency;
return ExtVehicleType.Service;
}
if (ai is CarTrailerAI)
return ExtVehicleType.None;
if (ai is BusAI)
return ExtVehicleType.Bus;
if (ai is TaxiAI)
return ExtVehicleType.Taxi;
if (ai is CargoTruckAI)
return ExtVehicleType.CargoTruck;
if (ai is HearseAI || ai is GarbageTruckAI || ai is MaintenanceTruckAI || ai is SnowTruckAI)
return ExtVehicleType.Service;
break;
case VehicleInfo.VehicleType.Metro:
case VehicleInfo.VehicleType.Train:
if (ai is PassengerTrainAI)
return ExtVehicleType.PassengerTrain;
if (ai is CargoTrainAI)
return ExtVehicleType.CargoTrain;
break;
case VehicleInfo.VehicleType.Tram:
return ExtVehicleType.Tram;
case VehicleInfo.VehicleType.Ship:
if (ai is PassengerShipAI)
return ExtVehicleType.PassengerShip;
//if (ai is CargoShipAI)
return ExtVehicleType.CargoShip;
//break;
case VehicleInfo.VehicleType.Plane:
//if (ai is PassengerPlaneAI)
return ExtVehicleType.PassengerPlane;
//break;
}
Log._Debug($"Could not determine vehicle type from ai type: {ai.GetType().ToString()}");
return null;
}
public static void UpdatePathTargetPositions(VehicleAI vehicleAI, ushort vehicleID, ref Vehicle vehicleData, Vector3 refPos, ref int index, int max, float minSqrDistanceA, float minSqrDistanceB)
{
PathManager instance = Singleton<PathManager>.instance;
NetManager instance2 = Singleton<NetManager>.instance;
Vector4 vector = vehicleData.m_targetPos0;
vector.w = 1000f;
float num = minSqrDistanceA;
uint num2 = vehicleData.m_path;
byte b = vehicleData.m_pathPositionIndex;
byte b2 = vehicleData.m_lastPathOffset;
if (b == 255)
{
b = 0;
if (index <= 0)
{
vehicleData.m_pathPositionIndex = 0;
}
if (!Singleton<PathManager>.instance.m_pathUnits.m_buffer[(int)((UIntPtr)num2)].CalculatePathPositionOffset(b >> 1, vector, out b2))
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
}
PathUnit.Position position;
if (!instance.m_pathUnits.m_buffer[(int)((UIntPtr)num2)].GetPosition(b >> 1, out position))
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
NetInfo info = instance2.m_segments.m_buffer[(int)position.m_segment].Info;
if (info.m_lanes.Length <= (int)position.m_lane)
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
uint num3 = PathManager.GetLaneID(position);
NetInfo.Lane lane = info.m_lanes[(int)position.m_lane];
Bezier3 bezier;
while (true)
{
if ((b & 1) == 0)
{
if (lane.m_laneType != NetInfo.LaneType.CargoVehicle)
{
bool flag = true;
while (b2 != position.m_offset)
{
if (flag)
{
flag = false;
}
else
{
float num4 = Mathf.Sqrt(num) - Vector3.Distance(vector, refPos);
int num5;
if (num4 < 0f)
{
num5 = 4;
}
else
{
num5 = 4 + Mathf.Max(0, Mathf.CeilToInt(num4 * 256f / (instance2.m_lanes.m_buffer[(int)((UIntPtr)num3)].m_length + 1f)));
}
if (b2 > position.m_offset)
{
b2 = (byte)Mathf.Max((int)b2 - num5, (int)position.m_offset);
}
else
{
if (b2 < position.m_offset)
{
b2 = (byte)Mathf.Min((int)b2 + num5, (int)position.m_offset);
}
}
}
Vector3 a;
Vector3 vector2;
float b3;
(vehicleAI as IVehicle).CalculateSegmentPosition(vehicleID, ref vehicleData, position, num3, b2, out a, out vector2, out b3);
b3 = RestrictSpeed(b3, num3, vehicleData.Info);
vector.Set(a.x, a.y, a.z, Mathf.Min(vector.w, b3));
float sqrMagnitude = (a - refPos).sqrMagnitude;
if (sqrMagnitude >= num)
{
if (index <= 0)
{
vehicleData.m_lastPathOffset = b2;
}
vehicleData.SetTargetPos(index++, vector);
num = minSqrDistanceB;
refPos = vector;
vector.w = 1000f;
if (index == max)
{
return;
}
}
}
}
b += 1;
b2 = 0;
if (index <= 0)
{
vehicleData.m_pathPositionIndex = b;
vehicleData.m_lastPathOffset = b2;
}
}
int num6 = (b >> 1) + 1;
uint num7 = num2;
if (num6 >= (int)instance.m_pathUnits.m_buffer[(int)((UIntPtr)num2)].m_positionCount)
{
num6 = 0;
num7 = instance.m_pathUnits.m_buffer[(int)((UIntPtr)num2)].m_nextPathUnit;
if (num7 == 0u)
{
if (index <= 0)
{
Singleton<PathManager>.instance.ReleasePath(vehicleData.m_path);
vehicleData.m_path = 0u;
}
vector.w = 1f;
vehicleData.SetTargetPos(index++, vector);
return;
}
}
PathUnit.Position position2;
if (!instance.m_pathUnits.m_buffer[(int)((UIntPtr)num7)].GetPosition(num6, out position2))
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
NetInfo info2 = instance2.m_segments.m_buffer[(int)position2.m_segment].Info;
if (info2.m_lanes.Length <= (int)position2.m_lane)
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
uint laneID = PathManager.GetLaneID(position2);
NetInfo.Lane lane2 = info2.m_lanes[(int)position2.m_lane];
ushort startNode = instance2.m_segments.m_buffer[(int)position.m_segment].m_startNode;
ushort endNode = instance2.m_segments.m_buffer[(int)position.m_segment].m_endNode;
ushort startNode2 = instance2.m_segments.m_buffer[(int)position2.m_segment].m_startNode;
ushort endNode2 = instance2.m_segments.m_buffer[(int)position2.m_segment].m_endNode;
if (startNode2 != startNode && startNode2 != endNode && endNode2 != startNode && endNode2 != endNode && ((instance2.m_nodes.m_buffer[(int)startNode].m_flags | instance2.m_nodes.m_buffer[(int)endNode].m_flags) & NetNode.Flags.Disabled) == NetNode.Flags.None && ((instance2.m_nodes.m_buffer[(int)startNode2].m_flags | instance2.m_nodes.m_buffer[(int)endNode2].m_flags) & NetNode.Flags.Disabled) != NetNode.Flags.None)
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
if (lane2.m_laneType == NetInfo.LaneType.Pedestrian)
{
if (vehicleID != 0 && (vehicleData.m_flags & Vehicle.Flags.Parking) == Vehicle.Flags.None)
{
byte offset = position.m_offset;
byte offset2 = position.m_offset;
if ((vehicleAI as IVehicle).ParkVehicle(vehicleID, ref vehicleData, position, num7, num6 << 1, out offset2))
{
if (offset2 != offset)
{
if (index <= 0)
{
vehicleData.m_pathPositionIndex = (byte)((int)vehicleData.m_pathPositionIndex & -2);
vehicleData.m_lastPathOffset = offset;
}
position.m_offset = offset2;
instance.m_pathUnits.m_buffer[(int)((UIntPtr)num2)].SetPosition(b >> 1, position);
}
vehicleData.m_flags |= Vehicle.Flags.Parking;
}
else
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
}
}
return;
}
if ((byte)(lane2.m_laneType & (NetInfo.LaneType.Vehicle | NetInfo.LaneType.CargoVehicle | NetInfo.LaneType.TransportVehicle)) == 0)
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
return;
}
if (lane2.m_vehicleType != vehicleAI.m_info.m_vehicleType && (vehicleAI as IVehicle).NeedChangeVehicleType(vehicleID, ref vehicleData, position2, laneID, lane2.m_vehicleType, ref vector))
{
float sqrMagnitude3 = (vector - (Vector4)refPos).sqrMagnitude;
if (sqrMagnitude3 >= num)
{
vehicleData.SetTargetPos(index++, vector);
}
if (index <= 0)
{
if (num6 == 0)
{
Singleton<PathManager>.instance.ReleaseFirstUnit(ref vehicleData.m_path);
}
vehicleData.m_pathPositionIndex = (byte)(num6 << 1);
PathUnit.CalculatePathPositionOffset(laneID, vector, out vehicleData.m_lastPathOffset);
if (vehicleID != 0 && !(vehicleAI as IVehicle).ChangeVehicleType(vehicleID, ref vehicleData, position2, laneID))
{
(vehicleAI as IVehicle).InvalidPath(vehicleID, ref vehicleData, vehicleID, ref vehicleData);
}
}
return;
}
if (position2.m_segment != position.m_segment && vehicleID != 0)
{
vehicleData.m_flags &= ~Vehicle.Flags.Leaving;
}
byte b4 = 0;
if ((vehicleData.m_flags & Vehicle.Flags.Flying) != Vehicle.Flags.None)
{
b4 = (byte)((position2.m_offset < 128) ? 255 : 0);
}
else
{
if (num3 != laneID && lane.m_laneType != NetInfo.LaneType.CargoVehicle)
{
PathUnit.CalculatePathPositionOffset(laneID, vector, out b4);
bezier = default(Bezier3);
Vector3 vector3;
float num8;
(vehicleAI as IVehicle).CalculateSegmentPosition(vehicleID, ref vehicleData, position, num3, position.m_offset, out bezier.a, out vector3, out num8);
num8 = RestrictSpeed(num8, num3, vehicleData.Info);
bool flag2 = b2 == 0;
if (flag2)
{
if ((vehicleData.m_flags & Vehicle.Flags.Reversed) != Vehicle.Flags.None)
{
flag2 = (vehicleData.m_trailingVehicle == 0);
}
else
{
flag2 = (vehicleData.m_leadingVehicle == 0);
}
}
Vector3 vector4;
float num9;
if (flag2)
{
PathUnit.Position nextPosition;
if (!instance.m_pathUnits.m_buffer[(int)((UIntPtr)num7)].GetNextPosition(num6, out nextPosition))
{
nextPosition = default(PathUnit.Position);
}
(vehicleAI as IVehicle).CalculateSegmentPosition(vehicleID, ref vehicleData, nextPosition, position2, laneID, b4, position, num3, position.m_offset, out bezier.d, out vector4, out num9);
num9 = RestrictSpeed(num9, laneID, vehicleData.Info);
}
else
{
(vehicleAI as IVehicle).CalculateSegmentPosition(vehicleID, ref vehicleData, position2, laneID, b4, out bezier.d, out vector4, out num9);
num9 = RestrictSpeed(num9, laneID, vehicleData.Info);
}
if (num9 < 0.01f || (instance2.m_segments.m_buffer[(int)position2.m_segment].m_flags & NetSegment.Flags.Flooded) != NetSegment.Flags.None)
{
if (index <= 0)
{
vehicleData.m_lastPathOffset = b2;
}
vector = bezier.a;
vector.w = 0f;
while (index < max)
{
vehicleData.SetTargetPos(index++, vector);
}
}
if (position.m_offset == 0)
{
vector3 = -vector3;
}
if (b4 < position2.m_offset)
{
vector4 = -vector4;
}
vector3.Normalize();
vector4.Normalize();
float num10;
NetSegment.CalculateMiddlePoints(bezier.a, vector3, bezier.d, vector4, true, true, out bezier.b, out bezier.c, out num10);
if (num10 > 1f)
{
ushort num11;
if (b4 == 0)
{
num11 = instance2.m_segments.m_buffer[(int)position2.m_segment].m_startNode;
}
else
{
if (b4 == 255)
{
num11 = instance2.m_segments.m_buffer[(int)position2.m_segment].m_endNode;
}
else
{
num11 = 0;
}
}
float num12 = 1.57079637f * (1f + Vector3.Dot(vector3, vector4));
if (num10 > 1f)
{
num12 /= num10;
}
num9 = Mathf.Min(num9, (vehicleAI as IVehicle).CalculateTargetSpeed(vehicleID, ref vehicleData, 1000f, num12));
while (b2 < 255)
{
float num13 = Mathf.Sqrt(num) - Vector3.Distance(vector, refPos);
int num14;
if (num13 < 0f)
{
num14 = 8;
}
else
{
num14 = 8 + Mathf.Max(0, Mathf.CeilToInt(num13 * 256f / (num10 + 1f)));
}
b2 = (byte)Mathf.Min((int)b2 + num14, 255);
Vector3 a2 = bezier.Position((float)b2 * 0.003921569f);
vector.Set(a2.x, a2.y, a2.z, Mathf.Min(vector.w, num9));
float sqrMagnitude2 = (a2 - refPos).sqrMagnitude;
if (sqrMagnitude2 >= num)
{
if (index <= 0)
{
vehicleData.m_lastPathOffset = b2;
}
if (num11 != 0)
{
(vehicleAI as IVehicle).UpdateNodeTargetPos(vehicleID, ref vehicleData, num11, ref instance2.m_nodes.m_buffer[(int)num11], ref vector, index);
}
vehicleData.SetTargetPos(index++, vector);
num = minSqrDistanceB;
refPos = vector;
vector.w = 1000f;
if (index == max)
{
return;
}
}
}
}
}
else
{
PathUnit.CalculatePathPositionOffset(laneID, vector, out b4);
}
}
if (index <= 0)
{
if (num6 == 0)
{
Singleton<PathManager>.instance.ReleaseFirstUnit(ref vehicleData.m_path);
}
if (num6 >= (int)(instance.m_pathUnits.m_buffer[(int)((UIntPtr)num7)].m_positionCount - 1) && instance.m_pathUnits.m_buffer[(int)((UIntPtr)num7)].m_nextPathUnit == 0u && vehicleID != 0)
{
(vehicleAI as IVehicle).ArrivingToDestination(vehicleID, ref vehicleData);
}
}
num2 = num7;
b = (byte)(num6 << 1);
b2 = b4;
if (index <= 0)
{
vehicleData.m_pathPositionIndex = b;
vehicleData.m_lastPathOffset = b2;
vehicleData.m_flags = ((vehicleData.m_flags & ~(Vehicle.Flags.OnGravel | Vehicle.Flags.Underground | Vehicle.Flags.Transition)) | info2.m_setVehicleFlags);
}
position = position2;
num3 = laneID;
lane = lane2;
}
}
