using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 RearMirrorCruiser
{
	[BepInPlugin("itsjustliliana.rearmirrorcruiser", "Rear Mirror Cruiser", "1.0.10")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "itsjustliliana.rearmirrorcruiser";

		public const string PluginName = "Rear Mirror Cruiser";

		public const string PluginVersion = "1.0.10";

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("RearMirrorCruiserController");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<RearMirrorController>().Initialize(((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Rear Mirror Cruiser 1.0.10 loaded.");
		}
	}
	public sealed class RearMirrorController : MonoBehaviour
	{
		private sealed class DriverState
		{
			public bool IsInVehicle { get; set; }

			public bool IsDriver { get; set; }

			public Transform? VehicleTransform { get; set; }
		}

		private ConfigEntry<bool>? _enableRearFeed;

		private ConfigEntry<bool>? _enableInteriorFeed;

		private ConfigEntry<float>? _feedOpacity;

		private ConfigEntry<float>? _cameraFieldOfView;

		private ConfigEntry<float>? _rearCameraFps;

		private ConfigEntry<float>? _interiorCameraFps;

		private const int RenderWidth = 320;

		private const int RenderHeight = 180;

		private const float DefaultFeedOpacity = 0.95f;

		private const float DefaultRearCameraFieldOfView = 62f;

		private const float RearCameraFarClip = 60f;

		private const float RearCameraBack = -3.9f;

		private const float RearCameraHeight = 2.2f;

		private const float RearCameraTilt = 18f;

		private const float InteriorRearCameraBack = 0.65f;

		private const float InteriorRearCameraHeight = 1.55f;

		private const float InteriorRearCameraTilt = 22f;

		private const float DefaultRearCameraFps = 12f;

		private const float DefaultInteriorCameraFps = 8f;

		private const float InteriorFeedWidth = 230f;

		private const float InteriorFeedHeight = 98f;

		private const float InteriorFeedGap = 14f;

		private const float RearFeedWidth = 520f;

		private const float RearFeedHeight = 165f;

		private const float FeedPosY = -18f;

		private const float RearFeedPosX = 0f;

		private const float InteriorFeedPosX = 389f;

		private ManualLogSource? _logger;

		private Canvas? _canvas;

		private RawImage? _feedImage;

		private RawImage? _interiorFeedImage;

		private RenderTexture? _renderTexture;

		private RenderTexture? _interiorRenderTexture;

		private Camera? _rearCamera;

		private Camera? _interiorCamera;

		private GameObject? _rearCameraObject;

		private GameObject? _interiorCameraObject;

		private bool _feedVisible;

		private float _lastDrivingTime;

		private Transform? _currentVehicleTransform;

		private bool _forceRenderThisFrame;

		private float _nextRearRenderAt;

		private float _nextInteriorRenderAt;

		private Type? _vehicleControllerType;

		private readonly BindingFlags _instanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public void Initialize(ConfigFile config, ManualLogSource logger)
		{
			_logger = logger;
			_enableRearFeed = config.Bind<bool>("General", "EnableRearMirrorFeed", true, "Enable the rear mirror feed.");
			_enableInteriorFeed = config.Bind<bool>("General", "EnableInsideViewFeed", true, "Enable the inside/interior view feed.");
			_feedOpacity = config.Bind<float>("UI", "FeedOpacity", 0.95f, "Feed opacity (0.0 to 1.0).");
			_cameraFieldOfView = config.Bind<float>("Camera", "FieldOfView", 62f, "Rear camera field of view.");
			_rearCameraFps = config.Bind<float>("Performance", "RearCameraFPS", 12f, "Rear camera render rate (frames per second).");
			_interiorCameraFps = config.Bind<float>("Performance", "InteriorCameraFPS", 8f, "Interior camera render rate (frames per second).");
			BuildUi();
		}

		private void Update()
		{
			bool flag = _enableRearFeed?.Value ?? true;
			bool flag2 = _enableInteriorFeed?.Value ?? true;
			if (!flag && !flag2)
			{
				_currentVehicleTransform = null;
				SetFeedVisible(visible: false);
				return;
			}
			object obj = TryGetLocalPlayer();
			if (obj == null)
			{
				SetFeedVisible(visible: false);
				return;
			}
			DriverState driverState = EvaluateDriverState(obj);
			Transform stableVehicleTransform = GetStableVehicleTransform(driverState.VehicleTransform);
			if (driverState.IsInVehicle && driverState.IsDriver && (Object)(object)stableVehicleTransform != (Object)null)
			{
				_lastDrivingTime = Time.unscaledTime;
				if ((Object)(object)_currentVehicleTransform != (Object)(object)stableVehicleTransform)
				{
					_currentVehicleTransform = stableVehicleTransform;
					if (flag)
					{
						EnsureRearCamera(stableVehicleTransform);
					}
					if (flag2)
					{
						EnsureInteriorCamera(stableVehicleTransform);
					}
					ManualLogSource? logger = _logger;
					if (logger != null)
					{
						logger.LogInfo((object)("Cameras initialized for vehicle: " + ((Object)stableVehicleTransform).name));
					}
				}
				else
				{
					if (flag && ((Object)(object)_rearCameraObject == (Object)null || (Object)(object)_rearCamera == (Object)null || (Object)(object)_rearCameraObject.transform.parent != (Object)(object)stableVehicleTransform))
					{
						EnsureRearCamera(stableVehicleTransform);
					}
					if (flag2 && ((Object)(object)_interiorCameraObject == (Object)null || (Object)(object)_interiorCamera == (Object)null || (Object)(object)_interiorCameraObject.transform.parent != (Object)(object)stableVehicleTransform))
					{
						EnsureInteriorCamera(stableVehicleTransform);
					}
				}
				ApplyFeedPresentation(flag, flag2);
				SetFeedVisible(visible: true);
			}
			else if (!(Time.unscaledTime - _lastDrivingTime < 0.2f))
			{
				_currentVehicleTransform = null;
				SetFeedVisible(visible: false);
			}
		}

		private void LateUpdate()
		{
			if (!_feedVisible)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			bool forceRenderThisFrame = _forceRenderThisFrame;
			bool flag = _enableRearFeed?.Value ?? true;
			bool flag2 = _enableInteriorFeed?.Value ?? true;
			if (forceRenderThisFrame)
			{
				_forceRenderThisFrame = false;
			}
			float configuredRearFov = GetConfiguredRearFov();
			if ((Object)(object)_rearCamera != (Object)null)
			{
				_rearCamera.fieldOfView = configuredRearFov;
			}
			if ((Object)(object)_interiorCamera != (Object)null)
			{
				_interiorCamera.fieldOfView = Mathf.Clamp(configuredRearFov - 6f, 35f, 110f);
			}
			float fps = _rearCameraFps?.Value ?? 12f;
			bool flag3 = ShouldRenderCamera(unscaledTime, fps, ref _nextRearRenderAt, forceRenderThisFrame);
			if (flag && flag3 && (Object)(object)_rearCamera != (Object)null && (Object)(object)_renderTexture != (Object)null)
			{
				if ((Object)(object)_rearCamera.targetTexture != (Object)(object)_renderTexture)
				{
					_rearCamera.targetTexture = _renderTexture;
				}
				_rearCamera.Render();
			}
			else if (!flag)
			{
				_nextRearRenderAt = 0f;
			}
			float fps2 = _interiorCameraFps?.Value ?? 8f;
			bool flag4 = ShouldRenderCamera(unscaledTime, fps2, ref _nextInteriorRenderAt, forceRenderThisFrame);
			if (flag2 && flag4 && (Object)(object)_interiorCamera != (Object)null && (Object)(object)_interiorRenderTexture != (Object)null)
			{
				if ((Object)(object)_interiorCamera.targetTexture != (Object)(object)_interiorRenderTexture)
				{
					_interiorCamera.targetTexture = _interiorRenderTexture;
				}
				_interiorCamera.Render();
			}
			else if (!flag2)
			{
				_nextInteriorRenderAt = 0f;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_renderTexture != (Object)null)
			{
				_renderTexture.Release();
				Object.Destroy((Object)(object)_renderTexture);
				_renderTexture = null;
			}
			if ((Object)(object)_interiorRenderTexture != (Object)null)
			{
				_interiorRenderTexture.Release();
				Object.Destroy((Object)(object)_interiorRenderTexture);
				_interiorRenderTexture = null;
			}
			if ((Object)(object)_rearCameraObject != (Object)null)
			{
				Object.Destroy((Object)(object)_rearCameraObject);
				_rearCameraObject = null;
				_rearCamera = null;
			}
			if ((Object)(object)_interiorCameraObject != (Object)null)
			{
				Object.Destroy((Object)(object)_interiorCameraObject);
				_interiorCameraObject = null;
				_interiorCamera = null;
			}
			if ((Object)(object)_canvas != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_canvas).gameObject);
				_canvas = null;
				_feedImage = null;
				_interiorFeedImage = null;
			}
		}

		private void BuildUi()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			GameObject val = new GameObject("RearMirrorCanvas");
			Object.DontDestroyOnLoad((Object)(object)val);
			((Object)val).hideFlags = (HideFlags)61;
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.overrideSorting = true;
			_canvas.sortingOrder = 32767;
			val.AddComponent<CanvasScaler>();
			val.AddComponent<GraphicRaycaster>();
			GameObject val2 = new GameObject("RearMirrorFeed");
			val2.transform.SetParent(val.transform, false);
			val2.SetActive(true);
			_feedImage = val2.AddComponent<RawImage>();
			ConfigureFeedImage(_feedImage, 0f, -18f, 520f, 165f);
			GameObject val3 = new GameObject("InteriorMirrorFeed");
			val3.transform.SetParent(val.transform, false);
			val3.SetActive(true);
			_interiorFeedImage = val3.AddComponent<RawImage>();
			ConfigureFeedImage(_interiorFeedImage, 389f, -18f, 230f, 98f);
			((Component)_canvas).gameObject.SetActive(false);
		}

		private void EnsureRearCamera(Transform vehicleTransform)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rearCameraObject == (Object)null)
			{
				_rearCameraObject = new GameObject("RearMirrorCamera");
				((Object)_rearCameraObject).hideFlags = (HideFlags)61;
				_rearCamera = _rearCameraObject.AddComponent<Camera>();
				((Behaviour)_rearCamera).enabled = false;
				_rearCamera.clearFlags = (CameraClearFlags)2;
				_rearCamera.backgroundColor = Color.black;
				_rearCamera.depth = -100f;
				_rearCamera.forceIntoRenderTexture = true;
				_rearCamera.allowHDR = false;
				_rearCamera.allowMSAA = false;
				_rearCamera.useOcclusionCulling = false;
			}
			if ((Object)(object)_rearCameraObject.transform.parent != (Object)(object)vehicleTransform)
			{
				_rearCameraObject.transform.SetParent(vehicleTransform, false);
			}
			_rearCameraObject.transform.localPosition = new Vector3(0f, 2.2f, -3.9f);
			_rearCameraObject.transform.localRotation = Quaternion.Euler(18f, 180f, 0f);
			EnsureRenderTextures();
			ConfigureMirrorCamera(_rearCamera, _renderTexture, GetConfiguredRearFov());
		}

		private void EnsureInteriorCamera(Transform vehicleTransform)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_interiorCameraObject == (Object)null)
			{
				_interiorCameraObject = new GameObject("InteriorMirrorCamera");
				((Object)_interiorCameraObject).hideFlags = (HideFlags)61;
				_interiorCamera = _interiorCameraObject.AddComponent<Camera>();
				((Behaviour)_interiorCamera).enabled = false;
				_interiorCamera.clearFlags = (CameraClearFlags)2;
				_interiorCamera.backgroundColor = Color.black;
				_interiorCamera.depth = -100f;
				_interiorCamera.forceIntoRenderTexture = true;
				_interiorCamera.allowHDR = false;
				_interiorCamera.allowMSAA = false;
				_interiorCamera.useOcclusionCulling = false;
			}
			if ((Object)(object)_interiorCameraObject.transform.parent != (Object)(object)vehicleTransform)
			{
				_interiorCameraObject.transform.SetParent(vehicleTransform, false);
			}
			_interiorCameraObject.transform.localPosition = new Vector3(0f, 1.55f, 0.65f);
			_interiorCameraObject.transform.localRotation = Quaternion.Euler(22f, 180f, 0f);
			EnsureRenderTextures();
			ConfigureMirrorCamera(_interiorCamera, _interiorRenderTexture, Mathf.Clamp(GetConfiguredRearFov() - 6f, 35f, 110f));
		}

		private void EnsureRenderTextures()
		{
			//IL_0083: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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)
			//IL_00ad: Expected O, but got Unknown
			//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_015c: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			int num = Mathf.Clamp(320, 128, 1024);
			int num2 = Mathf.Clamp(180, 72, 1024);
			if ((Object)(object)_renderTexture == (Object)null || ((Texture)_renderTexture).width != num || ((Texture)_renderTexture).height != num2)
			{
				if ((Object)(object)_renderTexture != (Object)null)
				{
					_renderTexture.Release();
					Object.Destroy((Object)(object)_renderTexture);
				}
				_renderTexture = new RenderTexture(num, num2, 16, (RenderTextureFormat)7)
				{
					name = "RearMirrorRT",
					antiAliasing = 1,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				_renderTexture.Create();
				_renderTexture.DiscardContents();
			}
			int num3 = Mathf.Clamp((int)((float)num * 0.6f), 96, 768);
			int num4 = Mathf.Clamp((int)((float)num2 * 0.6f), 54, 432);
			if ((Object)(object)_interiorRenderTexture == (Object)null || ((Texture)_interiorRenderTexture).width != num3 || ((Texture)_interiorRenderTexture).height != num4)
			{
				if ((Object)(object)_interiorRenderTexture != (Object)null)
				{
					_interiorRenderTexture.Release();
					Object.Destroy((Object)(object)_interiorRenderTexture);
				}
				_interiorRenderTexture = new RenderTexture(num3, num4, 16, (RenderTextureFormat)7)
				{
					name = "InteriorMirrorRT",
					antiAliasing = 1,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				_interiorRenderTexture.Create();
				_interiorRenderTexture.DiscardContents();
			}
			if ((Object)(object)_feedImage != (Object)null && (Object)(object)_feedImage.texture != (Object)(object)_renderTexture)
			{
				_feedImage.texture = (Texture)(object)_renderTexture;
			}
			if ((Object)(object)_interiorFeedImage != (Object)null && (Object)(object)_interiorFeedImage.texture != (Object)(object)_interiorRenderTexture)
			{
				_interiorFeedImage.texture = (Texture)(object)_interiorRenderTexture;
			}
		}

		private void SetFeedVisible(bool visible)
		{
			if (_feedVisible == visible)
			{
				return;
			}
			_feedVisible = visible;
			if (visible)
			{
				EnsureRenderTextures();
				bool rearEnabled = _enableRearFeed?.Value ?? true;
				bool interiorEnabled = _enableInteriorFeed?.Value ?? true;
				ApplyFeedPresentation(rearEnabled, interiorEnabled);
				if ((Object)(object)_canvas != (Object)null && ((Component)_canvas).gameObject.activeSelf)
				{
					Canvas.ForceUpdateCanvases();
				}
				_nextInteriorRenderAt = (_nextRearRenderAt = Time.unscaledTime);
				_forceRenderThisFrame = true;
				return;
			}
			_forceRenderThisFrame = false;
			_nextRearRenderAt = 0f;
			_nextInteriorRenderAt = 0f;
			GameObject? rearCameraObject = _rearCameraObject;
			object obj;
			if (rearCameraObject == null)
			{
				obj = null;
			}
			else
			{
				Transform parent = rearCameraObject.transform.parent;
				obj = ((parent != null) ? ((Object)parent).name : null);
			}
			if (obj == null)
			{
				GameObject? interiorCameraObject = _interiorCameraObject;
				if (interiorCameraObject == null)
				{
					obj = null;
				}
				else
				{
					Transform parent2 = interiorCameraObject.transform.parent;
					obj = ((parent2 != null) ? ((Object)parent2).name : null);
				}
			}
			string text = (string)obj;
			if (!string.IsNullOrEmpty(text))
			{
				ManualLogSource? logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)("Cameras deinitialized for vehicle: " + text));
				}
			}
			if ((Object)(object)_canvas != (Object)null)
			{
				((Component)_canvas).gameObject.SetActive(false);
			}
			if ((Object)(object)_rearCameraObject != (Object)null)
			{
				_rearCameraObject.transform.SetParent((Transform)null);
			}
			if ((Object)(object)_interiorCameraObject != (Object)null)
			{
				_interiorCameraObject.transform.SetParent((Transform)null);
			}
		}

		private float GetConfiguredRearFov()
		{
			return Mathf.Clamp(_cameraFieldOfView?.Value ?? 62f, 40f, 120f);
		}

		private void ApplyFeedPresentation(bool rearEnabled, bool interiorEnabled)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp01(_feedOpacity?.Value ?? 0.95f);
			if ((Object)(object)_feedImage != (Object)null)
			{
				((Graphic)_feedImage).color = new Color(1f, 1f, 1f, num);
				((Component)_feedImage).gameObject.SetActive(rearEnabled);
			}
			if ((Object)(object)_interiorFeedImage != (Object)null)
			{
				((Graphic)_interiorFeedImage).color = new Color(1f, 1f, 1f, num);
				((Component)_interiorFeedImage).gameObject.SetActive(interiorEnabled);
			}
			if ((Object)(object)_canvas != (Object)null)
			{
				((Component)_canvas).gameObject.SetActive(rearEnabled || interiorEnabled);
			}
		}

		private static bool ShouldRenderCamera(float now, float fps, ref float nextRenderAt, bool forceRender)
		{
			float num = Mathf.Clamp(fps, 1f, 60f);
			float num2 = 1f / num;
			if (forceRender)
			{
				nextRenderAt = now + num2;
				return true;
			}
			if (nextRenderAt <= 0f)
			{
				nextRenderAt = now;
			}
			if (now + 0.0001f < nextRenderAt)
			{
				return false;
			}
			nextRenderAt = now + num2;
			return true;
		}

		private object? TryGetLocalPlayer()
		{
			object singletonInstance = GetSingletonInstance("GameNetworkManager");
			object memberValue = GetMemberValue(singletonInstance, "localPlayerController");
			if (memberValue != null)
			{
				return memberValue;
			}
			object singletonInstance2 = GetSingletonInstance("StartOfRound");
			return GetMemberValue(singletonInstance2, "localPlayerController");
		}

		private DriverState EvaluateDriverState(object? localPlayer)
		{
			Type type = localPlayer?.GetType();
			object obj = ((localPlayer != null && type != null) ? GetMemberValue(localPlayer, "attachedVehicle") : null);
			object obj2 = FindLocalDrivenVehicle(localPlayer);
			object obj3 = obj2 ?? obj;
			bool flag = obj3 != null && IsVehicleDrivenByLocalPlayer(obj3, localPlayer);
			bool flag2 = ((localPlayer != null && type != null) ? ReadNamedBool(localPlayer, type, new string[3] { "invehicleanimation", "invehicle", "isinvehicle" }) : null) ?? (obj3 != null || flag);
			bool flag3 = flag;
			if (!flag3 && obj2 != null)
			{
				flag3 = true;
			}
			else if (!flag3 && localPlayer != null && type != null)
			{
				bool? flag4 = ReadNamedBool(localPlayer, type, new string[3] { "isdriver", "driving", "localplayerincontrol" });
				int? num = ReadNamedInt(localPlayer, type, new string[3] { "vehicleseat", "seatindex", "seat" });
				flag3 = flag4 ?? (num.HasValue && num.Value == 0);
			}
			return new DriverState
			{
				IsInVehicle = flag2,
				IsDriver = (flag2 && flag3),
				VehicleTransform = ResolveTransform(obj3)
			};
		}

		private object? FindLocalDrivenVehicle(object? localPlayer)
		{
			//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)
			if ((object)_vehicleControllerType == null)
			{
				_vehicleControllerType = FindTypeByName("VehicleController");
			}
			if (_vehicleControllerType == null)
			{
				return null;
			}
			Object[] array = Resources.FindObjectsOfTypeAll(_vehicleControllerType);
			foreach (Object obj in array)
			{
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if (val != null)
				{
					Scene scene = val.gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && IsVehicleDrivenByLocalPlayer(val, localPlayer))
					{
						return val;
					}
				}
			}
			return null;
		}

		private bool IsVehicleDrivenByLocalPlayer(object vehicle, object? localPlayer)
		{
			Type type = vehicle.GetType();
			if (GetBoolMemberValue(vehicle, type, "isLocalDriver").GetValueOrDefault())
			{
				return true;
			}
			bool? boolMemberValue = GetBoolMemberValue(vehicle, type, "localPlayerInControl");
			bool? boolMemberValue2 = GetBoolMemberValue(vehicle, type, "localPlayerInPassengerSeat");
			if (boolMemberValue.GetValueOrDefault() && !boolMemberValue2.GetValueOrDefault())
			{
				return true;
			}
			object memberValue = GetMemberValue(vehicle, "currentDriver");
			if (localPlayer != null && memberValue != null && memberValue == localPlayer)
			{
				return true;
			}
			long? numberMemberValue = GetNumberMemberValue(vehicle, type, "driverId");
			long? num = ((localPlayer != null) ? GetNumberMemberValue(localPlayer, localPlayer.GetType(), "playerClientId") : null);
			if (numberMemberValue.HasValue && num.HasValue && numberMemberValue.Value == num.Value)
			{
				return true;
			}
			return false;
		}

		private bool? ReadNamedBool(object target, Type type, IEnumerable<string> nameFragments)
		{
			FieldInfo[] fields = type.GetFields(_instanceFlags);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (!(fieldInfo.FieldType != typeof(bool)) && ContainsAny(fieldInfo.Name.ToLowerInvariant(), nameFragments))
				{
					try
					{
						return (bool)fieldInfo.GetValue(target);
					}
					catch
					{
					}
				}
			}
			PropertyInfo[] properties = type.GetProperties(_instanceFlags);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.PropertyType != typeof(bool)) && propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0 && ContainsAny(propertyInfo.Name.ToLowerInvariant(), nameFragments))
				{
					try
					{
						return (bool)propertyInfo.GetValue(target);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		private int? ReadNamedInt(object target, Type type, IEnumerable<string> nameFragments)
		{
			FieldInfo[] fields = type.GetFields(_instanceFlags);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (!(fieldInfo.FieldType != typeof(int)) && ContainsAny(fieldInfo.Name.ToLowerInvariant(), nameFragments))
				{
					try
					{
						return (int)fieldInfo.GetValue(target);
					}
					catch
					{
					}
				}
			}
			PropertyInfo[] properties = type.GetProperties(_instanceFlags);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (!(propertyInfo.PropertyType != typeof(int)) && propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0 && ContainsAny(propertyInfo.Name.ToLowerInvariant(), nameFragments))
				{
					try
					{
						return (int)propertyInfo.GetValue(target);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		private static bool ContainsAny(string source, IEnumerable<string> fragments)
		{
			foreach (string fragment in fragments)
			{
				if (source.Contains(fragment))
				{
					return true;
				}
			}
			return false;
		}

		private bool? GetBoolMemberValue(object target, Type type, string memberName)
		{
			object memberValueByName = GetMemberValueByName(target, type, memberName);
			if (!(memberValueByName is bool))
			{
				return null;
			}
			return (bool)memberValueByName;
		}

		private long? GetNumberMemberValue(object target, Type type, string memberName)
		{
			object memberValueByName = GetMemberValueByName(target, type, memberName);
			if (memberValueByName == null)
			{
				return null;
			}
			try
			{
				return Convert.ToInt64(memberValueByName);
			}
			catch
			{
				return null;
			}
		}

		private object? GetMemberValueByName(object target, Type type, string memberName)
		{
			FieldInfo field = type.GetField(memberName, _instanceFlags);
			if (field != null)
			{
				try
				{
					return field.GetValue(target);
				}
				catch
				{
				}
			}
			PropertyInfo property = type.GetProperty(memberName, _instanceFlags);
			if (property != null)
			{
				try
				{
					return property.GetValue(target);
				}
				catch
				{
				}
			}
			return null;
		}

		private object? GetSingletonInstance(string typeName)
		{
			Type type = FindTypeByName(typeName);
			if (type == null)
			{
				return null;
			}
			FieldInfo field = type.GetField("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					return field.GetValue(null);
				}
				catch
				{
				}
			}
			PropertyInfo property = type.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				try
				{
					return property.GetValue(null);
				}
				catch
				{
				}
			}
			return null;
		}

		private object? GetMemberValue(object? target, string memberName)
		{
			if (target == null)
			{
				return null;
			}
			Type type = target.GetType();
			FieldInfo field = type.GetField(memberName, _instanceFlags);
			if (field != null)
			{
				try
				{
					return field.GetValue(target);
				}
				catch
				{
				}
			}
			PropertyInfo property = type.GetProperty(memberName, _instanceFlags);
			if (property != null)
			{
				try
				{
					return property.GetValue(target);
				}
				catch
				{
				}
			}
			return null;
		}

		private static Type? FindTypeByName(string typeName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				Type type;
				try
				{
					type = assembly.GetType(typeName, throwOnError: false);
				}
				catch
				{
					continue;
				}
				if (type != null)
				{
					return type;
				}
				Type[] types;
				try
				{
					types = assembly.GetTypes();
				}
				catch
				{
					continue;
				}
				Type[] array = types;
				foreach (Type type2 in array)
				{
					if (string.Equals(type2.Name, typeName, StringComparison.Ordinal))
					{
						return type2;
					}
				}
			}
			return null;
		}

		private Transform? ResolveTransform(object? value)
		{
			if (value == null)
			{
				return null;
			}
			Transform val = (Transform)((value is Transform) ? value : null);
			if (val != null)
			{
				return val;
			}
			Component val2 = (Component)((value is Component) ? value : null);
			if (val2 != null)
			{
				return val2.transform;
			}
			GameObject val3 = (GameObject)((value is GameObject) ? value : null);
			if (val3 != null)
			{
				return val3.transform;
			}
			return null;
		}

		private static Transform? GetStableVehicleTransform(Transform? vehicleTransform)
		{
			if ((Object)(object)vehicleTransform == (Object)null)
			{
				return null;
			}
			if (!((Object)(object)vehicleTransform.root != (Object)null))
			{
				return vehicleTransform;
			}
			return vehicleTransform.root;
		}

		private void ConfigureFeedImage(RawImage image, float posX, float posY, float width, float height)
		{
			//IL_0032: 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_0093: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_006d: Expected O, but got Unknown
			((Graphic)image).raycastTarget = false;
			((Graphic)image).color = new Color(1f, 1f, 1f, Mathf.Clamp01(_feedOpacity?.Value ?? 0.95f));
			if ((Object)(object)((Graphic)image).material == (Object)null)
			{
				((Graphic)image).material = new Material(Shader.Find("Unlit/Texture") ?? Shader.Find("UI/Default"));
			}
			RectTransform rectTransform = ((Graphic)image).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(posX, posY);
			rectTransform.sizeDelta = new Vector2(width, height);
		}

		private static void ConfigureMirrorCamera(Camera? camera, RenderTexture? targetTexture, float fieldOfView)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)camera == (Object)null))
			{
				camera.fieldOfView = fieldOfView;
				camera.farClipPlane = Mathf.Clamp(60f, 10f, 200f);
				camera.nearClipPlane = 0.1f;
				camera.targetTexture = targetTexture;
				camera.depth = -100f;
				camera.forceIntoRenderTexture = true;
				camera.rect = new Rect(0f, 0f, 1f, 1f);
				Camera main = Camera.main;
				camera.cullingMask = (((Object)(object)main != (Object)null) ? main.cullingMask : (-1));
			}
		}
	}
}