using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using HawkNetworking;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Wobbly Life Traffic Plus")]
[assembly: AssemblyDescription("Ground-compatible varied traffic and Doomsday events for Wobbly Life.")]
[assembly: AssemblyCompany("Zappyix")]
[assembly: AssemblyProduct("Wobbly Life Traffic Plus")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyVersion("1.0.6.0")]
namespace Zappyix.WobblyLife.TrafficPlus;

[BepInPlugin("zappyix.wobblylife.trafficplus", "Wobbly Life Traffic Plus", "1.0.6")]
public sealed class WobblyLifeTrafficPlusPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "zappyix.wobblylife.trafficplus";

	public const string PluginName = "Wobbly Life Traffic Plus";

	public const string PluginVersion = "1.0.6";

	private const BindingFlags InstanceFields = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

	private static readonly Type TrafficManagerType = typeof(PlayerNPCNavigation).Assembly.GetType("TrafficManager");

	private static readonly FieldInfo TrafficLastUpdate = ((TrafficManagerType == null) ? null : TrafficManagerType.GetField("trafficUpdateTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly FieldInfo TrafficMaxVehicles = ((TrafficManagerType == null) ? null : TrafficManagerType.GetField("maxVehicles", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly FieldInfo VehicleDefaultTopSpeed = typeof(PlayerVehicleRoadMovement).GetField("defaultTopSpeedMph", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo VehicleTopSpeed = typeof(PlayerVehicleRoadMovement).GetField("topSpeedMph", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo VehiclePreSimulate = typeof(PlayerVehicleRoadMovement).GetField("onPreSimulate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo VehicleRoadRage = typeof(PlayerVehicleRoadAI).GetField("bRoadRage", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly MethodInfo SpawnAi = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("SpawnAI", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly MethodInfo GetVehicleSpawn = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("GetVehicleSpawn", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly MethodInfo SpawnAiVehicle = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("SpawnAIVehicle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly MethodInfo GetAvailableVehicleAi = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("GetAvaliableVehicleAI", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly MethodInfo MakeUnavailable = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("MakeUnavaliable", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly MethodInfo SetupAiVehicle = ((TrafficManagerType == null) ? null : TrafficManagerType.GetMethod("SetupAIVehicle", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

	private static readonly FieldInfo AllVehicleDatabases = typeof(VehicleManager).GetField("allVehiclesAssetReferences", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly MethodInfo ForceInputMethod = typeof(WobblyLifeTrafficPlusPlugin).GetMethod("ForceDoomsdayInput", BindingFlags.Static | BindingFlags.NonPublic);

	private readonly Dictionary<int, uint> originalTrafficCaps = new Dictionary<int, uint>();

	private readonly Dictionary<int, float> originalVehicleSpeeds = new Dictionary<int, float>();

	private readonly Dictionary<int, float> originalVehicleDefaultSpeeds = new Dictionary<int, float>();

	private readonly Dictionary<int, bool> originalRoadRage = new Dictionary<int, bool>();

	private readonly Dictionary<int, PlayerVehicleRoadMovement> forcedMovements = new Dictionary<int, PlayerVehicleRoadMovement>();

	private readonly List<object> groundVehiclePrefabs = new List<object>();

	private readonly Queue<object> uncheckedVehiclePrefabs = new Queue<object>();

	private readonly HashSet<string> discoveredVehiclePrefabGuids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private readonly HashSet<string> acceptedGroundVehicleGuids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

	private Delegate forceInputDelegate;

	private ConfigEntry<float> normalSpawnMultiplier;

	private ConfigEntry<float> doomsdayVehicleSpeedMultiplier;

	private ConfigEntry<float> doomsdaySpawnMultiplier;

	private ConfigEntry<float> doomsdayDurationSeconds;

	private ConfigEntry<bool> showDoomsdayBanner;

	private ConfigEntry<float> doomsdayDelaySeconds;

	private float nextScanTime;

	private float nextTrafficSpawnTime;

	private float nextDoomsdayTime;

	private float doomsdayEndTime;

	private float bannerEndTime;

	private float nextVehicleCatalogRefreshTime;

	private bool doomsdayActive;

	private bool warnedNotHost;

	private GUIStyle bannerStyle;

	private void Awake()
	{
		normalSpawnMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Traffic", "SpawnMultiplier", 3f, "Traffic spawn frequency and capacity multiplier outside Doomsday.");
		doomsdayVehicleSpeedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Doomsday", "VehicleSpeedMultiplier", 50f, "AI vehicle top-speed multiplier during Doomsday.");
		doomsdaySpawnMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Doomsday", "SpawnMultiplier", 100f, "Traffic spawn frequency and capacity multiplier during Doomsday.");
		doomsdayDelaySeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Doomsday", "DelaySeconds", 60f, "Fixed normal-mode delay before the next Doomsday.");
		doomsdayDurationSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Doomsday", "DurationSeconds", 60f, "How long one Doomsday lasts.");
		showDoomsdayBanner = ((BaseUnityPlugin)this).Config.Bind<bool>("Doomsday", "ShowBanner", true, "Show the red Doomsday countdown at the top of the screen.");
		if (Mathf.Approximately(doomsdayVehicleSpeedMultiplier.Value, 20f))
		{
			doomsdayVehicleSpeedMultiplier.Value = 50f;
		}
		if (Mathf.Approximately(doomsdaySpawnMultiplier.Value, 18f))
		{
			doomsdaySpawnMultiplier.Value = 100f;
		}
		ScheduleNextDoomsday();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Wobbly Life Traffic Plus 1.0.6 loaded.");
	}

	private void Update()
	{
		bool flag = IsHost();
		if (Time.unscaledTime >= nextScanTime)
		{
			nextScanTime = Time.unscaledTime + 0.5f;
			ApplyTraffic(flag);
			ApplyVehicleSpeed(flag);
		}
		if (!flag)
		{
			if (!warnedNotHost)
			{
				warnedNotHost = true;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Traffic and Doomsday are host-controlled.");
			}
			return;
		}
		warnedNotHost = false;
		if (!doomsdayActive && Time.unscaledTime >= nextDoomsdayTime)
		{
			BeginDoomsday();
		}
		else if (doomsdayActive && Time.unscaledTime >= doomsdayEndTime)
		{
			EndDoomsday();
		}
		RunTrafficSpawner();
	}

	private static bool IsHost()
	{
		try
		{
			HawkNetworkManager defaultInstance = HawkNetworkManager.DefaultInstance;
			return (Object)(object)defaultInstance != (Object)null && defaultInstance.IsServer();
		}
		catch
		{
			return false;
		}
	}

	private void ApplyTraffic(bool isHost)
	{
		if (!isHost || TrafficMaxVehicles == null)
		{
			return;
		}
		Object[] array = FindTrafficManagers();
		float num = CurrentSpawnMultiplier();
		foreach (Object val in array)
		{
			if (!Object.op_Implicit(val))
			{
				continue;
			}
			int instanceID = val.GetInstanceID();
			if (!originalTrafficCaps.TryGetValue(instanceID, out var value))
			{
				value = (uint)TrafficMaxVehicles.GetValue(val);
				if (value == 0)
				{
					value = 5u;
				}
				originalTrafficCaps[instanceID] = value;
			}
			uint num2 = (uint)Mathf.Clamp(Mathf.RoundToInt((float)value * num), 1, 120);
			TrafficMaxVehicles.SetValue(val, num2);
		}
	}

	private void ApplyVehicleSpeed(bool isHost)
	{
		if (!isHost || VehicleTopSpeed == null || VehicleDefaultTopSpeed == null)
		{
			return;
		}
		PlayerVehicleRoadAI[] array = Object.FindObjectsOfType<PlayerVehicleRoadAI>();
		foreach (PlayerVehicleRoadAI val in array)
		{
			if (!Object.op_Implicit((Object)(object)val))
			{
				continue;
			}
			PlayerVehicleRoadMovement val2 = ((Component)val).GetComponent<PlayerVehicleRoadMovement>();
			if (!Object.op_Implicit((Object)(object)val2))
			{
				val2 = ((Component)val).GetComponentInChildren<PlayerVehicleRoadMovement>();
			}
			if (!Object.op_Implicit((Object)(object)val2))
			{
				continue;
			}
			int instanceID = ((Object)val2).GetInstanceID();
			if (!originalVehicleSpeeds.TryGetValue(instanceID, out var value))
			{
				value = (float)VehicleDefaultTopSpeed.GetValue(val2);
				if (value <= 0f)
				{
					value = (float)VehicleTopSpeed.GetValue(val2);
				}
				if (value <= 0f)
				{
					value = 100f;
				}
				originalVehicleSpeeds[instanceID] = value;
				originalVehicleDefaultSpeeds[instanceID] = (float)VehicleDefaultTopSpeed.GetValue(val2);
			}
			float num = (doomsdayActive ? Mathf.Max(1f, doomsdayVehicleSpeedMultiplier.Value) : 1f);
			VehicleDefaultTopSpeed.SetValue(val2, originalVehicleDefaultSpeeds[instanceID] * num);
			VehicleTopSpeed.SetValue(val2, value * num);
			int instanceID2 = ((Object)val).GetInstanceID();
			if (VehicleRoadRage != null && !originalRoadRage.ContainsKey(instanceID2))
			{
				originalRoadRage[instanceID2] = (bool)VehicleRoadRage.GetValue(val);
			}
			if (doomsdayActive && ((Behaviour)val).enabled)
			{
				if (VehicleRoadRage != null)
				{
					VehicleRoadRage.SetValue(val, true);
				}
				AttachForcedInput(val2);
			}
			else
			{
				if (VehicleRoadRage != null && originalRoadRage.TryGetValue(instanceID2, out var value2))
				{
					VehicleRoadRage.SetValue(val, value2);
				}
				DetachForcedInput(val2);
			}
		}
	}

	private void AttachForcedInput(PlayerVehicleRoadMovement movement)
	{
		if (!Object.op_Implicit((Object)(object)movement) || VehiclePreSimulate == null || ForceInputMethod == null)
		{
			return;
		}
		int instanceID = ((Object)movement).GetInstanceID();
		if (!forcedMovements.ContainsKey(instanceID))
		{
			if ((object)forceInputDelegate == null)
			{
				forceInputDelegate = Delegate.CreateDelegate(VehiclePreSimulate.FieldType, ForceInputMethod);
			}
			Delegate a = (Delegate)VehiclePreSimulate.GetValue(movement);
			VehiclePreSimulate.SetValue(movement, Delegate.Combine(a, forceInputDelegate));
			forcedMovements[instanceID] = movement;
		}
	}

	private void DetachForcedInput(PlayerVehicleRoadMovement movement)
	{
		if (Object.op_Implicit((Object)(object)movement) && !(VehiclePreSimulate == null) && (object)forceInputDelegate != null)
		{
			int instanceID = ((Object)movement).GetInstanceID();
			if (forcedMovements.ContainsKey(instanceID))
			{
				Delegate source = (Delegate)VehiclePreSimulate.GetValue(movement);
				VehiclePreSimulate.SetValue(movement, Delegate.Remove(source, forceInputDelegate));
				forcedMovements.Remove(instanceID);
			}
		}
	}

	private static void ForceDoomsdayInput(ref VehicleRoadInput input)
	{
		input.acceleration = ((input.acceleration < -0.05f) ? (-1f) : 1f);
		input.bHandbrake = false;
		input.bHorn = Time.unscaledTime % 4f < 3f;
	}

	private void RunTrafficSpawner()
	{
		if (TrafficLastUpdate == null || SpawnAi == null)
		{
			return;
		}
		float num = CurrentSpawnMultiplier();
		float num2 = 1f / Mathf.Max(1f, num);
		if (Time.unscaledTime < nextTrafficSpawnTime)
		{
			return;
		}
		nextTrafficSpawnTime = Time.unscaledTime + num2;
		Object[] array = FindTrafficManagers();
		foreach (Object val in array)
		{
			if (!Object.op_Implicit(val))
			{
				continue;
			}
			TrafficLastUpdate.SetValue(val, Time.time);
			try
			{
				if (!TrySpawnRandomVehicle(val))
				{
					SpawnAi.Invoke(val, null);
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Traffic spawn failed: " + ex.GetBaseException().Message));
			}
		}
	}

	private bool TrySpawnRandomVehicle(Object trafficManager)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		if (GetVehicleSpawn == null || SpawnAiVehicle == null)
		{
			return false;
		}
		RefreshVehicleCatalog();
		if (groundVehiclePrefabs.Count == 0)
		{
			return false;
		}
		object obj = GetVehicleSpawn.Invoke(trafficManager, null);
		if (!(obj is Object) || !Object.op_Implicit((Object)obj))
		{
			return true;
		}
		object obj2 = groundVehiclePrefabs[Random.Range(0, groundVehiclePrefabs.Count)];
		if (Guid.TryParse(GetAssetGuid(obj2), out var result) && GetAvailableVehicleAi != null && MakeUnavailable != null && SetupAiVehicle != null)
		{
			object obj3 = GetAvailableVehicleAi.Invoke(trafficManager, new object[1] { result });
			if (Object.op_Implicit((Object)((obj3 is Object) ? obj3 : null)))
			{
				MakeUnavailable.Invoke(trafficManager, new object[1] { obj3 });
				SetupAiVehicle.Invoke(trafficManager, new object[2] { obj3, obj });
				return true;
			}
		}
		SpawnAiVehicle.Invoke(trafficManager, new object[2] { obj2, obj });
		return true;
	}

	private void RefreshVehicleCatalog()
	{
		if (Time.unscaledTime < nextVehicleCatalogRefreshTime)
		{
			return;
		}
		nextVehicleCatalogRefreshTime = Time.unscaledTime + 0.5f;
		Object[] array = Object.FindObjectsOfType(typeof(VehicleManager));
		if (array.Length == 0 || AllVehicleDatabases == null || !(AllVehicleDatabases.GetValue(array[0]) is IEnumerable enumerable))
		{
			return;
		}
		foreach (object item in enumerable)
		{
			if (item == null)
			{
				continue;
			}
			MethodInfo method = item.GetType().GetMethod("GetAllVehicleReferences", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			IEnumerable enumerable2 = ((method == null) ? null : (method.Invoke(item, null) as IEnumerable));
			if (enumerable2 == null)
			{
				continue;
			}
			foreach (object item2 in enumerable2)
			{
				if (item2 != null)
				{
					FieldInfo field = item2.GetType().GetField("prefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					object obj = ((field == null) ? null : field.GetValue(item2));
					string assetGuid = GetAssetGuid(obj);
					if (obj != null && !string.IsNullOrEmpty(assetGuid) && discoveredVehiclePrefabGuids.Add(assetGuid))
					{
						uncheckedVehiclePrefabs.Enqueue(obj);
					}
				}
			}
		}
		int num = 4;
		while (num-- > 0 && uncheckedVehiclePrefabs.Count > 0)
		{
			object obj2 = uncheckedVehiclePrefabs.Dequeue();
			GameObject val = LoadVehiclePrefab(obj2);
			if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.GetComponentInChildren<PlayerVehicleRoadMovement>(true)))
			{
				string assetGuid2 = GetAssetGuid(obj2);
				if (!string.IsNullOrEmpty(assetGuid2) && acceptedGroundVehicleGuids.Add(assetGuid2))
				{
					groundVehiclePrefabs.Add(obj2);
				}
			}
		}
		if (groundVehiclePrefabs.Count > 0)
		{
			((BaseUnityPlugin)this).Logger.LogDebug((object)("Ground-compatible traffic catalogue: " + groundVehiclePrefabs.Count + " vehicles."));
		}
	}

	private GameObject LoadVehiclePrefab(object assetReference)
	{
		if (assetReference == null)
		{
			return null;
		}
		try
		{
			PropertyInfo property = assetReference.GetType().GetProperty("Asset", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			GameObject val = (GameObject)((property == null) ? null : /*isinst with value type is only supported in some contexts*/);
			if (Object.op_Implicit((Object)(object)val))
			{
				return val;
			}
			MethodInfo methodInfo = null;
			MethodInfo[] methods = assetReference.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			for (int i = 0; i < methods.Length; i++)
			{
				if (methods[i].Name == "LoadAssetAsync" && methods[i].IsGenericMethodDefinition && methods[i].GetParameters().Length == 0)
				{
					methodInfo = methods[i];
					break;
				}
			}
			if (methodInfo == null)
			{
				return null;
			}
			object obj = methodInfo.MakeGenericMethod(typeof(GameObject)).Invoke(assetReference, null);
			if (obj == null)
			{
				return null;
			}
			MethodInfo method = obj.GetType().GetMethod("WaitForCompletion", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return (GameObject)((method == null) ? null : /*isinst with value type is only supported in some contexts*/);
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogDebug((object)("Skipped unreadable vehicle prefab: " + ex.GetBaseException().Message));
			return null;
		}
	}

	private static string GetAssetGuid(object prefab)
	{
		if (prefab == null)
		{
			return null;
		}
		PropertyInfo property = prefab.GetType().GetProperty("AssetGUID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (!(property == null))
		{
			return property.GetValue(prefab, null) as string;
		}
		return null;
	}

	private float CurrentSpawnMultiplier()
	{
		if (!doomsdayActive)
		{
			return Mathf.Max(1f, normalSpawnMultiplier.Value);
		}
		return Mathf.Max(1f, doomsdaySpawnMultiplier.Value);
	}

	private void BeginDoomsday()
	{
		doomsdayActive = true;
		doomsdayEndTime = Time.unscaledTime + Mathf.Max(5f, doomsdayDurationSeconds.Value);
		bannerEndTime = Time.unscaledTime + 5f;
		nextTrafficSpawnTime = 0f;
		((BaseUnityPlugin)this).Logger.LogWarning((object)("DOOMSDAY STARTED: traffic x" + CurrentSpawnMultiplier().ToString("0.#") + ", vehicle speed x" + doomsdayVehicleSpeedMultiplier.Value.ToString("0.#")));
	}

	private void EndDoomsday()
	{
		doomsdayActive = false;
		nextTrafficSpawnTime = 0f;
		ScheduleNextDoomsday();
		ApplyTraffic(isHost: true);
		ApplyVehicleSpeed(isHost: true);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Doomsday ended. Normal traffic restored.");
	}

	private void ScheduleNextDoomsday()
	{
		nextDoomsdayTime = Time.unscaledTime + Mathf.Max(1f, (doomsdayDelaySeconds == null) ? 60f : doomsdayDelaySeconds.Value);
	}

	private void OnGUI()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		if (showDoomsdayBanner.Value && doomsdayActive)
		{
			if (bannerStyle == null)
			{
				bannerStyle = new GUIStyle(GUI.skin.label);
				bannerStyle.alignment = (TextAnchor)4;
				bannerStyle.fontSize = 28;
				bannerStyle.fontStyle = (FontStyle)1;
				bannerStyle.normal.textColor = Color.red;
			}
			float num = Mathf.Max(0f, doomsdayEndTime - Time.unscaledTime);
			string text = ((Time.unscaledTime < bannerEndTime) ? "DOOMSDAY!  " : "");
			GUI.Label(new Rect(0f, 18f, (float)Screen.width, 42f), text + Mathf.CeilToInt(num) + "s", bannerStyle);
		}
	}

	private void OnDestroy()
	{
		RestoreAllValues();
	}

	private void RestoreAllValues()
	{
		Object[] array = FindTrafficManagers();
		for (int i = 0; i < array.Length; i++)
		{
			if (Object.op_Implicit(array[i]) && originalTrafficCaps.TryGetValue(array[i].GetInstanceID(), out var value) && TrafficMaxVehicles != null)
			{
				TrafficMaxVehicles.SetValue(array[i], value);
			}
		}
		PlayerVehicleRoadMovement[] array2 = Object.FindObjectsOfType<PlayerVehicleRoadMovement>();
		for (int j = 0; j < array2.Length; j++)
		{
			if (Object.op_Implicit((Object)(object)array2[j]) && originalVehicleSpeeds.TryGetValue(((Object)array2[j]).GetInstanceID(), out var value2) && VehicleTopSpeed != null)
			{
				VehicleTopSpeed.SetValue(array2[j], value2);
			}
			if (Object.op_Implicit((Object)(object)array2[j]) && originalVehicleDefaultSpeeds.TryGetValue(((Object)array2[j]).GetInstanceID(), out var value3) && VehicleDefaultTopSpeed != null)
			{
				VehicleDefaultTopSpeed.SetValue(array2[j], value3);
			}
			DetachForcedInput(array2[j]);
		}
		PlayerVehicleRoadAI[] array3 = Object.FindObjectsOfType<PlayerVehicleRoadAI>();
		for (int k = 0; k < array3.Length; k++)
		{
			if (Object.op_Implicit((Object)(object)array3[k]) && VehicleRoadRage != null && originalRoadRage.TryGetValue(((Object)array3[k]).GetInstanceID(), out var value4))
			{
				VehicleRoadRage.SetValue(array3[k], value4);
			}
		}
	}

	private static Object[] FindTrafficManagers()
	{
		if (!(TrafficManagerType == null))
		{
			return Object.FindObjectsOfType(TrafficManagerType);
		}
		return (Object[])(object)new Object[0];
	}
}