private static bool CheckOverlap(Segment3 segment, ushort ignoreVehicle)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 vector = segment.Min();
Vector3 vector2 = segment.Max();
int num = Mathf.Max((int)((vector.x - 100f) / 320f + 27f), 0);
int num2 = Mathf.Max((int)((vector.z - 100f) / 320f + 27f), 0);
int num3 = Mathf.Min((int)((vector2.x + 100f) / 320f + 27f), 53);
int num4 = Mathf.Min((int)((vector2.z + 100f) / 320f + 27f), 53);
bool result = false;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid2 [i * 54 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = CheckOverlap(segment, ignoreVehicle, num5, ref instance.m_vehicles.m_buffer [(int)num5], ref result);
if (++num6 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(result);
}
private void CheckOtherVehicles(ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData, ref float maxSpeed, ref bool blocked, float maxDistance, float maxBraking, int lodPhysics)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 vector = ((Vector3)vehicleData.m_targetPos3) - frameData.m_position;
Vector3 rhs = frameData.m_position + Vector3.ClampMagnitude(vector, maxDistance);
Vector3 min = Vector3.Min(vehicleData.m_segment.Min(), rhs);
Vector3 max = Vector3.Max(vehicleData.m_segment.Max(), rhs);
int num = Mathf.Max((int)((min.x - 100f) / 320f + 27f), 0);
int num2 = Mathf.Max((int)((min.z - 100f) / 320f + 27f), 0);
int num3 = Mathf.Min((int)((max.x + 100f) / 320f + 27f), 53);
int num4 = Mathf.Min((int)((max.z + 100f) / 320f + 27f), 53);
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid2 [i * 54 + j];
int num6 = 0;
while (num5 != 0)
{
num5 = this.CheckOtherVehicle(vehicleID, ref vehicleData, ref frameData, ref maxSpeed, ref blocked, maxBraking, num5, ref instance.m_vehicles.m_buffer [(int)num5], min, max, lodPhysics);
if (++num6 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
private void RefreshVehicleButtons(ushort lineID)
{
if (m_currentMode == MapMode.CONNECTIONS)
{
m_vehiclesLabel.isVisible = false;
m_vehicleButtons.SetItemCount(0);
m_connectionLabel.isVisible = true;
}
else
{
m_vehiclesLabel.isVisible = true;
m_connectionLabel.isVisible = false;
m_vehicleButtons.SetItemCount(Singleton <TransportManager> .instance.m_lines.m_buffer[lineID].CountVehicles(lineID));
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort num = Singleton <TransportManager> .instance.m_lines.m_buffer[lineID].m_vehicles;
int num2 = 0;
while (num != 0)
{
Vector3 relativePosition = m_vehicleButtons.items[num2].relativePosition;
relativePosition.x = m_kvehiclesX;
m_vehicleButtons.items[num2].relativePosition = relativePosition;
m_vehicleButtons.items[num2].objectUserData = num;
num = instance.m_vehicles.m_buffer[num].m_nextLineVehicle;
if (++num2 >= 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
private static ushort FindCargoParent(ushort sourceBuilding, ushort targetBuilding, ItemClass.Service service, ItemClass.SubService subService)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
VehicleManager instance2 = Singleton <VehicleManager> .instance;
ushort num = instance.m_buildings.m_buffer [(int)sourceBuilding].m_ownVehicles;
int num2 = 0;
while (num != 0)
{
if (instance2.m_vehicles.m_buffer [(int)num].m_targetBuilding == targetBuilding && (instance2.m_vehicles.m_buffer [(int)num].m_flags & Vehicle.Flags.WaitingCargo) != Vehicle.Flags.None)
{
VehicleInfo info = instance2.m_vehicles.m_buffer [(int)num].Info;
if (info.m_class.m_service == service && info.m_class.m_subService == subService)
{
int num3;
int num4;
info.m_vehicleAI.GetSize(num, ref instance2.m_vehicles.m_buffer [(int)num], out num3, out num4);
if (num3 < num4)
{
return(num);
}
}
}
num = instance2.m_vehicles.m_buffer [(int)num].m_nextOwnVehicle;
if (++num2 >= 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
return(0);
}
public void RemoveOwnVehicle(ushort vehicleID, ref Vehicle data)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort num = 0;
ushort num2 = this.m_ownVehicles;
int num3 = 0;
while (num2 != 0)
{
if (num2 == vehicleID)
{
if (num != 0)
{
instance.m_vehicles.m_buffer [(int)num].m_nextOwnVehicle = data.m_nextOwnVehicle;
}
else
{
this.m_ownVehicles = data.m_nextOwnVehicle;
}
data.m_nextOwnVehicle = 0;
return;
}
num = num2;
num2 = instance.m_vehicles.m_buffer [(int)num2].m_nextOwnVehicle;
if (++num3 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
CODebugBase <LogChannel> .Error(LogChannel.Core, "Vehicle not found!\n" + Environment.StackTrace);
}
private static uint GetPatientCitizen(ref Vehicle data)
{
// From AmbulanceCopterAI.GetPatientCitizen from original game code at version 1.7.0-f5.
CitizenManager instance = Singleton <CitizenManager> .instance;
uint num1 = data.m_citizenUnits;
int num2 = 0;
while ((int)num1 != 0)
{
uint nextUnit = instance.m_units.m_buffer[num1].m_nextUnit;
for (int index = 0; index < 5; ++index)
{
uint citizen = instance.m_units.m_buffer[num1].GetCitizen(index);
if ((int)citizen != 0 && instance.m_citizens.m_buffer[citizen].Sick)
{
return(citizen);
}
}
num1 = nextUnit;
if (++num2 > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
return(0);
}
public static ushort GetTotalPassengerCount(ushort vehicleID, int maxVehicleCount)
{
var instance = VehicleManager.instance;
var data = instance.m_vehicles.m_buffer[vehicleID];
var trailingVehicle = data.m_trailingVehicle;
var passengerCount = data.m_transferSize;
var num = 0;
while (trailingVehicle != 0)
{
var trailingData = instance.m_vehicles.m_buffer[trailingVehicle];
passengerCount += trailingData.m_transferSize;
trailingVehicle = trailingData.m_trailingVehicle;
if (++num <= maxVehicleCount)
{
continue;
}
CODebugBase <LogChannel> .Error(LogChannel.Core,
"Invalid list detected!\n" + Environment.StackTrace);
break;
}
return(passengerCount);
}
public static float GetResidentialBuildingAverageMoney(Building buildingData)
{
CitizenManager instance = Singleton <CitizenManager> .instance;
uint citzenUnit = buildingData.m_citizenUnits;
int unitCount = 0;
long totalMoney = 0;
float averageMoney = 0;
while (citzenUnit != 0u)
{
if ((ushort)(instance.m_units.m_buffer[citzenUnit].m_flags & CitizenUnit.Flags.Home) != 0)
{
if ((instance.m_units.m_buffer[citzenUnit].m_citizen0 != 0) || (instance.m_units.m_buffer[citzenUnit].m_citizen1 != 0) || (instance.m_units.m_buffer[citzenUnit].m_citizen2 != 0) || (instance.m_units.m_buffer[citzenUnit].m_citizen3 != 0) || (instance.m_units.m_buffer[citzenUnit].m_citizen4 != 0))
{
unitCount++;
totalMoney += (long)CitizenUnitData.familyMoney[citzenUnit];
}
}
citzenUnit = instance.m_units.m_buffer[citzenUnit].m_nextUnit;
if (++unitCount > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
if (unitCount != 0)
{
averageMoney = (float)totalMoney / unitCount;
}
return(averageMoney);
}
public override bool CanSpawnAt(Vector3 pos)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
int num = Mathf.Max((int)((pos.x - 300f) / 320f + 27f), 0);
int num2 = Mathf.Max((int)((pos.z - 300f) / 320f + 27f), 0);
int num3 = Mathf.Min((int)((pos.x + 300f) / 320f + 27f), 53);
int num4 = Mathf.Min((int)((pos.z + 300f) / 320f + 27f), 53);
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = instance.m_vehicleGrid2 [i * 54 + j];
int num6 = 0;
while (num5 != 0)
{
if (Vector3.SqrMagnitude(instance.m_vehicles.m_buffer [(int)num5].GetLastFramePosition() - pos) < 90000f)
{
return(false);
}
num5 = instance.m_vehicles.m_buffer [(int)num5].m_nextGridVehicle;
if (++num6 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(true);
}
public static ushort GetDriverInstanceId(ushort vehicleID, ref Vehicle data) // TODO reverse-redirect
{
CitizenManager instance = Singleton <CitizenManager> .instance;
uint curCitUnitId = data.m_citizenUnits;
int numIters = 0;
while (curCitUnitId != 0u)
{
uint nextUnit = instance.m_units.m_buffer[curCitUnitId].m_nextUnit;
for (int i = 0; i < 5; i++)
{
uint citizenId = instance.m_units.m_buffer[curCitUnitId].GetCitizen(i);
if (citizenId != 0u)
{
ushort citInstanceId = instance.m_citizens.m_buffer[citizenId].m_instance;
if (citInstanceId != 0)
{
return(citInstanceId);
}
}
}
curCitUnitId = nextUnit;
if (++numIters > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
return(0);
}
public string GenerateVehicleChainDebugInfo(ushort segmentId, bool startNode)
{
int index = GetIndex(segmentId, startNode);
ushort vehicleId = ExtSegmentEnds[index].firstVehicleId;
string ret = string.Empty;
int numIter = 0;
while (vehicleId != 0)
{
ref ExtVehicle extVehicle = ref Constants.ManagerFactory.ExtVehicleManager
.ExtVehicles[vehicleId];
ret += string.Format(
" -> {0} (seg: {1}@{2} , adj: {3}..{4})",
vehicleId,
extVehicle.currentSegmentId,
extVehicle.currentStartNode,
extVehicle.previousVehicleIdOnSegment,
extVehicle.nextVehicleIdOnSegment);
vehicleId = extVehicle.nextVehicleIdOnSegment;
if (++numIter > Constants.ServiceFactory.VehicleService.MaxVehicleCount)
{
CODebugBase <LogChannel> .Error(
LogChannel.Core,
"Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
private void RefreshVehicleButtons(ushort lineID)
{
this.m_vehicleButtons.SetItemCount(Singleton <TransportManager> .instance.m_lines.m_buffer[(int)lineID].CountVehicles(lineID));
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort num = Singleton <TransportManager> .instance.m_lines.m_buffer[(int)lineID].m_vehicles;
int index = 0;
while ((int)num != 0)
{
Vector3 relativePosition = this.m_vehicleButtons.items[index].relativePosition;
relativePosition.x = this.kvehiclesX;
this.m_vehicleButtons.items[index].relativePosition = relativePosition;
this.m_vehicleButtons.items[index].objectUserData = (object)num;
//begin mod(+): add tooltip with asset name
this.m_vehicleButtons.items[index].tooltip = Singleton <VehicleManager> .instance.GetVehicleName(num);
//end mod
num = instance.m_vehicles.m_buffer[(int)num].m_nextLineVehicle;
if (++index >= VehicleManagerMod.MaxVehicleCount)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
}
public static ushort[] GetStationStops(ushort buildingID)
{
List <ushort> stationStops = new List <ushort>();
NetManager instance = Singleton <NetManager> .instance;
ushort num1 = Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)buildingID].m_netNode;
int num2 = 0;
while ((int)num1 != 0)
{
if (instance.m_nodes.m_buffer[(int)num1].Info.m_class.m_layer != ItemClass.Layer.PublicTransport)
{
for (int index = 0; index < 8; ++index)
{
ushort segment = instance.m_nodes.m_buffer[(int)num1].GetSegment(index);
if ((int)segment != 0 && (int)instance.m_segments.m_buffer[(int)segment].m_startNode == (int)num1)
{
PanelExtenderCityService.CalculateLanes(instance.m_segments.m_buffer[(int)segment].m_lanes, ref stationStops);
}
}
}
num1 = instance.m_nodes.m_buffer[(int)num1].m_nextBuildingNode;
if (++num2 > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
return(stationStops.ToArray());
}
private static ushort GetBufferStatus(ushort vehicleID, ref Vehicle data)
{
ushort transferSize = data.m_transferSize;
if ((int)data.m_leadingVehicle == 0)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort trailingVehicle = data.m_trailingVehicle;
int num = 0;
while ((int)trailingVehicle != 0)
{
VehicleInfo info = instance.m_vehicles.m_buffer[(int)trailingVehicle].Info;
if ((int)instance.m_vehicles.m_buffer[(int)trailingVehicle].m_leadingVehicle != 0)
{
ushort bufferStatus = PassengerTrainAIDetour.GetBufferStatus(trailingVehicle, ref instance.m_vehicles.m_buffer[(int)trailingVehicle]);
transferSize += bufferStatus;
}
trailingVehicle = instance.m_vehicles.m_buffer[(int)trailingVehicle].m_trailingVehicle;
if (++num > VehicleManagerMod.MaxVehicleCount)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
}
return(transferSize);
}
/*
* Private unmodified methods
*/
private void TryCollectCrime(ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData)
{
Vector3 position = frameData.m_position;
float num = position.x - 32f;
float num2 = position.z - 32f;
float num3 = position.x + 32f;
float num4 = position.z + 32f;
int num5 = Mathf.Max((int)((num - 72f) / 64f + 135f), 0);
int num6 = Mathf.Max((int)((num2 - 72f) / 64f + 135f), 0);
int num7 = Mathf.Min((int)((num3 + 72f) / 64f + 135f), 269);
int num8 = Mathf.Min((int)((num4 + 72f) / 64f + 135f), 269);
BuildingManager instance = Singleton <BuildingManager> .instance;
for (int i = num6; i <= num8; i++)
{
for (int j = num5; j <= num7; j++)
{
ushort num9 = instance.m_buildingGrid[i * 270 + j];
int num10 = 0;
while (num9 != 0)
{
this.TryCollectCrime(vehicleID, ref vehicleData, ref frameData, num9, ref instance.m_buildings.m_buffer[(int)num9]);
num9 = instance.m_buildings.m_buffer[(int)num9].m_nextGridBuilding;
if (++num10 >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
public static void CalculateOwnVehicles(ref Building data, ref int count, ref int cargo, ref int capacity, ref int inbound, ref int outbound)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort num = data.m_ownVehicles;
int num2 = 0;
while (num != 0)
{
VehicleInfo info = instance.m_vehicles.m_buffer[num].Info;
info.m_vehicleAI.GetSize(num, ref instance.m_vehicles.m_buffer[num], out int a, out int num3);
cargo += Mathf.Min(a, num3);
capacity += num3;
count++;
if ((instance.m_vehicles.m_buffer[num].m_flags & (Vehicle.Flags.Importing)) != 0)
{
inbound++;
}
if ((instance.m_vehicles.m_buffer[num].m_flags & (Vehicle.Flags.Exporting)) != 0)
{
outbound++;
}
num = instance.m_vehicles.m_buffer[num].m_nextOwnVehicle;
if (++num2 > 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
protected override void Awake()
{
base.Awake();
this.m_audioLocation = Path.Combine(DataLocation.gameContentPath, "Audio");
this.m_currentMusicFile = null;
this.m_previousMusicFile = null;
this.m_streamCrossFade = 0;
this.m_listenerInfo = new AudioManager.ListenerInfo();
this.m_defaultGroup = new AudioGroup(3, new SavedFloat(Settings.uiAudioVolume, Settings.gameSettingsFile, DefaultSettings.uiAudioVolume, true));
this.m_ambientGroup = new AudioGroup(3, new SavedFloat(Settings.ambientAudioVolume, Settings.gameSettingsFile, DefaultSettings.ambientAudioVolume, true));
this.m_serviceProximity = new float[21];
this.m_subServiceProximity = new float[15];
this.m_eventBuffer = new FastList <AudioManager.SimulationEvent>();
this.m_mainAudioVolume = new SavedFloat(Settings.mainAudioVolume, Settings.gameSettingsFile, DefaultSettings.mainAudioVolume, true);
this.m_musicAudioVolume = new SavedFloat(Settings.musicAudioVolume, Settings.gameSettingsFile, DefaultSettings.musicAudioVolume, true);
this.m_tempBuffer1 = new byte[16384];
this.m_tempBuffer2 = new byte[16384];
this.m_streamBuffer = new float[65536];
this.m_streamLock = new object();
this.m_streamThread = new Thread(new ThreadStart(this.StreamThread));
this.m_streamThread.Name = "Music Stream";
this.m_streamThread.Priority = ThreadPriority.AboveNormal;
this.m_streamThread.Start();
if (!this.m_streamThread.IsAlive)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Audio stream thread failed to start!");
}
GameObject gameObject = new GameObject("Audio Listener");
Object.DontDestroyOnLoad(gameObject);
this.m_audioListener = gameObject.AddComponent <AudioListener>();
this.m_audioListener.enabled = false;
gameObject.AddComponent <MusicFilter>();
}
protected static void CalculateGuestVehicles(ushort buildingID, ref Building data, TransferManager.TransferReason material, ref int count, ref int cargo, ref int capacity, ref int outside)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
ushort num = data.m_guestVehicles;
int num2 = 0;
while (num != 0)
{
if ((TransferManager.TransferReason)instance.m_vehicles.m_buffer[(int)num].m_transferType == material)
{
VehicleInfo info = instance.m_vehicles.m_buffer[(int)num].Info;
int a;
int num3;
info.m_vehicleAI.GetSize(num, ref instance.m_vehicles.m_buffer[(int)num], out a, out num3);
cargo += Mathf.Min(a, num3);
capacity += num3;
count++;
if ((instance.m_vehicles.m_buffer[(int)num].m_flags & (Vehicle.Flags.Importing | Vehicle.Flags.Exporting)) != (Vehicle.Flags) 0)
{
outside++;
}
}
num = instance.m_vehicles.m_buffer[(int)num].m_nextGuestVehicle;
if (++num2 > Singleton <VehicleManager> .instance.m_vehicles.m_size)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
public static void Init()
{
var inst = Singleton <TransferManager> .instance;
var incomingCount = typeof(TransferManager).GetField("m_incomingCount", BindingFlags.NonPublic | BindingFlags.Instance);
var incomingOffers = typeof(TransferManager).GetField("m_incomingOffers", BindingFlags.NonPublic | BindingFlags.Instance);
var incomingAmount = typeof(TransferManager).GetField("m_incomingAmount", BindingFlags.NonPublic | BindingFlags.Instance);
var outgoingCount = typeof(TransferManager).GetField("m_outgoingCount", BindingFlags.NonPublic | BindingFlags.Instance);
var outgoingOffers = typeof(TransferManager).GetField("m_outgoingOffers", BindingFlags.NonPublic | BindingFlags.Instance);
var outgoingAmount = typeof(TransferManager).GetField("m_outgoingAmount", BindingFlags.NonPublic | BindingFlags.Instance);
if (inst == null)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "No instance of TransferManager found!");
DebugOutputPanel.AddMessage(PluginManager.MessageType.Error, "No instance of TransferManager found!");
return;
}
m_incomingCount = incomingCount.GetValue(inst) as ushort[];
m_incomingOffers = incomingOffers.GetValue(inst) as TransferManager.TransferOffer[];
m_incomingAmount = incomingAmount.GetValue(inst) as int[];
m_outgoingCount = outgoingCount.GetValue(inst) as ushort[];
m_outgoingOffers = outgoingOffers.GetValue(inst) as TransferManager.TransferOffer[];
m_outgoingAmount = outgoingAmount.GetValue(inst) as int[];
InitDelegate();
}
public static ushort GetPassengerInstance(ushort vehicleID, ref Vehicle data)
{
CitizenManager instance = Singleton <CitizenManager> .instance;
uint num = data.m_citizenUnits;
int num2 = 0;
while (num != 0u)
{
uint nextUnit = instance.m_units.m_buffer[(int)((UIntPtr)num)].m_nextUnit;
for (int i = 0; i < 5; i++)
{
uint citizen = instance.m_units.m_buffer[(int)((UIntPtr)num)].GetCitizen(i);
if (citizen != 0u)
{
ushort instance2 = instance.m_citizens.m_buffer[(int)((UIntPtr)citizen)].m_instance;
if (instance2 != 0)
{
return(instance2);
}
}
}
num = nextUnit;
if (++num2 > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
return(0);
}
public static bool GetClosestFreeTrailer(ushort vehicleID, Vector3 position, out ushort trailerID, out uint unitID)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
float num = 1E+10f;
trailerID = 0;
unitID = 0u;
int num2 = 0;
while (vehicleID != 0)
{
float num3 = Vector3.SqrMagnitude(position - instance.m_vehicles.m_buffer [(int)vehicleID].GetLastFrameData().m_position);
if (num3 < num)
{
uint notFullCitizenUnit = instance.m_vehicles.m_buffer [(int)vehicleID].GetNotFullCitizenUnit(CitizenUnit.Flags.Vehicle);
if (notFullCitizenUnit != 0u)
{
num = num3;
trailerID = vehicleID;
unitID = notFullCitizenUnit;
}
}
vehicleID = instance.m_vehicles.m_buffer [(int)vehicleID].m_trailingVehicle;
if (++num2 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
return(trailerID != 0);
}
private void RemoveLaneConnection(ushort nodeID, ref NetNode data)
{
NetManager instance = Singleton <NetManager> .instance;
ushort num = 0;
ushort num2 = instance.m_lanes.m_buffer[(int)((UIntPtr)data.m_lane)].m_nodes;
int num3 = 0;
while (num2 != 0)
{
if (num2 == nodeID)
{
if (num == 0)
{
instance.m_lanes.m_buffer[(int)((UIntPtr)data.m_lane)].m_nodes = data.m_nextLaneNode;
}
else
{
instance.m_nodes.m_buffer[(int)num].m_nextLaneNode = data.m_nextLaneNode;
}
break;
}
num = num2;
num2 = instance.m_nodes.m_buffer[(int)num2].m_nextLaneNode;
if (++num3 > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
data.m_lane = 0u;
data.m_laneOffset = 0;
data.m_nextLaneNode = 0;
}
private static ushort GetDriverInstance(ushort vehicleID, ref Vehicle data)
{
CitizenManager instance1 = Singleton <CitizenManager> .instance;
uint num1 = data.m_citizenUnits;
int num2 = 0;
while ((int)num1 != 0)
{
uint nextUnit = instance1.m_units.m_buffer[num1].m_nextUnit;
for (int index = 0; index < 5; ++index)
{
uint citizen = instance1.m_units.m_buffer[num1].GetCitizen(index);
if ((int)citizen != 0)
{
ushort instance2 = instance1.m_citizens.m_buffer[citizen].m_instance;
if ((int)instance2 != 0)
{
return(instance2);
}
}
}
num1 = nextUnit;
if (++num2 > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
return(0);
}
private static bool CheckOverlap(Segment3 segment, ushort ignoreVehicle, float maxVelocity)
{
VehicleManager instance = Singleton <VehicleManager> .instance;
Vector3 vector3_1 = segment.Min();
Vector3 vector3_2 = segment.Max();
int num1 = Mathf.Max((int)(((double)vector3_1.x - 10.0) / 32.0 + 270.0), 0);
int num2 = Mathf.Max((int)(((double)vector3_1.z - 10.0) / 32.0 + 270.0), 0);
int num3 = Mathf.Min((int)(((double)vector3_2.x + 10.0) / 32.0 + 270.0), 539);
int num4 = Mathf.Min((int)(((double)vector3_2.z + 10.0) / 32.0 + 270.0), 539);
bool overlap = false;
for (int index1 = num2; index1 <= num4; ++index1)
{
for (int index2 = num1; index2 <= num3; ++index2)
{
ushort otherID = instance.m_vehicleGrid[index1 * 540 + index2];
int num5 = 0;
while (otherID != (ushort)0)
{
otherID = CheckOverlap(segment, ignoreVehicle, maxVelocity, otherID, ref instance.m_vehicles.m_buffer[(int)otherID], ref overlap);
if (++num5 > 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
}
}
return(overlap);
}
public static bool GetNearStopPoints(Vector3 pos, float maxDistance, ref Dictionary <ushort, Vector3> stopsFound, ItemClass.SubService[] subservicesAllowed = null, int maxDepht = 4, int depth = 0)
{
if (depth >= maxDepht)
{
return(false);
}
if (subservicesAllowed == null)
{
subservicesAllowed = new ItemClass.SubService[] { ItemClass.SubService.PublicTransportTrain, ItemClass.SubService.PublicTransportMetro };
}
int num = Mathf.Max((int)((pos.x - maxDistance) / 64f + 135f), 0);
int num2 = Mathf.Max((int)((pos.z - maxDistance) / 64f + 135f), 0);
int num3 = Mathf.Min((int)((pos.x + maxDistance) / 64f + 135f), 269);
int num4 = Mathf.Min((int)((pos.z + maxDistance) / 64f + 135f), 269);
bool noneFound = true;
NetManager nm = Singleton <NetManager> .instance;
TransportManager tm = Singleton <TransportManager> .instance;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort stopId = nm.m_nodeGrid[i * 270 + j];
int num7 = 0;
while (stopId != 0)
{
NetInfo info = nm.m_nodes.m_buffer[stopId].Info;
if ((info.m_class.m_service == ItemClass.Service.PublicTransport) && subservicesAllowed.Contains(info.m_class.m_subService))
{
ushort transportLine = nm.m_nodes.m_buffer[stopId].m_transportLine;
if (transportLine != 0)
{
if (!stopsFound.Keys.Contains(stopId))
{
float num8 = Vector3.SqrMagnitude(pos - nm.m_nodes.m_buffer[stopId].m_position);
if (num8 < maxDistance * maxDistance)
{
stopsFound[stopId] = nm.m_nodes.m_buffer[stopId].m_position;
GetNearStopPoints(nm.m_nodes.m_buffer[stopId].m_position, maxDistance, ref stopsFound, subservicesAllowed, maxDepht, depth + 1);
noneFound = false;
}
}
}
}
stopId = nm.m_nodes.m_buffer[stopId].m_nextGridNode;
if (++num7 >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(noneFound);
}
private void WorkshopAdPanelOnQueryCompleted(UGCDetails result, bool ioError)
{
try
{
var workshopAdPanel = GameObject.Find("WorkshopAdPanel").GetComponent <WorkshopAdPanel>();
if (result.result == Result.OK)
{
UIComponent uIComponent = Util.GetPrivate <UIScrollablePanel>(workshopAdPanel, "m_ScrollContainer").AttachUIComponent
(UITemplateManager.GetAsGameObject("WorkshopAdTemplate"));
string price = String.Format(CultureInfo.CurrentCulture, "{0:C}", 0.99f);
if (UnityEngine.Random.Range(0, 2) == 0)
{
price = String.Format(CultureInfo.CurrentCulture, "{0:C}", 2.49f);
}
else if (UnityEngine.Random.Range(0, 7) == 0)
{
price = String.Format(CultureInfo.CurrentCulture, "{0:C}", 4.99f);
}
else if (UnityEngine.Random.Range(0, 25) == 0)
{
price = String.Format(CultureInfo.CurrentCulture, "{0:C}", 8.49f);
}
uIComponent.Find <UILabel>("Title").text = String.Format("{0} - {1}\n{2}", result.title, price, result.tags);
if (result.image != null)
{
result.image.wrapMode = TextureWrapMode.Clamp;
}
uIComponent.Find <UITextureSprite>("Image").texture = result.image;
UIProgressBar uIProgressBar = uIComponent.Find <UIProgressBar>("Rating");
uIProgressBar.isVisible = (result.score >= 0f);
uIProgressBar.value = result.score;
uIComponent.Find <UIButton>("ClickableArea").eventClick += delegate(UIComponent c, UIMouseEventParameter p)
{
if (Steam.IsOverlayEnabled())
{
Steam.ActivateGameOverlayToWorkshopItem(result.publishedFileId);
}
};
}
else
{
CODebugBase <LogChannel> .Warn(LogChannel.Core, string.Concat(new object[]
{
"Workshop item: ",
result.publishedFileId,
" error: ",
result.result
}));
}
}
catch (Exception ex)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, ex.ToString());
}
}
//based off code in the SimulationStep of TransportLine
public static int CountLineActiveVehicles(ushort lineID, out int allVehicles, Action <Int32> callback = null)
{
TransportLine thisLine = TransportManager.instance.m_lines.m_buffer[lineID];
int activeVehicles = 0;
allVehicles = 0;
//this part is directly taken from beginning of vanilla SimulationStep method (except for marked part)
if (thisLine.Complete)
{
int num2 = 0;
int num3 = 0;
if ((int)thisLine.m_vehicles != 0)
{
VehicleManager instance3 = Singleton <VehicleManager> .instance;
ushort num4 = thisLine.m_vehicles;
int num5 = 0;
while ((int)num4 != 0)
{
ushort nextLineVehicle = instance3.m_vehicles.m_buffer[(int)num4].m_nextLineVehicle;
++num2;
if ((instance3.m_vehicles.m_buffer[(int)num4].m_flags & Vehicle.Flags.GoingBack) ==
~(Vehicle.Flags.Created | Vehicle.Flags.Deleted | Vehicle.Flags.Spawned |
Vehicle.Flags.Inverted | Vehicle.Flags.TransferToTarget | Vehicle.Flags.TransferToSource |
Vehicle.Flags.Emergency1 | Vehicle.Flags.Emergency2 | Vehicle.Flags.WaitingPath |
Vehicle.Flags.Stopped | Vehicle.Flags.Leaving | Vehicle.Flags.Arriving |
Vehicle.Flags.Reversed | Vehicle.Flags.TakingOff | Vehicle.Flags.Flying |
Vehicle.Flags.Landing | Vehicle.Flags.WaitingSpace | Vehicle.Flags.WaitingCargo |
Vehicle.Flags.GoingBack | Vehicle.Flags.WaitingTarget | Vehicle.Flags.Importing |
Vehicle.Flags.Exporting | Vehicle.Flags.Parking | Vehicle.Flags.CustomName |
Vehicle.Flags.OnGravel | Vehicle.Flags.WaitingLoading | Vehicle.Flags.Congestion |
Vehicle.Flags.DummyTraffic | Vehicle.Flags.Underground | Vehicle.Flags.Transition |
Vehicle.Flags.InsideBuilding | Vehicle.Flags.LeftHandDrive))
{
//begin mod(+): callback
callback?.Invoke(num4);
//end mod
++num3;
}
num4 = nextLineVehicle;
if (++num5 > CachedVehicleData.MaxVehicleCount)
{
CODebugBase <LogChannel> .Error(LogChannel.Core,
"Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
}
//end of vanilla part
activeVehicles = num3;
allVehicles = num2;
}
return(activeVehicles);
}
/// <summary>
/// Detour for ToolManager.EndRenderingImpl
/// </summary>
private void EndRenderingImpl(RenderManager.CameraInfo cameraInfo)
{
ToolController properties = Singleton <ToolManager> .instance.m_properties;
if (properties != null)
{
PrefabInfo editPrefabInfo = properties.m_editPrefabInfo;
if (editPrefabInfo != null)
{
VehicleInfo vehicleInfo = editPrefabInfo as VehicleInfo;
if (vehicleInfo != null)
{
// Modified implementation
RenderInfo(cameraInfo, vehicleInfo, new Vector3(0f, 60f, 0f), false);
if (vehicleInfo.m_trailers != null)
{
// Bug(?) fix: main info's m_attachOffsetBack did not get applied
float num = vehicleInfo.m_generatedInfo.m_size.z * 0.5f - vehicleInfo.m_attachOffsetBack;
for (int i = 0; i < vehicleInfo.m_trailers.Length; i++)
{
VehicleInfo info = vehicleInfo.m_trailers[i].m_info;
// New: Support correct display of inverted trailers
bool isInverted = (vehicleInfo.m_trailers[i].m_invertProbability >= 100);
float frontDelta = info.m_generatedInfo.m_size.z * 0.5f - info.m_attachOffsetFront;
float backDelta = info.m_generatedInfo.m_size.z * 0.5f - info.m_attachOffsetBack;
num += isInverted ? backDelta : frontDelta;
Vector3 position = new Vector3(0f, 60f, 0f) + new Vector3(0f, 0f, -num);
RenderInfo(cameraInfo, info, position, isInverted);
// Change for inverted vehicles
num += isInverted ? frontDelta : backDelta;
}
}
}
else
{
//Default
editPrefabInfo.RenderMesh(cameraInfo);
}
}
try
{
ToolBase currentTool = properties.CurrentTool;
if (currentTool != null)
{
currentTool.RenderGeometry(cameraInfo);
}
}
catch (Exception ex)
{
UIView.ForwardException(ex);
CODebugBase <LogChannel> .Error(LogChannel.Core, "Tool error: " + ex.Message + "\n" + ex.StackTrace);
}
}
}
public override void SimulationStep(ushort vehicleID, ref Vehicle data, Vector3 physicsLodRefPos)
{
if ((data.m_flags & Vehicle.Flags.WaitingPath) != Vehicle.Flags.None)
{
PathManager instance = Singleton <PathManager> .instance;
byte pathFindFlags = instance.m_pathUnits.m_buffer [(int)((UIntPtr)data.m_path)].m_pathFindFlags;
if ((pathFindFlags & 4) != 0)
{
data.m_pathPositionIndex = 255;
data.m_flags &= ~Vehicle.Flags.WaitingPath;
this.TrySpawn(vehicleID, ref data);
}
else
{
if ((pathFindFlags & 8) != 0)
{
data.m_flags &= ~Vehicle.Flags.WaitingPath;
Singleton <PathManager> .instance.ReleasePath(data.m_path);
data.m_path = 0u;
data.Unspawn(vehicleID);
return;
}
}
}
else
{
if ((data.m_flags & Vehicle.Flags.WaitingSpace) != Vehicle.Flags.None)
{
this.TrySpawn(vehicleID, ref data);
}
}
this.SimulationStep(vehicleID, ref data, vehicleID, ref data, 0);
if (data.m_leadingVehicle == 0 && data.m_trailingVehicle != 0)
{
VehicleManager instance2 = Singleton <VehicleManager> .instance;
ushort num = data.m_trailingVehicle;
int num2 = 0;
while (num != 0)
{
ushort trailingVehicle = instance2.m_vehicles.m_buffer [(int)num].m_trailingVehicle;
VehicleInfo info = instance2.m_vehicles.m_buffer [(int)num].Info;
info.m_vehicleAI.SimulationStep(num, ref instance2.m_vehicles.m_buffer [(int)num], vehicleID, ref data, 0);
num = trailingVehicle;
if (++num2 > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
if ((data.m_flags & (Vehicle.Flags.Spawned | Vehicle.Flags.WaitingPath | Vehicle.Flags.WaitingSpace | Vehicle.Flags.WaitingCargo)) == Vehicle.Flags.None || data.m_blockCounter == 255)
{
Singleton <VehicleManager> .instance.ReleaseVehicle(vehicleID);
}
}
public override bool CalculateGroupData(int groupX, int groupZ, int layer, ref int vertexCount, ref int triangleCount, ref int objectCount, ref RenderGroup.VertexArrays vertexArrays)
{
bool result = false;
const int resolutionRatio = NODEGRID_RESOLUTION / RenderManager.GROUP_RESOLUTION; // = 270/45 = 6
int net_x0 = groupX * resolutionRatio;
int net_z0 = groupZ * resolutionRatio;
int net_x1 = (groupX + 1) * resolutionRatio - 1;
int net_z1 = (groupZ + 1) * resolutionRatio - 1;
for (int net_z = net_z0; net_z <= net_z1; net_z++)
{
for (int net_x = net_x0; net_x <= net_x1; net_x++)
{
ushort nodeID = m_nodeGrid[net_z * NODEGRID_RESOLUTION + net_x];
int watchdog = 0;
while (nodeID != 0)
{
if (nodeID.ToNode().CalculateGroupData(nodeID, layer, ref vertexCount, ref triangleCount, ref objectCount, ref vertexArrays))
{
result = true;
}
nodeID = nodeID.ToNode().m_nextGridNode;
if (++watchdog >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
for (int net_z = net_z0; net_z <= net_z1; net_z++)
{
for (int net_x = net_x0; net_x <= net_x1; net_x++)
{
ushort segmentID = m_segmentGrid[net_z * 270 + net_x];
int watchdog = 0;
while (segmentID != 0)
{
if (segmentID.ToSegment().CalculateGroupData(segmentID, layer, ref vertexCount, ref triangleCount, ref objectCount, ref vertexArrays))
{
result = true;
}
segmentID = segmentID.ToSegment().m_nextGridSegment;
if (++watchdog >= 36864)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
return(result);
}