Decompiled source of Yesla v1.0.0

Yesla.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using HarmonyLib;
using Il2Cpp;
using Il2CppFishNet;
using Il2CppFishNet.Connection;
using Il2CppFishNet.Managing;
using Il2CppFishNet.Managing.Object;
using Il2CppFishNet.Object;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPathfinding;
using Il2CppScheduleOne;
using Il2CppScheduleOne.Audio;
using Il2CppScheduleOne.Core.Audio;
using Il2CppScheduleOne.Core.Weather;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Dialogue;
using Il2CppScheduleOne.Economy;
using Il2CppScheduleOne.GameTime;
using Il2CppScheduleOne.Interaction;
using Il2CppScheduleOne.Map;
using Il2CppScheduleOne.Map.Infrastructure;
using Il2CppScheduleOne.Math;
using Il2CppScheduleOne.Misc;
using Il2CppScheduleOne.Money;
using Il2CppScheduleOne.NPCs;
using Il2CppScheduleOne.NPCs.CharacterClasses;
using Il2CppScheduleOne.Persistence;
using Il2CppScheduleOne.PlayerScripts;
using Il2CppScheduleOne.Police;
using Il2CppScheduleOne.Property;
using Il2CppScheduleOne.Quests;
using Il2CppScheduleOne.Storage;
using Il2CppScheduleOne.UI;
using Il2CppScheduleOne.UI.Compass;
using Il2CppScheduleOne.UI.Input;
using Il2CppScheduleOne.UI.Phone;
using Il2CppScheduleOne.UI.Phone.Map;
using Il2CppScheduleOne.Vehicles;
using Il2CppScheduleOne.Vehicles.AI;
using Il2CppScheduleOne.Vehicles.Modification;
using Il2CppScheduleOne.Vehicles.Sound;
using Il2CppScheduleOne.Weather;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using Sideload.Api;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;
using Yesla;
using Yesla.Config;
using Yesla.Driving;
using Yesla.Net;
using Yesla.Phone;
using Yesla.Vehicle;
using Yesla.Visual;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "Yesla", "1.0.0", "DooDesch", "https://github.com/DooDesch-Mods/ScheduleOne-Yesla")]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("DooDesch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © DooDesch")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+08312d09cf633055e63b288145130a4d092d1d33")]
[assembly: AssemblyProduct("Yesla")]
[assembly: AssemblyTitle("Yesla")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyMetadata("AI_Assisted_Creation", "This assembly was partially created with the assistance of Generative AI.")]
[assembly: AssemblyMetadata("AI_Model_Vendor", "Anthropic/OpenAI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DooDesch
{
	internal static class ModVersion
	{
		internal const string Current = "1.0.0";
	}
}
namespace Sideload.Api
{
	public static class Apps
	{
		private static bool _bound;

		private static int _probeAttempts;

		private static readonly List<Action> _pending = new List<Action>();

		private static Action<string, string, string, string, Assembly> _registerApp;

		private static Action<string, string, Func<string, string, string>> _handle;

		private static Action<string, string, string> _emit;

		private static Action<string, string> _allowHost;

		private static Action<string, string> _declareOrientations;

		private static Action<string, int> _setBadge;

		private static Action<string, string, string> _notify;

		private static Action<string, string, string, float> _notifyFor;

		private static Func<string, bool> _isOnScreen;

		private static Action<string, string, byte[]> _setImage;

		private static Action<string, bool> _setIconHidden;

		private static Action<string, bool> _setAppOpen;

		private static Func<string, bool> _isAppOpen;

		private static Func<bool, bool> _setPhoneRaised;

		private static Func<bool> _isPhoneRaised;

		private static Action<string, string, Func<string, string, bool>> _claimKeys;

		private static Func<object, string, string, Assembly, float, bool> _mountSurface;

		private static Action<string> _unmountSurface;

		private static Func<string, bool> _isSurfaceMounted;

		public static bool Available
		{
			get
			{
				EnsureBound();
				return _bound;
			}
		}

		internal static bool HasSurfaces
		{
			get
			{
				EnsureBound();
				return _mountSurface != null;
			}
		}

		internal static bool HasKeys
		{
			get
			{
				EnsureBound();
				return _claimKeys != null;
			}
		}

		internal static bool HasPhone
		{
			get
			{
				EnsureBound();
				return _setPhoneRaised != null;
			}
		}

		internal static bool HasOpen
		{
			get
			{
				EnsureBound();
				if (_setAppOpen != null)
				{
					return _setIconHidden != null;
				}
				return false;
			}
		}

		public static AppHandle Register(string id, string bundlePrefix, string title = null, string iconLabel = null, Assembly hostAssembly = null)
		{
			AppHandle result = new AppHandle(id);
			if (string.IsNullOrEmpty(id))
			{
				return result;
			}
			Assembly asm = hostAssembly ?? Assembly.GetCallingAssembly();
			string t = title;
			string il = iconLabel;
			string prefix = bundlePrefix;
			EnsureBound();
			if (_registerApp != null)
			{
				_registerApp(id, t, il, prefix, asm);
			}
			else
			{
				_pending.Add(delegate
				{
					_registerApp?.Invoke(id, t, il, prefix, asm);
				});
			}
			return result;
		}

		internal static void WhenBound(Action work)
		{
			if (work != null)
			{
				EnsureBound();
				if (_bound)
				{
					work();
				}
				else
				{
					_pending.Add(work);
				}
			}
		}

		internal static void HandleCall(string appId, string name, Func<string, string> handler)
		{
			if (_handle != null && handler != null)
			{
				_handle(appId, name, (string app, string argument) => handler(argument));
			}
		}

		internal static void EmitEvent(string appId, string name, string payload)
		{
			_emit?.Invoke(appId, name, payload);
		}

		internal static void AllowNetHost(string appId, string host)
		{
			_allowHost?.Invoke(appId, host);
		}

		internal static void Orient(string appId, string orientations)
		{
			_declareOrientations?.Invoke(appId, orientations);
		}

		internal static void Badge(string appId, int count)
		{
			_setBadge?.Invoke(appId, count);
		}

		internal static void Notify(string appId, string title, string subtitle, float seconds)
		{
			if (_notifyFor != null)
			{
				_notifyFor(appId, title, subtitle, seconds);
			}
			else if (_notify != null)
			{
				_notify(appId, title, subtitle);
			}
		}

		internal static bool OnScreen(string appId)
		{
			if (_isOnScreen != null)
			{
				return _isOnScreen(appId);
			}
			return false;
		}

		internal static void SetImage(string appId, string name, byte[] png)
		{
			_setImage?.Invoke(appId, name, png);
		}

		internal static void HideIcon(string appId, bool hidden)
		{
			_setIconHidden?.Invoke(appId, hidden);
		}

		internal static void OpenApp(string appId, bool open)
		{
			_setAppOpen?.Invoke(appId, open);
		}

		internal static bool AppIsOpen(string appId)
		{
			if (_isAppOpen != null)
			{
				return _isAppOpen(appId);
			}
			return false;
		}

		internal static bool RaisePhone(bool raised)
		{
			if (_setPhoneRaised != null)
			{
				return _setPhoneRaised(raised);
			}
			return false;
		}

		internal static bool PhoneIsRaised()
		{
			if (_isPhoneRaised != null)
			{
				return _isPhoneRaised();
			}
			return false;
		}

		internal static void ClaimKeys(string appId, string keys, Func<string, string, bool> handler)
		{
			_claimKeys?.Invoke(appId, keys, handler);
		}

		internal static bool MountSurface(object rect, string id, string prefix, Assembly host, float shortSide)
		{
			if (_mountSurface != null)
			{
				return _mountSurface(rect, id, prefix, host, shortSide);
			}
			return false;
		}

		internal static void UnmountSurface(string id)
		{
			_unmountSurface?.Invoke(id);
		}

		internal static bool SurfaceIsMounted(string id)
		{
			if (_isSurfaceMounted != null)
			{
				return _isSurfaceMounted(id);
			}
			return false;
		}

		private static void EnsureBound()
		{
			if (_bound)
			{
				return;
			}
			try
			{
				Type type = FindBridge(_probeAttempts++ % 30 == 0);
				if (type == null || (type.GetField("AbiVersion", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) is int num && num < 1))
				{
					return;
				}
				_registerApp = Get<Action<string, string, string, string, Assembly>>(type, "RegisterApp");
				if (_registerApp == null)
				{
					return;
				}
				_handle = Get<Action<string, string, Func<string, string, string>>>(type, "Handle");
				_emit = Get<Action<string, string, string>>(type, "Emit");
				_allowHost = Get<Action<string, string>>(type, "AllowHost");
				_declareOrientations = Get<Action<string, string>>(type, "DeclareOrientations");
				_setBadge = Get<Action<string, int>>(type, "SetBadge");
				_notify = Get<Action<string, string, string>>(type, "Notify");
				_notifyFor = Get<Action<string, string, string, float>>(type, "NotifyFor");
				_isOnScreen = Get<Func<string, bool>>(type, "IsAppOnScreen");
				_setImage = Get<Action<string, string, byte[]>>(type, "SetImage");
				_setIconHidden = Get<Action<string, bool>>(type, "SetIconHidden");
				_setAppOpen = Get<Action<string, bool>>(type, "SetAppOpen");
				_isAppOpen = Get<Func<string, bool>>(type, "IsAppOpen");
				_setPhoneRaised = Get<Func<bool, bool>>(type, "SetPhoneRaised");
				_isPhoneRaised = Get<Func<bool>>(type, "IsPhoneRaised");
				_claimKeys = Get<Action<string, string, Func<string, string, bool>>>(type, "ClaimKeys");
				_mountSurface = Get<Func<object, string, string, Assembly, float, bool>>(type, "MountSurface");
				_unmountSurface = Get<Action<string>>(type, "UnmountSurface");
				_isSurfaceMounted = Get<Func<string, bool>>(type, "IsSurfaceMounted");
				_bound = true;
				for (int i = 0; i < _pending.Count; i++)
				{
					try
					{
						_pending[i]();
					}
					catch
					{
					}
				}
				_pending.Clear();
			}
			catch
			{
			}
		}

		private static T Get<T>(Type t, string field) where T : class
		{
			return t.GetField(field, BindingFlags.Static | BindingFlags.Public)?.GetValue(null) as T;
		}

		private static Type FindBridge(bool scan)
		{
			Type type = Type.GetType("Sideload.Bridge.SideloadBridge, Sideload", throwOnError: false);
			if (type != null || !scan)
			{
				return type;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					type = assembly.GetType("Sideload.Bridge.SideloadBridge", throwOnError: false);
					if (type != null)
					{
						return type;
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	public sealed class AppHandle
	{
		private readonly string _id;

		public string Id => _id;

		public bool IsOnScreen
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.OnScreen(_id);
				}
				return false;
			}
		}

		public bool IsOpen
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.AppIsOpen(_id);
				}
				return false;
			}
		}

		public static bool CanOpenProgrammatically
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.HasOpen;
				}
				return false;
			}
		}

		public static bool CanClaimKeys
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.HasKeys;
				}
				return false;
			}
		}

		internal AppHandle(string id)
		{
			_id = id ?? "";
		}

		public AppHandle OnCall(string name, Func<string, string> handler)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.HandleCall(id, name, handler);
			});
			return this;
		}

		public void Emit(string name, string payload = "")
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.EmitEvent(id, name, payload);
			});
		}

		public AppHandle AllowHost(string host)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.AllowNetHost(id, host);
			});
			return this;
		}

		public AppHandle Orientation(params string[] supported)
		{
			string id = _id;
			string list = ((supported == null) ? "" : string.Join(",", supported));
			Apps.WhenBound(delegate
			{
				Apps.Orient(id, list);
			});
			return this;
		}

		public AppHandle Badge(int count)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.Badge(id, count);
			});
			return this;
		}

		public AppHandle Notify(string title, string subtitle = "", float seconds = 0f)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.Notify(id, title, subtitle, seconds);
			});
			return this;
		}

		public AppHandle Image(string name, byte[] png)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.SetImage(id, name, png);
			});
			return this;
		}

		public AppHandle Icon(bool visible)
		{
			Apps.HideIcon(_id, !visible);
			return this;
		}

		public AppHandle NoIcon()
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.HideIcon(id, hidden: true);
			});
			return this;
		}

		public AppHandle Open()
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.OpenApp(id, open: true);
			});
			return this;
		}

		public AppHandle Close()
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.OpenApp(id, open: false);
			});
			return this;
		}

		public bool Show()
		{
			if (!Apps.RaisePhone(raised: true))
			{
				return false;
			}
			Apps.OpenApp(_id, open: true);
			return true;
		}

		public AppHandle OnKey(string keys, Func<string, bool> handler)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.ClaimKeys(id, keys, (handler == null) ? null : ((Func<string, string, bool>)((string _, string key) => handler(key))));
			});
			return this;
		}

		public AppHandle Hide()
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.OpenApp(id, open: false);
				Apps.RaisePhone(raised: false);
			});
			return this;
		}
	}
	public static class Surfaces
	{
		public static bool Available
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.HasSurfaces;
				}
				return false;
			}
		}

		public static SurfaceHandle Mount(object hostRect, string id, string bundlePrefix, float designShortSide = 0f, Assembly hostAssembly = null)
		{
			SurfaceHandle result = new SurfaceHandle(id);
			if (string.IsNullOrEmpty(id) || hostRect == null)
			{
				return result;
			}
			Assembly host = hostAssembly ?? Assembly.GetCallingAssembly();
			Apps.MountSurface(hostRect, id, bundlePrefix, host, designShortSide);
			return result;
		}

		public static void Unmount(string id)
		{
			Apps.UnmountSurface(id);
		}

		public static bool IsMounted(string id)
		{
			return Apps.SurfaceIsMounted(id);
		}
	}
	public sealed class SurfaceHandle
	{
		private readonly string _id;

		public string Id => _id;

		internal SurfaceHandle(string id)
		{
			_id = id;
		}

		public SurfaceHandle OnCall(string name, Func<string, string> handler)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.HandleCall(id, name, handler);
			});
			return this;
		}

		public SurfaceHandle Emit(string name, string payload = "")
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.EmitEvent(id, name, payload);
			});
			return this;
		}

		public SurfaceHandle AllowHost(string host)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.AllowNetHost(id, host);
			});
			return this;
		}

		public SurfaceHandle Image(string name, byte[] png)
		{
			string id = _id;
			Apps.WhenBound(delegate
			{
				Apps.SetImage(id, name, png);
			});
			return this;
		}

		public void Unmount()
		{
			Apps.UnmountSurface(_id);
		}
	}
	public static class PhoneScreen
	{
		public static bool IsRaised
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.PhoneIsRaised();
				}
				return false;
			}
		}

		public static bool Available
		{
			get
			{
				if (Apps.Available)
				{
					return Apps.HasPhone;
				}
				return false;
			}
		}

		public static bool Raise()
		{
			return Apps.RaisePhone(raised: true);
		}

		public static bool Lower()
		{
			return Apps.RaisePhone(raised: false);
		}
	}
}
namespace Yesla
{
	public sealed class Core : MelonMod
	{
		private bool _inWorld;

		public static Core Instance { get; private set; }

		public static Instance Log { get; private set; }

		public override void OnInitializeMelon()
		{
			Instance = this;
			Log = ((MelonBase)this).LoggerInstance;
			Preferences.Initialize();
			YeslaNet.Apply(((MelonBase)this).HarmonyInstance);
			Remote.Init();
			YeslaApp.Register();
			int num = 0;
			foreach (MethodBase patchedMethod in ((MelonBase)this).HarmonyInstance.GetPatchedMethods())
			{
				_ = patchedMethod;
				num++;
			}
			Log.Msg("[Core] Harmony patches applied by MelonLoader on " + num + " method(s).");
			Log.Msg("Yesla loaded.");
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			_inWorld = sceneName == "Main";
			if (!_inWorld)
			{
				ResetWorld();
			}
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			if (!(sceneName != "Main"))
			{
				if (!NetworkSingleton<VehicleManager>.InstanceExists)
				{
					Log.Warning("[Core] Main is up but there is no VehicleManager - the Yesla Model 3 is not registered.");
				}
				else
				{
					YeslaVehicleType.Register(NetworkSingleton<VehicleManager>.Instance);
				}
			}
		}

		public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
		{
			_inWorld = false;
			ResetWorld();
		}

		private static void ResetWorld()
		{
			Autopilot.Reset();
			Parking.Reset();
			Summon.Reset();
			PathFollower.Reset();
			RoadRouter.Reset();
			Sentry.Reset();
			Fleet.Reset();
			Plate.Reset();
			DestinationMarker.Reset();
			Indicators.Reset();
			Pws.Reset();
			AutoLights.Reset();
			MovingParts.Reset();
			KeyHint.Reset();
			FirstPerson.Reset();
			Viz.Reset();
			YeslaApp.Reset();
		}

		public override void OnUpdate()
		{
			if (_inWorld)
			{
				Fleet.Tick();
				Autopilot.Tick();
				Summon.Tick();
				if (YeslaNet.IsHost)
				{
					Parking.HostTick();
				}
				Sentry.Tick();
				Plate.Tick();
				Indicators.Tick();
				Pws.Tick();
				if (YeslaNet.IsHost)
				{
					AutoLights.Tick();
				}
				DestinationMarker.Tick();
				FirstPerson.Tick();
				Viz.Tick();
				KeyHint.Tick();
				YeslaApp.Tick();
			}
		}

		public override void OnLateUpdate()
		{
			if (_inWorld)
			{
				Autopilot.LateTick();
				Parking.LateTick();
				PathFollower.LateTick();
				MovingParts.LateTick();
				Viz.LateTick();
			}
		}
	}
}
namespace Yesla.Visual
{
	internal static class Cabin
	{
		internal const string LowName = "Cabin_LOD0";

		internal const string HighName = "Cabin_HI";

		private static Transform _shownIn;

		private static IntPtr _car;

		internal static void Show(LandVehicle car)
		{
			IntPtr intPtr = (((Object)(object)car != (Object)null) ? ((Il2CppObjectBase)car).Pointer : IntPtr.Zero);
			if (!(intPtr == _car))
			{
				_car = intPtr;
				Transform val = (((Object)(object)car != (Object)null) ? VizScene.FindDeep(((Component)car).transform, "YeslaModel") : null);
				if ((Object)(object)_shownIn != (Object)null && ((Object)(object)val == (Object)null || ((Il2CppObjectBase)_shownIn).Pointer != ((Il2CppObjectBase)val).Pointer))
				{
					Swap(_shownIn, detailed: false);
				}
				if ((Object)(object)val != (Object)null && ((Object)(object)_shownIn == (Object)null || ((Il2CppObjectBase)_shownIn).Pointer != ((Il2CppObjectBase)val).Pointer))
				{
					Swap(val, detailed: true);
				}
				_shownIn = val;
			}
		}

		private static void Swap(Transform model, bool detailed)
		{
			Transform val = model.Find("Cabin_LOD0");
			Transform val2 = model.Find("Cabin_HI");
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				Core.Log.Warning("[Cabin] " + ((Object)model.root).name + " has no " + (((Object)(object)val == (Object)null) ? "Cabin_LOD0" : "Cabin_HI") + " - cabin left as it is.");
				return;
			}
			foreach (MeshRenderer componentsInChild in ((Component)val).GetComponentsInChildren<MeshRenderer>(true))
			{
				((Renderer)componentsInChild).enabled = !detailed;
			}
			((Component)val2).gameObject.SetActive(detailed);
			Core.Log.Msg("[Cabin] " + ((Object)model.root).name + ": " + (detailed ? "detailed cabin on" : "low cabin back") + ".");
		}

		internal static void Reset()
		{
			_shownIn = null;
			_car = IntPtr.Zero;
		}
	}
	internal static class CabinGlass
	{
		private const float InsideAlpha = 0.18f;

		private static readonly int BaseColor = Shader.PropertyToID("_BaseColor");

		private static readonly List<Renderer> Clear = new List<Renderer>();

		private static IntPtr _car;

		internal static void Show(LandVehicle car, bool firstPerson)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (!firstPerson)
			{
				car = null;
			}
			IntPtr intPtr = (((Object)(object)car != (Object)null) ? ((Il2CppObjectBase)car).Pointer : IntPtr.Zero);
			if (intPtr == _car)
			{
				return;
			}
			Restore();
			_car = intPtr;
			if ((Object)(object)car == (Object)null)
			{
				return;
			}
			Transform val = VizScene.FindDeep(((Component)car).transform, "YeslaModel");
			if ((Object)(object)val == (Object)null)
			{
				Core.Log.Warning("[Viz] the Yesla has no YeslaModel - the windows keep their tint.");
				return;
			}
			MaterialPropertyBlock val2 = new MaterialPropertyBlock();
			foreach (MeshRenderer componentsInChild in ((Component)val).GetComponentsInChildren<MeshRenderer>(true))
			{
				if (!((Object)(object)componentsInChild == (Object)null) && !((Object)(object)((Renderer)componentsInChild).sharedMaterial == (Object)null) && GlbModel.InGroup(((Object)((Component)componentsInChild).gameObject).name, "Glass"))
				{
					Color color = ((Renderer)componentsInChild).sharedMaterial.GetColor(BaseColor);
					color.a = 0.18f;
					val2.Clear();
					val2.SetColor(BaseColor, color);
					((Renderer)componentsInChild).SetPropertyBlock(val2);
					Clear.Add((Renderer)(object)componentsInChild);
				}
			}
			if (Clear.Count == 0)
			{
				Core.Log.Warning("[Viz] no window renderers in " + ((Object)car).name + " - the windows keep their tint.");
				return;
			}
			Core.Log.Msg("[Viz] " + Clear.Count + " window(s) in " + ((Object)car).name + " clearer for the first-person view.");
		}

		private static void Restore()
		{
			foreach (Renderer item in Clear)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.SetPropertyBlock((MaterialPropertyBlock)null);
				}
			}
			if (Clear.Count > 0)
			{
				Core.Log.Msg("[Viz] windows back to their outside tint.");
			}
			Clear.Clear();
		}

		internal static void Reset()
		{
			Clear.Clear();
			_car = IntPtr.Zero;
		}
	}
	internal static class CabinLight
	{
		private static float Range = 2.4f;

		private static float Intensity = 7f;

		private static Vector3 Position = new Vector3(0f, 1.12f, -0.05f);

		private static readonly Vector3 Aim = new Vector3(0f, 0.72f, 0.5f);

		private const float Angle = 120f;

		private static Light _light;

		private static LandVehicle _car;

		internal static void Show(LandVehicle car, bool on)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			if (!on)
			{
				car = null;
			}
			if ((Object)(object)_car != (Object)null && ((Object)(object)car == (Object)null || ((Il2CppObjectBase)_car).Pointer != ((Il2CppObjectBase)car).Pointer))
			{
				if ((Object)(object)_light != (Object)null)
				{
					((Behaviour)_light).enabled = false;
				}
				_car = null;
			}
			if ((Object)(object)car == (Object)null)
			{
				return;
			}
			if ((Object)(object)_car != (Object)null && (Object)(object)_light != (Object)null)
			{
				((Behaviour)_light).enabled = true;
				return;
			}
			Transform val = VizScene.FindDeep(((Component)car).transform, "YeslaModel");
			if ((Object)(object)val == (Object)null)
			{
				Core.Log.Warning("[Viz] the Yesla has no YeslaModel - no cabin light.");
				return;
			}
			Transform val2 = val.Find("YeslaCabinLight");
			if ((Object)(object)val2 == (Object)null)
			{
				GameObject val3 = new GameObject("YeslaCabinLight");
				val3.transform.SetParent(val, false);
				val3.transform.localPosition = Position;
				_light = val3.AddComponent<Light>();
				_light.type = (LightType)0;
				_light.spotAngle = 120f;
				val3.transform.localRotation = Quaternion.LookRotation(Aim - Position, Vector3.up);
				_light.range = Range;
				_light.intensity = Intensity;
				_light.color = new Color(1f, 0.95f, 0.88f);
				_light.shadows = (LightShadows)0;
				Core.Log.Msg("[Viz] cabin light fitted to " + ((Object)car).name + ".");
			}
			else
			{
				_light = ((Component)val2).GetComponent<Light>();
			}
			((Behaviour)_light).enabled = true;
			_car = car;
		}

		internal static string Tune(float intensity, float range, Vector3? position)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			Intensity = intensity;
			Range = range;
			if (position.HasValue)
			{
				Position = position.Value;
			}
			if ((Object)(object)_light == (Object)null)
			{
				return "cabin light set to " + Intensity + " / " + Range + " m; it applies once first person is on";
			}
			_light.intensity = Intensity;
			_light.range = Range;
			((Component)_light).transform.localPosition = Position;
			((Component)_light).transform.localRotation = Quaternion.LookRotation(Aim - Position, Vector3.up);
			return "cabin light " + Intensity + " / " + Range + " m at " + ((Vector3)(ref Position)).ToString("F2");
		}

		internal static void Reset()
		{
			_light = null;
			_car = null;
		}
	}
	internal static class CenterScreen
	{
		private const string Name = "YeslaScreen";

		private static readonly Vector3 LcdCentre = new Vector3(0.0002f, 0.8113f, 0.5063f);

		private static readonly Vector3 LcdNormal = new Vector3(0f, 0.2264f, -0.974f);

		private const float LcdWidth = 0.338f;

		private const float LcdHeight = 0.265f;

		private static Material _mat;

		private static Mesh _mesh;

		private static GameObject _shown;

		internal static void Show(LandVehicle car)
		{
			GameObject val = (((Object)(object)car != (Object)null && (Object)(object)VizScene.Texture != (Object)null) ? ScreenOf(car) : null);
			if ((Object)(object)_shown != (Object)null && ((Object)(object)val == (Object)null || ((Il2CppObjectBase)_shown).Pointer != ((Il2CppObjectBase)val).Pointer))
			{
				_shown.SetActive(false);
			}
			if ((Object)(object)val != (Object)null)
			{
				_mat.SetTexture("_BaseMap", (Texture)(object)VizScene.Texture);
				if (!val.activeSelf)
				{
					val.SetActive(true);
				}
			}
			_shown = val;
		}

		private static GameObject ScreenOf(LandVehicle car)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Transform val = VizScene.FindDeep(((Component)car).transform, "YeslaModel");
			if ((Object)(object)val == (Object)null)
			{
				Core.Log.Warning("[Viz] the Yesla has no YeslaModel - no centre screen.");
				return null;
			}
			Transform val2 = val.Find("YeslaScreen");
			if ((Object)(object)val2 != (Object)null)
			{
				return ((Component)val2).gameObject;
			}
			if ((Object)(object)_mat == (Object)null)
			{
				Shader val3 = Shader.Find("Universal Render Pipeline/Unlit");
				if ((Object)(object)val3 == (Object)null)
				{
					Core.Log.Error("[Viz] URP/Unlit missing - no centre screen.");
					return null;
				}
				_mat = new Material(val3)
				{
					name = "Yesla_CenterScreen"
				};
				((Object)_mat).hideFlags = (HideFlags)52;
				_mat.SetColor("_BaseColor", new Color(0.9f, 0.9f, 0.9f));
			}
			if ((Object)(object)_mesh == (Object)null)
			{
				float num = 0.169f;
				float num2 = 0.1325f;
				_mesh = new Mesh
				{
					name = "Yesla_CenterScreen"
				};
				_mesh.vertices = Il2CppStructArray<Vector3>.op_Implicit((Vector3[])(object)new Vector3[4]
				{
					new Vector3(0f - num, 0f - num2, 0f),
					new Vector3(num, 0f - num2, 0f),
					new Vector3(0f - num, num2, 0f),
					new Vector3(num, num2, 0f)
				});
				_mesh.uv = Il2CppStructArray<Vector2>.op_Implicit((Vector2[])(object)new Vector2[4]
				{
					new Vector2(0f, 0f),
					new Vector2(1f, 0f),
					new Vector2(0f, 1f),
					new Vector2(1f, 1f)
				});
				_mesh.triangles = Il2CppStructArray<int>.op_Implicit(new int[6] { 0, 2, 1, 1, 2, 3 });
				_mesh.RecalculateBounds();
				((Object)_mesh).hideFlags = (HideFlags)52;
			}
			GameObject val4 = new GameObject("YeslaScreen")
			{
				layer = ((Component)val).gameObject.layer
			};
			val4.transform.SetParent(val, false);
			Vector3 val5 = LcdNormal;
			Vector3 normalized = ((Vector3)(ref val5)).normalized;
			val4.transform.localPosition = LcdCentre + normalized * 0.003f;
			val4.transform.localRotation = Quaternion.LookRotation(-normalized, Vector3.up);
			val4.AddComponent<MeshFilter>().sharedMesh = _mesh;
			MeshRenderer obj = val4.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterial = _mat;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			Instance log = Core.Log;
			string[] obj2 = new string[5]
			{
				"[Viz] centre screen fitted to ",
				((Object)car).name,
				" at ",
				null,
				null
			};
			val5 = val4.transform.position;
			obj2[3] = ((Vector3)(ref val5)).ToString("F2");
			obj2[4] = ".";
			log.Msg(string.Concat(obj2));
			return val4;
		}

		internal static void Reset()
		{
			_shown = null;
		}
	}
	internal enum NextStep
	{
		None,
		Left,
		Right,
		Arrive
	}
	internal struct VizInfo
	{
		internal float SpeedKmh;

		internal float LimitKmh;

		internal int Cars;

		internal int People;

		internal bool Driving;

		internal string State;

		internal string Destination;

		internal float RouteMetres;

		internal NextStep Next;

		internal float NextMetres;
	}
	internal static class Route
	{
		private const float Lift = 0.06f;

		private const float Sample = 5f;

		private const float TurnAngle = 40f;

		private const float LookAhead = 600f;

		private const float FrontOffset = 2.3f;

		private const float StripStep = 2f;

		private static readonly List<Vector3> Strip = new List<Vector3>();

		private static readonly List<Vector3> Pts = new List<Vector3>();

		private static float _carAlong;

		private const float SwitchAfter = 0.75f;

		private const float OnPath = 4f;

		private static NextStep _shown;

		private static NextStep _pending;

		private static Vector3 _shownAt;

		private static Vector3 _pendingAt;

		private static float _pendingSince;

		private static readonly List<Vector3> Samples = new List<Vector3>();

		internal static VizInfo Update(LandVehicle car, Mesh band, float ahead, float width, Transform pin)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			bool driving;
			VizInfo info = new VizInfo
			{
				State = StateText(car, out driving),
				Driving = driving
			};
			bool flag = (Object)(object)Autopilot.DrivenCar != (Object)null && ((Il2CppObjectBase)Autopilot.DrivenCar).Pointer == ((Il2CppObjectBase)car).Pointer;
			info.Destination = (((flag || Autopilot.State == DriveState.Ready) && Autopilot.Destination.HasValue) ? Autopilot.DestinationLabel : string.Empty);
			Pts.Clear();
			VehicleAgent agent = car.Agent;
			SmoothedPath val = (((Object)(object)agent != (Object)null && agent.AutoDriving) ? agent.path : null);
			List<Vector3> val2 = ((val != null) ? val.vectorPath : null);
			Vector3 val3;
			if (val2 != null && val2.Count >= 2)
			{
				Vector3 position = ((Component)car).transform.position;
				float t;
				int num = Closest(val2, position, out t);
				_carAlong = 0f;
				for (int i = 0; i < num; i++)
				{
					float carAlong = _carAlong;
					val3 = VizScene.Flat(val2[i + 1] - val2[i]);
					_carAlong = carAlong + ((Vector3)(ref val3)).magnitude;
				}
				float carAlong2 = _carAlong;
				val3 = VizScene.Flat(val2[num + 1] - val2[num]);
				_carAlong = carAlong2 + ((Vector3)(ref val3)).magnitude * t;
				Pts.Add(Vector3.Lerp(val2[num], val2[num + 1], t));
				for (int j = num + 1; j < val2.Count; j++)
				{
					Pts.Add(val2[j]);
				}
			}
			float num2 = 0f;
			for (int k = 0; k + 1 < Pts.Count; k++)
			{
				float num3 = num2;
				val3 = VizScene.Flat(Pts[k + 1] - Pts[k]);
				num2 = num3 + ((Vector3)(ref val3)).magnitude;
			}
			BuildBand(band, ahead, width);
			info.RouteMetres = num2;
			NextTurn(ref info, num2);
			Vector3? val4 = ((flag || Autopilot.State == DriveState.Ready) ? Autopilot.Destination : ((Vector3?)null));
			if (val4.HasValue && Pts.Count > 0)
			{
				val4 = Pts[Pts.Count - 1];
			}
			((Component)pin).gameObject.SetActive(val4.HasValue);
			if (val4.HasValue)
			{
				pin.position = val4.Value + Vector3.up * 1.6f + VizScene.Origin;
			}
			return info;
		}

		private static void BuildBand(Mesh band, float ahead, float width)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			Strip.Clear();
			float num = 0f;
			float num2 = 2.3f;
			float num3 = 2.3f + ahead;
			Vector3 val3;
			for (int i = 0; i + 1 < Pts.Count; i++)
			{
				if (!(num2 <= num3))
				{
					break;
				}
				Vector3 val = Pts[i];
				Vector3 val2 = Pts[i + 1];
				val3 = VizScene.Flat(val2 - val);
				float magnitude;
				for (magnitude = ((Vector3)(ref val3)).magnitude; num2 <= num + magnitude && num2 <= num3; num2 += 2f)
				{
					Strip.Add(Vector3.Lerp(val, val2, (magnitude < 0.001f) ? 0f : ((num2 - num) / magnitude)));
				}
				num += magnitude;
			}
			if (Pts.Count > 1 && num > 2.3f && Strip.Count > 0 && num < num3)
			{
				Strip.Add(Pts[Pts.Count - 1]);
			}
			band.Clear();
			if (Strip.Count < 2)
			{
				return;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[Strip.Count * 2];
			Vector2[] array2 = (Vector2[])(object)new Vector2[Strip.Count * 2];
			int[] array3 = new int[(Strip.Count - 1) * 6];
			float num4 = 0f;
			float num5 = 0f;
			for (int j = 0; j + 1 < Strip.Count; j++)
			{
				float num6 = num5;
				val3 = VizScene.Flat(Strip[j + 1] - Strip[j]);
				num5 = num6 + ((Vector3)(ref val3)).magnitude;
			}
			for (int k = 0; k < Strip.Count; k++)
			{
				Vector3 val4 = ((k > 0) ? VizScene.Flat(Strip[k] - Strip[k - 1]) : Vector3.zero);
				Vector3 val5 = ((k + 1 < Strip.Count) ? VizScene.Flat(Strip[k + 1] - Strip[k]) : Vector3.zero);
				val3 = ((Vector3)(ref val4)).normalized + ((Vector3)(ref val5)).normalized;
				Vector3 val6 = ((Vector3)(ref val3)).normalized;
				if (((Vector3)(ref val6)).sqrMagnitude < 0.01f)
				{
					val6 = ((((Vector3)(ref val5)).sqrMagnitude > 0f) ? ((Vector3)(ref val5)).normalized : ((Vector3)(ref val4)).normalized);
				}
				Vector3 val7 = Vector3.Cross(Vector3.up, val6) * (width * 0.5f);
				if (k > 0)
				{
					num4 += ((Vector3)(ref val4)).magnitude;
				}
				float num7 = ((num5 > 0.01f) ? (num4 / num5) : 0f);
				Vector3 val8 = Strip[k] + Vector3.up * 0.06f;
				array[k * 2] = val8 - val7;
				array[k * 2 + 1] = val8 + val7;
				array2[k * 2] = new Vector2(0f, num7);
				array2[k * 2 + 1] = new Vector2(1f, num7);
			}
			for (int l = 0; l + 1 < Strip.Count; l++)
			{
				int num8 = l * 6;
				int num9 = (array3[num8] = l * 2);
				array3[num8 + 1] = num9 + 2;
				array3[num8 + 2] = num9 + 1;
				array3[num8 + 3] = num9 + 1;
				array3[num8 + 4] = num9 + 2;
				array3[num8 + 5] = num9 + 3;
			}
			band.vertices = Il2CppStructArray<Vector3>.op_Implicit(array);
			band.uv = Il2CppStructArray<Vector2>.op_Implicit(array2);
			band.triangles = Il2CppStructArray<int>.op_Implicit(array3);
			band.RecalculateBounds();
		}

		internal static bool Along(Vector3 p, out float along, out float side)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			along = 0f;
			side = float.MaxValue;
			if (Pts.Count < 2)
			{
				return false;
			}
			float num = 0f;
			float num2 = float.MaxValue;
			for (int i = 0; i + 1 < Pts.Count; i++)
			{
				if (!(num < 120f))
				{
					break;
				}
				Vector3 val = VizScene.Flat(Pts[i]);
				Vector3 val2 = VizScene.Flat(Pts[i + 1] - Pts[i]);
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				float num3 = ((sqrMagnitude < 0.0001f) ? 0f : Mathf.Clamp01(Vector3.Dot(VizScene.Flat(p) - val, val2) / sqrMagnitude));
				Vector3 val3 = val + val2 * num3 - VizScene.Flat(p);
				float magnitude = ((Vector3)(ref val3)).magnitude;
				if (magnitude < num2)
				{
					num2 = magnitude;
					along = num + Mathf.Sqrt(sqrMagnitude) * num3;
				}
				num += Mathf.Sqrt(sqrMagnitude);
			}
			side = num2;
			return along > 0.5f;
		}

		private static string StateText(LandVehicle car, out bool driving)
		{
			driving = (Object)(object)Autopilot.DrivenCar != (Object)null && ((Il2CppObjectBase)Autopilot.DrivenCar).Pointer == ((Il2CppObjectBase)car).Pointer;
			if (driving)
			{
				if (Autopilot.State != DriveState.Parking)
				{
					return "Assisted Driving";
				}
				return "Parking";
			}
			return Autopilot.State switch
			{
				DriveState.Ready => "Ready", 
				DriveState.Arrived => "Arrived", 
				DriveState.Aborted => "Driver in control", 
				_ => string.Empty, 
			};
		}

		private static void NextTurn(ref VizInfo info, float total)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			Find(total, out var next, out var at);
			if (next != _shown)
			{
				goto IL_003f;
			}
			Vector3 val;
			if (next != NextStep.None)
			{
				val = VizScene.Flat(at - _shownAt);
				if (!(((Vector3)(ref val)).magnitude < 15f))
				{
					goto IL_003f;
				}
			}
			goto IL_00ca;
			IL_0084:
			_pending = next;
			_pendingAt = at;
			_pendingSince = Time.unscaledTime;
			goto IL_009a;
			IL_009a:
			float metres;
			if (Time.unscaledTime - _pendingSince < 0.75f)
			{
				info.Next = _shown;
				info.NextMetres = ((_shown == NextStep.Arrive) ? total : metres);
				return;
			}
			goto IL_00ca;
			IL_003f:
			if (_shown != NextStep.None && ShownAhead(out metres))
			{
				if (next != _pending)
				{
					goto IL_0084;
				}
				if (next != NextStep.None)
				{
					val = VizScene.Flat(at - _pendingAt);
					if (!(((Vector3)(ref val)).magnitude < 15f))
					{
						goto IL_0084;
					}
				}
				goto IL_009a;
			}
			goto IL_00ca;
			IL_00ca:
			_shown = next;
			_shownAt = at;
			_pending = next;
			_pendingAt = at;
			info.Next = next;
			info.NextMetres = next switch
			{
				NextStep.Arrive => total, 
				NextStep.None => 0f, 
				_ => Metres(at), 
			};
		}

		private static void Find(float total, out NextStep next, out Vector3 at)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			next = NextStep.None;
			at = Vector3.zero;
			if (Pts.Count < 2)
			{
				return;
			}
			Samples.Clear();
			float num = _carAlong % 5f;
			for (int i = 0; i + 1 < Pts.Count; i++)
			{
				if (!((float)Samples.Count * 5f < 600f))
				{
					break;
				}
				Vector3 val = Pts[i];
				Vector3 val2 = Pts[i + 1];
				Vector3 val3 = VizScene.Flat(val2 - val);
				float magnitude = ((Vector3)(ref val3)).magnitude;
				float num2;
				for (num2 = 5f - num; num2 <= magnitude; num2 += 5f)
				{
					Samples.Add(Vector3.Lerp(val, val2, num2 / magnitude));
				}
				num = magnitude - (num2 - 5f);
			}
			for (int j = 1; j + 2 < Samples.Count; j++)
			{
				float num3 = Vector3.SignedAngle(VizScene.Flat(Samples[j] - Samples[j - 1]), VizScene.Flat(Samples[j + 2] - Samples[j + 1]), Vector3.up);
				if (!(Mathf.Abs(num3) < 40f))
				{
					next = ((!(num3 > 0f)) ? NextStep.Left : NextStep.Right);
					at = Vector3.Lerp(Samples[j], Samples[j + 1], 0.5f);
					return;
				}
			}
			if (total < 600f)
			{
				next = NextStep.Arrive;
				at = Pts[Pts.Count - 1];
			}
		}

		private static bool ShownAhead(out float metres)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			metres = 0f;
			if (_shown == NextStep.Arrive)
			{
				return Pts.Count >= 2;
			}
			metres = Metres(_shownAt, out var side);
			if (metres > 0.5f)
			{
				return side < 4f;
			}
			return false;
		}

		private static float Metres(Vector3 p)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			float side;
			return Metres(p, out side);
		}

		private static float Metres(Vector3 p, out float side)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			float result = 0f;
			float num2 = float.MaxValue;
			for (int i = 0; i + 1 < Pts.Count; i++)
			{
				if (!(num < 600f))
				{
					break;
				}
				Vector3 val = VizScene.Flat(Pts[i]);
				Vector3 val2 = VizScene.Flat(Pts[i + 1] - Pts[i]);
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				float num3 = ((sqrMagnitude < 0.0001f) ? 0f : Mathf.Clamp01(Vector3.Dot(VizScene.Flat(p) - val, val2) / sqrMagnitude));
				Vector3 val3 = val + val2 * num3 - VizScene.Flat(p);
				float magnitude = ((Vector3)(ref val3)).magnitude;
				if (magnitude < num2)
				{
					num2 = magnitude;
					result = num + Mathf.Sqrt(sqrMagnitude) * num3;
				}
				num += Mathf.Sqrt(sqrMagnitude);
			}
			side = num2;
			return result;
		}

		private static int Closest(List<Vector3> vp, Vector3 p, out float t)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int result = 0;
			float num = float.MaxValue;
			t = 0f;
			for (int i = 0; i + 1 < vp.Count; i++)
			{
				Vector3 val = vp[i];
				Vector3 val2 = vp[i + 1] - val;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				float num2 = ((sqrMagnitude < 0.0001f) ? 0f : Mathf.Clamp01(Vector3.Dot(p - val, val2) / sqrMagnitude));
				Vector3 val3 = val + val2 * num2 - p;
				float sqrMagnitude2 = ((Vector3)(ref val3)).sqrMagnitude;
				if (sqrMagnitude2 < num)
				{
					num = sqrMagnitude2;
					result = i;
					t = num2;
				}
			}
			return result;
		}
	}
	internal enum VizMode
	{
		Hud,
		Full,
		Off
	}
	internal static class Viz
	{
		private static LandVehicle _car;

		private static bool _failed;

		internal static VizMode Mode { get; private set; }

		internal static void Tick()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			LandVehicle val = Autopilot.CurrentCar();
			if (!((Object)(object)val != (Object)null) || !YeslaApp.IsYesla(val))
			{
				if ((Object)(object)_car != (Object)null)
				{
					Leave(((Object)(object)val == (Object)null) ? "left the car" : "not a Yesla");
				}
				return;
			}
			if ((Object)(object)_car == (Object)null || ((Il2CppObjectBase)_car).Pointer != ((Il2CppObjectBase)val).Pointer)
			{
				_car = val;
				Core.Log.Msg("[Viz] in a Yesla (" + ((Object)val).name + "), view " + Mode.ToString() + ".");
			}
			if (!GameInput.IsTyping && Input.GetKeyDown(Preferences.VizKey))
			{
				Cycle("visualisation key");
			}
		}

		internal static void LateTick()
		{
			if ((Object)(object)_car == (Object)null || _failed)
			{
				return;
			}
			try
			{
				if (!VizScene.Ensure(_car))
				{
					_failed = true;
					Core.Log.Error("[Viz] the visualisation could not be built and stays off until the world reloads.");
					return;
				}
				VizMode vizMode = (UiBlocks() ? VizMode.Off : ((Mode == VizMode.Hud && FirstPerson.Active) ? VizMode.Off : Mode));
				if (FirstPerson.Active || vizMode != VizMode.Off)
				{
					VizScene.Tick(_car);
				}
				VizHud.Show(vizMode);
				CenterScreen.Show(_car);
				Cabin.Show(_car);
				CabinLight.Show(_car, FirstPerson.Active);
				CabinGlass.Show(_car, FirstPerson.Active);
			}
			catch (Exception ex)
			{
				_failed = true;
				Core.Log.Error("[Viz] the visualisation failed and is switched off until the world reloads: " + ex);
				VizHud.Show(VizMode.Off);
			}
		}

		internal static void Set(VizMode mode, string reason)
		{
			Mode = mode;
			Core.Log.Msg("[Viz] view " + mode.ToString() + " (" + reason + ").");
		}

		private static void Cycle(string reason)
		{
			Set((Mode == VizMode.Hud) ? VizMode.Full : ((Mode == VizMode.Full) ? VizMode.Off : VizMode.Hud), reason);
		}

		private static bool UiBlocks()
		{
			if (PlayerSingleton<Phone>.InstanceExists && PlayerSingleton<Phone>.Instance.IsOpen)
			{
				return true;
			}
			if (Singleton<PauseMenu>.InstanceExists && Singleton<PauseMenu>.Instance.IsPaused)
			{
				return true;
			}
			return false;
		}

		private static void Leave(string reason)
		{
			Core.Log.Msg("[Viz] off (" + reason + ").");
			_car = null;
			VizHud.Show(VizMode.Off);
			CenterScreen.Show(null);
			Cabin.Show(null);
			CabinLight.Show(null, on: false);
			CabinGlass.Show(null, firstPerson: false);
		}

		internal static void Reset()
		{
			_car = null;
			_failed = false;
			CenterScreen.Reset();
			Cabin.Reset();
			CabinLight.Reset();
			CabinGlass.Reset();
			VizHud.Destroy();
			VizScene.Destroy();
		}
	}
	internal static class VizBuildings
	{
		private sealed class Block
		{
			internal Collider Collider;

			internal IntPtr Pointer;

			internal Mesh Mesh;

			internal Vector3 Position;

			internal Vector3 Scale;

			internal Quaternion Rotation;

			internal Bounds Bounds;

			internal bool Seen;

			internal GameObject Shown;
		}

		private const float MinHeight = 2.5f;

		private const float MinFootprint = 2.5f;

		private const float MaxFootprint = 150f;

		private const float Overhead = 2f;

		private const float CellSize = 25f;

		private const double SlowCellMs = 6.0;

		private const float EyeHeight = 1.4f;

		private const int LooksPerTick = 30;

		private const float SeenUpClose = 4f;

		private static readonly Dictionary<(int, int), List<Block>> Cells = new Dictionary<(int, int), List<Block>>();

		private static readonly HashSet<IntPtr> Taken = new HashSet<IntPtr>();

		private static readonly List<Block> Unseen = new List<Block>();

		private static readonly List<Block> Active = new List<Block>();

		private static readonly int Invisible = LayerMask.NameToLayer("Invisible");

		private static (int, int) _shownAround = (int.MinValue, int.MinValue);

		private static int _shownCells = -1;

		private static int _look;

		private static bool _reported;

		private static int _small;

		private static int _overhead;

		private static int _huge;

		private static int _moving;

		private static int _shape;

		private static int _hidden;

		private static int _colliders;

		private static int _seen;

		private static int _seenLogged;

		private static float _nextSeenLog;

		private static double _slowest;

		internal static void Tick(Vector3 centre, float radius, Transform parent, Material mat, Mesh cube)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			(int, int) tuple = CellOf(centre);
			int num = Mathf.CeilToInt(radius / 25f);
			(int, int) cell = (0, 0);
			bool flag = false;
			float num2 = float.MaxValue;
			int num3 = 0;
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					(int, int) tuple2 = (tuple.Item1 + i, tuple.Item2 + j);
					Vector3 val = Flat(CellCentre(tuple2, centre.y) - centre);
					if (((Vector3)(ref val)).magnitude > radius + 17.75f)
					{
						continue;
					}
					if (Cells.ContainsKey(tuple2))
					{
						num3++;
						continue;
					}
					float num4 = i * i + j * j;
					if (num4 < num2)
					{
						num2 = num4;
						cell = tuple2;
						flag = true;
					}
				}
			}
			if (flag)
			{
				Read(cell, centre.y, cube);
				num3++;
			}
			if (!flag)
			{
				(int, int) tuple3 = tuple;
				(int, int) shownAround = _shownAround;
				if (tuple3.Item1 == shownAround.Item1 && tuple3.Item2 == shownAround.Item2 && num3 == _shownCells)
				{
					goto IL_0124;
				}
			}
			Show(tuple, num, centre, radius, parent, mat, num3);
			goto IL_0124;
			IL_0124:
			Look(centre + Vector3.up * 1.4f, parent, mat);
			if (!flag && !_reported)
			{
				_reported = true;
				Core.Log.Msg("[Viz] buildings: " + Cells.Values.Sum((List<Block> l) => l.Count) + " block(s) in " + Cells.Count + " cell(s) of " + 25f + " m from " + _colliders + " collider(s); skipped " + _small + " small, " + _overhead + " overhead, " + _huge + " ground-sized, " + _moving + " moving, " + _hidden + " invisible, " + _shape + " other shapes; slowest cell " + _slowest.ToString("F1") + " ms.");
			}
			if (_seen != _seenLogged && Time.unscaledTime >= _nextSeenLog)
			{
				_seenLogged = _seen;
				_nextSeenLog = Time.unscaledTime + 10f;
				Core.Log.Msg("[Viz] buildings: " + _seen + " of " + Cells.Values.Sum((List<Block> l) => l.Count) + " block(s) seen so far, " + Unseen.Count + " in range still hidden from the car.");
			}
		}

		private static void Look(Vector3 eye, Transform parent, Material mat)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (Unseen.Count == 0)
			{
				return;
			}
			int num = Mathf.Min(30, Unseen.Count);
			for (int i = 0; i < num && Unseen.Count > 0; i++)
			{
				if (_look >= Unseen.Count)
				{
					_look = 0;
				}
				Block block = Unseen[_look];
				if (block.Seen)
				{
					Unseen.RemoveAt(_look);
					continue;
				}
				bool flag;
				try
				{
					flag = Visible(eye, block);
				}
				catch (Exception ex)
				{
					Core.Log.Error("[Viz] buildings: line-of-sight check failed, the block stays hidden: " + ex.Message);
					Unseen.RemoveAt(_look);
					continue;
				}
				if (!flag)
				{
					_look++;
					continue;
				}
				block.Seen = true;
				_seen++;
				Unseen.RemoveAt(_look);
				Active.Add(block);
				Place(block, parent, mat);
			}
		}

		private static bool Visible(Vector3 eye, Block b)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)b.Collider == (Object)null)
			{
				return false;
			}
			Vector3 val = ((Bounds)(ref b.Bounds)).ClosestPoint(eye);
			Vector3 val2 = Flat(val - eye);
			if (((Vector3)(ref val2)).magnitude < 4f && val.y > eye.y - 1.4f - 0.5f)
			{
				return true;
			}
			Vector3 center = ((Bounds)(ref b.Bounds)).center;
			center.y = ((Bounds)(ref b.Bounds)).max.y - 0.3f;
			if (!Clear(eye, ((Bounds)(ref b.Bounds)).center, b.Pointer) && !Clear(eye, center, b.Pointer))
			{
				return Clear(eye, val, b.Pointer);
			}
			return true;
		}

		private static bool Clear(Vector3 eye, Vector3 at, IntPtr target)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = at - eye;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.01f)
			{
				return true;
			}
			RaycastHit[] array = Il2CppArrayBase<RaycastHit>.op_Implicit((Il2CppArrayBase<RaycastHit>)(object)Physics.RaycastAll(eye, val / magnitude, magnitude + 1f, -5, (QueryTriggerInteraction)1));
			float num = float.MaxValue;
			IntPtr intPtr = IntPtr.Zero;
			for (int i = 0; i < array.Length; i++)
			{
				Collider collider = ((RaycastHit)(ref array[i])).collider;
				if (!((Object)(object)collider == (Object)null) && !((Object)(object)collider.attachedRigidbody != (Object)null) && ((Component)collider).gameObject.layer != Invisible && ((RaycastHit)(ref array[i])).distance < num)
				{
					num = ((RaycastHit)(ref array[i])).distance;
					intPtr = ((Il2CppObjectBase)collider).Pointer;
				}
			}
			return intPtr == target;
		}

		private static void Read((int, int) cell, float y, Mesh cube)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			Stopwatch stopwatch = Stopwatch.StartNew();
			List<Block> list = new List<Block>();
			Cells[cell] = list;
			Collider[] array;
			try
			{
				array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapBox(CellCentre(cell, y), new Vector3(12.5f, 300f, 12.5f), Quaternion.identity, -5, (QueryTriggerInteraction)1));
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				(int, int) tuple = cell;
				log.Error("[Viz] reading the buildings of cell " + tuple.ToString() + " failed, the cell stays empty: " + ex);
				return;
			}
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				if ((Object)(object)val == (Object)null || !Taken.Add(((Il2CppObjectBase)val).Pointer))
				{
					continue;
				}
				_colliders++;
				if ((Object)(object)val.attachedRigidbody != (Object)null)
				{
					_moving++;
					continue;
				}
				if (((Component)val).gameObject.layer == Invisible)
				{
					_hidden++;
					continue;
				}
				Bounds bounds = val.bounds;
				float num = Mathf.Max(((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.z);
				if (((Bounds)(ref bounds)).size.y < 2.5f || num < 2.5f)
				{
					_small++;
					continue;
				}
				if (num > 150f)
				{
					_huge++;
					continue;
				}
				if (((Bounds)(ref bounds)).min.y > y + 2f)
				{
					_overhead++;
					continue;
				}
				Transform transform = ((Component)val).transform;
				BoxCollider val2 = ((Il2CppObjectBase)val).TryCast<BoxCollider>();
				MeshCollider val3 = (((Object)(object)val2 == (Object)null) ? ((Il2CppObjectBase)val).TryCast<MeshCollider>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					list.Add(new Block
					{
						Collider = val,
						Pointer = ((Il2CppObjectBase)val).Pointer,
						Bounds = bounds,
						Mesh = cube,
						Position = transform.TransformPoint(val2.center),
						Rotation = transform.rotation,
						Scale = Vector3.Scale(transform.lossyScale, val2.size)
					});
				}
				else if ((Object)(object)val3 != (Object)null && (Object)(object)val3.sharedMesh != (Object)null)
				{
					list.Add(new Block
					{
						Collider = val,
						Pointer = ((Il2CppObjectBase)val).Pointer,
						Bounds = bounds,
						Mesh = val3.sharedMesh,
						Position = transform.position,
						Rotation = transform.rotation,
						Scale = transform.lossyScale
					});
				}
				else
				{
					_shape++;
				}
			}
			double totalMilliseconds = stopwatch.Elapsed.TotalMilliseconds;
			if (totalMilliseconds > _slowest)
			{
				_slowest = totalMilliseconds;
			}
			if (totalMilliseconds > 6.0)
			{
				Instance log2 = Core.Log;
				string[] obj = new string[7] { "[Viz] buildings: cell ", null, null, null, null, null, null };
				(int, int) tuple = cell;
				obj[1] = tuple.ToString();
				obj[2] = " took ";
				obj[3] = totalMilliseconds.ToString("F1");
				obj[4] = " ms for ";
				obj[5] = array.Length.ToString();
				obj[6] = " collider(s).";
				log2.Warning(string.Concat(obj));
			}
		}

		private static void Show((int, int) here, int reach, Vector3 centre, float radius, Transform parent, Material mat, int inRange)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			foreach (Block item in Active)
			{
				if ((Object)(object)item.Shown != (Object)null && item.Shown.activeSelf)
				{
					item.Shown.SetActive(false);
				}
			}
			Active.Clear();
			Unseen.Clear();
			for (int i = -reach; i <= reach; i++)
			{
				for (int j = -reach; j <= reach; j++)
				{
					(int, int) tuple = (here.Item1 + i, here.Item2 + j);
					if (!Cells.TryGetValue(tuple, out var value))
					{
						continue;
					}
					Vector3 val = Flat(CellCentre(tuple, centre.y) - centre);
					if (((Vector3)(ref val)).magnitude > radius + 17.75f)
					{
						continue;
					}
					foreach (Block item2 in value)
					{
						if (!item2.Seen)
						{
							Unseen.Add(item2);
							continue;
						}
						Active.Add(item2);
						Place(item2, parent, mat);
					}
				}
			}
			_look = 0;
			_shownAround = here;
			_shownCells = inRange;
		}

		private static void Place(Block b, Transform parent, Material mat)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)b.Shown == (Object)null)
			{
				GameObject val = new GameObject("Building")
				{
					layer = 20
				};
				val.transform.SetParent(parent, false);
				val.AddComponent<MeshFilter>().sharedMesh = b.Mesh;
				MeshRenderer obj = val.AddComponent<MeshRenderer>();
				((Renderer)obj).sharedMaterial = mat;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)obj).receiveShadows = false;
				val.transform.localPosition = b.Position;
				val.transform.localRotation = b.Rotation;
				val.transform.localScale = b.Scale;
				b.Shown = val;
			}
			if (!b.Shown.activeSelf)
			{
				b.Shown.SetActive(true);
			}
		}

		private static (int, int) CellOf(Vector3 p)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return (Mathf.FloorToInt(p.x / 25f), Mathf.FloorToInt(p.z / 25f));
		}

		private static Vector3 CellCentre((int, int) c, float y)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(((float)c.Item1 + 0.5f) * 25f, y, ((float)c.Item2 + 0.5f) * 25f);
		}

		private static Vector3 Flat(Vector3 v)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			v.y = 0f;
			return v;
		}

		internal static void Reset()
		{
			Cells.Clear();
			Taken.Clear();
			Unseen.Clear();
			Active.Clear();
			_shownAround = (int.MinValue, int.MinValue);
			_shownCells = -1;
			_look = 0;
			_reported = false;
			_nextSeenLog = 0f;
			_small = (_overhead = (_huge = (_moving = (_shape = (_hidden = (_colliders = (_seen = (_seenLogged = 0))))))));
			_slowest = 0.0;
		}
	}
	internal static class VizHud
	{
		private const float PanelHeight = 0.3f;

		private const float FullHeight = 0.86f;

		private const float Margin = 24f;

		private static GameObject _canvas;

		private static RawImage _image;

		private static RawImage _backdrop;

		private static VizMode _shown = VizMode.Off;

		internal static void Show(VizMode mode)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if ((mode != VizMode.Off && !Build()) || (Object)(object)_canvas == (Object)null)
			{
				return;
			}
			bool flag = mode != VizMode.Off && (Object)(object)VizScene.Texture != (Object)null;
			if (_canvas.activeSelf != flag)
			{
				_canvas.SetActive(flag);
			}
			if (!flag)
			{
				_shown = VizMode.Off;
				return;
			}
			_image.texture = (Texture)(object)VizScene.Texture;
			float num = 1.28f;
			RectTransform rectTransform = ((Graphic)_image).rectTransform;
			Vector2 val = default(Vector2);
			if (mode == VizMode.Full)
			{
				float num2 = (float)Screen.height * 0.86f;
				((Vector2)(ref val))..ctor(0.5f, 0.5f);
				rectTransform.pivot = val;
				Vector2 anchorMin = (rectTransform.anchorMax = val);
				rectTransform.anchorMin = anchorMin;
				rectTransform.anchoredPosition = Vector2.zero;
				rectTransform.sizeDelta = new Vector2(num2 * num, num2);
			}
			else
			{
				float num3 = (float)Screen.height * 0.3f;
				((Vector2)(ref val))..ctor(1f, 0f);
				rectTransform.pivot = val;
				Vector2 anchorMin = (rectTransform.anchorMax = val);
				rectTransform.anchorMin = anchorMin;
				rectTransform.anchoredPosition = new Vector2(-24f, 24f);
				rectTransform.sizeDelta = new Vector2(num3 * num, num3);
			}
			((Component)_backdrop).gameObject.SetActive(mode == VizMode.Full);
			if (_shown != mode)
			{
				Core.Log.Msg("[Viz] on screen: " + mode.ToString() + ", " + rectTransform.sizeDelta.x.ToString("F0") + "x" + rectTransform.sizeDelta.y.ToString("F0") + " px.");
			}
			_shown = mode;
		}

		private static bool Build()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas != (Object)null)
			{
				return true;
			}
			_canvas = new GameObject("YeslaViz_Hud");
			Object.DontDestroyOnLoad((Object)(object)_canvas);
			((Object)_canvas).hideFlags = (HideFlags)52;
			Canvas obj = _canvas.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 5;
			_backdrop = Image("Backdrop", new Color(0f, 0f, 0f, 0.55f));
			RectTransform rectTransform = ((Graphic)_backdrop).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.sizeDelta = Vector2.zero;
			_image = Image("Picture", Color.white);
			_canvas.SetActive(false);
			Core.Log.Msg("[Viz] HUD canvas built.");
			return true;
		}

		private static RawImage Image(string name, Color colour)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(_canvas.transform, false);
			RawImage obj = val.AddComponent<RawImage>();
			((Graphic)obj).color = colour;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		internal static void Destroy()
		{
			if ((Object)(object)_canvas != (Object)null)
			{
				Object.Destroy((Object)(object)_canvas);
			}
			_canvas = null;
			_image = null;
			_backdrop = null;
			_shown = VizMode.Off;
		}
	}
	internal static class VizOverlay
	{
		internal const float ShownSpeed = 1.4f;

		private const float Depth = 1f;

		private const float W = 0.597f;

		private const float H = 0.466f;

		private const float Now = 10f;

		private static readonly Color Blue = new Color(0.173f, 0.529f, 0.98f);

		private static readonly Color Grey = new Color(0.62f, 0.64f, 0.68f);

		private static readonly Color Card = new Color(0.098f, 0.106f, 0.118f);

		private static TextMeshPro _speed;

		private static TextMeshPro _unit;

		private static TextMeshPro _limit;

		private static TextMeshPro _limitTitle;

		private static TextMeshPro _state;

		private static TextMeshPro _nextDistance;

		private static TextMeshPro _nextWhat;

		private static TextMeshPro _destName;

		private static TextMeshPro _destDetail;

		private static GameObject _nextCard;

		private static GameObject _destCard;

		private static MeshFilter _arrow;

		private static Mesh _left;

		private static Mesh _right;

		private static Mesh _pin;

		private static TMP_FontAsset _font;

		internal static void Build(Camera cam)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			_font = FindFont();
			float num = 1f * Mathf.Tan(cam.fieldOfView * 0.5f * ((float)Math.PI / 180f));
			Transform transform = new GameObject("YeslaViz_Overlay")
			{
				layer = 20
			}.transform;
			transform.SetParent(((Component)cam).transform, false);
			transform.localPosition = new Vector3(0f, 0f, 1f);
			transform.localScale = Vector3.one * (num / 0.466f);
			_speed = Text(transform, "Speed", new Vector2(-0.557f, 0.436f), new Vector2(0.3f, 0.14f), 1.25f, (TextAlignmentOptions)257, Color.white);
			_unit = Text(transform, "Unit", new Vector2(-0.552f, 0.296f), new Vector2(0.3f, 0.05f), 0.3f, (TextAlignmentOptions)257, Grey);
			_state = Text(transform, "State", new Vector2(-0.552f, 0.241f), new Vector2(0.4f, 0.05f), 0.3f, (TextAlignmentOptions)257, Blue);
			Quad(transform, "LimitBorder", new Vector2(-0.287f, 0.35099998f), new Vector2(0.118f, 0.158f), Color.black, 0.012f);
			Quad(transform, "LimitSign", new Vector2(-0.287f, 0.35099998f), new Vector2(0.106f, 0.146f), Color.white, 0.01f);
			_limitTitle = Text(transform, "LimitTitle", new Vector2(-0.34f, 0.41799998f), new Vector2(0.106f, 0.05f), 0.15f, (TextAlignmentOptions)258, Color.black);
			((TMP_Text)_limitTitle).lineSpacing = -30f;
			_limit = Text(transform, "Limit", new Vector2(-0.34f, 0.366f), new Vector2(0.106f, 0.08f), 0.58f, (TextAlignmentOptions)258, Color.black);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.16f);
			_nextCard = Quad(transform, "NextCard", new Vector2(-0.17700002f + val.x * 0.5f, 0.431f - val.y * 0.5f), val, Card, 0.01f);
			Transform transform2 = _nextCard.transform;
			_left = Arrow(right: false);
			_right = Arrow(right: true);
			_pin = Pin();
			GameObject val2 = new GameObject("Arrow")
			{
				layer = 20
			};
			val2.transform.SetParent(transform2, false);
			val2.transform.localPosition = new Vector3((0f - val.x) * 0.5f + 0.075f, 0f, -0.002f);
			_arrow = val2.AddComponent<MeshFilter>();
			MeshRenderer obj = val2.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterial = VizScene.Flat(Color.white);
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			_nextDistance = Text(transform2, "NextDistance", new Vector2((0f - val.x) * 0.5f + 0.15f, 0.07f), new Vector2(0.34f, 0.08f), 0.56f, (TextAlignmentOptions)257, Color.white, -0.01f);
			_nextWhat = Text(transform2, "NextWhat", new Vector2((0f - val.x) * 0.5f + 0.152f, -0.005f), new Vector2(0.34f, 0.06f), 0.28f, (TextAlignmentOptions)257, Grey, -0.01f);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.44f, 0.13f);
			_destCard = Quad(transform, "DestCard", new Vector2(0.56700003f - val3.x * 0.5f, -0.436f + val3.y * 0.5f), val3, Card, 0.01f);
			Transform transform3 = _destCard.transform;
			_destName = Text(transform3, "DestName", new Vector2((0f - val3.x) * 0.5f + 0.03f, 0.052f), new Vector2(val3.x - 0.06f, 0.06f), 0.36f, (TextAlignmentOptions)257, Color.white, -0.01f);
			_destDetail = Text(transform3, "DestDetail", new Vector2((0f - val3.x) * 0.5f + 0.03f, -0.005f), new Vector2(val3.x - 0.06f, 0.05f), 0.27f, (TextAlignmentOptions)257, Grey, -0.01f);
			Core.Log.Msg("[Viz] overlay text " + (((Object)(object)_font != (Object)null) ? ("in " + ((Object)_font).name) : "in TextMeshPro's default font") + ".");
		}

		internal static void Update(VizInfo info)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_speed == (Object)null))
			{
				bool flag = Imperial();
				float num = info.SpeedKmh * 1.4f;
				float num2 = info.LimitKmh * 1.4f;
				((TMP_Text)_speed).text = Mathf.RoundToInt(flag ? (num * 0.621371f) : num).ToString();
				((TMP_Text)_unit).text = (flag ? "MPH" : "KM/H");
				((TMP_Text)_limit).text = Mathf.RoundToInt(flag ? (num2 * 0.621371f) : num2).ToString();
				((TMP_Text)_limitTitle).text = "SPEED\nLIMIT";
				((TMP_Text)_state).text = info.State ?? string.Empty;
				((Graphic)_state).color = (info.Driving ? Blue : Grey);
				Mesh val = null;
				string text = null;
				switch (info.Next)
				{
				case NextStep.Left:
					val = _left;
					text = "Turn left";
					break;
				case NextStep.Right:
					val = _right;
					text = "Turn right";
					break;
				case NextStep.Arrive:
					val = _pin;
					text = (string.IsNullOrEmpty(info.Destination) ? "Arrive" : info.Destination);
					break;
				}
				_nextCard.SetActive((Object)(object)val != (Object)null);
				if ((Object)(object)val != (Object)null)
				{
					_arrow.sharedMesh = val;
					((TMP_Text)_nextDistance).text = ((info.NextMetres < 10f) ? "Now" : Distance(info.NextMetres, flag));
					((TMP_Text)_nextWhat).text = text;
				}
				bool flag2 = !string