using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AdvancedCompany.Game;
using AdvancedCompany.Objects;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using GeneralImprovements.API;
using HarmonyLib;
using LethalLib.Modules;
using LethalVRM;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using ModelReplacement.Monobehaviors;
using MoreCompany.Cosmetics;
using OpenBodyCams.API;
using OpenBodyCams.Compatibility;
using OpenBodyCams.Components;
using OpenBodyCams.Overlay;
using OpenBodyCams.Patches;
using OpenBodyCams.Utilities;
using OpenBodyCams.Utilities.IL;
using ReservedItemSlotCore.Data;
using ReservedItemSlotCore.Patches;
using TMPro;
using Unity.Netcode;
using Unity.Profiling;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OpenBodyCams")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OpenBodyCams")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3d49e5ff-443d-44f6-90aa-a870ecfeb2d5")]
[assembly: AssemblyFileVersion("3.0.11")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.0.11.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[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 OpenBodyCams
{
	public class BodyCamComponent : MonoBehaviour
	{
		public delegate bool TargetChangedToTransform(MonoBehaviour bodyCam, Transform target, ref Transform attachmentPoint, ref Vector3 offset, ref Quaternion angle, ref Renderer[] renderersToHide);

		public delegate void RenderersToHideTransformer(MonoBehaviour bodyCam, ref Renderer[] renderers);

		[Flags]
		private enum TargetDirtyStatus
		{
			None = 0,
			Immediate = 1,
			UntilRender = 2
		}

		private const float RADAR_BOOSTER_INITIAL_PAN = 270f;

		private static readonly Vector3 BODY_CAM_OFFSET = new Vector3(0.07f, 0f, 0.16f);

		private static readonly Vector3 PLAYER_HEAD_CAM_OFFSET = new Vector3(0.07f, 0f, 0.125f);

		private static readonly Vector3 CORPSE_HEAD_CAM_OFFSET = new Vector3(0.07f, -0.1f, 0.125f);

		private static readonly Vector3 MASKED_HEAD_CAM_OFFSET = new Vector3(0.07f, 0.1f, 0.031f);

		private static readonly int CullModeProperty = Shader.PropertyToID("_CullMode");

		private static int bodyCamCullingMask;

		private static FrameSettings mainCameraCustomFrameSettings;

		private static FrameSettingsOverrideMask mainCameraCustomFrameSettingsMask;

		private static Material fogShaderMaterial;

		private static GameObject nightVisionPrefab;

		private static BodyCamComponent[] AllBodyCams = Array.Empty<BodyCamComponent>();

		private static BodyCamComponent lastBodyCamCulled;

		private static BodyCamComponent lastBodyCamRendered;

		private static Transform sunRootTransform = null;

		private static MatchLocalPlayerPosition[] matchLocalPlayerPositions = Array.Empty<MatchLocalPlayerPosition>();

		internal static WeatherEffectComponents[] weatherEffects = Array.Empty<WeatherEffectComponents>();

		private static bool disableCameraWhileTargetIsOnShip = false;

		private static float radarBoosterPanSpeed;

		private Transform CameraContainer;

		internal Transform CameraTransform;

		internal Camera Camera;

		internal Renderer MonitorRenderer;

		internal int MonitorMaterialIndex = -1;

		internal Material MonitorOnMaterial;

		internal Material MonitorNoTargetMaterial;

		internal Material MonitorOffMaterial;

		internal Material MonitorDisabledMaterial;

		internal bool MonitorIsOn = true;

		internal bool EnableCamera = true;

		private bool keepCameraOn;

		private static readonly Vector2Int DefaultResolution = new Vector2Int(160, 120);

		private Vector2Int resolution = DefaultResolution;

		private bool isRemoteCamera = true;

		private PlayerModelState localPlayerModelState;

		private PlayerControllerB currentPlayer;

		private PlayerModelState currentPlayerModelState;

		private Transform currentActualTarget;

		private Transform currentAttachmentPoint;

		private Renderer[] currentRenderersToHide = Array.Empty<Renderer>();

		private Material currentObstructingMaterial;

		private float currentObstructingMaterialCullMode;

		private bool originalDirectSunlightEnabled;

		private bool originalIndirectSunlightEnabled;

		private bool targetSunlightEnabled = true;

		private float originalBlackSkyVolumeWeight;

		private float targetBlackSkyVolumeWeight;

		private float originalIndirectSunlightDimmer;

		private float targetIndirectSunlightDimmer;

		private Vector3 originalSunRootScale = Vector3.one;

		private Transform targetWeatherParent;

		private WeatherEffectComponents[] targetWeatherComponents;

		private Light nightVisionLight;

		private MeshRenderer greenFlashRenderer;

		private Animator greenFlashAnimator;

		private MeshRenderer fogShaderPlaneRenderer;

		private TargetDirtyStatus targetDirtyStatus;

		private float elapsedSinceLastFrame;

		private float timePerFrame;

		private bool panCamera;

		private float panAngle = 270f;

		private CameraRenderingStatus cameraStatus;

		private const string profilerMarkerPrefix = "OpenBodyCams:";

		private static readonly ProfilerMarker markerRevertCullingOverrides = new ProfilerMarker("OpenBodyCams:RevertCullingOverrides");

		private static readonly ProfilerMarker markerBeforeCullingAnyCamera = new ProfilerMarker("OpenBodyCams:BeforeCullingAnyCamera");

		private static readonly ProfilerMarker markerBeforeRenderingAnyCamera = new ProfilerMarker("OpenBodyCams:BeforeRenderingAnyCamera");

		private static readonly ProfilerMarker markerAfterRenderingAnyCamera = new ProfilerMarker("OpenBodyCams:AfterRenderingAnyCamera");

		private static readonly ProfilerMarker markerApplyCullingOverrides = new ProfilerMarker("OpenBodyCams:ApplyCullingOverrides");

		private static readonly ProfilerMarker markerApplyViewPerspective = new ProfilerMarker("OpenBodyCams:ViewPerspective.Apply");

		public bool IsRemoteCamera
		{
			get
			{
				return isRemoteCamera;
			}
			set
			{
				if (isRemoteCamera != value)
				{
					isRemoteCamera = value;
					TargetHasChanged();
				}
			}
		}

		public bool ForceEnableCamera
		{
			get
			{
				return keepCameraOn;
			}
			set
			{
				keepCameraOn = value;
			}
		}

		public Vector2Int Resolution
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return resolution;
			}
			set
			{
				//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)
				resolution = value;
				UpdateSettings();
			}
		}

		public bool IsBlanked => !CameraShouldRender(cameraStatus);

		public CameraRenderingStatus CameraStatus => cameraStatus;

		public bool ForceTargetInvalid { get; set; }

		public float Framerate
		{
			get
			{
				return 1f / timePerFrame;
			}
			set
			{
				if (value != 0f)
				{
					timePerFrame = 1f / value;
				}
				else
				{
					timePerFrame = 0f;
				}
			}
		}

		public PlayerControllerB? CurrentPlayerTarget => currentPlayer;

		public Transform? CurrentTarget => currentActualTarget;

		public static event TargetChangedToTransform? BeforeTargetChangedToTransform;

		public static event RenderersToHideTransformer? RenderersToHideTransformers;

		public event Action<Camera>? OnCameraCreated;

		public event Action<RenderTexture>? OnRenderTextureCreated;

		public event Action<bool>? OnBlankedSet;

		public event Action<CameraRenderingStatus>? OnCameraStatusChanged;

		public event Action<bool>? OnScreenPowerChanged;

		public event BodyCam.BodyCamStatusUpdate? OnTargetChanged;

		public static BodyCamComponent[] GetAllBodyCams()
		{
			return AllBodyCams.ToArray();
		}

		public Camera? GetCamera()
		{
			CreateCameraIfNotCreated();
			return Camera;
		}

		internal static void InitializeStatic()
		{
			SceneManager.sceneLoaded += delegate
			{
				UpdateSceneStaticObjects();
			};
			SceneManager.sceneUnloaded += delegate
			{
				UpdateSceneStaticObjects();
			};
		}

		private static void UpdateSceneStaticObjects()
		{
			animatedSun obj = Object.FindAnyObjectByType<animatedSun>();
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				MatchLocalPlayerPosition componentInParent = ((Component)obj).GetComponentInParent<MatchLocalPlayerPosition>();
				obj2 = ((componentInParent != null) ? ((Component)componentInParent).transform : null);
			}
			sunRootTransform = (Transform)obj2;
			matchLocalPlayerPositions = Object.FindObjectsByType<MatchLocalPlayerPosition>((FindObjectsSortMode)0);
		}

		internal static void UpdateWeathers()
		{
			if ((Object)(object)TimeOfDay.Instance != (Object)null)
			{
				int num = TimeOfDay.Instance.effects.Length;
				weatherEffects = new WeatherEffectComponents[num];
				for (int i = 0; i < num; i++)
				{
					weatherEffects[i] = new WeatherEffectComponents((LevelWeatherType)i);
				}
			}
			else
			{
				weatherEffects = Array.Empty<WeatherEffectComponents>();
			}
			CreateTargetWeatherEffectsForAllCams();
		}

		internal static void InitializeAtStartOfGame()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[0];
			bodyCamCullingMask = val.gameplayCamera.cullingMask & ~LayerMask.GetMask(new string[3] { "Ignore Raycast", "UI", "HelmetVisor" });
			HDAdditionalCameraData component = ((Component)val.gameplayCamera).GetComponent<HDAdditionalCameraData>();
			if (component.customRenderingSettings)
			{
				Plugin.Instance.Logger.LogInfo((object)("Using custom camera settings from " + ((Object)component).name + "."));
				mainCameraCustomFrameSettings = component.renderingPathCustomFrameSettings;
				mainCameraCustomFrameSettingsMask = component.renderingPathCustomFrameSettingsOverrideMask;
			}
			fogShaderMaterial = ((Renderer)((Component)((Component)val.localVisor).transform.Find("ScavengerHelmet/Plane")).GetComponent<MeshRenderer>()).sharedMaterial;
			nightVisionPrefab = Object.Instantiate<GameObject>(((Component)val.nightVision).gameObject);
			((Object)nightVisionPrefab).hideFlags = (HideFlags)61;
			((Object)nightVisionPrefab).name = "NightVision";
			nightVisionPrefab.transform.localPosition = Vector3.zero;
			nightVisionPrefab.SetActive(false);
			Light component2 = nightVisionPrefab.GetComponent<Light>();
			((Behaviour)component2).enabled = false;
			UpdateAllCameraSettings();
		}

		internal static bool HasFinishedGameStartSetup()
		{
			return (Object)(object)nightVisionPrefab != (Object)null;
		}

		public static void UpdateAllCameraSettings()
		{
			UpdateStaticSettings();
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.UpdateSettings();
			}
		}

		internal static void UpdateStaticSettings()
		{
			disableCameraWhileTargetIsOnShip = Plugin.DisableCameraWhileTargetIsOnShip.Value;
			radarBoosterPanSpeed = Plugin.RadarBoosterPanRPM.Value * 360f / 60f;
		}

		internal static void CreateTargetWeatherEffectsForAllCams()
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.CreateTargetWeatherEffects();
			}
		}

		public static void MarkTargetDirtyUntilRenderForAllBodyCams(Transform target)
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.MarkTargetDirtyUntilRender(target);
			}
		}

		public static void MarkAnyParentDirtyUntilRenderForAllBodyCams(Transform target)
		{
			while ((Object)(object)target != (Object)null)
			{
				MarkTargetDirtyUntilRenderForAllBodyCams(target);
				target = target.parent;
			}
		}

		public static void MarkTargetDirtyUntilRenderForAllBodyCams()
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.MarkTargetDirtyUntilRender();
			}
		}

		public static void MarkTargetStatusChangedForAllBodyCams(Transform target)
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.MarkTargetStatusChanged(target);
			}
		}

		public static void MarkTargetStatusChangedForAllBodyCams()
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				bodyCamComponent.MarkTargetStatusChanged();
			}
		}

		private static void RevertLastOverrides()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker val = markerRevertCullingOverrides;
			AutoScope val2 = ((ProfilerMarker)(ref val)).Auto();
			try
			{
				if ((Object)(object)lastBodyCamCulled != (Object)null)
				{
					lastBodyCamCulled.RevertCullingOverrides();
					lastBodyCamCulled = null;
				}
				if ((Object)(object)lastBodyCamRendered != (Object)null)
				{
					lastBodyCamRendered.RevertRenderingOverrides();
					lastBodyCamRendered = null;
				}
			}
			finally
			{
				((IDisposable)(AutoScope)(ref val2)).Dispose();
			}
		}

		internal static void BeforeCullingAnyCamera(Camera camera)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker val = markerBeforeCullingAnyCamera;
			((ProfilerMarker)(ref val)).Begin((Object)(object)camera);
			RevertLastOverrides();
			int num = AllBodyCams.Length;
			for (int i = 0; i < num; i++)
			{
				BodyCamComponent bodyCamComponent = AllBodyCams[i];
				if (bodyCamComponent.Camera == camera)
				{
					lastBodyCamCulled = bodyCamComponent;
					bodyCamComponent.ApplyCullingOverrides();
					break;
				}
			}
			val = markerBeforeCullingAnyCamera;
			((ProfilerMarker)(ref val)).End();
		}

		internal static void BeforeRenderingAnyCamera(Camera camera)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker val = markerBeforeRenderingAnyCamera;
			((ProfilerMarker)(ref val)).Begin((Object)(object)camera);
			RevertLastOverrides();
			int num = AllBodyCams.Length;
			for (int i = 0; i < num; i++)
			{
				BodyCamComponent bodyCamComponent = AllBodyCams[i];
				if (bodyCamComponent.Camera == camera)
				{
					lastBodyCamRendered = bodyCamComponent;
					bodyCamComponent.ApplyRenderingOverrides();
					break;
				}
			}
			val = markerBeforeRenderingAnyCamera;
			((ProfilerMarker)(ref val)).End();
		}

		internal static void AfterRenderingAnyCamera(Camera camera)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker val = markerAfterRenderingAnyCamera;
			((ProfilerMarker)(ref val)).Begin((Object)(object)camera);
			RevertLastOverrides();
			val = markerAfterRenderingAnyCamera;
			((ProfilerMarker)(ref val)).End();
		}

		private void Awake()
		{
			if (!HasFinishedGameStartSetup())
			{
				Plugin.Instance.Logger.LogError((object)"Attempted to create a body cam before static initialization has been completed.");
				Plugin.Instance.Logger.LogError((object)"This may occur if the save is corrupted, or if a mod caused an error during the start of the game.");
				Object.Destroy((Object)(object)this);
				return;
			}
			BodyCamComponent[] allBodyCams = AllBodyCams;
			int num = 0;
			BodyCamComponent[] array = new BodyCamComponent[1 + allBodyCams.Length];
			ReadOnlySpan<BodyCamComponent> readOnlySpan = new ReadOnlySpan<BodyCamComponent>(allBodyCams);
			readOnlySpan.CopyTo(new Span<BodyCamComponent>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array[num] = this;
			AllBodyCams = array;
			BodyCam.BodyCamInstantiated(this);
		}

		private void Start()
		{
			if (HasFinishedGameStartSetup())
			{
				CreateCameraIfNotCreated();
				CreateTargetWeatherEffects();
				SyncBodyCamToRadarMap.UpdateBodyCamTarget(this);
			}
		}

		private void SetMonitorMaterial(Material material)
		{
			if (!((Object)(object)MonitorRenderer == (Object)null))
			{
				MonitorRenderer.SetMaterial(MonitorMaterialIndex, material);
			}
		}

		private void EnsureMaterialsExist()
		{
			//IL_0019: 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_002e: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MonitorOnMaterial == (Object)null)
			{
				MonitorOnMaterial = new Material(Shader.Find("HDRP/Unlit"))
				{
					name = "BodyCamMaterial"
				};
				MonitorOnMaterial.SetFloat("_AlbedoAffectEmissive", 1f);
				MonitorOnMaterial.SetColor("_EmissiveColor", Color.white);
			}
			if ((Object)(object)MonitorOffMaterial == (Object)null)
			{
				MonitorOffMaterial = ShipObjects.BlackScreenMaterial;
			}
		}

		private void CreateCameraIfNotCreated()
		{
			//IL_004f: 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_0069: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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)
			//IL_00e5: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_0175: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Camera != (Object)null))
			{
				Plugin.Instance.Logger.LogInfo((object)("Creating a new camera for " + ((Object)this).name + "."));
				UpdateScreenMaterial();
				CameraContainer = new GameObject("BodyCam_" + ((Object)this).name + "_Container").transform;
				GameObject val = new GameObject("BodyCam");
				CameraTransform = val.transform;
				CameraTransform.SetParent(CameraContainer, false);
				Camera = val.AddComponent<Camera>();
				Camera.nearClipPlane = 0.01f;
				Camera.cullingMask = bodyCamCullingMask;
				HDAdditionalCameraData val2 = val.AddComponent<HDAdditionalCameraData>();
				val2.volumeLayerMask = LayerMask.op_Implicit(1);
				_ = mainCameraCustomFrameSettings;
				val2.customRenderingSettings = true;
				ref FrameSettings renderingPathCustomFrameSettings = ref val2.renderingPathCustomFrameSettings;
				ref FrameSettingsOverrideMask renderingPathCustomFrameSettingsOverrideMask = ref val2.renderingPathCustomFrameSettingsOverrideMask;
				renderingPathCustomFrameSettings = mainCameraCustomFrameSettings;
				renderingPathCustomFrameSettingsOverrideMask = mainCameraCustomFrameSettingsMask;
				((FrameSettings)(ref renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)93, false);
				((BitArray128)(ref renderingPathCustomFrameSettingsOverrideMask.mask))[93u] = true;
				((FrameSettings)(ref renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)88, false);
				((BitArray128)(ref renderingPathCustomFrameSettingsOverrideMask.mask))[88u] = true;
				val2.hasPersistentHistory = true;
				GameObject val3 = Object.Instantiate<GameObject>(nightVisionPrefab);
				val3.transform.SetParent(CameraTransform, false);
				val3.SetActive(true);
				nightVisionLight = val3.GetComponent<Light>();
				UpdateSettings();
				GameObject val4 = new GameObject("CameraGreenTransitionScaler");
				val4.transform.SetParent(CameraTransform, false);
				val4.transform.localScale = new Vector3(1f, 0.004f, 1f);
				GameObject val5 = Object.Instantiate<GameObject>(((Component)StartOfRound.Instance.mapScreen.mapCameraAnimator).gameObject);
				val5.transform.SetParent(val4.transform, false);
				val5.transform.localPosition = new Vector3(0f, 0f, 0.1f);
				val5.layer = 0;
				greenFlashRenderer = val5.GetComponent<MeshRenderer>();
				((Renderer)greenFlashRenderer).forceRenderingOff = true;
				greenFlashAnimator = val5.GetComponent<Animator>() ?? throw new Exception("Green flash object copied from the map screen has no Animator.");
				greenFlashAnimator.Play("MapTransitionGreen", 0, 1f);
				greenFlashAnimator.WriteDefaultValues();
				GameObject val6 = GameObject.CreatePrimitive((PrimitiveType)5);
				Object.Destroy((Object)(object)val6.GetComponent<MeshCollider>());
				val6.transform.SetParent(CameraTransform, false);
				val6.transform.localPosition = new Vector3(0f, 0f, Camera.nearClipPlane * 2f);
				val6.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
				fogShaderPlaneRenderer = val6.GetComponent<MeshRenderer>();
				((Renderer)fogShaderPlaneRenderer).sharedMaterial = fogShaderMaterial;
				((Renderer)fogShaderPlaneRenderer).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)fogShaderPlaneRenderer).receiveShadows = false;
				((Renderer)fogShaderPlaneRenderer).forceRenderingOff = true;
				this.OnCameraCreated?.Invoke(Camera);
			}
		}

		private bool PositionIsInInterior(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return position.y < -80f;
		}

		private void CreateTargetWeatherEffects()
		{
			//IL_003c: 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_0146: 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_015e: Invalid comparison between Unknown and I4
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			DestroyTargetWeatherEffects();
			if (Plugin.DisplayWeatherBasedOnPerspective.Value != BoolWithDefault.True)
			{
				return;
			}
			targetWeatherComponents = new WeatherEffectComponents[weatherEffects.Length];
			targetWeatherParent = new GameObject("BodyCam_" + ((Object)this).name + "_TargetWeathers").transform;
			TimeOfDay instance = TimeOfDay.Instance;
			LevelWeatherType val = (LevelWeatherType)((instance == null) ? (-1) : ((int)instance.currentLevelWeather));
			Dictionary<GameObject, GameObject> dictionary = new Dictionary<GameObject, GameObject>();
			for (int i = 0; i < targetWeatherComponents.Length; i++)
			{
				WeatherEffectComponents weatherEffectComponents = weatherEffects[i];
				GameObject value = null;
				if ((Object)(object)weatherEffectComponents.effectObject != (Object)null && !dictionary.TryGetValue(weatherEffectComponents.effectObject, out value))
				{
					value = Object.Instantiate<GameObject>(weatherEffectComponents.effectObject);
					value.transform.SetParent(targetWeatherParent, false);
					OccludeAudio[] componentsInChildren = value.GetComponentsInChildren<OccludeAudio>();
					foreach (OccludeAudio val2 in componentsInChildren)
					{
						Object.Destroy((Object)(object)val2);
					}
					AudioLowPassFilter[] componentsInChildren2 = value.GetComponentsInChildren<AudioLowPassFilter>();
					foreach (AudioLowPassFilter val3 in componentsInChildren2)
					{
						Object.Destroy((Object)(object)val3);
					}
					AudioSource[] componentsInChildren3 = value.GetComponentsInChildren<AudioSource>();
					foreach (AudioSource val4 in componentsInChildren3)
					{
						Object.Destroy((Object)(object)val4);
					}
					dictionary.Add(weatherEffectComponents.effectObject, value);
				}
				WeatherEffectComponents weatherEffectComponents2 = new WeatherEffectComponents(weatherEffectComponents.weatherType, value);
				weatherEffectComponents2.SetVisibility(show: false);
				if ((int)val == i && !PositionIsInInterior(CameraTransform.position))
				{
					weatherEffectComponents2.enabled = true;
				}
				targetWeatherComponents[i] = weatherEffectComponents2;
			}
		}

		private void DestroyTargetWeatherEffects()
		{
			targetWeatherComponents = Array.Empty<WeatherEffectComponents>();
			if ((Object)(object)targetWeatherParent != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)targetWeatherParent).gameObject);
			}
			targetWeatherParent = null;
		}

		public void UpdateSettings()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0061: Expected O, but got Unknown
			if (!((Object)(object)Camera == (Object)null))
			{
				int x = ((Vector2Int)(ref resolution)).x;
				int y = ((Vector2Int)(ref resolution)).y;
				Camera.targetTexture = new RenderTexture(x, y, 32)
				{
					name = ((Object)this).name + ".RenderTexture",
					filterMode = Plugin.MonitorTextureFiltering.Value
				};
				Camera.fieldOfView = Plugin.FieldOfView.Value;
				if ((Object)(object)MonitorOnMaterial != (Object)null)
				{
					MonitorOnMaterial.mainTexture = (Texture)(object)Camera.targetTexture;
				}
				Camera.farClipPlane = Plugin.RenderDistance.Value;
				nightVisionLight.intensity = 367f * Plugin.NightVisionBrightness.Value;
				nightVisionLight.range = 12f * Plugin.NightVisionBrightness.Value;
				this.OnRenderTextureCreated?.Invoke(Camera.targetTexture);
				CreateTargetWeatherEffects();
			}
		}

		public void StartTargetTransition()
		{
			if (Plugin.UseTargetTransitionAnimation.Value)
			{
				Animator obj = greenFlashAnimator;
				if (obj != null)
				{
					obj.SetTrigger("Transition");
				}
			}
		}

		public void UpdateScreenMaterial()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!HasFinishedGameStartSetup())
			{
				return;
			}
			EnsureMaterialsExist();
			if (!MonitorIsOn)
			{
				if ((Object)(object)MonitorOffMaterial != (Object)null)
				{
					SetMonitorMaterial(MonitorOffMaterial);
				}
				return;
			}
			bool enabled = ((Behaviour)this).enabled;
			if (IsBlanked || !enabled)
			{
				MonitorOnMaterial.color = Color.black;
				if (!enabled && (Object)(object)MonitorDisabledMaterial != (Object)null)
				{
					SetMonitorMaterial(MonitorDisabledMaterial);
					return;
				}
				if ((Object)(object)MonitorNoTargetMaterial != (Object)null)
				{
					SetMonitorMaterial(MonitorNoTargetMaterial);
					return;
				}
			}
			else
			{
				MonitorOnMaterial.color = Color.white;
			}
			SetMonitorMaterial(MonitorOnMaterial);
		}

		public void SetScreenPowered(bool powered)
		{
			if (!((Object)(object)MonitorRenderer == (Object)null) && powered != MonitorIsOn)
			{
				if (powered)
				{
					StartTargetTransition();
				}
				MonitorIsOn = powered;
				UpdateScreenMaterial();
				this.OnScreenPowerChanged?.Invoke(MonitorIsOn);
			}
		}

		public bool IsScreenPowered()
		{
			return MonitorIsOn;
		}

		private bool CameraShouldRender(CameraRenderingStatus status)
		{
			return status == CameraRenderingStatus.Rendering;
		}

		private void SetStatus(CameraRenderingStatus newStatus)
		{
			if (newStatus != cameraStatus)
			{
				bool flag = CameraShouldRender(cameraStatus) != CameraShouldRender(newStatus);
				cameraStatus = newStatus;
				UpdateScreenMaterial();
				if (flag)
				{
					this.OnBlankedSet?.Invoke(IsBlanked);
				}
				this.OnCameraStatusChanged?.Invoke(cameraStatus);
			}
		}

		private CameraRenderingStatus GetUpdatedCameraStatus()
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (!EnableCamera)
			{
				return CameraRenderingStatus.Disabled;
			}
			if ((Object)(object)currentActualTarget == (Object)null || ForceTargetInvalid)
			{
				return CameraRenderingStatus.TargetInvalid;
			}
			if (currentPlayer != null)
			{
				if (currentPlayer.isPlayerControlled)
				{
					if (currentPlayer.isInHangarShipRoom)
					{
						return CameraRenderingStatus.TargetDisabledOnShip;
					}
					return CameraRenderingStatus.Rendering;
				}
				if (!currentPlayer.isPlayerDead)
				{
					return CameraRenderingStatus.Rendering;
				}
				if ((Object)(object)currentPlayer.redirectToEnemy != (Object)null)
				{
					if (currentPlayer.redirectToEnemy.isInsidePlayerShip)
					{
						return CameraRenderingStatus.TargetDisabledOnShip;
					}
					return CameraRenderingStatus.Rendering;
				}
				if ((Object)(object)currentPlayer.deadBody != (Object)null)
				{
					if (!((Component)currentPlayer.deadBody).gameObject.activeSelf)
					{
						return CameraRenderingStatus.TargetInvalid;
					}
					if (currentPlayer.deadBody.isInShip)
					{
						return CameraRenderingStatus.TargetDisabledOnShip;
					}
					return CameraRenderingStatus.Rendering;
				}
			}
			RadarBoosterItem component = ((Component)currentActualTarget).GetComponent<RadarBoosterItem>();
			if (component != null)
			{
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(3000f, -400f, 3000f);
				if (((Vector3)(ref ((GrabbableObject)component).targetFloorPosition)).Equals(val))
				{
					return CameraRenderingStatus.TargetInvalid;
				}
				if (((GrabbableObject)component).isInShipRoom)
				{
					return CameraRenderingStatus.TargetDisabledOnShip;
				}
				return CameraRenderingStatus.Rendering;
			}
			return CameraRenderingStatus.Rendering;
		}

		private static void CollectDescendentModelsToHide(Transform parent, List<Renderer> list)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				if ((Object)(object)parent == (Object)(object)bodyCamComponent.CameraTransform)
				{
					return;
				}
			}
			Renderer component = ((Component)parent).GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null && ((1 << ((Component)component).gameObject.layer) & bodyCamCullingMask) != 0)
			{
				list.Add(component);
			}
			foreach (Transform item in parent)
			{
				Transform parent2 = item;
				CollectDescendentModelsToHide(parent2, list);
			}
		}

		private static Renderer[] CollectModelsToHide(Transform parent)
		{
			List<Renderer> list = new List<Renderer>(20);
			CollectDescendentModelsToHide(parent, list);
			return list.ToArray();
		}

		private bool TargetWouldRequireUpdate(Transform target)
		{
			if (target == null)
			{
				return true;
			}
			if (currentActualTarget == target)
			{
				return true;
			}
			if (((Component)StartOfRound.Instance.localPlayerController).transform == target)
			{
				return true;
			}
			return false;
		}

		public void MarkTargetStatusChanged(Transform transform)
		{
			if (!targetDirtyStatus.HasFlag(TargetDirtyStatus.Immediate) && TargetWouldRequireUpdate(transform))
			{
				targetDirtyStatus |= TargetDirtyStatus.Immediate;
			}
		}

		public void MarkTargetStatusChanged()
		{
			MarkTargetStatusChanged(null);
		}

		public void MarkTargetDirtyUntilRender(Transform transform)
		{
			if (!targetDirtyStatus.HasFlag(TargetDirtyStatus.UntilRender) && TargetWouldRequireUpdate(transform))
			{
				targetDirtyStatus |= TargetDirtyStatus.UntilRender;
			}
		}

		public void MarkTargetDirtyUntilRender()
		{
			MarkTargetDirtyUntilRender(null);
		}

		private void ClearTargetDirtyImmediate()
		{
			targetDirtyStatus &= ~TargetDirtyStatus.Immediate;
		}

		private void SetRenderersToHide(Renderer[] renderers)
		{
			BodyCamComponent.RenderersToHideTransformers?.Invoke((MonoBehaviour)(object)this, ref renderers);
			currentRenderersToHide = renderers;
		}

		private void TargetHasChanged()
		{
			UpdateOverrides(float.PositiveInfinity);
			this.OnTargetChanged?.Invoke((MonoBehaviour)(object)this);
		}

		public void SetTargetToNone()
		{
			//IL_003f: 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)
			CreateCameraIfNotCreated();
			ClearTargetDirtyImmediate();
			currentPlayer = null;
			currentActualTarget = null;
			currentAttachmentPoint = null;
			SetRenderersToHide(Array.Empty<Renderer>());
			UpdateModelReferences();
			currentObstructingMaterial = null;
			CameraTransform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			TargetHasChanged();
		}

		public void SetTargetToPlayer(PlayerControllerB player)
		{
			//IL_0045: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: 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_01f3: 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_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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)
			CreateCameraIfNotCreated();
			if ((Object)(object)player == (Object)null)
			{
				SetTargetToNone();
				return;
			}
			ClearTargetDirtyImmediate();
			currentPlayer = player;
			currentActualTarget = null;
			currentAttachmentPoint = null;
			UpdateModelReferences();
			panCamera = false;
			currentObstructingMaterial = null;
			Vector3 val = Vector3.zero;
			if (!currentPlayer.isPlayerDead)
			{
				if (Plugin.CameraMode.Value == CameraModeOptions.Head)
				{
					currentAttachmentPoint = ((Component)currentPlayer.gameplayCamera).transform;
					val = PLAYER_HEAD_CAM_OFFSET;
				}
				else
				{
					currentAttachmentPoint = ((Component)currentPlayer.playerGlobalHead).transform.parent;
					val = BODY_CAM_OFFSET;
				}
				currentActualTarget = ((Component)currentPlayer).transform;
				SetRenderersToHide(Array.Empty<Renderer>());
			}
			else if ((Object)(object)currentPlayer.redirectToEnemy != (Object)null)
			{
				EnemyAI redirectToEnemy = currentPlayer.redirectToEnemy;
				MaskedPlayerEnemy val2 = (MaskedPlayerEnemy)(object)((redirectToEnemy is MaskedPlayerEnemy) ? redirectToEnemy : null);
				if (val2 != null)
				{
					if (Plugin.CameraMode.Value == CameraModeOptions.Head)
					{
						currentAttachmentPoint = ((EnemyAI)val2).eye;
						val = MASKED_HEAD_CAM_OFFSET;
					}
					else
					{
						currentAttachmentPoint = val2.animationContainer.Find("metarig/spine/spine.001/spine.002/spine.003");
						val = BODY_CAM_OFFSET;
					}
				}
				else
				{
					currentAttachmentPoint = currentPlayer.redirectToEnemy.eye;
				}
				currentActualTarget = ((Component)currentPlayer.redirectToEnemy).transform;
				SetRenderersToHide(CollectModelsToHide(currentActualTarget));
			}
			else if ((Object)(object)currentPlayer.deadBody != (Object)null)
			{
				Transform parent;
				if (Plugin.CameraMode.Value == CameraModeOptions.Head)
				{
					currentAttachmentPoint = ((Component)currentPlayer.deadBody).transform.Find("spine.001/spine.002/spine.003/spine.004/spine.004_end");
					parent = currentAttachmentPoint.parent;
					val = CORPSE_HEAD_CAM_OFFSET;
				}
				else
				{
					currentAttachmentPoint = ((Component)currentPlayer.deadBody).transform.Find("spine.001/spine.002/spine.003");
					parent = currentAttachmentPoint;
					val = BODY_CAM_OFFSET;
				}
				currentActualTarget = ((Component)currentPlayer.deadBody).transform;
				SetRenderersToHide(CollectModelsToHide(parent));
				Renderer component = ((Component)currentActualTarget).GetComponent<Renderer>();
				currentObstructingMaterial = ((component != null) ? component.sharedMaterial : null);
			}
			if ((Object)(object)currentAttachmentPoint == (Object)null)
			{
				currentAttachmentPoint = currentActualTarget;
			}
			CameraTransform.SetLocalPositionAndRotation(val, Quaternion.identity);
			TargetHasChanged();
		}

		public void SetTargetToTransform(Transform transform)
		{
			//IL_004c: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			CreateCameraIfNotCreated();
			if ((Object)(object)transform == (Object)null || (Object)(object)((Component)transform).gameObject == (Object)null)
			{
				SetTargetToNone();
				return;
			}
			ClearTargetDirtyImmediate();
			currentPlayer = null;
			currentActualTarget = transform;
			currentAttachmentPoint = null;
			UpdateModelReferences();
			panCamera = false;
			Vector3 offset = Vector3.zero;
			Quaternion angle = Quaternion.identity;
			currentRenderersToHide = Array.Empty<Renderer>();
			RadarBoosterItem component = ((Component)currentActualTarget).GetComponent<RadarBoosterItem>();
			if (component != null)
			{
				SetRenderersToHide((Renderer[])(object)new Renderer[1] { ((Component)((Component)currentActualTarget).transform.Find("AnimContainer/Rod")).GetComponent<Renderer>() });
				currentAttachmentPoint = currentActualTarget;
				((Vector3)(ref offset))..ctor(0f, 1.5f, 0f);
				panCamera = true;
			}
			else
			{
				currentAttachmentPoint = currentActualTarget;
				if (BodyCamComponent.BeforeTargetChangedToTransform != null)
				{
					Delegate[] invocationList = BodyCamComponent.BeforeTargetChangedToTransform.GetInvocationList();
					foreach (Delegate @delegate in invocationList)
					{
						if (((TargetChangedToTransform)@delegate)((MonoBehaviour)(object)this, currentActualTarget, ref currentAttachmentPoint, ref offset, ref angle, ref currentRenderersToHide))
						{
							SetRenderersToHide(currentRenderersToHide);
							break;
						}
					}
				}
			}
			CameraTransform.SetLocalPositionAndRotation(offset, angle);
			TargetHasChanged();
		}

		private void UpdateTargetStatus()
		{
			if ((Object)(object)currentPlayer != (Object)null)
			{
				SetTargetToPlayer(currentPlayer);
			}
			else
			{
				SetTargetToTransform(currentActualTarget);
			}
		}

		private void UpdateModelReferences()
		{
			ViewPerspective.PrepareModelState(currentPlayer, ref currentPlayerModelState);
			if ((Object)(object)currentPlayer != (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				ViewPerspective.PrepareModelState(StartOfRound.Instance.localPlayerController, ref localPlayerModelState);
			}
		}

		private void UpdateTargetStatusBeforeRender()
		{
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.UntilRender))
			{
				UpdateTargetStatus();
				targetDirtyStatus ^= TargetDirtyStatus.UntilRender;
			}
		}

		private void SetTargetWeathersVisible(bool visible)
		{
			for (int i = 0; i < targetWeatherComponents.Length; i++)
			{
				WeatherEffectComponents weatherEffectComponents = weatherEffects[i];
				WeatherEffectComponents weatherEffectComponents2 = targetWeatherComponents[i];
				if (weatherEffectComponents != null && weatherEffectComponents2 != null)
				{
					weatherEffectComponents.SetVisibility(!visible);
					weatherEffectComponents2.SetVisibility(visible);
				}
			}
		}

		private static void SetMatchLocalPlayerPositions(Vector3 position)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			MatchLocalPlayerPosition[] array = matchLocalPlayerPositions;
			foreach (MatchLocalPlayerPosition val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					((Component)val).transform.position = position;
				}
			}
		}

		private void ApplyCullingOverrides()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000e: 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_0058: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker val = markerApplyCullingOverrides;
			AutoScope val2 = ((ProfilerMarker)(ref val)).Auto();
			try
			{
				UpdateTargetStatusBeforeRender();
				if ((Object)(object)currentAttachmentPoint == (Object)null)
				{
					return;
				}
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if ((Object)(object)localPlayerController == (Object)null)
				{
					return;
				}
				CameraContainer.SetPositionAndRotation(currentAttachmentPoint.position, currentAttachmentPoint.rotation);
				((Behaviour)nightVisionLight).enabled = true;
				((Renderer)greenFlashRenderer).forceRenderingOff = false;
				((Renderer)fogShaderPlaneRenderer).forceRenderingOff = false;
				val = markerApplyViewPerspective;
				AutoScope val3 = ((ProfilerMarker)(ref val)).Auto();
				try
				{
					ViewPerspective.Apply(ref currentPlayerModelState, Perspective.FirstPerson);
					if (currentPlayer != localPlayerController)
					{
						ViewPerspective.Apply(ref localPlayerModelState, Perspective.ThirdPerson);
					}
				}
				finally
				{
					((IDisposable)(AutoScope)(ref val3)).Dispose();
				}
				bool flag = false;
				Renderer[] array = currentRenderersToHide;
				foreach (Renderer val4 in array)
				{
					if ((Object)(object)val4 == (Object)null)
					{
						if (!flag)
						{
							Plugin.Instance.Logger.LogError((object)("Mesh on " + ((Object)currentActualTarget).name + " that would obstruct the " + ((Object)this).name + " body cam was unexpectedly null."));
						}
						flag = true;
					}
					else
					{
						val4.forceRenderingOff = true;
					}
				}
				if ((Object)(object)currentObstructingMaterial != (Object)null)
				{
					currentObstructingMaterialCullMode = currentObstructingMaterial.GetFloat(CullModeProperty);
					currentObstructingMaterial.SetFloat(CullModeProperty, 2f);
				}
				Light sunDirect = TimeOfDay.Instance.sunDirect;
				if ((Object)(object)sunDirect != (Object)null)
				{
					Light sunIndirect = TimeOfDay.Instance.sunIndirect;
					originalDirectSunlightEnabled = ((Behaviour)sunDirect).enabled;
					originalIndirectSunlightEnabled = ((Behaviour)sunIndirect).enabled;
					((Behaviour)sunDirect).enabled = targetSunlightEnabled;
					((Behaviour)sunIndirect).enabled = targetSunlightEnabled;
				}
				Volume blackSkyVolume = StartOfRound.Instance.blackSkyVolume;
				originalBlackSkyVolumeWeight = blackSkyVolume.weight;
				blackSkyVolume.weight = targetBlackSkyVolumeWeight;
				if ((Object)(object)sunRootTransform != (Object)null)
				{
					originalSunRootScale = sunRootTransform.localScale;
					Transform obj = sunRootTransform;
					obj.localScale *= Math.Min(Camera.farClipPlane * 0.005f, 1f);
				}
				SetMatchLocalPlayerPositions(((Component)Camera).transform.position);
				SetTargetWeathersVisible(visible: true);
			}
			finally
			{
				((IDisposable)(AutoScope)(ref val2)).Dispose();
			}
		}

		private void RevertCullingOverrides()
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentAttachmentPoint == (Object)null)
			{
				return;
			}
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				return;
			}
			((Behaviour)nightVisionLight).enabled = false;
			((Renderer)greenFlashRenderer).forceRenderingOff = true;
			((Renderer)fogShaderPlaneRenderer).forceRenderingOff = true;
			ViewPerspective.Restore(ref currentPlayerModelState);
			if (currentPlayer != localPlayerController)
			{
				ViewPerspective.Restore(ref localPlayerModelState);
			}
			Renderer[] array = currentRenderersToHide;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.forceRenderingOff = false;
				}
			}
			Material obj = currentObstructingMaterial;
			if (obj != null)
			{
				obj.SetFloat(CullModeProperty, currentObstructingMaterialCullMode);
			}
			Light sunDirect = TimeOfDay.Instance.sunDirect;
			if ((Object)(object)sunDirect != (Object)null)
			{
				Light sunIndirect = TimeOfDay.Instance.sunIndirect;
				((Behaviour)sunDirect).enabled = originalDirectSunlightEnabled;
				((Behaviour)sunIndirect).enabled = originalIndirectSunlightEnabled;
			}
			Volume blackSkyVolume = StartOfRound.Instance.blackSkyVolume;
			blackSkyVolume.weight = originalBlackSkyVolumeWeight;
			if ((Object)(object)sunRootTransform != (Object)null)
			{
				sunRootTransform.localScale = originalSunRootScale;
			}
			SetMatchLocalPlayerPositions(((Component)localPlayerController).transform.position);
			SetTargetWeathersVisible(visible: false);
		}

		private void ApplyRenderingOverrides()
		{
			if (!((Object)(object)currentAttachmentPoint == (Object)null))
			{
				HDAdditionalLightData indirectLightData = TimeOfDay.Instance.indirectLightData;
				if ((Object)(object)indirectLightData != (Object)null)
				{
					originalIndirectSunlightDimmer = indirectLightData.lightDimmer;
					indirectLightData.lightDimmer = targetIndirectSunlightDimmer;
					targetIndirectSunlightDimmer = indirectLightData.lightDimmer;
				}
				SetTargetWeathersVisible(visible: true);
			}
		}

		private void RevertRenderingOverrides()
		{
			if (!((Object)(object)currentAttachmentPoint == (Object)null))
			{
				HDAdditionalLightData indirectLightData = TimeOfDay.Instance.indirectLightData;
				if ((Object)(object)indirectLightData != (Object)null)
				{
					indirectLightData.lightDimmer = originalIndirectSunlightDimmer;
				}
				SetTargetWeathersVisible(visible: false);
			}
		}

		private void UpdateTargetStatusDuringUpdate()
		{
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.Immediate))
			{
				UpdateTargetStatus();
			}
		}

		private void UpdateOverrides(float deltaTime)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentActualTarget == (Object)null)
			{
				return;
			}
			TargetTracker.TargetInfo currentInfo = TargetTracker.GetCurrentInfo(currentActualTarget);
			bool flag = PositionIsInInterior(CameraTransform.position);
			bool flag2 = false;
			if ((Object)(object)currentInfo?.lastTrigger != (Object)null)
			{
				flag2 = currentInfo.lastTrigger.insideLighting;
			}
			targetSunlightEnabled = !flag;
			targetBlackSkyVolumeWeight = (flag ? 1 : 0);
			targetIndirectSunlightDimmer = Mathf.Lerp(targetIndirectSunlightDimmer, (float)((!flag2) ? 1 : 0), Mathf.Clamp01(5f * deltaTime));
			for (int i = 0; i < targetWeatherComponents.Length; i++)
			{
				WeatherEffectComponents weatherEffectComponents = targetWeatherComponents[i];
				if (weatherEffectComponents != null)
				{
					if (flag)
					{
						weatherEffectComponents.enabled = false;
					}
					else if (currentInfo != null && i < currentInfo.enabledWeathers.Length)
					{
						weatherEffectComponents.enabled = currentInfo.enabledWeathers[i];
					}
					else
					{
						weatherEffectComponents.enabled = false;
					}
					weatherEffectComponents.Update(currentActualTarget, flag, deltaTime);
				}
			}
		}

		private void LateUpdate()
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Camera == (Object)null)
			{
				return;
			}
			UpdateTargetStatusDuringUpdate();
			PlayerControllerB val = StartOfRound.Instance.localPlayerController;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)val.spectatedPlayerScript != (Object)null)
			{
				val = val.spectatedPlayerScript;
			}
			UpdateOverrides(Time.deltaTime);
			bool flag = keepCameraOn || ((Object)(object)MonitorRenderer != (Object)null && MonitorRenderer.isVisible && val.isInHangarShipRoom && IsScreenPowered());
			CameraRenderingStatus cameraRenderingStatus = CameraRenderingStatus.Culled;
			if (flag)
			{
				cameraRenderingStatus = GetUpdatedCameraStatus();
				if (cameraRenderingStatus == CameraRenderingStatus.TargetDisabledOnShip && (!disableCameraWhileTargetIsOnShip || keepCameraOn))
				{
					cameraRenderingStatus = CameraRenderingStatus.Rendering;
				}
				flag = !IsBlanked;
			}
			SetStatus(cameraRenderingStatus);
			if (!flag)
			{
				((Behaviour)Camera).enabled = false;
				return;
			}
			if (radarBoosterPanSpeed != 0f)
			{
				panAngle = (panAngle + Time.deltaTime * radarBoosterPanSpeed) % 360f;
			}
			else
			{
				panAngle = 270f;
			}
			if (panCamera)
			{
				CameraTransform.localRotation = Quaternion.Euler(0f, panAngle, 0f);
			}
			if (timePerFrame > 0f)
			{
				elapsedSinceLastFrame += Time.deltaTime;
				((Behaviour)Camera).enabled = elapsedSinceLastFrame >= timePerFrame;
				elapsedSinceLastFrame %= timePerFrame;
			}
			else
			{
				((Behaviour)Camera).enabled = true;
			}
		}

		private void OnDisable()
		{
			SetStatus(CameraRenderingStatus.Disabled);
			UpdateScreenMaterial();
			if ((Object)(object)Camera != (Object)null)
			{
				((Behaviour)Camera).enabled = false;
			}
		}

		private void OnEnable()
		{
			UpdateScreenMaterial();
		}

		private void OnDestroy()
		{
			if ((Object)(object)CameraContainer != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)CameraContainer).gameObject);
			}
			AllBodyCams = AllBodyCams.Where((BodyCamComponent bodyCam) => bodyCam != this).ToArray();
			DestroyTargetWeatherEffects();
			SyncBodyCamToRadarMap.OnBodyCamDestroyed(this);
			BodyCam.BodyCamDestroyed(this);
		}

		private static bool PlayerContainsRenderer(PlayerControllerB player, Renderer renderer)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player.thisPlayerModelArms == (Object)(object)renderer)
			{
				return true;
			}
			if ((Object)(object)player.thisPlayerModel == (Object)(object)renderer)
			{
				return true;
			}
			return false;
		}

		public bool HasReference(Renderer renderer)
		{
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.UntilRender))
			{
				return false;
			}
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.Immediate))
			{
				UpdateTargetStatus();
			}
			if (PlayerContainsRenderer(currentPlayer, renderer))
			{
				return true;
			}
			if (PlayerContainsRenderer(StartOfRound.Instance?.localPlayerController, renderer))
			{
				return true;
			}
			if (Array.IndexOf(currentRenderersToHide, renderer) != -1)
			{
				return true;
			}
			return false;
		}

		public bool HasReference(GameObject gameObject)
		{
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.UntilRender))
			{
				return false;
			}
			if (targetDirtyStatus.HasFlag(TargetDirtyStatus.Immediate))
			{
				UpdateTargetStatus();
			}
			if (currentPlayerModelState.ReferencesObject(gameObject))
			{
				return true;
			}
			if (localPlayerModelState.ReferencesObject(gameObject))
			{
				return true;
			}
			return false;
		}

		public static bool AnyBodyCamHasReference(Renderer renderer)
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				if (bodyCamComponent.HasReference(renderer))
				{
					return true;
				}
			}
			return false;
		}

		public static bool AnyBodyCamHasReference(GameObject gameObject)
		{
			BodyCamComponent[] allBodyCams = AllBodyCams;
			foreach (BodyCamComponent bodyCamComponent in allBodyCams)
			{
				if (bodyCamComponent.HasReference(gameObject))
				{
					return true;
				}
			}
			return false;
		}
	}
	public enum CameraRenderingStatus
	{
		Rendering,
		Disabled,
		TargetInvalid,
		TargetDisabledOnShip,
		Culled
	}
	public enum CameraModeOptions
	{
		Body,
		Head
	}
	public enum BoolWithDefault
	{
		False,
		True,
		Default
	}
	[BepInPlugin("Sygnano.OpenBodyCams-V81", "OpenBodyCams-V81", "3.0.11")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string MOD_NAME = "OpenBodyCams-V81";

		public const string MOD_UNIQUE_NAME = "Sygnano.OpenBodyCams-V81";

		public const string MOD_VERSION = "3.0.11";

		private readonly Harmony harmony = new Harmony("Sygnano.OpenBodyCams-V81");

		public static ConfigEntry<CameraModeOptions> CameraMode;

		public static ConfigEntry<int> HorizontalResolution;

		public static ConfigEntry<float> FieldOfView;

		public static ConfigEntry<float> RenderDistance;

		public static ConfigEntry<float> Framerate;

		public const float NightVisionIntensityBase = 367f;

		public const float NightVisionRangeBase = 12f;

		public static ConfigEntry<float> NightVisionBrightness;

		public static ConfigEntry<string> MonitorEmissiveColor;

		public static ConfigEntry<FilterMode> MonitorTextureFiltering;

		public static ConfigEntry<float> RadarBoosterPanRPM;

		public static ConfigEntry<bool> UseTargetTransitionAnimation;

		public static ConfigEntry<bool> DisableCameraWhileTargetIsOnShip;

		public static ConfigEntry<bool> EnableCamera;

		public static ConfigEntry<bool> DisplayOriginalScreenWhenDisabled;

		public static ConfigEntry<bool> OverlayEnabled;

		public static ConfigEntry<float> OverlayTextScale;

		public static ConfigEntry<string> DefaultText;

		public static ConfigEntry<string> BuyAntennaText;

		public static ConfigEntry<string> AntennaStoredText;

		public static ConfigEntry<string> TargetInvalidText;

		public static ConfigEntry<string> TargetOnShipText;

		public static ConfigEntry<bool> TerminalPiPBodyCamEnabled;

		public static ConfigEntry<PiPPosition> TerminalPiPPosition;

		public static ConfigEntry<int> TerminalPiPWidth;

		public static ConfigEntry<bool> ShipUpgradeEnabled;

		public static ConfigEntry<int> ShipUpgradePrice;

		public static ConfigEntry<int> GeneralImprovementsBetterMonitorIndex;

		public static ConfigEntry<bool> EnableMoreCompanyCosmeticsCompatibility;

		public static ConfigEntry<bool> EnableAdvancedCompanyCosmeticsCompatibility;

		public static ConfigEntry<bool> EnableModelReplacementAPICompatibility;

		public static ConfigEntry<bool> EnableLethalVRMCompatibility;

		public static ConfigEntry<bool> EnableReservedItemSlotsCompatibility;

		public static ConfigEntry<bool> SwapInternalAndExternalShipCameras;

		public static ConfigEntry<bool> DisableCameraOnSmallMonitor;

		public static ConfigEntry<string> ExternalCameraEmissiveColor;

		public static ConfigEntry<bool> FixDroppedItemRotation;

		public static ConfigEntry<bool> FixMaskedConversionForClients;

		public static ConfigEntry<BoolWithDefault> DisplayWeatherBasedOnPerspective;

		public static ConfigEntry<bool> PrintCosmeticsDebugInfo;

		public static ConfigEntry<bool> ReferencedObjectDestructionDetectionEnabled;

		public static ConfigEntry<string> LastConfigVersion;

		private static readonly Harmony DestructionDetectionPatch = new Harmony("Sygnano.OpenBodyCams-V81.DestructionDetectionPatch");

		internal static AssetBundle Assets;

		private const string OptionDisabledWithBetterMonitors = "This has no effect when GeneralImprovements's UseBetterMonitors option is enabled.";

		public static Plugin Instance { get; private set; }

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		private void Awake()
		{
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Expected O, but got Unknown
			Instance = this;
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "openbodycams");
			Assets = AssetBundle.LoadFromFile(text);
			if ((Object)(object)Assets != (Object)null)
			{
				Instance.Logger.LogInfo((object)"Successfully loaded OpenBodyCams assets.");
			}
			else
			{
				Instance.Logger.LogError((object)"Failed to load the asset bundle, some features may be missing.");
			}
			CameraMode = ((BaseUnityPlugin)this).Config.Bind<CameraModeOptions>("Camera", "Mode", CameraModeOptions.Head, "Choose where to attach the camera. 'Head' will attach the camera to the right side of the head, 'Body' will attach it to the chest.");
			HorizontalResolution = ((BaseUnityPlugin)this).Config.Bind<int>("Camera", "HorizontalResolution", 160, "The horizontal resolution of the rendering. The vertical resolution is calculated based on the aspect ratio of the monitor.");
			FieldOfView = ((BaseUnityPlugin)this).Config.Bind<float>("Camera", "FieldOfView", 65f, "The vertical FOV of the camera in degrees.");
			RenderDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Camera", "RenderDistance", 25f, "The far clip plane for the body cam. Lowering may improve framerates.");
			Framerate = ((BaseUnityPlugin)this).Config.Bind<float>("Camera", "Framerate", 0f, "The number of frames to render per second. A value of 0 will render at the game's framerate. Setting this significantly below the average framerate on the ship will improve performance.");
			NightVisionBrightness = ((BaseUnityPlugin)this).Config.Bind<float>("Camera", "NightVisionBrightness", 1f, "A multiplier for the intensity of the area light used to brighten dark areas. A value of 1 is identical to the player's actual vision.");
			MonitorEmissiveColor = ((BaseUnityPlugin)this).Config.Bind<string>("Camera", "MonitorEmissiveColor", "0.05, 0.13, 0.05", "Adjust the color that is emitted from the body cam monitor, using comma-separated decimal numbers for red, green and blue.");
			MonitorTextureFiltering = ((BaseUnityPlugin)this).Config.Bind<FilterMode>("Camera", "MonitorTextureFiltering", (FilterMode)1, "The texture filtering to use for the body cam on the monitor. Bilinear and Trilinear will result in a smooth image, while Point will result in sharp square edges. If Point is used, a fairly high resolution is recommended.");
			RadarBoosterPanRPM = ((BaseUnityPlugin)this).Config.Bind<float>("Camera", "RadarBoosterPanRPM", 9f, "The rotations per minute to turn the camera when a radar booster is selected. If the value is set to 0, the radar booster camera will face in the direction player faces when it is placed.");
			UseTargetTransitionAnimation = ((BaseUnityPlugin)this).Config.Bind<bool>("Camera", "UseTargetTransitionAnimation", true, "Enables a green flash animation on the body cam screen mirroring the one that the radar map shows when switching targets.");
			DisableCameraWhileTargetIsOnShip = ((BaseUnityPlugin)this).Config.Bind<bool>("Camera", "DisableCameraWhileTargetIsOnShip", false, "With this option enabled, the camera will stop rendering when the target is onboard the ship to reduce the performance hit of rendering a large number of items on the ship twice.");
			EnableCamera = ((BaseUnityPlugin)this).Config.Bind<bool>("Camera", "EnableCamera", true, "Enables/disables rendering of the body cam, and can be enabled/disabled during a game with LethalConfig.");
			DisplayOriginalScreenWhenDisabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Camera", "DisplayOriginalScreenWhenDisabled", true, "When enabled, the screen that the body cam replaces will be displayed when it is disabled due to invalid targets.");
			CameraMode.SettingChanged += delegate
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams();
			};
			FieldOfView.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			RenderDistance.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			NightVisionBrightness.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			MonitorTextureFiltering.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			RadarBoosterPanRPM.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			DisableCameraWhileTargetIsOnShip.SettingChanged += delegate
			{
				BodyCamComponent.UpdateAllCameraSettings();
			};
			DisplayOriginalScreenWhenDisabled.SettingChanged += delegate
			{
				ShipObjects.UpdateMainBodyCamNoTargetMaterial();
			};
			HorizontalResolution.SettingChanged += delegate
			{
				ShipObjects.UpdateMainBodyCamSettings();
			};
			Framerate.SettingChanged += delegate
			{
				ShipObjects.UpdateMainBodyCamSettings();
			};
			MonitorEmissiveColor.SettingChanged += delegate
			{
				ShipObjects.UpdateMainBodyCamSettings();
			};
			EnableCamera.SettingChanged += delegate
			{
				ShipObjects.UpdateMainBodyCamSettings();
			};
			OverlayEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "Enabled", true, "Displays an overlay on the monitor that the body cam replaces to communicate the status of the body cam. This will only work if the screen is displaying a render texture connected to a camera. Restart the lobby to apply.");
			OverlayTextScale = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "TextScale", 1f, "The factor by which to scale the text on the overlay screen.");
			DefaultText = ((BaseUnityPlugin)this).Config.Bind<string>("Overlay", "DefaultText", "", "The text displayed on the body cam monitor when it is operating normally.");
			BuyAntennaText = ((BaseUnityPlugin)this).Config.Bind<string>("Overlay", "BuyAntennaText", "<color=\"yellow\">Body cam ${price}", "The text displayed on the body cam monitor to prompt players to buy the antenna in the store to enable body cams.");
			AntennaStoredText = ((BaseUnityPlugin)this).Config.Bind<string>("Overlay", "AntennaStoredText", "<color=\"yellow\">Antenna stored", "The text displayed when the antenna is stored, preventing the body cams displaying on the monitor.");
			TargetInvalidText = ((BaseUnityPlugin)this).Config.Bind<string>("Overlay", "TargetInvalidText", "<color=\"red\">Signal lost", "The text displayed when the selected target is invalid (for example, the target is a player that has been eaten).");
			TargetOnShipText = ((BaseUnityPlugin)this).Config.Bind<string>("Overlay", "TargetOnShipText", "<color=\"green\">Target on ship", "The text displayed when the selected target is safe on the ship with DisableCameraWhileTargetIsOnShip enabled.");
			OverlayTextScale.SettingChanged += UpdateOverlayPrefs;
			DefaultText.SettingChanged += UpdateOverlayText;
			BuyAntennaText.SettingChanged += UpdateOverlayText;
			AntennaStoredText.SettingChanged += UpdateOverlayText;
			TargetInvalidText.SettingChanged += UpdateOverlayText;
			TargetOnShipText.SettingChanged += UpdateOverlayText;
			TerminalPiPBodyCamEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Terminal", "EnablePiPBodyCam", false, "Adds a 'view bodycam' command to the terminal that places a picture-in-picture view of the bodycam in front of the radar map.");
			TerminalPiPPosition = ((BaseUnityPlugin)this).Config.Bind<PiPPosition>("Terminal", "PiPPosition", PiPPosition.BottomRight, "The corner inside the terminal's radar map to align the body cam to.");
			TerminalPiPWidth = ((BaseUnityPlugin)this).Config.Bind<int>("Terminal", "PiPWidth", 150, "The width of the picture-in-picture in pixels.");
			TerminalPiPBodyCamEnabled.SettingChanged += delegate
			{
				TerminalCommands.Initialize();
			};
			TerminalPiPPosition.SettingChanged += delegate
			{
				TerminalCommands.Initialize();
			};
			TerminalPiPWidth.SettingChanged += delegate
			{
				TerminalCommands.Initialize();
			};
			harmony.PatchAll(typeof(TerminalCommands));
			ShipUpgradeEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("ShipUpgrade", "Enabled", true, "Adds a ship upgrade that enables the body cam on the main monitors only after it is bought.\n\nNOTE: The upgrade will only be available if LethalLib is installed. Without it, the main body cam will always be enabled.");
			ShipUpgradePrice = ((BaseUnityPlugin)this).Config.Bind<int>("ShipUpgrade", "Price", 200, "The price at which the ship upgrade is sold in the store.");
			GeneralImprovementsBetterMonitorIndex = ((BaseUnityPlugin)this).Config.Bind<int>("Compatibility", "GeneralImprovementsBetterMonitorIndex", 0, new ConfigDescription("With GeneralImprovements's UseBetterMonitors enabled, choose which monitor to display the body cam on.\nA value of 0 will place it on the large monitor on the right.\nValues greater than 0 go left to right, top to bottom, skipping the large center monitor. Without AddMoreBetterMonitors, the maximum value is 9, rather than 14.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 14), Array.Empty<object>()));
			EnableMoreCompanyCosmeticsCompatibility = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "EnableMoreCompanyCosmeticsCompatibility", true, "If this is enabled, a patch will be applied to MoreCompany to spawn cosmetics for the local player, and all cosmetics will be shown and hidden based on the camera's perspective.");
			EnableAdvancedCompanyCosmeticsCompatibility = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "EnableAdvancedCompanyCosmeticsCompatibility", true, "When this is enabled and AdvancedCompany is installed, all cosmetics will be shown and hidden based on the camera's perspective.");
			EnableModelReplacementAPICompatibility = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "EnableModelReplacementAPICompatibility", true, "When enabled, this will get the third person model replacement and hide/show it based on the camera's perspective.");
			EnableLethalVRMCompatibility = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "EnableLethalVRMCompatibility", true, "When enabled, any VRM model will be hidden/shown based on the camera's perspective.");
			EnableReservedItemSlotsCompatibility = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "EnableReservedItemSlotsCompatibility", true, "When enabled, items holstered in reserved item slots will be hidden/shown based on the perspective.");
			SwapInternalAndExternalShipCameras = ((BaseUnityPlugin)this).Config.Bind<bool>("Ship", "SwapInternalAndExternalShipCameras", false, "Causes the internal ship camera to be placed onto big monitor, and the external one to be placed onto the small monitor. This has no effect when GeneralImprovements's UseBetterMonitors option is enabled.");
			DisableCameraOnSmallMonitor = ((BaseUnityPlugin)this).Config.Bind<bool>("Ship", "DisableCameraOnSmallMonitor", false, "Disables whichever camera is placed onto the small camera monitor. This has no effect when GeneralImprovements's UseBetterMonitors option is enabled.");
			ExternalCameraEmissiveColor = ((BaseUnityPlugin)this).Config.Bind<string>("Ship", "ExternalCameraEmissiveColor", "", "Sets the color emitted by the external camera screen, using comma-separated decimal numbers for red, green and blue.");
			ExternalCameraEmissiveColor.SettingChanged += delegate
			{
				ShipObjects.SetExternalCameraEmissiveColor();
			};
			FixDroppedItemRotation = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "FixDroppedItemRotation", true, "If enabled, the mod will patch a bug that causes the rotation of dropped items to be desynced between clients.");
			FixMaskedConversionForClients = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "FixMaskedConversionForClients", true, "If enabled, the mod will patch a bug that causes maps and body cams to be unable to target a player that was converted into a masked enemy.");
			DisplayWeatherBasedOnPerspective = ((BaseUnityPlugin)this).Config.Bind<BoolWithDefault>("Experimental", "DisplayWeatherBasedOnPerspective", BoolWithDefault.Default, "If enabled, a clone of each weather effect will be simulated on the body cam target. This allows rain and fog effects to be visible on body cams when far from the viewer. This may cause issues with some modded weathers.\n\nThe Default value will leave the feature disabled, but may be changed in future versions.");
			DisplayWeatherBasedOnPerspective.SettingChanged += delegate
			{
				BodyCamComponent.CreateTargetWeatherEffectsForAllCams();
			};
			PrintCosmeticsDebugInfo = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "PrintCosmeticsDebugInfo", false, "Prints extra information about the cosmetics being collected for each player, as well as the code that is causing the collection.");
			ReferencedObjectDestructionDetectionEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "ModelDestructionDebuggingPatchEnabled", false, "Enable this option when reproducing a camera freeze. This will cause a debug message to be printed when a model that a body cam is tracking is destroyed.");
			LastConfigVersion = ((BaseUnityPlugin)this).Config.Bind<string>("Debug", "LastConfigVersion", "", "The last version of the mod that loaded/saved this config file. Used for setting migration.");
			PrintCosmeticsDebugInfo.SettingChanged += delegate
			{
				Cosmetics.PrintDebugInfo = PrintCosmeticsDebugInfo.Value;
			};
			Cosmetics.PrintDebugInfo = PrintCosmeticsDebugInfo.Value;
			ReferencedObjectDestructionDetectionEnabled.SettingChanged += delegate
			{
				UpdateReferencedObjectDestructionDetectionEnabled();
			};
			UpdateReferencedObjectDestructionDetectionEnabled();
			MigrateSettings();
			harmony.PatchAll(typeof(PatchTerminal));
			harmony.PatchAll(typeof(PatchStartOfRound));
			harmony.PatchAll(typeof(PatchManualCameraRenderer));
			harmony.PatchAll(typeof(PatchPlayerControllerB));
			harmony.PatchAll(typeof(PatchHauntedMaskItem));
			harmony.PatchAll(typeof(PatchMaskedPlayerEnemy));
			harmony.PatchAll(typeof(PatchUnlockableSuit));
			harmony.PatchAll(typeof(PatchCentipedeAI));
			harmony.PatchAll(typeof(PatchFlowerSnakeEnemy));
			harmony.PatchAll(typeof(PatchHDRenderPipeline));
			harmony.PatchAll(typeof(PatchRadarBoosterItem));
			harmony.PatchAll(typeof(PatchDeadBodyInfo));
			harmony.PatchAll(typeof(PatchTimeOfDay));
			harmony.PatchAll(typeof(PatchFixItemDropping));
			BodyCamComponent.InitializeStatic();
			SetUpCameraCallbacks();
			ShipUpgrades.Initialize();
			Cosmetics.Initialize(harmony);
			Application.SetStackTraceLogType((LogType)3, (StackTraceLogType)0);
			Application.SetStackTraceLogType((LogType)2, (StackTraceLogType)0);
			Application.SetStackTraceLogType((LogType)0, (StackTraceLogType)0);
			Application.SetStackTraceLogType((LogType)1, (StackTraceLogType)0);
			static void UpdateOverlayPrefs(object target, EventArgs args)
			{
				if ((Object)(object)ShipObjects.Overlay != (Object)null)
				{
					ShipObjects.Overlay.UpdatePreferences();
				}
			}
			static void UpdateOverlayText(object target, EventArgs args)
			{
				if ((Object)(object)ShipObjects.Overlay != (Object)null)
				{
					ShipObjects.Overlay.UpdateText();
				}
			}
		}

		private void UpdateReferencedObjectDestructionDetectionEnabled()
		{
			if (ReferencedObjectDestructionDetectionEnabled.Value)
			{
				DestructionDetectionPatch.PatchAll(typeof(PatchModelDestructionDebugging));
			}
			else
			{
				DestructionDetectionPatch.UnpatchSelf();
			}
		}

		private void MigrateSettings()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			Dictionary<ConfigDefinition, string> orphanedEntries;
			try
			{
				orphanedEntries = ((BaseUnityPlugin)this).Config.OrphanedEntries;
			}
			catch (MissingFieldException)
			{
				Logger.LogError((object)"Failed to migrate config, orphaned entries property was not found.");
				return;
			}
			if (!Version.TryParse(LastConfigVersion.Value, out Version result))
			{
				result = new Version(2, 0, 0);
			}
			Logger.LogInfo((object)$"Last config version is {result}.");
			ConfigDefinition val = new ConfigDefinition("Misc", "DisableInternalShipCamera");
			if (orphanedEntries.TryGetValue(val, out var value))
			{
				Logger.LogInfo((object)$"{val} option was found set to '{value}' in the config, migrating it over to {((ConfigEntryBase)DisableCameraOnSmallMonitor).Definition}.");
				orphanedEntries.Remove(val);
				DisableCameraOnSmallMonitor.Value = TomlTypeConverter.ConvertToValue<bool>(value);
			}
			if (result < new Version(2, 0, 2) && !ShipUpgradeEnabled.Value)
			{
				Logger.LogInfo((object)$"{((ConfigEntryBase)ShipUpgradeEnabled).Definition} was set to its 2.0.0 default value 'false', resetting it to 'true'.");
				ShipUpgradeEnabled.Value = true;
			}
			if (result < new Version(3, 0, 0))
			{
				orphanedEntries.Remove(new ConfigDefinition("Debug", "BruteForcePreventFreezes"));
			}
			LastConfigVersion.Value = "3.0.11";
		}

		private static Color ParseColor(string str)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			float[] array = (from x in str.Split(new char[2] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)
				select float.Parse(x.Trim(), CultureInfo.InvariantCulture)).ToArray();
			if (array.Length < 3)
			{
				throw new FormatException("Not enough color components");
			}
			if (array.Length > 4)
			{
				throw new FormatException("Too many color components");
			}
			return new Color(array[0], array[1], array[2], (array.Length == 4) ? array[3] : 0f);
		}

		internal static Color GetBodyCamEmissiveColor()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ParseColor(MonitorEmissiveColor.Value);
			}
			catch (Exception arg)
			{
				Instance.Logger.LogWarning((object)$"Failed to parse the body cam screen's emissive color: {arg}");
				return ParseColor((string)((ConfigEntryBase)MonitorEmissiveColor).DefaultValue);
			}
		}

		internal static Color? GetExternalCameraEmissiveColor()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			string value = ExternalCameraEmissiveColor.Value;
			if (value == "")
			{
				return null;
			}
			try
			{
				return ParseColor(ExternalCameraEmissiveColor.Value);
			}
			catch (Exception arg)
			{
				Instance.Logger.LogWarning((object)$"Failed to parse the external camera screen's emissive color: {arg}");
				return null;
			}
		}

		private void SetUpCameraCallbacks()
		{
			PatchHDRenderPipeline.BeforeCameraCulling = (Action<ScriptableRenderContext, Camera>)Delegate.Combine(PatchHDRenderPipeline.BeforeCameraCulling, new Action<ScriptableRenderContext, Camera>(BeforeCullingAnyCamera));
			PatchHDRenderPipeline.BeforeCameraRendering = (Action<ScriptableRenderContext, Camera>)Delegate.Combine(PatchHDRenderPipeline.BeforeCameraRendering, new Action<ScriptableRenderContext, Camera>(BeforeRenderingAnyCamera));
			RenderPipelineManager.endCameraRendering += AfterRenderingAnyCamera;
		}

		private void BeforeCullingAnyCamera(ScriptableRenderContext context, Camera camera)
		{
			BodyCamComponent.BeforeCullingAnyCamera(camera);
		}

		private void BeforeRenderingAnyCamera(ScriptableRenderContext context, Camera camera)
		{
			BodyCamComponent.BeforeRenderingAnyCamera(camera);
			OverlayManager.BeforeRenderingAnyCamera(camera);
		}

		private void AfterRenderingAnyCamera(ScriptableRenderContext context, Camera camera)
		{
			BodyCamComponent.AfterRenderingAnyCamera(camera);
			OverlayManager.AfterRenderingAnyCamera(camera);
		}
	}
	public static class ShipObjects
	{
		internal static Material BlackScreenMaterial;

		internal static Terminal TerminalScript;

		internal static bool TwoRadarCamsPresent;

		internal static BodyCamComponent MainBodyCam;

		internal static OverlayManager Overlay;

		internal static ManualCameraRenderer InternalCameraRenderer;

		internal static ManualCameraRenderer ExternalCameraRenderer;

		internal static Material ExternalCameraMaterial;

		internal static Color OriginalExternalCameraEmissiveColor;

		internal static MeshRenderer DoorScreenRenderer;

		internal static bool DoorScreenUsesExternalCamera;

		internal static ManualCameraRenderer ShipCameraOnSmallMonitor;

		internal static ManualCameraRenderer CameraReplacedByBodyCam;

		public static void EarlyInitialization()
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (HasFinishedEarlyInitialization())
			{
				return;
			}
			BlackScreenMaterial = StartOfRound.Instance.mapScreen.offScreenMat;
			GameObject obj = GameObject.Find("Environment/HangarShip/Cameras/ShipCamera");
			InternalCameraRenderer = ((obj != null) ? obj.GetComponent<ManualCameraRenderer>() : null);
			GameObject obj2 = GameObject.Find("Environment/HangarShip/Cameras/FrontDoorSecurityCam/SecurityCamera");
			ExternalCameraRenderer = ((obj2 != null) ? obj2.GetComponent<ManualCameraRenderer>() : null);
			GameObject obj3 = GameObject.Find("Environment/HangarShip/ShipModels2b/MonitorWall/SingleScreen");
			DoorScreenRenderer = ((obj3 != null) ? obj3.GetComponent<MeshRenderer>() : null);
			ShipCameraOnSmallMonitor = InternalCameraRenderer;
			BodyCamComponent.InitializeAtStartOfGame();
			if ((Object)(object)ExternalCameraRenderer != (Object)null)
			{
				int cameraMaterialIndex = GetCameraMaterialIndex(ExternalCameraRenderer);
				if (cameraMaterialIndex != -1)
				{
					ExternalCameraMaterial = ((Renderer)ExternalCameraRenderer.mesh).sharedMaterials[cameraMaterialIndex];
					OriginalExternalCameraEmissiveColor = ExternalCameraMaterial.GetColor("_EmissiveColor");
					SetExternalCameraEmissiveColor();
				}
			}
		}

		private static bool HasFinishedEarlyInitialization()
		{
			return (Object)(object)ShipCameraOnSmallMonitor != (Object)null;
		}

		internal static void SetExternalCameraEmissiveColor()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			Color valueOrDefault = Plugin.GetExternalCameraEmissiveColor().GetValueOrDefault(OriginalExternalCameraEmissiveColor);
			Material externalCameraMaterial = ExternalCameraMaterial;
			if (externalCameraMaterial != null)
			{
				externalCameraMaterial.SetColor("_EmissiveColor", valueOrDefault);
			}
		}

		public static void LateInitialization()
		{
			ManageShipCameras();
			TwoRadarCamsPresent = (Object)(object)((Component)TerminalScript).GetComponent<ManualCameraRenderer>() != (Object)null;
			if ((Object)(object)DoorScreenRenderer != (Object)null && (Object)(object)ExternalCameraRenderer?.cam != (Object)null)
			{
				DoorScreenUsesExternalCamera = ((Renderer)DoorScreenRenderer).sharedMaterials.Any((Material mat) => (Object)(object)mat.mainTexture == (Object)(object)ExternalCameraRenderer.cam.targetTexture);
			}
			InitializeBodyCam();
			TerminalCommands.Initialize();
			if (!TwoRadarCamsPresent && ((NetworkBehaviour)StartOfRound.Instance).IsServer)
			{
				ManualCameraRenderer mapScreen = StartOfRound.Instance.mapScreen;
				mapScreen.SwitchRadarTargetAndSync(Math.Min(mapScreen.targetTransformIndex, mapScreen.radarTargets.Count - 1));
			}
		}

		private static void ManageShipCameras()
		{
			if (!GeneralImprovementsCompatibility.BetterMonitorsEnabled)
			{
				if (Plugin.SwapInternalAndExternalShipCameras.Value)
				{
					SwapShipCameras();
				}
				if (Plugin.DisableCameraOnSmallMonitor.Value)
				{
					DisableCameraOnSmallMonitor();
				}
			}
		}

		private static int GetCameraMaterialIndex(ManualCameraRenderer shipCamera)
		{
			if ((Object)(object)shipCamera == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)shipCamera.mesh == (Object)null)
			{
				return -1;
			}
			Camera val = shipCamera.cam;
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)shipCamera).GetComponent<Camera>();
			}
			RenderTexture texture = val.targetTexture;
			return Array.FindIndex(((Renderer)shipCamera.mesh).sharedMaterials, (Material material) => (Object)(object)material.mainTexture == (Object)(object)texture);
		}

		private static void SwapShipCameras()
		{
			int cameraMaterialIndex = GetCameraMaterialIndex(InternalCameraRenderer);
			int cameraMaterialIndex2 = GetCameraMaterialIndex(ExternalCameraRenderer);
			if (cameraMaterialIndex == -1 || cameraMaterialIndex2 == -1)
			{
				Plugin.Instance.Logger.LogError((object)$"{((ConfigEntryBase)Plugin.SwapInternalAndExternalShipCameras).Definition} is enabled, but one of the ship's cameras' materials was not found.");
				return;
			}
			Material material = ((Renderer)InternalCameraRenderer.mesh).sharedMaterials[cameraMaterialIndex];
			((Renderer)(object)InternalCameraRenderer.mesh).SetMaterial(cameraMaterialIndex, ((Renderer)ExternalCameraRenderer.mesh).sharedMaterials[cameraMaterialIndex2]);
			((Renderer)(object)ExternalCameraRenderer.mesh).SetMaterial(cameraMaterialIndex2, material);
			ManualCameraRenderer internalCameraRenderer = InternalCameraRenderer;
			ManualCameraRenderer externalCameraRenderer = ExternalCameraRenderer;
			MeshRenderer mesh = ExternalCameraRenderer.mesh;
			MeshRenderer mesh2 = InternalCameraRenderer.mesh;
			internalCameraRenderer.mesh = mesh;
			externalCameraRenderer.mesh = mesh2;
			ShipCameraOnSmallMonitor = ExternalCameraRenderer;
		}

		private static void DisableCameraOnSmallMonitor()
		{
			int cameraMaterialIndex = GetCameraMaterialIndex(ShipCameraOnSmallMonitor);
			if (cameraMaterialIndex == -1)
			{
				Plugin.Instance.Logger.LogError((object)$"{((ConfigEntryBase)Plugin.DisableCameraOnSmallMonitor).Definition} is enabled, but the small monitor's camera material was not found.");
				return;
			}
			((Renderer)(object)ShipCameraOnSmallMonitor.mesh).SetMaterial(cameraMaterialIndex, BlackScreenMaterial);
			((Behaviour)ShipCameraOnSmallMonitor.cam).enabled = false;
			((Behaviour)ShipCameraOnSmallMonitor).enabled = false;
		}

		private static void InitializeBodyCam()
		{
			GameObject val = GameObject.Find("Environment/HangarShip/ShipModels2b/MonitorWall/Cube.001");
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Instance.Logger.LogError((object)"Could not find the bottom monitors' game object.");
				return;
			}
			if ((Object)(object)val.GetComponent<BodyCamComponent>() == (Object)null)
			{
				MainBodyCam = val.AddComponent<BodyCamComponent>();
				val.AddComponent<SyncBodyCamToRadarMap>();
				if (!GeneralImprovementsCompatibility.BetterMonitorsEnabled)
				{
					MainBodyCam.MonitorRenderer = (Renderer)(object)val.GetComponent<MeshRenderer>();
					MainBodyCam.MonitorMaterialIndex = 2;
					MainBodyCam.MonitorDisabledMaterial = MainBodyCam.MonitorRenderer.sharedMaterials[MainBodyCam.MonitorMaterialIndex];
				}
				else
				{
					int id = Plugin.GeneralImprovementsBetterMonitorIndex.Value - 1;
					GeneralImprovementsCompatibility.GeneralImprovementsMonitorSpecification? monitorForID = GeneralImprovementsCompatibility.GetMonitorForID(id);
					if (monitorForID.HasValue)
					{
						MainBodyCam.MonitorRenderer = monitorForID.Value.Renderer;
						MainBodyCam.MonitorMaterialIndex = monitorForID.Value.MaterialIndex;
						MainBodyCam.MonitorDisabledMaterial = monitorForID.Value.OriginalMaterial;
					}
				}
				if ((Object)(object)MainBodyCam.MonitorRenderer == (Object)null)
				{
					Plugin.Instance.Logger.LogError((object)"Failed to find the monitor renderer.");
					Object.DestroyImmediate((Object)(object)MainBodyCam);
					return;
				}
				if ((Object)(object)MainBodyCam.MonitorDisabledMaterial == (Object)null)
				{
					MainBodyCam.MonitorDisabledMaterial = BlackScreenMaterial;
				}
				UpdateMainBodyCamNoTargetMaterial();
				if (ShipUpgrades.BodyCamUnlockable != null)
				{
					((Behaviour)MainBodyCam).enabled = ShipUpgrades.BodyCamUnlockableIsPlaced;
				}
				else
				{
					BodyCam.BodyCamReceiverBecameEnabled();
				}
				CameraReplacedByBodyCam = null;
				Texture mainTexture = MainBodyCam.MonitorDisabledMaterial.mainTexture;
				RenderTexture val2 = (RenderTexture)(object)((mainTexture is RenderTexture) ? mainTexture : null);
				if (val2 != null)
				{
					ManualCameraRenderer internalCameraRenderer = InternalCameraRenderer;
					object obj;
					if (internalCameraRenderer == null)
					{
						obj = null;
					}
					else
					{
						Camera cam = internalCameraRenderer.cam;
						obj = ((cam != null) ? cam.targetTexture : null);
					}
					if ((Object)(object)val2 == (Object)obj)
					{
						CameraReplacedByBodyCam = InternalCameraRenderer;
					}
					else
					{
						ManualCameraRenderer externalCameraRenderer = ExternalCameraRenderer;
						object obj2;
						if (externalCameraRenderer == null)
						{
							obj2 = null;
						}
						else
						{
							Camera cam2 = externalCameraRenderer.cam;
							obj2 = ((cam2 != null) ? cam2.targetTexture : null);
						}
						if ((Object)(object)val2 == (Object)obj2)
						{
							CameraReplacedByBodyCam = ExternalCameraRenderer;
						}
					}
				}
			}
			UpdateMainBodyCamSettings();
			InitializeMainBodyCamOverlay();
		}

		private static void InitializeMainBodyCamOverlay()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Plugin.Assets == (Object)null) && Plugin.OverlayEnabled.Value)
			{
				GameObject val = Object.Instantiate<GameObject>(Plugin.Assets.LoadAsset<GameObject>("Assets/OpenBodyCams/Prefabs/BodyCamOverlayCanvas.prefab"));
				val.transform.SetParent(GameObject.Find("Systems/UI").transform, false);
				val.transform.position = new Vector3(0f, 1000f, 0f);
				Overlay = val.AddComponent<OverlayManager>();
				Overlay.BodyCam = MainBodyCam;
			}
		}

		internal static void UpdateMainBodyCamNoTargetMaterial()
		{
			if (Plugin.DisplayOriginalScreenWhenDisabled.Value)
			{
				MainBodyCam.MonitorNoTargetMaterial = MainBodyCam.MonitorDisabledMaterial;
			}
			else
			{
				MainBodyCam.MonitorNoTargetMaterial = null;
			}
			MainBodyCam.UpdateScreenMaterial();
		}

		internal static void UpdateMainBodyCamSettings()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)MainBodyCam == (Object)null))
			{
				MainBodyCam.Resolution = new Vector2Int(Plugin.HorizontalResolution.Value, Plugin.HorizontalResolution.Value * 3 / 4);
				MainBodyCam.Framerate = Plugin.Framerate.Value;
				MainBodyCam.EnableCamera = Plugin.EnableCamera.Value;
				MainBodyCam.UpdateScreenMaterial();
				MainBodyCam.MonitorOnMaterial.SetColor("_EmissiveColor", Plugin.GetBodyCamEmissiveColor());
			}
		}
	}
	internal static class ShipUpgrades
	{
		internal static UnlockableItem BodyCamUnlockable;

		internal static int BodyCamPrice;

		internal static bool BodyCamUnlockableIsPlaced;

		public static void Initialize()
		{
			if (!Chainloader.PluginInfos.ContainsKey("evaisa.lethallib"))
			{
				Plugin.Instance.Logger.LogInfo((object)"LethalLib is not present, body cam will be enabled by default.");
			}
			else
			{
				RegisterUnlockables();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void RegisterUnlockables()
		{
			RegisterBodyCamShipUpgrade();
		}

		private static void RegisterBodyCamShipUpgrade()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			if (!((Object)(object)Plugin.Assets == (Object)null) && Plugin.ShipUpgradeEnabled.Value)
			{
				GameObject val = Plugin.Assets.LoadAsset<GameObject>("Assets/OpenBodyCams/Prefabs/BodyCamAntenna.prefab");
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Instance.Logger.LogInfo((object)"Body cam antenna prop was not found within the asset bundle.");
					return;
				}
				val.AddComponent<EnableMainBodyCam>();
				UnlockableItem val2 = new UnlockableItem
				{
					unlockableName = "Bodycam",
					unlockableType = 1,
					prefabObject = val,
					IsPlaceable = true,
					alwaysInStock = true
				};
				BodyCamPrice = Plugin.ShipUpgradePrice.Value;
				Unlockables.RegisterUnlockable(val2, BodyCamPrice, (StoreType)1);
				NetworkPrefabs.RegisterNetworkPrefab(val);
				Utilities.FixMixerGroups(val);
				BodyCamUnlockable = val2;
				Plugin.Instance.Logger.LogInfo((object)$"Registered body cam unlockable for {BodyCamPrice} credits.");
			}
		}
	}
	internal class EnableMainBodyCam : MonoBehaviour
	{
		private void OnEnable()
		{
			ShipUpgrades.BodyCamUnlockableIsPlaced = true;
			BodyCam.BodyCamReceiverBecameEnabled();
			if (!((Object)(object)ShipObjects.MainBodyCam == (Object)null))
			{
				((Behaviour)ShipObjects.MainBodyCam).enabled = true;
			}
		}

		private void OnDisable()
		{
			ShipUpgrades.BodyCamUnlockableIsPlaced = false;
			BodyCam.BodyCamReceiverBecameDisabled();
			if (!((Object)(object)ShipObjects.MainBodyCam == (Object)null))
			{
				((Behaviour)ShipObjects.MainBodyCam).enabled = false;
			}
		}
	}
	public class SyncBodyCamToRadarMap : MonoBehaviour
	{
		private static SyncBodyCamToRadarMap[] AllSynchronizedCams = new SyncBodyCamToRadarMap[0];

		internal ManualCameraRenderer MapRenderer;

		internal BodyCamComponent BodyCam;

		public static SyncBodyCamToRadarMap[] GetAllSynchronizedCams()
		{
			return AllSynchronizedCams;
		}

		public ManualCameraRenderer GetMapRenderer()
		{
			return MapRenderer;
		}

		public BodyCamComponent GetBodyCam()
		{
			return BodyCam;
		}

		private static void DoForMap(ManualCameraRenderer mapRenderer, Action<SyncBodyCamToRadarMap> action)
		{
			SyncBodyCamToRadarMap[] allSynchronizedCams = AllSynchronizedCams;
			foreach (SyncBodyCamToRadarMap syncBodyCamToRadarMap in allSynchronizedCams)
			{
				if (syncBodyCamToRadarMap.MapRenderer == mapRenderer)
				{
					action(syncBodyCamToRadarMap);
				}
			}
		}

		public static void UpdateBodyCamTargetForMap(ManualCameraRenderer mapRenderer)
		{
			DoForMap(mapRenderer, delegate(SyncBodyCamToRadarMap syncedCam)
			{
				syncedCam.UpdateBodyCamTarget();
			});
		}

		public static void StartTargetTransitionForMap(ManualCameraRenderer mapRenderer)
		{
			DoForMap(mapRenderer, delegate(SyncBodyCamToRadarMap syncedCam)
			{
				syncedCam.StartTargetTransition();
			});
		}

		private static void DoForCam(BodyCamComponent bodyCam, Action<SyncBodyCamToRadarMap> action)
		{
			SyncBodyCamToRadarMap[] allSynchronizedCams = AllSynchronizedCams;
			foreach (SyncBodyCamToRadarMap syncBodyCamToRadarMap in allSynchronizedCams)
			{
				if (syncBodyCamToRadarMap.BodyCam == bodyCam)
				{
					action(syncBodyCamToRadarMap);
				}
			}
		}

		public static void UpdateBodyCamTarget(BodyCamComponent bodyCam)
		{
			DoForCam(bodyCam, delegate(SyncBodyCamToRadarMap syncedCam)
			{
				syncedCam.UpdateBodyCamTarget();
			});
		}

		private void Awake()
		{
			SyncBodyCamToRadarMap[] allSynchronizedCams = AllSynchronizedCams;
			int num = 0;
			SyncBodyCamToRadarMap[] array = new SyncBodyCamToRadarMap[1 + allSynchronizedCams.Length];
			ReadOnlySpan<SyncBodyCamToRadarMap> readOnlySpan = new ReadOnlySpan<SyncBodyCamToRadarMap>(allSynchronizedCams);
			readOnlySpan.CopyTo(new Span<SyncBodyCamToRadarMap>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array[num] = this;
			AllSynchronizedCams = array;
			if ((Object)(object)MapRenderer == (Object)null)
			{
				MapRenderer = ((Component)this).GetComponentsInChildren<ManualCameraRenderer>()?.FirstOrDefault((Func<ManualCameraRenderer, bool>)((ManualCameraRenderer renderer) => (Object)(object)renderer.cam == (Object)(object)renderer.mapCamera));
			}
			if ((Object)(object)BodyCam == (Object)null)
			{
				BodyCam = ((Component)this).GetComponent<BodyCamComponent>();
			}
		}

		private void Start()
		{
			UpdateBodyCamTarget();
		}

		private void OnEnable()
		{
			if ((Object)(object)BodyCam != (Object)null && (Object)(object)MapRenderer != (Object)null)
			{
				UpdateBodyCamTarget();
			}
		}

		private void Update()
		{
			BodyCam.ForceTargetInvalid = MapRenderer.playerIsInCaves;
		}

		public void UpdateBodyCamTarget()
		{
			if (((Behaviour)this).isActiveAndEnabled)
			{
				if ((Object)(object)MapRenderer.targetedPlayer != (Object)null)
				{
					BodyCam.SetTargetToPlayer(MapRenderer.targetedPlayer);
				}
				else
				{
					BodyCam.SetTargetToTransform(MapRenderer.radarTargets[MapRenderer.targetTransformIndex].transform);
				}
				BodyCam.SetScreenPowered(MapRenderer.isScreenOn);
			}
		}

		public void StartTargetTransition()
		{
			if (((Behaviour)this).isActiveAndEnabled)
			{
				BodyCam.StartTargetTransition();
			}
		}

		internal static void OnBodyCamDestroyed(BodyCamComponent bodyCam)
		{
			DoForCam(bodyCam, (Action<SyncBodyCamToRadarMap>)Object.Destroy);
		}

		private void OnDestroy()
		{
			AllSynchronizedCams = AllSynchronizedCams.Where((SyncBodyCamToRadarMap syncedCam) => syncedCam != this).ToArray();
		}
	}
	public static class TerminalCommands
	{
		private static TerminalNode ViewMonitorNode;

		private static TerminalNode ViewBodyCamNode;

		private static TerminalKeyword BodyCamKeyword;

		private static TerminalNode BodyCamFailedNode;

		private static TerminalNode BodyCamLockedNode;

		private static RawImage PiPImage;

		private static readonly List<TerminalKeyword> newTerminalKeywords = new List<TerminalKeyword>();

		private static readonly Dictionary<TerminalKeyword, List<TerminalKeyword>> addedCompatibleNouns = new Dictionary<TerminalKeyword, List<TerminalKeyword>>();

		public static void Initialize()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_0167: 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_01c8: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: 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_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ShipObjects.TerminalScript == (Object)null || (Object)(object)ShipObjects.MainBodyCam == (Object)null)
			{
				return;
			}
			if ((Object)(object)PiPImage != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)PiPImage).gameObject);
			}
			PiPImage = null;
			ShipObjects.MainBodyCam.OnRenderTextureCreated -= SetRenderTexture;
			ShipObjects.MainBodyCam.OnBlankedSet -= SetBodyCamBlanked;
			BodyCam.OnBodyCamReceiverBecameDisabled -= DisablePiPImage;
			if (Plugin.TerminalPiPBodyCamEnabled.Value)
			{
				GameObject val = new GameObject("PictureInPictureImage");
				val.transform.SetParent(((Component)ShipObjects.TerminalScript.terminalImageMask).transform, false);
				PiPImage = val.AddComponent<RawImage>();
				val.AddComponent<TerminalBodyCamVisibilityTracker>().BodyCamToActivate = ShipObjects.MainBodyCam;
				RectTransform rectTransform = ((Graphic)ShipObjects.TerminalScript.terminalImage).rectTransform;
				Vector2 val2 = default(Vector2);
				((Vector2)(ref val2))..ctor(0f, 0f);
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(1f, 1f);
				int value = (int)Plugin.TerminalPiPPosition.Value;
				ref float x = ref val2.x;
				ref float x2 = ref val3.x;
				(float, int) tuple = ((((uint)value & (true ? 1u : 0u)) != 0) ? (rectTransform.offsetMax.x, -1) : (rectTransform.offsetMin.x, 1));
				(float, int) tuple2 = tuple;
				float num = tuple2.Item2;
				x = tuple2.Item1;
				x2 = num;
				ref float y = ref val2.y;
				ref float y2 = ref val3.y;
				(float, int) tuple3 = ((((uint)value & 2u) != 0) ? (rectTransform.offsetMax.y, -1) : (rectTransform.offsetMin.y, 1));
				(float, int) tuple4 = tuple3;
				float num2 = tuple4.Item2;
				y = tuple4.Item1;
				y2 = num2;
				Vector2 val4 = val2 + new Vector2(1f, 0.75f) * val3 * (float)Plugin.TerminalPiPWidth.Value;
				((Graphic)PiPImage).rectTransform.offsetMin = Vector2.Min(val2, val4);
				((Graphic)PiPImage).rectTransform.offsetMax = Vector2.Max(val2, val4);
				if ((Object)(object)ShipObjects.MainBodyCam.Camera != (Object)null)
				{
					PiPImage.texture = (Texture)(object)ShipObjects.MainBodyCam.Camera.targetTexture;
				}
				ShipObjects.MainBodyCam.OnRenderTextureCreated += SetRenderTexture;
				ShipObjects.MainBodyCam.OnBlankedSet += SetBodyCamBlanked;
				BodyCam.OnBodyCamReceiverBecameDisabled += DisablePiPImage;
				val.SetActive(false);
			}
			InitializeCommands();
		}

		public static void SetRenderTexture(RenderTexture texture)
		{
			PiPImage.texture = (Texture)(object)texture;
		}

		public static void SetBodyCamBlanked(bool blanked)
		{
			((Behaviour)PiPImage).enabled = !blanked;
		}

		private static void DisablePiPImage()
		{
			((Component)PiPImage).gameObject.SetActive(false);
		}

		private static void EnablePiPImage()
		{
			((Component)PiPImage).gameObject.SetActive(true);
		}

		private static void InitializeCommands()
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			RemoveAddedKeywords();
			ViewBodyCamNode = null;
			BodyCamKeyword = null;
			TerminalKeyword val = FindKeyword("view", verb: true);
			ViewMonitorNode = ((val == null) ? null : val.FindCompatibleNoun("monitor")?.result);
			if (Plugin.TerminalPiPBodyCamEnabled.Value)
			{
				if ((Object)(object)ViewMonitorNode == (Object)null)
				{
					Plugin.Instance.Logger.LogWarning((object)"'view monitor' command does not exist, terminal PiP body cam view will be disabled.");
					return;
				}
				ViewBodyCamNode = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)ViewBodyCamNode).name = "ViewBodyCam";
				ViewBodyCamNode.displayText = "Toggling picture-in-picture body cam.\n\n";
				ViewBodyCamNode.clearPreviousText = true;
				BodyCamKeyword = FindOrCreateKeyword("BodyCam", "bodycam", verb: false);
				AddCompatibleNoun(val, BodyCamKeyword, ViewBodyCamNode);
				CompatibleNoun[] array = val.compatibleNouns ?? Array.Empty<CompatibleNoun>();
				int num = 0;
				CompatibleNoun[] array2 = (CompatibleNoun[])(object)new CompatibleNoun[1 + array.Length];
				ReadOnlySpan<CompatibleNoun> readOnlySpan = new ReadOnlySpan<CompatibleNoun>(array);
				readOnlySpan.CopyTo(new Span<CompatibleNoun>(array2).Slice(num, readOnlySpan.Length));
				num += readOnlySpan.Length;
				array2[num] = new CompatibleNoun(BodyCamKeyword, ViewBodyCamNode);
				val.compatibleNouns = array2;
				BodyCamFailedNode = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)BodyCamFailedNode).name = "BodyCamFailed";
				BodyCamFailedNode.displayText = "Map view is currently disabled.\n\n";
				BodyCamFailedNode.clearPreviousText = true;
				BodyCamLockedNode = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)BodyCamLockedNode).name = "BodyCamFailed";
				BodyCamLockedNode.displayText = "Please place a body cams receiver antenna on the ship.\n\n";
				BodyCamLockedNode.clearPreviousText = true;
			}
			AddNewlyCreatedCommands();
		}

		private static bool TerminalIsDisplayingMap()
		{
			if ((Object)(object)ViewMonitorNode == (Object)null)
			{
				return false;
			}
			return (Object)(object)ShipObjects.TerminalScript.displayingPersistentImage == (Object)(object)ViewMonitorNode.displayTexture;
		}

		internal static bool TerminalIsDisplayingBodyCam()
		{
			if ((Object)(object)PiPImage == (Object)null)
			{
				return false;
			}
			return ((Component)PiPImage).gameObject.activeSelf;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Terminal), "LoadNewNode")]
		private static void LoadNewNodePrefix(ref TerminalNode node)
		{
			if ((Object)(object)node == (Object)null || !((Object)(object)node == (Object)(object)ViewBodyCamNode))
			{
				return;
			}
			if (TerminalIsDisplayingBodyCam())
			{
				DisablePiPImage();
				return;
			}
			if (!BodyCam.BodyCamsAreAvailable)
			{
				node = BodyCamLockedNode;
				return;
			}
			if (!TerminalIsDisplayingMap())
			{
				ShipObjects.TerminalScript.LoadTerminalImage(ViewMonitorNode);
			}
			if (!TerminalIsDisplayingMap())
			{
				node = BodyCamFailedNode;
			}
			else
			{
				EnablePiPImage();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Terminal), "LoadNewNode")]
		private static void LoadNewNodePostfix(TerminalNode node)
		{
			if (!((Object)(object)PiPImage == (Object)null) && !((Object)(object)node != (Object)(object)ViewMonitorNode) && !TerminalIsDisplayingMap())
			{
				DisablePiPImage();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "SwitchMapMonitorPurpose")]
		private static void SwitchMapMonitorPurposePostfix()
		{
			if (!((Object)(object)PiPImage == (Object)null) && !TerminalIsDisplayingMap())
			{
				DisablePiPImage();
			}
		}

		private static TerminalKeyword FindKeyword(string word, bool verb)
		{
			return ((IEnumerable<TerminalKeyword>)ShipObjects.TerminalScript.terminalNodes.allKeywords).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword keyword) => keyword.word == word && keyword.isVerb == verb));
		}

		private static CompatibleNoun FindCompatibleNoun(this TerminalKeyword keyword, string noun)
		{
			return ((IEnumerable<CompatibleNoun>)keyword.compatibleNouns).FirstOrDefault((Func<CompatibleNoun, bool>)((CompatibleNoun compatible) => compatible.noun.word == noun));
		}

		private static TerminalKeyword FindOrCreateKeyword(string name, string word, bool verb, CompatibleNoun[] compatibleNouns = null)
		{
			Plugin.Instance.Logger.LogInfo((object)("Creating terminal " + (verb ? "verb" : "noun") + " '" + word + "' (" + name + ")."));
			TerminalKeyword val = FindKeyword(word, verb);
			if ((Object)(object)val == (Object)null)
			{
				val = ScriptableObject.CreateInstance<TerminalKeyword>();
				((Object)val).name = name;
				val.isVerb = verb;
				val.word = word;
				val.compatibleNouns = compatibleNouns;
				newTerminalKeywords.Add(val);
				Plugin.Instance.Logger.LogInfo((object)"  Keyword was not found, created a new one.");
			}
			else if (compatibleNouns != null)
			{
				foreach (CompatibleNoun compatibleNoun in compatibleNouns)
				{
					AddCompatibleNoun(val, compatibleNoun);
				}
				Plugin.Instance.Logger.LogInfo((object)"  Keyword existed, appended nouns.");
			}
			return val;
		}

		private static void AddCompatibleNoun(TerminalKeyword keyword, CompatibleNoun compatibleNoun)
		{
			if (!addedCompatibleNouns.TryGetValue(keyword, out var value))
			{
				value = new List<TerminalKeyword>();
				addedCompatibleNouns[keyword] = value;
			}
			CompatibleNoun[] array = keyword.compatibleNouns ?? Array.Empty<CompatibleNoun>();
			int num = 0;
			CompatibleNoun[] array2 = (CompatibleNoun[])(object)new CompatibleNoun[1 + array.Length];
			ReadOnlySpan<CompatibleNoun> readOnlySpan = new ReadOnlySpan<CompatibleNoun>(array);
			readOnlySpan.CopyTo(new Span<CompatibleNoun>(array2).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array2[num] = compatibleNoun;
			keyword.compatibleNouns = array2;
			value.Add(compatibleNoun.noun);
		}

		private static void AddCompatibleNoun(TerminalKeyword keyword, TerminalKeyword compatibleKeyword, TerminalNode result)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			AddCompatibleNoun(keyword, new CompatibleNoun(compatibleKeyword, result));
		}

		private static void AddNewlyCreatedCommands()
		{
			TerminalNodesList terminalNodes = ShipObjects.TerminalScript.terminalNodes;
			TerminalNodesList val = terminalNodes;
			TerminalKeyword[] allKeywords = terminalNodes.allKeywords;
			List<TerminalKeyword> list = newTerminalKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + list.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in list)
			{
				array[num] = item;
				num++;
			}
			val.allKeywords = array;
		}

		private static void RemoveAddedKeywords()
		{
			foreach (KeyValuePair<TerminalKeyword, List<TerminalKeyword>> addedCompatibleNoun in addedCompatibleNouns)
			{
				var (val2, addedNouns) = (KeyValuePair<TerminalKeyword, List<TerminalKeyword>>)(ref addedCompatibleNoun);
				if (val2.compatibleNouns != null)
				{
					val2.compatibleNouns = val2.compatibleNouns.Where((CompatibleNoun compatible) => !addedNouns.Contains(compatible.noun)).ToArray();
				}
			}
			addedCompatibleNouns.Clear();
			TerminalNodesList terminalNodes = ShipObjects.TerminalScript.terminalNodes;
			terminalNodes.allKeywords = terminalNodes.allKeywords.Where((TerminalKeyword keyword) => !newTerminalKeywords.Contains(keyword)).ToArray();
			foreach (TerminalKeyword newTerminalKeyword in newTerminalKeywords)
			{
				Object.Destroy((Object)(object)newTerminalKeyword);
			}
			newTerminalKeywords.Clear();
		}
	}
	public enum PiPPosition : uint
	{
		BottomLeft,
		BottomRight,
		TopLeft,
		TopRight
	}
	public class TerminalBodyCamVisibilityTracker : MonoBehaviour
	{
		public BodyCamComponent BodyCamToActivate;

		private void OnEnable()
		{
			if ((Object)(object)BodyCamToActivate != (Object)null)
			{
				BodyCamToActivate.ForceEnableCamera = true;
			}
		}

		private void OnDisable()
		{
			if ((Object)(object)BodyCamToActivate != (Object)null)
			{
				BodyCamToActivate.ForceEnableCamera = false;
			}
		}
	}
}
namespace OpenBodyCams.Utilities
{
	internal static class Cosmetics
	{
		[Flags]
		private enum CompatibilityMode
		{
			None = 0,
			MoreCompany = 1,
			AdvancedCompany = 4,
			ModelReplacementAPI = 8,
			LethalVRM = 0x10,
			ReservedItemSlots = 0x20
		}

		internal static bool PrintDebugInfo;

		private static CompatibilityMode compatibilityMode;

		public static void Initialize(Harmony harmony)
		{
			bool flag = Chainloader.PluginInfos.ContainsKey("com.potatoepet.AdvancedCompany");
			if (Plugin.EnableAdvancedCompanyCosmeticsCompatibility.Value && flag)
			{
				if (AdvancedCompanyCompatibility.Initialize(harmony))
				{
					compatibilityMode |= CompatibilityMode.AdvancedCompany;
					Plugin.Instance.Logger.LogInfo((object)"AdvancedCompany compatibility mode is enabled.");
				}
				else
				{
					Plugin.Instance.Logger.LogWarning((object)"AdvancedCompany is installed, but the compatibility feature failed to initialize.");
				}
			}
			if (Plugin.EnableMoreCompanyCosmeticsCompatibility.Value && !flag && Chainloader.PluginInfos.ContainsKey("me.swipez.melonloader.morecompany"))
			{
				if (MoreCompanyCompatibility.Initialize(harmony))
				{
					compatibilityMode |= CompatibilityMode.MoreCompany;
					Plugin.Instance.Logger.LogInfo((object)"MoreCompany compatibility mode is enabled.");
				}
				else
				{
					Plugin.Instance.Logger.LogWarning((object)"MoreCompany is installed, but the compatibility feature failed to initialize.");
				}
			}
			if (Plugin.EnableModelReplacementAPICompatibility.Value && Chainloader.PluginInfos.ContainsKey("meow.ModelReplacementAPI"))
			{
				if (ModelReplacementAPICompatibility.Initialize(harmony))
				{
					compatibilityMode |= CompatibilityMode.ModelReplacementAPI;
					Plugin.Instance.Logger.LogInfo((object)"ModelReplacementAPI compatibility mode is enabled.");
				}
				else
				{
					Plugin.Instance.Logger.LogWarning((object)"ModelReplacementAPI is installed, but the compatibility feature failed to initialize.");
				}
			}
			if (Plugin.EnableLethalVRMCompatibility.Value && Chainloader.PluginInfos.ContainsKey("Ooseykins.LethalVRM"))
			{
				if (LethalVRMCompatibility.Initialize(harmony))
				{
					compatibilityMode |= CompatibilityMode.LethalVRM;
					Plugin.Instance.Logger.LogInfo((object)"LethalVRM compatibility mode is enabled.");
				}
				else
				{
					Plugin.Instance.Logger.LogWarning((object)"LethalVRM is installed, but the compatibility feature failed to initialize.");
				}
			}
			if (Plugin.EnableReservedItemSlotsCompatibility.Value && Chainloader.PluginInfos.ContainsKey("FlipMods.ReservedItemSlotCore"))
			{
				if (ReservedItemSlotsCompatibility.Initialize(harmony))
				{
					compatibilityMode |= CompatibilityMode.ReservedItemSlots;
					Plugin.Instance.Logger.LogInfo((object)"ReservedItemSlots compatibility mode is enabled.");
				}
				else
				{
					Plugin.Instance.Logger.LogWarning((object)"ReservedItemSlotCore is installed, but the compatibility feature failed to initialize.");
				}
			}
		}

		internal static List<GameObject> CollectVanillaFirstPersonCosmetics(PlayerControllerB player)
		{
			Renderer[] componentsInChildren = ((Component)player.headCostumeContainerLocal).GetComponentsInChildren<Renderer>();
			List<GameObject> list = new List<GameObject>(componentsInChildren.Length);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				list.Add(((Component)componentsInChildren[i]).gameObject);
			}
			return list;
		}

		internal static List<GameObject> CollectVanillaThirdPersonCosmetics(PlayerControllerB player)
		{
			Renderer[] componentsInChildren = ((Component)player.headCostumeContainer).GetComponentsInChildren<Renderer>();
			Renderer[] componentsInChildren2 = ((Component)player.lowerTorsoCostumeContainer).GetComponentsInChildren<Renderer>();
			List<GameObject> list = new List<GameObject>(componentsInChildren.Length + componentsInChildren2.Length);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				list.Add(((Component)componentsInChildren[i]).gameObject);
			}
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				list.Add(((Component)componentsInChildren2[j]).gameObject);
			}
			return list;
		}

		private static void DoCollectCosmetics(PlayerControllerB player, out GameObject[] thirdPersonCosmetics, out GameObject[] firstPersonCosmetics, out bool hasViewmodelReplacement)
		{
			if ((Object)(object)player == (Object)null)
			{
				thirdPersonCosmetics = Array.Empty<GameObject>();
				firstPersonCosmetics = Array.Empty<GameObject>();
				hasViewmodelReplacement = false;
				return;
			}
			double num = 0.0;
			if (PrintDebugInfo)
			{
				num = Time.realtimeSinceStartupAsDouble;
			}
			List<GameObject> list = CollectVanillaThirdPersonCosmetics(player);
			List<GameObject> list2 = CollectVanillaFirstPersonCosmetics(player);
			hasViewmodelReplacement = false;
			BodyCam.CollectPlayerThirdPersonCosmetics(player, list);
			BodyCam.CollectPlayerFirstPersonCosmetics(player, list2, ref hasViewmodelReplacement);
			if (compatibilityMode.HasFlag(CompatibilityMode.MoreCompany))
			{
				MoreCompanyCompatibility.CollectCosmetics(player, list);
			}
			if (compatibilityMode.HasFlag(CompatibilityMode.AdvancedCompany))
			{
				AdvancedCompanyCompatibility.CollectCosmetics(player, list);
			}
			if (compatibilityMode.HasFlag(CompatibilityMode.LethalVRM))
			{
				LethalVRMCompatibility.CollectCosmetics(player, list);
			}
			if (compatibilityMode.HasFlag(CompatibilityMode.ModelReplacementAPI))
			{
				ModelReplacementAPICompatibility.CollectCosmetics(player, list, list2, ref hasViewmodelReplacement);
			}
			if (compatibilityMode.HasFlag(CompatibilityMode.ReservedItemSlots))
			{
				ReservedItemSlotsCompatibility.CollectCosmetics(player, list);
			}
			thirdPersonCosmetics = list.ToArray();
			firstPersonCosmetics = list2.ToArray();
			if (PrintDebugInfo)
			{
				double num2 = (Time.realtimeSinceStartupAsDouble - num) * 1000000.0;
				Plugin.Instance.Logger.LogInfo((object)string.Format("Collected {0} third-person and {1} cosmetics for {2} with{3} a viewmodel replacement in {4:0.##} microseconds.", thirdPersonCosmetics.Length, firstPersonCosmetics.Length, player.playerUsername, hasViewmodelReplacement ? "" : "out", num2));
			}
		}

		public static void CollectCosmetics(PlayerControllerB player, out GameObject[] thirdPersonCosmetics, out GameObject[] firstPersonCosmetics, out bool hasViewmodelReplacement)
		{
			try
			{
				DoCollectCosmetics(player, out thirdPersonCosmetics, out firstPersonCosmetics, out hasViewmodelReplacement);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)("Failed to get third-person cosmetics for player " + player.playerUsername + ":"));
				Plugin.Instance.Logger.LogError((object)ex);
				thirdPersonCosmetics = Array.Empty<GameObject>();
				firstPersonCosmetics = Array.Empty<GameObject>();
				hasViewmodelReplacement = false;
			}
		}

		internal static void CollectChildCosmetics(GameObject obj, List<GameObject> children)
		{
			Renderer[] componentsInChildren = obj.GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				children.Add(((Component)val).gameObject);
			}
		}
	}
	internal static class MeshUtils
	{
		private static Mesh MakeReadableMeshCopy(Mesh nonReadableMesh)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0012: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = new Mesh
			{
				indexFormat = nonReadableMesh.indexFormat
			};
			nonReadableMesh.vertexBufferTarget = (Target)1;
			if (nonReadableMesh.vertexBufferCount > 0)
			{
				GraphicsBuffer vertexBuffer = nonReadableMesh.GetVertexBuffer(0);
				try
				{
					int num = vertexBuffer.stride * vertexBuffer.count;
					byte[] array = new byte[num];
					vertexBuffer.GetData((Array)array);
					val.SetVertexBufferParams(nonReadableMesh.vertexCount, nonReadableMesh.GetVertexAttributes());
					val.SetVertexBufferData<byte>(array, 0, 0, num, 0, (MeshUpdateFlags)0);
				}
				finally
				{
					((IDisposable)vertexBuffer)?.Dispose();
				}
			}
			nonReadableMesh.indexBufferTarget = (Target)2;
			val.subMeshCount = nonReadableMesh.subMeshCount;
			GraphicsBuffer indexBuffer = nonReadableMesh.GetIndexBuffer();
			try
			{
				int num2 = indexBuffer.stride * indexBuffer.count;
				byte[] array2 = new byte[num2];
				indexBuffer.GetData((Array)array2);
				val.SetIndexBufferParams(indexBuffer.count, nonReadableMesh.indexFormat);
				val.SetIndexBufferData<byte>(array2, 0, 0, num2, (MeshUpdateFlags)0);
				indexBuffer.Release();
			}
			finally
			{
				((IDisposable)indexBuffer)?.Dispose();
			}
			int num3 = 0;
			for (int i = 0; i < val.subMeshCount; i++)
			{
				int indexCount = (int)nonReadableMesh.GetIndexCount(i);
				val.SetSubMesh(i, new SubMeshDescriptor(num3, indexCount, (MeshTopology)0), (MeshUpdateFlags)0);
				num3 += indexCount;
			}
			return val;
		}

		internal static Mesh CopySubmesh(Mesh mesh, int submesh)
		{
			//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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (!mesh.isReadable)
			{
				mesh = MakeReadableMeshCopy(mesh);
			}
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			Vector3[] vertices = mesh.vertices;
			int[] triangles = mesh.GetTriangles(submesh);
			Vector2[] uv = mesh.uv;
			List<Vector3> list = new List<Vector3>(vertices.Length);
			List<Vector2> list2 = new List<Vector2>(uv.Length);
			int[] array = new int[triangles.Length];
			for (int i = 0; i < triangles.Length; i++)
			{
				int num = triangles[i];
				if (!dictionary.TryGetValue(num, out var value))
				{
					value = (dictionary[num] = list.Count);
					list.Add(vertices[num]);
					list2.Add(uv[num]);
				}
				array[i] = value;
			}
			return new Mesh
			{
				vertices = list.ToArray(),
				uv = list2.ToArray(),
				triangles = array
			};
		}
	}
	public static class Utilities
	{
		private static Camera[] allCameras = Array.Empty<Camera>();

		private static readonly Plane[] frustumPlanes = (Plane[])(object)new Plane[6];

		private static Queue<Transform> transformQueue = new Queue<Transform>();

		public static bool IsVisibleToAnyCameraExcept(this Renderer renderer, Camera cameraToSkip)
		{
			//IL_0029: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			if (allCameras.Length != Camera.allCamerasCount)
			{
				allCameras = (Camera[])(object)new Camera[Camera.allCamerasCount];
			}
			Camera.GetAllCameras(allCameras);
			Bounds bounds = renderer.bounds;
			int layer = ((Component)renderer).gameObject.layer;
			Camera[] array = allCameras;
			foreach (Camera val in array)
			{
				if ((val == null || val != cameraToSkip) && (val.cullingMask & (1 << layer)) != 0)
				{
					GeometryUtility.CalculateFrustumPlanes(val, frustumPlanes);
					if (GeometryUtility.TestPlanesAABB(frustumPlanes, bounds))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static void SetMaterial(this Renderer renderer, int index, Material material)
		{
			Material[] sharedMaterials = renderer.sharedMaterials;
			sharedMaterials[index] = material;
			renderer.sharedMaterials = sharedMaterials;
		}

		public static T GetComponentInChildrenBreadthFirst<T>(this Component self, Func<T, bool> predicate) where T : Component
		{
			transformQueue.Clear();
			transformQueue.Enqueue(self.transform);
			Transform result;
			while (transformQueue.TryDequeue(out result))
			{
				T[] components = ((Component)result).GetComponents<T>();
				foreach (T val in components)
				{
					if (predicate == null || predicate(val))
					{
						return val;
					}
				}
				for (int j = 0; j < result.childCount; j++)
				{
					transformQueue.Enqueue(result.GetChild(j));
				}
			}
			return default(T);
		}
	}
	public enum Perspective
	{
		Original,
		FirstPerson,
		ThirdPerson
	}
	public static class ViewPerspective
	{
		public const int DEFAULT_LAYER = 0;

		public const int ENEMIES_LAYER = 19;

		public const int ENEMIES_NOT_RENDERED_LAYER = 23;

		private static void SetCosmeticHidden(GameObject cosmetic, bool hidden)
		{
			cosmetic.layer = (hidden ? 23 : 0);
		}

		public static void PrepareModelState(PlayerControllerB player, ref PlayerModelState state)
		{
			Restore(ref state);
			state.player = player;
			state.lastPerspective = Perspective.Original;
			if (player == null)
			{
				state.thirdPersonCosmetics = Array.Empty<GameObject>();
				state.thirdPersonCosmeticsLayers = Array.Empty<int>();
				state.thirdPersonCosmeticNames = Array.Empty<string>();
				state.firstPersonCosmetics = Array.Empty<GameObject>();
				state.firstPersonCosmeticsLayers = Array.Empty<int>();
				state.firstPersonCosmeticNames = Array.Empty<string>();
			}
			else
			{
				Cosmetics.CollectCosmetics(player, out state.thirdPersonCosmetics, out state.firstPersonCosmetics, out state.hasViewmodelReplacement);
				state.thirdPersonCosmeticsLayers = new int[state.thirdPersonCosmetics.Length];
				state.thirdPersonCosmeticNames = GetCosmeticsPaths(state.thirdPersonCosmetics, ((Component)player.playerBodyAnimator).transform);
				state.firstPersonCosmeticsLayers = new int[state.firstPersonCosmetics.Length];
				state.firstPersonCosmeticNames = GetCosmeticsPaths(state.firstPersonCosmetics, ((Component)player.playerBodyAnimator).transform);
			}
		}

		public static void Apply(ref PlayerModelState state, Perspective perspective)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB player = state.player;
			if (player == null)
			{
				return;
			}
			Restore(ref state);
			if (perspective == Perspective.Original)
			{
				return;
			}
			state.thirdPersonBodyShadowMode = ((Renderer)player.thisPlayerModel).shadowCastingMode;
			state.thirdPersonBodyLayer = ((Component)player.thisPlayerModel).gameObject.layer;
			state.firstPersonArmsEnabled = ((Renderer)player.thisPlayerModelArms).enabled;
			state.firstPersonArmsLayer = ((Component)player.thisPlayerModelArms).gameObject.layer;
			if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
			{
				state.heldItemPosition = ((Component)player.currentlyHeldObjectServer).transform.position;
				state.heldItemRotation = ((Component)player.currentlyHeldObjectServer).transform.rotation;
				GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
				FlashlightItem val = (FlashlightItem)(object)((currentlyHeldObjectServer is FlashlightItem) ? currentlyHeldObjectServer : null);
				if (val != null)
				{
					state.helmetLightEnabled = ((Behaviour)player.helmetLight).enabled;
					state.heldLightEnabled = ((Behaviour)val.flashlightBulb).enabled;
				}
			}
			for (int i = 0; i < state.thirdPersonCosmetics.Length; i++)
			{
				if ((Object)(object)state.thirdPersonCosmetics[i] == (Object)null)
				{
					ref string reference = ref state.thirdPersonCosmeticNames[i];
					if (reference != null)
					{
						Plugin.Instance.Logger.LogWarning((object)$"{player.playerUsername}'s third-person cosmetic {reference} is null.\n{new StackTrace()}");
						reference = null;
					}
				}
				else
				{
					state.thirdPersonCosmeticsLayers[i] = state.thirdPersonCosmetics[i].layer;
				}
			}
			for (int j = 0; j < state.firstPersonCosmetics.Length; j++)
			{
				if ((Object)(object)state.firstPersonCosmetics[j] == (Object)null)
				{
					ref string reference2 = ref state.firstPersonCosmeticNames[j];
					if (reference2 != null)
					{
						Plugin.Instance.Logger.LogWarning((object)$"{player.playerUsername}'s first-person cosmetic {reference2} is null.\n{new StackTrace()}");
						reference2 = null;
					}
				}
				else
				{
					state.firstPersonCosmeticsLayers[j] = state.firstPersonCosmetics[j].layer;
				}
			}
			switch (perspective)
			{
			case Perspective.FirstPerson:
			{
				((Renderer)player.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)3;
				((Component)player.thisPlayerModel).gameObject.layer = 23;
				if (!state.hasViewmodelReplacement)
				{
					((Renderer)player.thisPlayerModelArms).enabled = true;
					((Component)player.thisPlayerModelArms).gameObject.layer = 0;
				}
				if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
				{
					AttachItem(player.currentlyHeldObjectServer, player.localItemHolder);
					GrabbableObject currentlyHeldObjectServer3 = player.currentlyHeldObjectServer;
					FlashlightItem val5 = (FlashlightItem)(object)((currentlyHeldObjectServer3 is FlashlightItem) ? currentlyHeldObjectServer3 : null);
					if (val5 != null)
					{
						((Behaviour)player.helmetLight).enabled = false;
						((Behaviour)val5.flashlightBulb).enabled = ((GrabbableObject)val5).isBeingUsed;
						((Behaviour)val5.flashlightBulbGlow).enabled = ((GrabbableObject)val5).isBeingUsed;
					}
				}
				GameObject[] thirdPersonCosmetics2 = state.thirdPersonCosmetics;
				foreach (GameObject val6 in thirdPersonCosmetics2)
				{
					if (!((Object)(object)val6 == (Object)null))
					{
						SetCosmeticHidden(val6, hidden: true);
					}
				}
				GameObject[] firstPersonCosmetics2 = state.firstPersonCosmetics;
				foreach (GameObject val7 in firstPersonCosmetics2)
				{
					if (!((Object)(object)val7 == (Object)null))
					{
						SetCosmeticHidden(val7, hidden: false);
					}
				}
				break;
			}
			case Perspective.ThirdPerson:
			{
				((Renderer)player.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
				((Component)player.thisPlayerModel).gameObject.layer = 0;
				if (!state.hasViewmodelReplacement)
				{
					((Renderer)player.thisPlayerModelArms).enabled = false;
					((Component)player.thisPlayerModelArms).gameObject.layer = 23;
				}
				if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
				{
					AttachItem(player.currentlyHeldObjectServer, player.serverItemHolder);
					GrabbableObject currentlyHeldObjectServer2 = player.currentlyHeldObjectServer;
					FlashlightItem val2 = (FlashlightItem)(object)((currentlyHeldObjectServer2 is FlashlightItem) ? currentlyHeldObjectServer2 : null);
					if (val2 != null)
					{
						((Behaviour)player.helmetLight).enabled = ((GrabbableObject)val2).isBeingUsed;
						((Behaviour)val2.flashlightBulb).enabled = false;
						((Behaviour)val2.flashlightBulbGlow).enabled = false;
					}
				}
				GameObject[] thirdPersonCosmetics = state.thirdPersonCosmetics;
				foreach (GameObject val3 in thirdPersonCosmetics)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						SetCosmeticHidden(val3, hidden: false);
					}
				}
				GameObject[] firstPersonCosmetics = state.firstPersonCosmetics;
				foreach (GameObject val4 in firstPersonCosmetics)
				{
					if (!((Object)(object)val4 == (Object)null))
					{
						SetCosmeticHidden(val4, hidden: true);
					}
				}
				break;
			}
			}
			PatchFlowerSnakeEnemy.SetClingingAnimationPositionsForPlayer(player, perspective);
			PatchCentipedeAI.SetClingingAnimationPositionsForPlayer(player, perspective);
			state.lastPerspective = perspective;
			static void AttachItem(GrabbableObject item, Transform holder)
			{
				//IL_0007: 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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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_0044: 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)
				((Component)item).transform.rotation = holder.rotation;
				((Component)item).transform.Rotate(item.itemProperties.rotationOffset);
				((Component)item).transform.position = holder.position + holder.rotation * item.itemProperties.positionOffset;
			}
		}

		public static void Restore(ref PlayerModelState state)
		{
			//IL_001a: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB player = state.player;
			if (player == null || state.lastPerspective == Perspective.Original)
			{
				return;
			}
			((Renderer)player.thisPlayerModel).shadowCastingMode = state.thirdPersonBodyShadowMode;
			((Component)player.thisPlayerModel).gameObject.layer = state.thirdPersonBodyLayer;
			((Renderer)player.thisPlayerModelArms).enabled = state.firstPersonArmsEnabled;
			((Component)player.thisPlayerModelArms).gameObject.layer = state.firstPersonArmsLayer;
			for (int i = 0; i < state.thirdPersonCosmetics.Length; i++)
			{
				if (!((Object)(object)state.thirdPersonCosmetics[i] == (Object)null))
				{
					state.thirdPersonCosmetics[i].layer = state.thirdPersonCosmeticsLayers[i];
				}
			}
			for (int j = 0; j < state.firstPersonCosmetics.Length; j++)
			{
				if (!((Object)(object)state.firstPersonCosmetics[j] == (Object)null))
				{
					state.firstPersonCosmetics[j].layer = state.firstPersonCosmeticsLayers[j];
				}
			}
			if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
			{
				((Component)player.currentlyHeldObjectServer).transform.position = state.heldItemPosition;
				((Component)player.currentlyHeldObjectServer).transform.rotation = state.heldItemRotation;
				GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
				FlashlightItem val = (FlashlightItem)(object)((currentlyHeldObjectServer is FlashlightItem) ? currentlyHeldObjectServer : null);
				if (val != null)
				{
					((Behaviour)player.helmetLight).enabled = state.helmetLightEnabled;
					((Behaviour)val.flashlightBulb).enabled = state.heldLightEnabled;
					((Behaviour)val.flashlightBulbGlow).enabled = state.heldLightEnabled;
				}
			}
			PatchFlowerSnakeEnemy.SetClingingAnimationPositionsForPlayer(player, Perspective.Original);
			PatchCentipedeAI.SetClingingAnimationPositionsForPlayer(player, Perspective.Original);
			state.lastPerspective = Perspective.Original;
		}

		private static string[] GetCosmeticsPaths(GameObject[] objects, Transform root)
		{
			string[] array = new string[objects.Length];
			for (int i = 0; i < objects.Length; i++)
			{
				Transform val = objects[i].transform;
				StringBuilder stringBuilder = new StringBuilder(((Object)val).name);
				do
				{
					val = val.parent;
					if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)root)
					{
						break;
					}
					stringBuilder.Insert(0, '/');
					stringBuilder.Insert(0, ((Object)val).name);
				}
				while (!((Object)val).name.EndsWith("(Clone)"));
				array[i] = stringBuilder.ToString();
			}
			return array;
		}
	}
	public struct PlayerModelState
	{
		internal PlayerControllerB player;

		internal Perspective lastPerspective;

		internal ShadowCastingMode thirdPersonBodyShadowMode;

		internal int thirdPersonBodyLayer;

		internal bool firstPersonArmsEnabled;

		internal int firstPersonArmsLayer;

		internal GameObject[] thirdPersonCosmetics;

		internal int[] thirdPersonCosmeticsLayers;

		internal string[] thirdPersonCosmeticNames;

		internal GameObject[] firstPersonCosmetics;

		internal int[] firstPersonCosmeticsLayers;

		internal string[] firstPersonCosmeticNames;

		internal bool hasViewmodelReplacement;

		internal Vector3 heldItemPosition;

		internal Quaternion heldItemRotation;

		internal bool helmetLightEnabled;

		internal bool heldLightEnabled;

		public PlayerModelState()
		{
			//IL_0009: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			player = null;
			thirdPersonBodyShadowMode = (ShadowCastingMode)0;
			thirdPersonBodyLayer = 0;
			firstPersonArmsEnabled = false;
			firstPersonArmsLayer = 0;
			heldItemPosition = default(Vector3);
			heldItemRotation = default(Quaternion);
			helmetLightEnabled = false;
			heldLightEnabled = false;
			lastPerspective = Perspective.Original;
			thirdPersonCosmetics = Array.Empty<GameObject>();
			thirdPersonCosmeticsLayers = Array.Empty<int>();
			thirdPersonCosmeticNames = Array.Empty<string>();
			firstPersonCosmetics = Array.Empty<GameObject>();
			firstPersonCosmeticsLayers = Array.Empty<int>();
			firstPersonCosmeticNames = Array.Empty<string>();
			hasViewmodelReplacement = false;
		}

		private static bool AllObjectsExistInArray(GameObject[] objects)
		{
			foreach (GameObject val in objects)
			{
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		internal readonly bool VerifyCosmeticsExist(string name)
		{
			if ((Object)(object)player == (Object)null)
			{
				return true;
			}
			if (!AllObjectsExistInArray(thirdPersonCosmetics))
			{
				Plugin.Instance.Logger.LogError((object)("A third-person cosmetic attached to " + name + " has been destroyed."));
				return false;
			}
			if (!AllObjectsExistInArray(firstPersonCosmetics))
			{
				Plugin.Instance.Logger.LogError((object)("A first-person cosmetic attached to " + name + " has been destroyed."));
				return false;
			}
			return true;
		}

		internal readonly bool ReferencesObject(GameObject obj)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (Array.IndexOf(thirdPersonCosmetics, obj) != -1)
			{
				return true;
			}
			if (Array.IndexOf(firstPersonCosmetics, obj) != -1)
			{
				return true;
			}
			return false;
		}
	}
	internal class WeatherEffectComponents
	{
		internal LevelWeatherType weatherType;

		internal WeatherEffect effect;

		internal GameObject effectObject;

		internal Behaviour[] behaviours = Array.Empty<Behaviour>();

		internal Renderer[] renderers = Array.Empty<Renderer>();

		internal bool enabled;

		internal bool active;

		internal bool visible = true;

		internal Vector3 transitionPoint = Vector3.zero;

		internal int transitionFrame = -1;

		internal WeatherEffectComponents(LevelWeatherType weatherType, GameObject overrideEffectObject = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			this.weatherType = weatherType;
			effect = TimeOfDay.Instance.effects[weatherType];
			effectObject = overrideEffectObject ?? effect.effectObject;
			if ((Object)(object)effectObject != (Object)null)
			{
				behaviours = (from b in effectObject.GetComponentsInChildren<Behaviour>()
					where b.enabled && (b is Light || b is LocalVolumetricFog)
					select b).ToArray();
				renderers = (from r in effectObject.GetComponentsInChildren<Renderer>()
					where r.enabled
					select r).ToArray();
			}
		}

		internal void SetVisibility(bool show)
		{
			visible = show;
			if (!((Object)(object)effectObject == (Object)null) && effectObject.activeInHierarchy)
			{
				Behaviour[] array = behaviours;
				foreach (Behaviour val in array)
				{
					val.enabled = show;
				}
				Renderer[] array2 = renderers;
				foreach (Renderer val2 in array2)
				{
					val2.enabled = show;
				}
			}
		}

		internal void Update(Transform target, bool isInInterior, float deltaTime)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (enabled)
			{
				if ((Object)(object)effectObject != (Object)null)
				{
					if (effect.lerpPosition)
					{
						effectObject.transform.position = Vector3.Lerp(effectObject.transform.position, target.position, Mathf.Clamp01(deltaTime));
					}
					else
					{
						effectObject.transform.position = target.position;
					}
					SetActive(value: true);
				}
				transitionFrame = -1;
			}
			else if ((Object)(object)effectObject != (Object)null && effect.lerpPosition)
			{
				if (transitionFrame == -1)
				{
					transitionFrame = 0;
					transitionPoint = target.position;
				}
			}
			else
			{
				SetActive(value: false);
				transitionFrame = -1;
			}
			if (transitionFrame >= 0)
			{
				float num = Math.Min((float)transitionFrame / 270f, 1f);
				effectObject.transform.position = Vector3.Lerp(effectObject.transform.position, transitionPoint + Vector3.down * 50f, num);
				if (num < 1f)
				{
					transitionFrame++;
					SetActive(value: true);
				}
				else
				{
					SetActive(value: false);
				}
			}
			void SetActive(bool value)
			{
				if (value != active)
				{
					GameObject obj = effectObject;
					if (obj != null)
					{
						obj.SetActive(value);
					}
					active = value;
					if (value)
					{
						SetVisibility(visible);
					}
				}
			}
		}
	}
}
namespace OpenBodyCams.Utilities.IL
{
	internal class ILInjector
	{
		[CompilerGenerated]
		private sealed class <GetRelativeInstructions>d__34 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			public ILInjector <>4__this;

			private int offset;

			public int <>3__offset;

			private int size;

			public int <>3__size;

			private int <i>5__2;

			CodeInstruction IEnumerator<CodeInstruction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetRelativeInstructions>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ILInjector iLInjector = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < size)
				{
					<>2__current = iLInjector.instructions[iLInjector.index + offset + <i>5__2];
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<GetRelativeInstructions>d__34 <GetRelativeInstructions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetRelativeInstructions>d__ = this;
				}
				else
				{
					<GetRelativeInstructions>d__ = new <GetRelativeInstructions>d__34(0)
					{
						<>4__this = <>4__this
					};
				}
				<GetRelativeInstructions>d__.offset = <>3__offset;
				<GetRelativeInstructions>d__.size = <>3__size;
				return <GetRelativeInstructions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		private const string INVALID = "Injector is invalid";

		private List<CodeInstruction> instructions = instructions.ToList();

		private ILGenerator generator;

		private int index;

		private int matchEnd;

		public int Index
		{
			get
			{
				return index;
			}
			set
			{
				index = value;
			}
		}

		public bool IsValid
		{
			get
			{
				if (instructions != null)
				{
					return IsIndexValid(index);
				}
				return false;
			}
		}

		public CodeInstruction Instruction
		{
			get
			{
				if (!IsIndexInRange(index))
				{
					return null;
				}
				return instructions[index];
			}
			set
			{
				if (!IsIndexInRange(index))
				{
					throw new InvalidOperationException($"Current index {index} is out of range of instruction count {instructions.Count}");
				}
				instructions[index] = value;
			}
		}

		public CodeInstruction LastMatchedInstruction
		{
			get
			{
				int num = matchEnd - 1;
				if (!IsIndexInRange(num))
				{
					return null;
				}
				return instructions[num];
			}
			set
			{
				int num = matchEnd - 1;
				if (!IsIndexInRange(num))
				{
					throw new InvalidOperationException($"Last matched index {index} is out of range of instruction count {instructions.Count}");
				}
				instructions[num] = value;
			}
		}

		public ICollection<CodeInstruction> Instructions => instructions.AsReadOnly();

		public ILInjector(IEnumerable<CodeInstruction> instructions, ILGenerator generator = null)
		{
			this.generator = generator;
			matchEnd = -1;
			base..ctor();
		}

		public ILInjector GoToStart()
		{
			matchEnd = index;
			index = 0;
			return this;
		}

		public ILInjector GoToEnd()
		{
			matchEnd = index;
			index = instructions.Count;
			return this;
		}

		public ILInjector Forward(int offset)
		{
			if (!IsValid)
			{
				return this;
			}
			matchEnd = index;
			index = Math.Clamp(index + offset, -1, instructions.Count);
			return this;
		}

		public ILInjector Back(int offset)
		{
			return Forward(-offset);
		}

		private void MarkInvalid()
		{
			index = -1;
			matchEnd = -1;
		}

		private void Search(bool forward, ILMatcher[] predicates)
		{
			if (!IsValid)
			{
				return;
			}
			int num = 1;
			if (!forward)
			{
				num = -1;
				index--;
			}
			while (forward ? (index < instructions.Count) : (index >= 0))
			{
				if (forward && index + predicates.Length > instructions.Count)
				{
					index = instructions.Count;
					break;
				}
				int i;
				for (i = 0; i < predicates.Length && predicates[i].Matches(instructions[index + i]); i++)
				{
				}
				if (i == predicates.Length)
				{
					matchEnd = index + i;
					return;
				}
				index += num;
			}
			MarkInvalid();
		}

		public ILInjector Find(params ILMatcher[] predicates)
		{
			Search(forward: true, predicates);
			return this;
		}

		public ILInjector ReverseFind(params ILMatcher[] predicates)
		{
			Search(forward: false, predicates);
			return this;
		}

		public ILInjector GoToPush(int popIndex)
		{
			if (!IsValid)
			{
				return this;
			}
			matchEnd = index;
			index--;
			int num = 0;
			while (index >= 0)
			{
				CodeInstruction instruction = instructions[index];
				num += instruction.PushCount();
				num -= instruction.PopCount();
				if (num >= popIndex)
				{
					return this;
				}
				index--;
			}
			return this;
		}

		public ILInjector SkipBranch()
		{
			if (Instruction == null)
			{
				return this;
			}
			if (!(Instruction.operand is Label label))
			{
				throw new InvalidOperationException($"Current instruction is not a branch: {Instruction}");
			}
			return FindLabel(label);
		}

		public ILInjector FindLabel(Label label)
		{
			if (label == default(Label))
			{
				return this;
			}
			matchEnd = index;
			for (index = 0; index < instructions.Count; index++)
			{
				if (instructions[index].labels.Contains(label))
				{
					return this;
				}
			}
			MarkInvalid();
			return this;
		}

		public ILInjector GoToMatchEnd()
		{
			index = matchEnd;
			return this;
		}

		public ILInjector GoToLastMatchedInstruction()
		{
			if (!IsIndexValid(matchEnd))
			{
				return this;
			}
			index = matchEnd - 1;
			return this;
		}

		private bool IsIndexValid(int index)
		{
			return index != -1;
		}

		private bool IsIndexInRange(int index)
		{
			if (index >= 0)
			{
				return index < instructions.Count;
			}
			return false;
		}

		public CodeInstruction GetRelativeInstruction(int offset)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			int num = index + offset;
			if (!IsIndexInRange(num))
			{
				throw new IndexOutOfRangeException($"Offset {offset} would read out of bounds at index {num}");
			}
			return instructions[num];
		}

		public ILInjector SetRelativeInstruction(int offset, CodeInstruction instruction)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			int num = index + offset;
			if (!IsIndexInRange(num))
			{
				throw new IndexOutOfRangeException($"Offset {offset} would write out of bounds at index {num}");
			}
			instructions[num] = instruction;
			return this;
		}

		[IteratorStateMachine(typeof(<GetRelativeInstructions>d__34))]
		public IEnumerable<CodeInstruction> GetRelativeInstructions(int offset, int size)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetRelativeInstructions>d__34(-2)
			{
				<>4__this = this,
				<>3__offset = offset,
				<>3__size = size
			};
		}

		public IEnumerable<CodeInstruction> GetRelativeInstructions(int size)
		{
			return GetRelativeInstructions(0, size);
		}

		private void GetLastMatchRangeAbsolute(out int start, out int end)
		{
			start = index;
			end = matchEnd;
			if (start > end)
			{
				int num = end;
				int num2 = start;
				start = num;
				end = num2;
			}
		}

		private void GetLastMatchRange(out int start, out int size)
		{
			GetLastMatchRangeAbsolute(out start, out var end);
			if (start < 0 || start >= instructions.Count)
			{
				throw new InvalidOperationException($"Last match range starts at invalid index {start}");
			}
			if (end < 0 || end > instructions.Count)
			{
				throw new InvalidOperationException($"Last match range ends at invalid index {end}");
			}
			size = end - start;
		}

		public List<CodeInstruction> GetLastMatch()
		{
			GetLastMatchRange(out var start, out var size);
			return instructions.GetRange(start, size);
		}

		public ILInjector DefineLabel(out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("No ILGenerator was provided");
			}
			label = generator.DefineLabel();
			return this;
		}

		public ILInjector AddLabel(out Label label)
		{
			DefineLabel(out label);
			return AddLabel(label);
		}

		public ILInjector AddLabel(Label label)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Instruction = new CodeInstruction(Instruction);
			Instruction.labels.Add(label);
			return this;
		}

		public ILInjector InsertInPlace(ICollection<CodeInstruction> instructions)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			this.instructions.InsertRange(index, instructions);
			if (matchEnd >= index)
			{
				matchEnd += instructions.Count;
			}
			return this;
		}

		public ILInjector Insert(ICollection<CodeInstruction> instructions)
		{
			InsertInPlace(instructions);
			index += instructions.Count;
			return this;
		}

		public ILInjector InsertInPlaceAfterBranch(ICollection<CodeInstruction> instructions)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			List<Label> labels = Instruction.labels;
			Instruction = new CodeInstruction(Instruction);
			Instruction.labels.Clear();
			this.instructions.InsertRange(index, instructions);
			Instruction.labels.AddRange(labels);
			if (matchEnd >= index)
			{
				matchEnd += instructions.Count;
			}
			return this;
		}

		public ILInjector InsertAfterBranch(ICollection<CodeInstruction> instructions)
		{
			InsertInPlaceAfterBranch(instructions);
			index += instructions.Count;
			return this;
		}

		public ILInjector RemoveAllPreviousInstructions()
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			instructions.RemoveRange(0, index);
			matchEnd -= index;
			if (matchEnd < 0)
			{
				matchEnd = 0;
			}
			index = 0;
			return this;
		}

		public ILInjector Remove(int count = 1)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			instructions.RemoveRange(index, count);
			if (matchEnd > index)
			{
				matchEnd = Math.Max(index, matchEnd - count);
			}
			return this;
		}

		public ILInjector RemoveLastMatch()
		{
			GetLastMatchRange(out var start, out var size);
			List<Label> labels = instructions[start].labels;
			instructions.RemoveRange(start, size);
			index = start;
			matchEnd = start;
			instructions[start].labels.AddRange(labels);
			return this;
		}

		public ILInjector ReplaceLastMatch(params CodeInstruction[] replacementInstructions)
		{
			if (replacementInstructions.Length == 0)
			{
				throw new ArgumentException("Cannot replace a match with an empty array.");
			}
			GetLastMatchRange(out var start, out var size);
			List<Label> labels = instructions[start].labels;
			instructions.RemoveRange(start, size);
			instructions.InsertRange(start, replacementInstructions);
			index = start;
			matchEnd = start + replacementInstructions.Length;
			instructions[start].labels.AddRange(labels);
			return this;
		}

		public List<CodeInstruction> ReleaseInstructions()
		{
			List<CodeInstruction> result = instructions;
			instructions = null;
			return result;
		}

		public ILInjector PrintContext(int context, string header = "")
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid (" + header + ")");
			}
			StringBuilder stringBuilder = new StringBuilder(header);
			if (header.Length > 0)
			{
				stringBuilder.Append(':');
			}
			stringBuilder.AppendLine();
			GetLastMatchRangeAbsolute(out var start, out var end);
			int num = Math.Min(end + 1 + context, instructions.Count);
			for (int i = Math.Max(start - context, 0); i < num; i++)
			{
				if (end == -1 && i == index)
				{
					stringBuilder.Append("╶> ");
				}
				else
				{
					if (i >= start && i < end)
					{
						stringBuilder.Append("│");
					}
					else
					{
						stringBuilder.Append(" ");
					}
					if (i == index)
					{
						stringBuilder.Append("╶> ");
					}
					else
					{
						stringBuilder.Append("   ");
					}
				}
				stringBuilder.AppendLine($"{i}: {instructions[i]}");
			}
			Plugin.Instance.Logger.LogInfo((object)stringBuilder);
			return this;
		}

		public ILInjector PrintContext(string header = "")
		{
			return PrintContext(4, header);
		}
	}
	internal interface ILMatcher
	{
		bool Matches(CodeInstruction instruction);

		ILMatcher CaptureAs(out CodeInstruction variable)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			variable = new CodeInstruction(OpCodes.Nop, (object)null);
			return new InstructionCapturingMatcher(this, variable);
		}

		unsafe ILMatcher CaptureOperandAs<T>(out T operand) where T : unmanaged
		{
			operand = default(T);
			fixed (T* operand2 = &operand)
			{
				return new OperandCapturingMatcher<T>(this, operand2);
			}
		}

		ILMatcher Debug()
		{
			return new DebuggingMatcher(this);
		}

		static ILMatcher Not(ILMatcher matcher)
		{
			return new NotMatcher(matcher);
		}

		static ILMatcher Opcode(OpCode opcode)
		{
			return new OpcodeMatcher(opcode);
		}

		static ILMatcher Opcodes(params OpCode[] opcodes)
		{
			return new OpcodesMatcher(opcodes);
		}

		static ILMatcher OpcodeOperand(OpCode opcode, object operand)
		{
			return new OpcodeOperandMatcher(opcode, operand);
		}

		static ILMatcher Instruction(CodeInstruction instruction)
		{
			return new InstructionMatcher(instruction);
		}

		static ILMatcher Ldarg(int? arg = null)
		{
			return new LdargMatcher(arg);
		}

		static ILMatcher Ldloc(int? loc = null)
		{
			return new LdlocMatcher(loc);
		}

		static ILMatcher Stloc(int? loc = null)
		{
			return new StlocMatcher(loc);
		}

		static ILMatcher Ldc(int? value = null)
		{
			return new LdcI32Matcher(value);
		}

		static ILMatcher LdcF32(float? value = null)
		{
			return new LdcF32Matcher(value);
		}

		unsafe static ILMatcher LdlocCapture(out int localIndex)
		{
			localIndex = -1;
			fixed (int* localIndex2 = &localIndex)
			{
				return new LdlocCapturingMatcher(localIndex2);
			}
		}

		unsafe static ILMatcher Ldloc(in int localIndex)
		{
			fixed (int* localIndexPtr = &localIndex)
			{
				return new LdlocByRefMatcher(localIndexPtr);
			}
		}

		unsafe static ILMatcher StlocCapture(out int localIndex)
		{
			localIndex = -1;
			fixed (int* localIndex2 = &localIndex)
			{
				return new StlocCapturingMatcher(localIndex2);
			}
		}

		unsafe static ILMatcher Stloc(in int localIndex)
		{
			fixed (int* localIndexPtr = &localIndex)
			{
				return new StlocByRefMatcher(localIndexPtr);
			}
		}

		static ILMatcher Branch()
		{
			return new BranchMatcher();
		}

		static ILMatcher Ldfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Field passed to ILMatcher.Ldfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Ldfld, field);
		}

		static ILMatcher Ldsfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Field passed to ILMatcher.Ldsfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Ldsfld, field);
		}

		static ILMatcher Stfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Field passed to ILMatcher.Stfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Stfld, field);
		}

		static ILMatcher Stsfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Field passed to ILMatcher.Stsfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Stsfld, field);
		}

		static ILMatcher Callvirt(MethodBase method, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (method == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Method passed to ILMatcher.Callvirt() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return OpcodeOperand(OpCodes.Callvirt, method);
		}

		static ILMatcher Call(MethodBase method, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (method == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Method passed to ILMatcher.Call() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return OpcodeOperand(OpCodes.Call, method);
		}

		static ILMatcher Newobj(ConstructorInfo ctor, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (ctor == null)
			{
				Plugin.Instance.Logger.LogWarning((object)$"Constructor passed to ILMatcher.Newobj() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return OpcodeOperand(OpCodes.Newobj, ctor);
		}

		static ILMatcher Predicate(Func<CodeInstruction, bool> predicate)
		{
			return new PredicateMatcher(predicate);
		}

		static ILMatcher Predicate(Func<FieldInfo, bool> predicate)
		{
			return new PredicateMatcher((CodeInstruction insn) => insn.operand is FieldInfo arg && predicate(arg));
		}
	}
	internal class NotMatcher : ILMatcher
	{
		private readonly ILMatcher matcher;

		public NotMatcher(ILMatcher matcher)
		{
			this.matcher = matcher;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			return !matcher.Matches(instruction);
		}
	}
	internal class OpcodeMatcher : ILMatcher
	{
		private readonly OpCode opcode;

		public OpcodeMatcher(OpCode opcode)
		{
			this.opcode = opcode;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			return instruction.opcode == opcode;
		}
	}
	internal class OpcodesMatcher : ILMatcher
	{
		private readonly OpCode[] opcodes;

		public OpcodesMatcher(OpCode[] opcodes)
		{
			this.opcodes = opcodes;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			return opcodes.Contains(instruction.opcode);
		}
	}
	internal class OpcodeOperandMatcher : ILMatcher
	{
		private readonly OpCode opcode;

		private readonly object operand;

		public OpcodeOperandMatcher(OpCode opcode, object operand)
		{
			this.opcode = opcode;
			this.operand = operand;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (instruction.opcode == opcode)
			{
				return instruction.operand == operand;
			}
			return false;
		}
	}
	internal class InstructionMatcher : ILMatcher
	{
		private readonly OpCode opcode = instruction.opcode;

		private readonly object operand = instruction.operand;

		private readonly Label[] labels = instruction.labels.ToArray();

		public InstructionMatcher(CodeInstruction instruction)
		{
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (instruction.opcode != opcode)
			{
				return false;
			}
			if (instruction.operand != operand)
			{
				return false;
			}
			if (instruction.labels.Count != labels.Length)
			{
				return false;
			}
			for (int i = 0; i < labels.Length; i++)
			{
				if (labels[i] != instruction.labels[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	internal class LdargMatcher : ILMatcher
	{
		private readonly int? arg;

		public LdargMatcher(int? arg)
		{
			this.arg = arg;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (!arg.HasValue)
			{
				return instruction.GetLdargIndex().HasValue;
			}
			return instruction.GetLdargIndex() == arg;
		}
	}
	internal class LdlocMatcher : ILMatcher
	{
		private readonly int? loc;

		public LdlocMatcher(int? loc)
		{
			this.loc = loc;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (!loc.HasValue)
			{
				return instruction.GetLdlocIndex().HasValue;
			}
			return instruction.GetLdlocIndex() == loc;
		}
	}
	internal class StlocMatcher : ILMatcher
	{
		private readonly int? loc;

		public StlocMatcher(int? loc)
		{
			this.loc = loc;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (!loc.HasValue)
			{
				return instruction.GetStlocIndex().HasValue;
			}
			return instruction.GetStlocIndex() == loc;
		}
	}
	internal class LdcI32Matcher : ILMatcher
	{
		private readonly int? value;

		public LdcI32Matcher(int? value)
		{
			this.value = value;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (!value.HasValue)
			{
				return instruction.GetLdcI32().HasValue;
			}
			return instruction.GetLdcI32() == value;
		}
	}
	internal class LdcF32Matcher : ILMatcher
	{
		private readonly float? value;

		public LdcF32Matcher(float? value)
		{
			this.value = value;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Ldc_R4)
			{
				if (value.HasValue)
				{
					return (float)instruction.operand == value.Value;
				}
				return true;
			}
			return false;
		}
	}
	internal class BranchMatcher : ILMatcher
	{
		public bool Matches(CodeInstruction instruction)
		{
			Label? label = default(Label?);
			return CodeInstructionExtensions.Branches(instruction, ref label);
		}
	}
	internal class PredicateMatcher : ILMatcher
	{
		private readonly Func<CodeInstruction, bool> predicate;

		public PredicateMatcher(Func<CodeInstruction, bool> predicate)
		{
			this.predicate = predicate;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			return predicate(instruction);
		}
	}
	internal class InstructionCapturingMatcher : ILMatcher
	{
		private readonly ILMatcher matcher;

		private readonly CodeInstruction variable;

		public InstructionCapturingMatcher(ILMatcher matcher, CodeInstruction variable)
		{
			this.matcher = matcher;
			this.variable = variable;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			bool flag = matcher.Matches(instruction);
			if (flag)
			{
				variable.opcode = instruction.opcode;
				variable.operand = instruction.operand;
				variable.blocks = instruction.blocks.ToList();
				variable.labels = instruction.labels.ToList();
			}
			return flag;
		}
	}
	internal class OperandCapturingMatcher<T> : ILMatcher where T : unmanaged
	{
		private readonly ILMatcher matcher;

		private unsafe readonly T* operand;

		public unsafe OperandCapturingMatcher(ILMatcher matcher, T* operand)
		{
			this.matcher = matcher;
			this.operand = operand;
			base..ctor();
		}

		public unsafe bool Matches(CodeInstruction instruction)
		{
			bool flag = matcher.Matches(instruction);
			if (flag)
			{
				*operand = (T)instruction.operand;
			}
			return flag;
		}
	}
	internal class LdlocCapturingMatcher : ILMatcher
	{
		private unsafe readonly int* localIndex;

		public unsafe LdlocCapturingMatcher(int* localIndex)
		{
			this.localIndex = localIndex;
			base..ctor();
		}

		public unsafe bool Matches(CodeInstruction instruction)
		{
			int? ldlocIndex = instruction.GetLdlocIndex();
			if (ldlocIndex.HasValue)
			{
				*localIndex = ldlocIndex.Value;
				return true;
			}
			return false;
		}
	}
	internal class LdlocByRefMatcher : ILMatcher
	{
		private unsafe readonly int* localIndexPtr;

		public unsafe LdlocByRefMatcher(int* localIndexPtr)
		{
			this.localIndexPtr = localIndexPtr;
			base..ctor();
		}

		public unsafe bool Matches(CodeInstruction instruction)
		{
			return instruction.GetLdlocIndex() == *localIndexPtr;
		}
	}
	internal class StlocCapturingMatcher : ILMatcher
	{
		private unsafe readonly int* localIndex;

		public unsafe StlocCapturingMatcher(int* localIndex)
		{
			this.localIndex = localIndex;
			base..ctor();
		}

		public unsafe bool Matches(CodeInstruction instruction)
		{
			int? stlocIndex = instruction.GetStlocIndex();
			if (stlocIndex.HasValue)
			{
				*localIndex = stlocIndex.Value;
				return true;
			}
			return false;
		}
	}
	internal class StlocByRefMatcher : ILMatcher
	{
		private unsafe readonly int* localIndexPtr;

		public unsafe StlocByRefMatcher(int* localIndexPtr)
		{
			this.localIndexPtr = localIndexPtr;
			base..ctor();
		}

		public unsafe bool Matches(CodeInstruction instruction)
		{
			return instruction.GetStlocIndex() == *localIndexPtr;
		}
	}
	internal class DebuggingMatcher : ILMatcher
	{
		private readonly ILMatcher matcher;

		public DebuggingMatcher(ILMatcher matcher)
		{
			this.matcher = matcher;
			base..ctor();
		}

		public bool Matches(CodeInstruction instruction)
		{
			bool flag = matcher.Matches(instruction);
			if (flag)
			{
				Plugin.Instance.Logger.LogInfo((object)$"{matcher} matched {instruction}");
			}
			return flag;
		}
	}
	internal static class InstructionUtilities
	{
		public static CodeInstruction MakeLdarg(int index)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (index < 256)
			{
				return (CodeInstruction)(index switch
				{
					0 => (object)new CodeInstruction(OpCodes.Ldarg_0, (object)null), 
					1 => (object)new CodeInstruction(OpCodes.Ldarg_1, (object)null), 
					2 => (object)new CodeInstruction(OpCodes.Ldarg_2, (object)null), 
					3 => (object)new CodeInstruction(OpCodes.Ldarg_3, (object)null), 
					_ => (object)new CodeInstruction(OpCodes.Ldarg_S, (object)index), 
				});
			}
			return new CodeInstruction(OpCodes.Ldarg, (object)index);
		}

		public static int PopCount(this CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Call || instruction.opcode == OpCodes.Callvirt || instruction.opcode == OpCodes.Newobj)
			{
				MethodBase methodBase = (MethodBase)instruction.operand;
				int num = methodBase.GetParameters().Length;
				if (!methodBase.IsStatic)
				{
					num++;
				}
				return num;
			}
			if (instruction.opcode == OpCodes.Ret)
			{
				return 1;
			}
			return instruction.opcode.StackBehaviourPop switch
			{
				StackBehaviour.Pop0 => 0, 
				StackBehaviour.Pop1 => 1, 
				StackBehaviour.Pop1_pop1 => 2, 
				StackBehaviour.Popi => 1, 
				StackBehaviour.Popi_pop1 => 2, 
				StackBehaviour.Popi_popi => 2, 
				StackBehaviour.Popi_popi8 => 2, 
				StackBehaviour.Popi_popi_popi => 3, 
				StackBehaviour.Popi_popr4 => 2, 
				StackBehaviour.Popi_popr8 => 2, 
				StackBehaviour.Popref => 1, 
				StackBehaviour.Popref_pop1 => 2, 
				StackBehaviour.Popref_popi => 2, 
				StackBehaviour.Popref_popi_popi => 3, 
				StackBehaviour.Popref_popi_popi8 => 3, 
				StackBehaviour.Popref_popi_popr4 => 3, 
				StackBehaviour.Popref_popi_popr8 => 3, 
				StackBehaviour.Popref_popi_popref => 3, 
				StackBehaviour.Varpop => throw new NotImplementedException($"Variable pop on non-call instruction '{instruction}'"), 
				StackBehaviour.Popref_popi_pop1 => 3, 
				_ => throw new NotSupportedException($"StackBehaviourPop of {instruction.opcode.StackBehaviourPop} was not a pop for instruction '{instruction}'"), 
			};
		}

		public static int PushCount(this CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Call || instruction.opcode == OpCodes.Callvirt || instruction.opcode == OpCodes.Newobj)
			{
				if (instruction.operand is MethodInfo methodInfo && methodInfo.ReturnType == typeof(void))
				{
					return 0;
				}
				return 1;
			}
			return instruction.opcode.StackBehaviourPush switch
			{
				StackBehaviour.Push0 => 0, 
				StackBehaviour.Push1 => 1, 
				StackBehaviour.Push1_push1 => 2, 
				StackBehaviour.Pushi => 1, 
				StackBehaviour.Pushi8 => 1, 
				StackBehaviour.Pushr4 => 1, 
				StackBehaviour.Pushr8 => 1, 
				StackBehaviour.Pushref => 1, 
				StackBehaviour.Varpush => throw new NotImplementedException($"Variable push on non-call instruction '{instruction}'"), 
				_ => throw new NotSupportedException($"StackBehaviourPush of {instruction.opcode.StackBehaviourPush} was not a push for instruction '{instruction}'"), 
			};
		}

		public static int? GetLdargIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldarg_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldarg_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldarg_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldarg_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldarg || opcode == OpCodes.Ldarg_S)
			{
				return instruction.operand as int?;
			}
			return null;
		}

		public static int? GetLdlocIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldloc_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldloc_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldloc_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldloc_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldloc || opcode == OpCodes.Ldloc_S)
			{
				return (instruction.operand as LocalBuilder)?.LocalIndex;
			}
			return null;
		}

		public static int? GetStlocIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Stloc_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Stloc_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Stloc_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Stloc_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Stloc || opcode == OpCodes.Stloc_S)
			{
				return (instruction.operand as LocalBuilder)?.LocalIndex;
			}
			return null;
		}

		public static CodeInstruction LdlocToStloc(this CodeInstruction instruction)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldloc_0)
			{
				return new CodeInstruction(OpCodes.Stloc_0, (object)null);
			}
			if (opcode == OpCodes.Ldloc_1)
			{
				return new CodeInstruction(OpCodes.Stloc_1, (object)null);
			}
			if (opcode == OpCodes.Ldloc_2)
			{
				return new CodeInstruction(OpCodes.Stloc_2, (object)null);
			}
			if (opcode == OpCodes.Ldloc_3)
			{
				return new CodeInstruction(OpCodes.Stloc_3, (object)null);
			}
			if (opcode == OpCodes.Ldloc || opcode == OpCodes.Ldloc_S)
			{
				return new CodeInstruction(OpCodes.Stloc, instruction.operand);
			}
			return null;
		}

		public static CodeInstruction StlocToLdloc(this CodeInstruction instruction)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Stloc_0)
			{
				return new CodeInstruction(OpCodes.Ldloc_0, (object)null);
			}
			if (opcode == OpCodes.Stloc_1)
			{
				return new CodeInstruction(OpCodes.Ldloc_1, (object)null);
			}
			if (opcode == OpCodes.Stloc_2)
			{
				return new CodeInstruction(OpCodes.Ldloc_2, (object)null);
			}
			if (opcode == OpCodes.Stloc_3)
			{
				return new CodeInstruction(OpCodes.Ldloc_3, (object)null);
			}
			if (opcode == OpCodes.Stloc || opcode == OpCodes.Stloc_S)
			{
				return new CodeInstruction(OpCodes.Ldloc, instruction.operand);
			}
			return null;
		}

		public static int? GetLdcI32(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldc_I4_M1)
			{
				return -1;
			}
			if (opcode == OpCodes.Ldc_I4_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldc_I4_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldc_I4_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldc_I4_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldc_I4_4)
			{
				return 4;
			}
			if (opcode == OpCodes.Ldc_I4_5)
			{
				return 5;
			}
			if (opcode == OpCodes.Ldc_I4_6)
			{
				return 6;
			}
			if (opcode == OpCodes.Ldc_I4_7)
			{
				return 7;
			}
			if (opcode == OpCodes.Ldc_I4_8)
			{
				return 8;
			}
			if (opcode == OpCodes.Ldc_I4_S)
			{
				return instruction.operand as sbyte?;
			}
			if (opcode == OpCodes.Ldc_I4)
			{
				return instruction.operand as int?;
			}
			return null;
		}
	}
}
namespace OpenBodyCams.Patches
{
	[HarmonyPatch(typeof(CentipedeAI))]
	internal class PatchCentipedeAI
	{
		internal static HashSet<CentipedeAI>[] CentipedesAttachedToPlayers;

		internal static bool HasWarnedClingingMismatch;

		public static void SetClingingAnimationPositionsForPlayer(PlayerControllerB player, Perspective perspective)
		{
			if (CentipedesAttachedToPlayers == null || player.playerClientId < 0 || (int)player.playerClientId >= CentipedesAttachedToPlayers.Length)
			{
				return;
			}
			foreach (CentipedeAI item in CentipedesAttachedToPlayers[player.playerClientId])
			{
				if ((Object)(object)item == (Object)null || ((EnemyAI)item).isEnemyDead || item.clingingToDeadBody)
				{
					continue;
				}
				if ((Object)(object)item.clingingToPlayer == (Object)null)
				{
					if (!HasWarnedClingingMismatch)
					{
						Plugin.Instance.Logger.LogWarning((object)$"{item} should be clinging to a player according to our hooks, but it is not.");
						HasWarnedClingingMismatch = true;
					}
					continue;
				}
				bool clingingToLocalClient = item.clingingToLocalClient;
				switch (perspective)
				{
				case Perspective.FirstPerson:
					item.clingingToLocalClient = true;
					break;
				case Perspective.ThirdPerson:
					item.clingingToLocalClient = false;
					break;
				}
				item.UpdatePositionToClingingPlayerHead();
				item.clingingToLocalClient = clingingToLocalClient;
			}
		}

		private static void EnsureCentipedesAttachedToPlayersArrayIsCorrectSize()
		{
			int num = StartOfRound.Instance.allPlayerScripts.Length;
			if (CentipedesAttachedToPlayers == null)
			{
				CentipedesAttachedToPlayers = new HashSet<CentipedeAI>[num];
			}
			else
			{
				if (CentipedesAttachedToPlayers.Length == num)
				{
					return;
				}
				Array.Resize(ref CentipedesAttachedToPlayers, num);
			}
			for (int i = 0; i < num; i++)
			{
				if (CentipedesAttachedToPlayers[i] == null)
				{
					CentipedesAttachedToPlayers[i] = new HashSet<CentipedeAI>();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("ClingToPlayer")]
		private static void ClingToPlayerPrefix(CentipedeAI __instance, PlayerControllerB playerScript)
		{
			CentipedeStartedClingingToPlayer(__instance, playerScript);
		}

		internal static void CentipedeStartedClingingToPlayer(CentipedeAI centipede, PlayerControllerB player)
		{
			EnsureCentipedesAttachedToPlayersArrayIsCorrectSize();
			if ((Object)(object)centipede.clingingToPlayer != (Object)null)
			{
				CentipedesAttachedToPlayers[centipede.clingingToPlayer.playerClientId].Remove(centipede);
			}
			CentipedesAttachedToPlayers[player.playerClientId].Add(centipede);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> UnclingFromPlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			ILInjector iLInjector = new ILInjector(instructions);
			iLInjector.Find(ILMatcher.Opcode(OpCodes.Ldnull), ILMatcher.Stfld(typeof(CentipedeAI).GetField("clingingToPlayer"), "UnclingFromPlayerTranspiler", "./Patches/PatchCentipedeAI.cs", 105));
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)"Failed to patch CentipedeAI.UnclingFromPlayer()");
				return instructions;
			}
			return iLInjector.Insert(new List<CodeInstruction>(2)
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(PatchCentipedeAI), "CentipedeStoppedClingingToPlayer", BindingFlags.Static | BindingFlags.NonPublic, new Type[1] { typeof(CentipedeAI) }))
			}).ReleaseInstructions();
		}

		internal static void CentipedeStoppedClingingToPlayer(CentipedeAI centipede)
		{
			EnsureCentipedesAttachedToPlayersArrayIsCorrectSize();
			if ((Object)(object)centipede.clingingToPlayer != (Object)null)
			{
				CentipedesAttachedToPlayers[centipede.clingingToPlayer.playerClientId].Remove(centipede);
			}
		}
	}
	[HarmonyPatch(typeof(DeadBodyInfo))]
	internal static class PatchDeadBodyInfo
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(DeadBodyInfo __instance)
		{
			Transform transform = ((Component)__instance).transform;
			PlayerControllerB playerScript = __instance.playerScript;
			TargetTracker.AddTrackersToTarget(transform, (playerScript != null) ? ((Component)playerScript).transform : null);
		}
	}
	[HarmonyPatch(typeof(EnemyAI))]
	internal static class PatchEnemyAI
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(EnemyAI __instance)
		{
			PlayerControllerB val = null;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val2 in allPlayerScripts)
			{
				if ((Object)(object)val2.redirectToEnemy == (Object)(object)__instance)
				{
					val = val2;
					break;
				}
			}
			TargetTracker.AddTrackersToTarget(((Component)((NetworkBehaviour)__instance).NetworkObject).transform, (val != null) ? ((Component)val).transform : null);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EnemyAI), "OnDestroy")]
		private static void OnDestroyPrefix(EnemyAI __instance)
		{
			FlowerSnakeEnemy val = (FlowerSnakeEnemy)(object)((__instance is FlowerSnakeEnemy) ? __instance : null);
			if (val != null)
			{
				PatchFlowerSnakeEnemy.FlowerSnakeStoppedClingingToPlayer(val);
				return;
			}
			CentipedeAI val2 = (CentipedeAI)(object)((__instance is CentipedeAI) ? __instance : null);
			if (val2 != null)
			{
				PatchCentipedeAI.CentipedeStoppedClingingToPlayer(val2);
			}
		}
	}
	internal static class PatchFixItemDropping
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(PlayerControllerB), "ThrowObjectClientRpc")]
		private static IEnumerable<CodeInstruction> ThrowObjectClientRpcTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase method)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			if (!Plugin.FixDroppedItemRotation.Value)
			{
				return instructions;
			}
			int num = Array.FindIndex(method.GetParameters(), (ParameterInfo p) => p.Name == "floorYRot") + 1;
			if (num < 1)
			{
				Plugin.Instance.Logger.LogWarning((object)"Dropped item patch transpiler failed to find the floorYRot argument.");
				return instructions;
			}
			ILInjector iLInjector = new ILInjector(instructions).Find(ILMatcher.Call(typeof(PlayerControllerB).GetMethod("SetObjectAsNoLongerHeld", new Type[5]
			{
				typeof(bool),
				typeof(bool),
				typeof(Vector3),
				typeof(GrabbableObject),
				typeof(int)
			}), "ThrowObjectClientRpcTranspiler", "./Patches/PatchFixItemDropping.cs", 33)).GoToPush(1);
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogWarning((object)"Dropped item patch transpiler failed to get the instructions pushing the floorYRot value.");
				return instructions;
			}
			return iLInjector.ReplaceLastMatch(new CodeInstruction(OpCodes.Ldarg, (object)num)).ReleaseInstructions();
		}
	}
	[HarmonyPatch(typeof(FlowerSnakeEnemy))]
	internal static class PatchFlowerSnakeEnemy
	{
		internal static HashSet<FlowerSnakeEnemy>[] FlowerSnakesAttachedToPlayers;

		internal static bool HasWarnedClingingMismatch;

		public static void SetClingingAnimationPositionsForPlayer(PlayerControllerB player, Perspective perspective)
		{
			if (FlowerSnakesAttachedToPlayers == null || player.playerClientId < 0 || (int)player.playerClientId >= FlowerSnakesAttachedToPlayers.Length)
			{
				return;
			}
			foreach (FlowerSnakeEnemy item in FlowerSnakesAttachedToPlayers[player.playerClientId])
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				if ((Object)(object)item.clingingToPlayer == (Object)null)
				{
					if (!HasWarnedClingingMismatch)
					{
						Plugin.Instance.Logger.LogWarning((object)$"{item} should be clinging to a player according to our hooks, but it is not.");
						HasWarnedClingingMismatch = true;
					}
					continue;
				}
				PlayerControllerB localPlayer = GameNetworkManager.Instance.localPlayerController;
				switch (perspective)
				{
				case Perspective.FirstPerson:
					GameNetworkManager.Instance.localPlayerController = player;
					break;
				case Perspective.ThirdPerson:
					GameNetworkManager.Instance.localPlayerController = StartOfRound.Instance.allPlayerScripts.First((PlayerControllerB p) => (Object)(object)p != (Object)(object)localPlayer);
					break;
				}
				item.SetClingingAnimationPosition();
				GameNetworkManager.Instance.localPlayerController = localPlayer;
			}
		}

		private static void EnsureFlowerSnakesAttachedToPlayersArrayIsCorrectSize()
		{
			int num = StartOfRound.Instance.allPlayerScripts.Length;
			if (FlowerSnakesAttachedToPlayers == null)
			{
				FlowerSnakesAttachedToPlayers = new HashSet<FlowerSnakeEnemy>[num];
			}
			else
			{
				if (FlowerSnakesAttachedToPlayers.Length == num)
				{
					return;
				}
				Array.Resize(ref FlowerSnakesAttachedToPlayers, num);
			}
			for (int i = 0; i < num; i++)
			{
				if (FlowerSnakesAttachedToPlayers[i] == null)
				{
					FlowerSnakesAttachedToPlayers[i] = new HashSet<FlowerSnakeEnemy>();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetClingToPlayer")]
		private static void SetClingToPlayerPrefix(FlowerSnakeEnemy __instance, PlayerControllerB playerToCling)
		{
			FlowerSnakeStartedClingingToPlayer(__instance, playerToCling);
		}

		internal static void FlowerSnakeStartedClingingToPlayer(FlowerSnakeEnemy flowerSnake, PlayerControllerB player)
		{
			EnsureFlowerSnakesAttachedToPlayersArrayIsCorrectSize();
			if ((Object)(object)flowerSnake.clingingToPlayer != (Object)null)
			{
				FlowerSnakesAttachedToPlayers[flowerSnake.clingingToPlayer.playerClientId].Remove(flowerSnake);
			}
			FlowerSnakesAttachedToPlayers[player.playerClientId].Add(flowerSnake);
		}

		[HarmonyPrefix]
		[HarmonyPatch("StopClingingOnLocalClient")]
		private static void StopClingingToPlayerPrefix(FlowerSnakeEnemy __instance)
		{
			FlowerSnakeStoppedClingingToPlayer(__instance);
		}

		internal static void FlowerSnakeStoppedClingingToPlayer(FlowerSnakeEnemy flowerSnake)
		{
			EnsureFlowerSnakesAttachedToPlayersArrayIsCorrectSize();
			if ((Object)(object)flowerSnake.clingingToPlayer != (Object)null)
			{
				FlowerSnakesAttachedToPlayers[flowerSnake.clingingToPlayer.playerClientId].Remove(flowerSnake);
			}
		}
	}
	[HarmonyPatch(typeof(HDRenderPipeline))]
	internal static class PatchHDRenderPipeline
	{
		internal static Action<ScriptableRenderContext, Camera> BeforeCameraCulling;

		internal static Action<ScriptableRenderContext, Camera> BeforeCameraRendering;

		private static ColorBufferFormat? originalColorBufferFormat;

		internal static bool ForceEnableAlpha
		{
			get
			{
				return originalColorBufferFormat.HasValue;
			}
			set
			{
				//IL_0005: 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)
				//IL_0016: 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_0050: 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_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				ref RenderPipelineSettings renderPipelineSettings = ref ((HDRenderPipelineAsset)GraphicsSettings.currentRenderPipeline).m_RenderPipelineSettings;
				ColorBufferFormat colorBufferFormat = renderPipelineSettings.colorBufferFormat;
				if (!value)
				{
					if (originalColorBufferFormat.HasValue)
					{
						renderPipelineSettings.colorBufferFormat = originalColorBufferFormat.Value;
						originalColorBufferFormat = null;
					}
				}
				else
				{
					if (!originalColorBufferFormat.HasValue)
					{
						originalColorBufferFormat = renderPipelineSettings.colorBufferFormat;
					}
					renderPipelineSettings.colorBufferFormat = (ColorBufferFormat)48;
				}
				if (renderPipelineSettings.colorBufferFormat != colorBufferFormat)
				{
					HDRenderPipeline val = (HDRenderPipeline)RenderPipelineManager.currentPipeline;
					bool flag = ((RenderPipelineSettings)(ref renderPipelineSettings)).SupportsAlpha();
					val.m_EnableAlpha = flag && ((GlobalPostProcessSettings)(ref renderPipelineSettings.postProcessSettings)).supportsAlpha;
					val.m_KeepAlpha = flag;
				}
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Render", new Type[]
		{
			typeof(ScriptableRenderContext),
			typeof(List<Camera>)
		})]
		private static IEnumerable<CodeInstruction> RenderTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			ILInjector iLInjector = new ILInjector(instructions);
			iLInjector.Find(ILMatcher.Call(Reflection.GetMethod(typeof(HDRenderPipeline), "PrepareAndCullCamera", BindingFlags.Instance | BindingFlags.NonPublic, new Type[7]
			{
				typeof(Camera),
				typeof(XRPass),
				typeof(bool),
				typeof(List<RenderRequest>),
				typeof(ScriptableRenderContext),
				typeof(RenderRequest).MakeByRefType(),
				typeof(CubemapFace)
			}), "RenderTranspiler", "./Patches/PatchHDRenderPipeline.cs", 72)).GoToPush(7).Forward(1);
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)"Failed to find the HDRP culling loop");
				return instructions;
			}
			iLInjector.InsertInPlace(new List<CodeInstruction>(3)
			{
				new CodeInstruction(OpCodes.Dup, (object)null),
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(PatchHDRenderPipeline), "BeforeCameraCullingHook", BindingFlags.Static | BindingFlags.NonPublic, new Type[2]
				{
					typeof(Camera),
					typeof(ScriptableRenderContext)
				}))
			});
			iLInjector.Find(ILMatcher.Ldloc(), ILMatcher.Ldloc(), ILMatcher.Callvirt(typeof(List<RenderRequest>).GetMethod("get_Item", new Type[1] { typeof(int) }), "RenderTranspiler", "./Patches/PatchHDRenderPipeline.cs", 98), ILMatcher.Stloc()).GoToMatchEnd();
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)"Failed to find the HDRP render loop");
				return instructions;
			}
			CodeInstruction item = iLInjector.GetRelativeInstruction(-1).StlocToLdloc();
			return iLInjector.InsertInPlace(new List<CodeInstruction>(3)
			{
				item,
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(PatchHDRenderPipeline), "BeforeCameraRenderingHook", BindingFlags.Static | BindingFlags.NonPublic, new Type[2]
				{
					typeof(RenderRequest),
					typeof(ScriptableRenderContext)
				}))
			}).ReleaseInstructions();
		}

		private static void BeforeCameraCullingHook(Camera camera, ScriptableRenderContext context)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			BeforeCameraCulling?.Invoke(context, camera);
		}

		private static void BeforeCameraRenderingHook(RenderRequest request, ScriptableRenderContext context)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			BeforeCameraRendering?.Invoke(context, request.hdCamera.camera);
		}
	}
	[HarmonyPatch(typeof(ManualCameraRenderer))]
	internal static class PatchManualCameraRenderer
	{
		[CompilerGenerated]
		private sealed class <updateMapTargetPostfix>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ManualCameraRenderer __instance;

			public IEnumerator result;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <updateMapTargetPostfix>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					SyncBodyCamToRadarMap.StartTargetTransitionForMap(__instance);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (result.MoveNext())
				{
					<>2__current = result.Current;
					<>1__state = 1;
					return true;
				}
				SyncBodyCamToRadarMap.UpdateBodyCamTargetForMap(__instance);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[IteratorStateMachine(typeof(<updateMapTargetPostfix>d__0))]
		[HarmonyPostfix]
		[HarmonyPatch("updateMapTarget")]
		private static IEnumerator updateMapTargetPostfix(IEnumerator result, ManualCameraRenderer __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <updateMapTargetPostfix>d__0(0)
			{
				result = result,
				__instance = __instance
			};
		}

		[HarmonyPostfix]
		[HarmonyPatch("SwitchScreenOn")]
		[HarmonyAfter(new string[] { "ShaosilGaming.GeneralImprovements" })]
		private static void SwitchScreenOnPostfix(ManualCameraRenderer __instance)
		{
			SyncBodyCamToRadarMap.UpdateBodyCamTargetForMap(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("MeetsCameraEnabledConditions")]
		private static void MeetsCameraEnabledConditionsPostfix(ManualCameraRenderer __instance, ref bool __result, PlayerControllerB player)
		{
			if (((__instance == ShipObjects.CameraReplacedByBodyCam) & __result) && !ShipObjects.MainBodyCam.IsBlanked)
			{
				__result = false;
			}
			if (__instance == ShipObjects.InternalCameraRenderer)
			{
				if (__result)
				{
					__result = ((Renderer)(object)__instance.mesh).IsVisibleToAnyCameraExcept(__instance.cam);
				}
			}
			else if (__instance == StartOfRound.Instance.mapScreen)
			{
				if (!__result && !ShipObjects.TwoRadarCamsPresent)
				{
					__result = ((Behaviour)ShipObjects.TerminalScript.terminalUIScreen).isActiveAndEnabled;
				}
			}
			else if (__instance == ShipObjects.ExternalCameraRenderer && ShipObjects.DoorScreenUsesExternalCamera && !__result && ((Renderer)ShipObjects.DoorScreenRenderer).isVisible && (player.isInHangarShipRoom || !StartOfRound.Instance.shipDoorsEnabled))
			{
				__result = ((Renderer)(object)ShipObjects.DoorScreenRenderer).IsVisibleToAnyCameraExcept(ShipObjects.InternalCameraRenderer.cam);
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("AddTransformAsTargetToRadar")]
		private static IEnumerable<CodeInstruction> AddTransformAsTargetToRadarTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase method)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			int index = method.GetFirstParameterIndexOfType(typeof(Transform)) + 1;
			return new ILInjector(instructions).GoToEnd().ReverseFind(ILMatcher.Opcode(OpCodes.Ret)).Insert(new List<CodeInstruction>(3)
			{
				InstructionUtilities.MakeLdarg(index),
				new CodeInstruction(OpCodes.Ldnull, (object)null),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(TargetTracker), "AddTrackersToTarget", BindingFlags.Static | BindingFlags.NonPublic, new Type[2]
				{
					typeof(Transform),
					typeof(Transform)
				}))
			})
				.ReleaseInstructions();
		}

		[HarmonyTranspiler]
		[HarmonyPatch("RemoveTargetFromRadar")]
		private static IEnumerable<CodeInstruction> RemoveTargetFromRadarTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			ILInjector iLInjector = new ILInjector(instructions).Find(ILMatcher.Ldarg(0), ILMatcher.Ldc(0), ILMatcher.Call(typeof(ManualCameraRenderer).GetMethod("SwitchRadarTargetForward", new Type[1] { typeof(bool) }), "RemoveTargetFromRadarTranspiler", "./Patches/PatchManualCameraRenderer.cs", 130));
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)$"Failed to find call to SwitchRadarTargetForward\n{new StackTrace()}");
				return instructions;
			}
			Label label = generator.DefineLabel();
			iLInjector.GetRelativeInstruction(1).opcode = OpCodes.Ldc_I4_1;
			return iLInjector.Insert(new List<CodeInstruction>(3)
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)typeof(NetworkBehaviour).GetMethod("get_IsOwner")),
				new CodeInstruction(OpCodes.Brfalse, (object)label)
			}).GoToMatchEnd().AddLabel(label)
				.ReleaseInstructions();
		}
	}
	[HarmonyPatch(typeof(HauntedMaskItem))]
	internal static class PatchHauntedMaskItem
	{
		[HarmonyPostfix]
		[HarmonyPatch("CreateMimicServerRpc")]
		private static void CreateMimicServerRpcPostfix()
		{
			BodyCamComponent.MarkTargetStatusChangedForAllBodyCams();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> waitForMimicEnemySpawnTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			return new ILInjector(instructions).GoToEnd().ReverseFind(ILMatcher.Opcode(OpCodes.Ldc_I4_0), ILMatcher.Opcode(OpCodes.Ret)).Insert(new List<CodeInstruction>(1)
			{
				new CodeInstruction(OpCodes.Call, (object)typeof(BodyCamComponent).GetMethod("MarkTargetStatusChangedForAllBodyCams", Array.Empty<Type>()))
			})
				.ReleaseInstructions();
		}
	}
	[HarmonyPatch(typeof(MaskedPlayerEnemy))]
	internal static class PatchMaskedPlayerEnemy
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public NetworkObjectReference maskedReference;

			public NetworkObject maskedObject;

			internal bool <SetPlayerMimicked>b__0()
			{
				return ((NetworkObjectReference)(ref maskedReference)).TryGet(ref maskedObject, (NetworkManager)null);
			}
		}

		[CompilerGenerated]
		private sealed class <SetPlayerMimicked>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObjectReference maskedReference;

			private <>c__DisplayClass3_0 <>8__1;

			public PlayerControllerB player;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetPlayerMimicked>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: 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_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass3_0();
					<>8__1.maskedReference = maskedReference;
					<>8__1.maskedObject = null;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => ((NetworkObjectReference)(ref <>8__1.maskedReference)).TryGet(ref <>8__1.maskedObject, (NetworkManager)null)));
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					MaskedPlayerEnemy redirectToEnemy = default(MaskedPlayerEnemy);
					if (!((Component)<>8__1.maskedObject).TryGetComponent<MaskedPlayerEnemy>(ref redirectToEnemy))
					{
						return false;
					}
					player.redirectToEnemy = (EnemyAI)(object)redirectToEnemy;
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("FinishKillAnimation")]
		private static void FinishKillAnimationPrefix(bool __0)
		{
			if (__0)
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams();
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> waitForMimicEnemySpawnTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			return new ILInjector(instructions).GoToEnd().ReverseFind(ILMatcher.Opcode(OpCodes.Ldc_I4_0), ILMatcher.Opcode(OpCodes.Ret)).Insert(new List<CodeInstruction>(1)
			{
				new CodeInstruction(OpCodes.Call, (object)typeof(BodyCamComponent).GetMethod("MarkTargetStatusChangedForAllBodyCams", Array.Empty<Type>()))
			})
				.ReleaseInstructions();
		}

		private static void StartCoroutineToSetPlayerMimicked(int playerID, in NetworkObjectReference maskedReference)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.FixMaskedConversionForClients.Value)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerID];
				((MonoBehaviour)val).StartCoroutine(SetPlayerMimicked(val, maskedReference));
			}
		}

		[IteratorStateMachine(typeof(<SetPlayerMimicked>d__3))]
		private static IEnumerator SetPlayerMimicked(PlayerControllerB player, NetworkObjectReference maskedReference)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetPlayerMimicked>d__3(0)
			{
				player = player,
				maskedReference = maskedReference
			};
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> waitForMimicEnemySpawnTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase method)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			int localIndex;
			ILInjector iLInjector = new ILInjector(instructions).Find(ILMatcher.Ldarg(0), ILMatcher.Predicate((CodeInstruction insn) => insn.opcode == OpCodes.Ldfld && ((FieldInfo)insn.operand).Name.EndsWith("state")), ILMatcher.StlocCapture(out localIndex), ILMatcher.Ldloc(in localIndex), ILMatcher.Opcode(OpCodes.Switch));
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)"Failed to find the switch statement in MaskedPlayerEnemy.waitForMimicEnemySpawn");
				return instructions;
			}
			Label[] array = (Label[])iLInjector.LastMatchedInstruction.operand;
			return iLInjector.FindLabel(array[0]).InsertAfterBranch(new List<CodeInstruction>(5)
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)method.DeclaringType.GetField("playerKilled")),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldflda, (object)method.DeclaringType.GetField("netObjectRef")),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(PatchMaskedPlayerEnemy), "StartCoroutineToSetPlayerMimicked", BindingFlags.Static | BindingFlags.NonPublic, new Type[2]
				{
					typeof(int),
					typeof(NetworkObjectReference).MakeByRefType()
				}))
			}).ReleaseInstructions();
		}
	}
	internal static class PatchModelDestructionDebugging
	{
		private static bool IsChildReferenced(GameObject obj)
		{
			Transform[] componentsInChildren = obj.GetComponentsInChildren<Transform>(true);
			Transform[] array = componentsInChildren;
			foreach (Transform val in array)
			{
				if (BodyCamComponent.AnyBodyCamHasReference(((Component)val).gameObject))
				{
					return true;
				}
			}
			Renderer[] componentsInChildren2 = obj.GetComponentsInChildren<Renderer>(true);
			Renderer[] array2 = componentsInChildren2;
			foreach (Renderer renderer in array2)
			{
				if (BodyCamComponent.AnyBodyCamHasReference(renderer))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsReferencedObject(Object obj)
		{
			if (obj == (Object)null)
			{
				return false;
			}
			Renderer val = (Renderer)(object)((obj is Renderer) ? obj : null);
			if (val != null)
			{
				return BodyCamComponent.AnyBodyCamHasReference(val);
			}
			GameObject val2 = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (val2 != null)
			{
				return IsChildReferenced(val2);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Object), "Destroy", new Type[]
		{
			typeof(Object),
			typeof(float)
		})]
		private static void DestroyingObject(Object obj, float t)
		{
			if (IsReferencedObject(obj))
			{
				Plugin.Instance.Logger.LogWarning((object)$"In {t} seconds, {obj.name} will be destroyed while it is referenced by a body cam.\n{new StackTrace(2)}");
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Object), "DestroyImmediate", new Type[]
		{
			typeof(Object),
			typeof(bool)
		})]
		private static void DestroyingObjectImmediately(Object obj)
		{
			if (IsReferencedObject(obj))
			{
				Plugin.Instance.Logger.LogWarning((object)$"Immediately destroying {obj.name} which is referenced by a body cam.\n{new StackTrace(2)}");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PatchPlayerControllerB
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(PlayerControllerB __instance)
		{
			TargetTracker.AddTrackersToTarget(((Component)((NetworkBehaviour)__instance).NetworkObject).transform);
		}

		[HarmonyFinalizer]
		[HarmonyPatch("ConnectClientToPlayerObject")]
		[HarmonyPriority(100)]
		private static void ConnectClientToPlayerObjectFinalizer()
		{
			ShipObjects.LateInitialization();
		}

		[HarmonyPostfix]
		[HarmonyPatch("KillPlayer")]
		private static void KillPlayerPostfix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner)
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams(((Component)__instance).transform);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("KillPlayerClientRpc")]
		private static void KillPlayerClientRpcPostfix(PlayerControllerB __instance)
		{
			if (!((NetworkBehaviour)__instance).IsOwner)
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams(((Component)__instance).transform);
			}
		}
	}
	[HarmonyPatch(typeof(RadarBoosterItem))]
	internal static class PatchRadarBoosterItem
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(RadarBoosterItem __instance)
		{
			Transform transform = ((Component)((NetworkBehaviour)__instance).NetworkObject).transform;
			PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
			TargetTracker.AddTrackersToTarget(transform, (playerHeldBy != null) ? ((Component)playerHeldBy).transform : null);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class PatchStartOfRound
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix()
		{
			ShipObjects.EarlyInitialization();
		}

		[HarmonyPostfix]
		[HarmonyPatch("ReviveDeadPlayers")]
		private static void ReviveDeadPlayersPostfix()
		{
			BodyCamComponent.MarkTargetStatusChangedForAllBodyCams();
		}

		[HarmonyPostfix]
		[HarmonyPatch("SyncShipUnlockablesClientRpc")]
		private static void SyncShipUnlockablesClientRpcPostfix()
		{
			ShipObjects.Overlay?.UpdateText();
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal static class PatchTerminal
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void AwakePostfix(Terminal __instance)
		{
			ShipObjects.TerminalScript = __instance;
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix()
		{
			ShipObjects.EarlyInitialization();
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class PatchTimeOfDay
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch("Start")]
		private static void StartPostfix()
		{
			BodyCamComponent.UpdateWeathers();
		}
	}
	[HarmonyPatch(typeof(UnlockableSuit))]
	internal static class PatchUnlockableSuit
	{
		[HarmonyTranspiler]
		[HarmonyPatch("SwitchSuitForPlayer")]
		private static IEnumerable<CodeInstruction> SwitchSuitForPlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			ILInjector iLInjector = new ILInjector(instructions).Find(ILMatcher.Call(Reflection.m_GameNetworkManager_get_Instance, "SwitchSuitForPlayerTranspiler", "./Patches/PatchUnlockableSuit.cs", 23), ILMatcher.Ldfld(Reflection.f_GameNetworkManager_localPlayerController, "SwitchSuitForPlayerTranspiler", "./Patches/PatchUnlockableSuit.cs", 24), ILMatcher.Ldarg(0), ILMatcher.Call(Reflection.m_Object_op_Inequality, "SwitchSuitForPlayerTranspiler", "./Patches/PatchUnlockableSuit.cs", 26), ILMatcher.Opcode(OpCodes.Brfalse));
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)$"Failed to find branch to spawn vanilla third-person suit cosmetics.{new StackTrace()}");
				return instructions;
			}
			Label label = (Label)iLInjector.LastMatchedInstruction.operand;
			iLInjector.RemoveLastMatch().FindLabel(label).ReverseFind(ILMatcher.Opcode(OpCodes.Br));
			if (!iLInjector.IsValid)
			{
				Plugin.Instance.Logger.LogError((object)$"Failed to find branch to spawn vanilla first-person suit cosmetics.{new StackTrace()}");
				return instructions;
			}
			Label label2 = (Label)iLInjector.LastMatchedInstruction.operand;
			return iLInjector.Remove().FindLabel(label2).Insert(new List<CodeInstruction>(2)
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)Reflection.GetMethod(typeof(PatchUnlockableSuit), "AfterCosmeticsSpawned", BindingFlags.Static | BindingFlags.NonPublic, new Type[1] { typeof(PlayerControllerB) }))
			})
				.ReleaseInstructions();
		}

		private static void AfterCosmeticsSpawned(PlayerControllerB player)
		{
			int num = 23;
			int num2 = 0;
			if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				int num3 = num2;
				num2 = num;
				num = num3;
			}
			foreach (GameObject item in Cosmetics.CollectVanillaFirstPersonCosmetics(player))
			{
				item.gameObject.layer = num;
			}
			foreach (GameObject item2 in Cosmetics.CollectVanillaThirdPersonCosmetics(player))
			{
				item2.gameObject.layer = num2;
			}
			BodyCamComponent.MarkTargetDirtyUntilRenderForAllBodyCams(((Component)player).transform);
		}
	}
	public static class Reflection
	{
		public static readonly MethodInfo m_StartOfRound_get_Instance = typeof(StartOfRound).GetMethod("get_Instance", Array.Empty<Type>());

		public static readonly FieldInfo f_StartOfRound_thisClientPlayerId = typeof(StartOfRound).GetField("thisClientPlayerId");

		public static readonly MethodInfo m_GameNetworkManager_get_Instance = typeof(GameNetworkManager).GetMethod("get_Instance", Array.Empty<Type>());

		public static readonly FieldInfo f_GameNetworkManager_localPlayerController = typeof(GameNetworkManager).GetField("localPlayerController");

		public static readonly MethodInfo m_Object_op_Equality = typeof(Object).GetMethod("op_Equality", new Type[2]
		{
			typeof(Object),
			typeof(Object)
		});

		public static readonly MethodInfo m_Object_op_Inequality = typeof(Object).GetMethod("op_Inequality", new Type[2]
		{
			typeof(Object),
			typeof(Object)
		});

		public static MethodInfo GetMethod(this Type type, string name, BindingFlags bindingFlags, Type[] parameters)
		{
			return type.GetMethod(name, bindingFlags, null, parameters, null);
		}

		public static int GetParameterIndex(this MethodBase method, string name)
		{
			ParameterInfo[] parameters = method.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i].Name == name)
				{
					return i;
				}
			}
			return -1;
		}

		public static int GetFirstParameterIndexOfType(this MethodBase method, Type type)
		{
			ParameterInfo[] parameters = method.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				if (parameters[i].ParameterType == type)
				{
					return i;
				}
			}
			return -1;
		}
	}
}
namespace OpenBodyCams.Overlay
{
	internal class OverlayManager : MonoBehaviour
	{
		private static OverlayManager[] Instances = Array.Empty<OverlayManager>();

		internal BodyCamComponent BodyCam;

		private Camera camera;

		private Canvas canvas;

		private TextMeshProUGUI textRenderer;

		private float baseFontSize;

		private Vector4 baseMargin;

		private bool renderThisFrame;

		private void Start()
		{
			//IL_00ac: 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)
			camera = ((Component)this).GetComponentInChildren<Camera>();
			CustomPassVolume val = ((Component)camera).gameObject.AddComponent<CustomPassVolume>();
			val.targetCamera = camera;
			HDAdditionalCameraData component = ((Component)camera).GetComponent<HDAdditionalCameraData>();
			component.customRenderingSettings = true;
			((BitArray128)(ref component.renderingPathCustomFrameSettingsOverrideMask.mask))[96u] = true;
			((FrameSettings)(ref component.renderingPathCustomFrameSettings)).SetEnabled((FrameSettingsField)96, false);
			canvas = ((Component)this).GetComponentInChildren<Canvas>();
			textRenderer = ((Component)canvas).GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)textRenderer).font = ((TMP_Text)StartOfRound.Instance.screenLevelDescription).font;
			baseFontSize = ((TMP_Text)textRenderer).fontSize;
			baseMargin = ((TMP_Text)textRenderer).margin;
			BodyCam.OnCameraStatusChanged += BodyCamStatusChanged;
			BodyCam.OnScreenPowerChanged += BodyCamScreenPowerChanged;
			OpenBodyCams.API.BodyCam.OnBodyCamReceiverBecameEnabled += UpdateText;
			OpenBodyCams.API.BodyCam.OnBodyCamReceiverBecameDisabled += UpdateText;
			CreateOverlayMesh();
			UpdatePreferences();
			UpdateText();
			OverlayManager[] instances = Instances;
			int num = 0;
			OverlayManager[] array = new OverlayManager[1 + instances.Length];
			ReadOnlySpan<OverlayManager> readOnlySpan = new ReadOnlySpan<OverlayManager>(instances);
			readOnlySpan.CopyTo(new Span<OverlayManager>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			array[num] = this;
			Instances = array;
		}

		internal static void BeforeRenderingAnyCamera(Camera camera)
		{
			OverlayManager[] instances = Instances;
			foreach (OverlayManager overlayManager in instances)
			{
				if ((Object)(object)overlayManager.camera == (Object)(object)camera)
				{
					PatchHDRenderPipeline.ForceEnableAlpha = true;
				}
			}
		}

		internal static void AfterRenderingAnyCamera(Camera camera)
		{
			OverlayManager[] instances = Instances;
			foreach (OverlayManager overlayManager in instances)
			{
				if ((Object)(object)overlayManager.camera == (Object)(object)camera)
				{
					PatchHDRenderPipeline.ForceEnableAlpha = false;
				}
			}
		}

		private void CreateOverlayMesh()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			GameObject val = Object.Instantiate<GameObject>(Plugin.Assets.LoadAsset<GameObject>("Assets/OpenBodyCams/Prefabs/BodyCamOverlayMesh.prefab"));
			Transform transform = val.transform;
			Transform transform2 = ((Component)BodyCam.MonitorRenderer).transform;
			transform.parent = transform2.parent;
			transform.localScale = transform2.localScale;
			transform.SetLocalPositionAndRotation(transform2.localPosition, transform2.localRotation);
			MeshFilter component = val.GetComponent<MeshFilter>();
			component.mesh = MeshUtils.CopySubmesh(((Component)BodyCam.MonitorRenderer).GetComponent<MeshFilter>().mesh, BodyCam.MonitorMaterialIndex);
		}

		private void Update()
		{
			((Behaviour)camera).enabled = renderThisFrame;
			renderThisFrame = false;
		}

		internal void UpdatePreferences()
		{
			//IL_0023: 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)
			((TMP_Text)textRenderer).fontSize = baseFontSize * Plugin.OverlayTextScale.Value;
			((TMP_Text)textRenderer).margin = baseMargin * Plugin.OverlayTextScale.Value;
			renderThisFrame = true;
		}

		private void BodyCamStatusChanged(CameraRenderingStatus _)
		{
			UpdateText();
		}

		private void BodyCamScreenPowerChanged(bool _)
		{
			UpdateText();
		}

		internal void UpdateText()
		{
			((Component)canvas).gameObject.SetActive(BodyCam.IsScreenPowered());
			((TMP_Text)textRenderer).text = GetText();
			((Behaviour)textRenderer).enabled = ((TMP_Text)textRenderer).text != "";
			renderThisFrame = true;
		}

		private string GetText()
		{
			if (ShipUpgrades.BodyCamUnlockable != null)
			{
				if (!ShipUpgrades.BodyCamUnlockable.hasBeenUnlockedByPlayer)
				{
					return Plugin.BuyAntennaText.Value.Replace("{price}", ShipUpgrades.BodyCamPrice.ToString(), StringComparison.OrdinalIgnoreCase);
				}
				if (!ShipUpgrades.BodyCamUnlockableIsPlaced)
				{
					return Plugin.AntennaStoredText.Value;
				}
			}
			return BodyCam.CameraStatus switch
			{
				CameraRenderingStatus.Rendering => Plugin.DefaultText.Value, 
				CameraRenderingStatus.TargetInvalid => Plugin.TargetInvalidText.Value, 
				CameraRenderingStatus.TargetDisabledOnShip => Plugin.TargetOnShipText.Value, 
				_ => "", 
			};
		}

		private void OnDestroy()
		{
			BodyCam.OnCameraStatusChanged -= BodyCamStatusChanged;
			BodyCam.OnScreenPowerChanged -= BodyCamScreenPowerChanged;
			OpenBodyCams.API.BodyCam.OnBodyCamReceiverBecameEnabled -= UpdateText;
			OpenBodyCams.API.BodyCam.OnBodyCamReceiverBecameDisabled -= UpdateText;
			Instances = Instances.Where((OverlayManager manager) => (Object)(object)manager != (Object)(object)this).ToArray();
		}
	}
}
namespace OpenBodyCams.Components
{
	internal class TargetTracker : MonoBehaviour
	{
		internal class TargetInfo
		{
			internal Transform root;

			internal AudioReverbTrigger lastTrigger;

			internal BitArray enabledWeathers = new BitArray(0);

			internal TargetInfo(Transform root, TargetInfo copyFrom = null)
			{
				this.root = root;
				if (copyFrom != null)
				{
					lastTrigger = copyFrom.lastTrigger;
					enabledWeathers = new BitArray(copyFrom.enabledWeathers);
				}
			}
		}

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

		private static readonly int triggersExclusionMask = ~LayerMask.GetMask(new string[2] { "Triggers", "InteractableObject" });

		private static readonly Material colliderMaterial = new Material(Shader.Find("HDRP/Lit"));

		private static readonly Dictionary<Transform, TargetInfo> targetReverbTriggers = new Dictionary<Transform, TargetInfo>();

		internal TargetInfo info;

		internal static bool CanCloneCollider(Collider collider)
		{
			if (collider is BoxCollider)
			{
				return true;
			}
			return false;
		}

		internal static GameObject CreateColliderObjectAsChildOf(Collider collider)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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)
			//IL_0055: 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)
			BoxCollider val = (BoxCollider)(object)((collider is BoxCollider) ? collider : null);
			if (val != null)
			{
				Vector3 size = val.size;
				if (size.y < 2.5f)
				{
					size.y = 2.5f;
				}
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				((Object)val2).name = "OpenBodyCams_TargetTracker";
				val2.transform.SetParent(((Component)collider).transform, false);
				val2.transform.localPosition = val.center;
				val2.transform.localScale = val.size;
				return val2;
			}
			return null;
		}

		internal static void AddTrackersToTarget(Transform target, Transform copyFrom = null)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00c2: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			if (targetReverbTriggers.ContainsKey(target))
			{
				return;
			}
			Collider componentInChildrenBreadthFirst = ((Component)(object)target).GetComponentInChildrenBreadthFirst<Collider>((Func<Collider, bool>)CanCloneCollider);
			if ((Object)(object)componentInChildrenBreadthFirst == (Object)null)
			{
				Plugin.Instance.Logger.LogWarning((object)("Radar target " + ((Object)target).name + " has no usable colliders"));
				return;
			}
			GameObject val = CreateColliderObjectAsChildOf(componentInChildrenBreadthFirst);
			val.layer = triggersLayer;
			Collider component = val.GetComponent<Collider>();
			component.excludeLayers = LayerMask.op_Implicit(triggersExclusionMask);
			GrabbableObject val2 = default(GrabbableObject);
			if (((Component)target).TryGetComponent<GrabbableObject>(ref val2))
			{
				Transform transform = val.transform;
				transform.localPosition -= new Vector3(0f, 0.625f, 0f);
				Transform transform2 = val.transform;
				transform2.localScale += new Vector3(0f, 1.25f, 0f);
			}
			val.GetComponent<Renderer>().sharedMaterial = colliderMaterial;
			val.GetComponent<Collider>().isTrigger = true;
			Rigidbody val3 = val.AddComponent<Rigidbody>();
			val3.isKinematic = true;
			TargetTracker targetTracker = val.AddComponent<TargetTracker>();
			targetTracker.info = new TargetInfo(target, ((Object)(object)copyFrom != (Object)null) ? GetCurrentInfo(copyFrom) : null);
			targetReverbTriggers.Add(target, targetTracker.info);
		}

		internal static TargetInfo GetCurrentInfo(Transform target)
		{
			if (!targetReverbTriggers.TryGetValue(target, out var value))
			{
				return null;
			}
			return value;
		}

		private void Start()
		{
			if ((Object)(object)info?.root == (Object)null)
			{
				Object.Destroy((Object)(object)this);
			}
			Collider val = default(Collider);
			if (!((Component)this).TryGetComponent<Collider>(ref val))
			{
				Plugin.Instance.Logger.LogError((object)$"{this} was added to an object without a collider.");
			}
		}

		private void OnTriggerStay(Collider other)
		{
			AudioReverbTrigger val = default(AudioReverbTrigger);
			if (((Component)other).TryGetComponent<AudioReverbTrigger>(ref val))
			{
				if ((Object)(object)info.lastTrigger != (Object)(object)val)
				{
					ChangeTriggers(val);
				}
				info.lastTrigger = val;
			}
		}

		private void ChangeTriggers(AudioReverbTrigger trigger)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected I4, but got Unknown
			if (trigger.usePreset != -1)
			{
				AudioReverbPresets val = Object.FindAnyObjectByType<AudioReverbPresets>();
				if (!((Object)(object)val == (Object)null) && trigger.usePreset >= 0 && trigger.usePreset < val.audioPresets.Length)
				{
					ChangeTriggers(val.audioPresets[trigger.usePreset]);
				}
				return;
			}
			BitArray enabledWeathers = info.enabledWeathers;
			TimeOfDay instance = TimeOfDay.Instance;
			enabledWeathers.Length = ((instance != null) ? instance.effects.Length : 0);
			if (trigger.disableAllWeather)
			{
				enabledWeathers.SetAll(value: false);
				return;
			}
			if (trigger.weatherEffect >= 0 && trigger.weatherEffect < enabledWeathers.Length)
			{
				enabledWeathers[trigger.weatherEffect] = trigger.effectEnabled;
			}
			if (trigger.enableCurrentLevelWeather)
			{
				int num = (int)TimeOfDay.Instance.currentLevelWeather;
				if (num >= 0 && num < enabledWeathers.Length)
				{
					enabledWeathers[num] = true;
				}
			}
		}

		private void OnDestroy()
		{
			if (info != null)
			{
				targetReverbTriggers.Remove(info.root);
			}
		}
	}
}
namespace OpenBodyCams.Compatibility
{
	internal static class AdvancedCompanyCompatibility
	{
		[CompilerGenerated]
		private sealed class <UpdateCosmeticsAfterCoroutine>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator __result;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateCosmeticsAfterCoroutine>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
				}
				try
				{
					if (!__result.MoveNext())
					{
						goto IL_0073;
					}
				}
				catch (Exception ex)
				{
					Plugin.Instance.Logger.LogError((object)"AdvancedCompany encountered an error in a coroutine:");
					Plugin.Instance.Logger.LogError((object)ex);
					goto IL_0073;
				}
				<>2__current = __result.Current;
				<>1__state = 1;
				return true;
				IL_0073:
				BodyCamComponent.MarkTargetDirtyUntilRenderForAllBodyCams();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool Initialize(Harmony harmony)
		{
			try
			{
				return InitializeImpl(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)ex);
				return false;
			}
		}

		internal static bool InitializeImpl(Harmony harmony)
		{
			Type typeFromHandle = typeof(Player);
			(string, Type[])[] array = new(string, Type[])[6]
			{
				("SetCosmetics", new Type[2]
				{
					typeof(string[]),
					typeof(bool)
				}),
				("AddCosmetic", new Type[1] { typeof(string) }),
				("ReequipHead", Array.Empty<Type>()),
				("ReequipBody", Array.Empty<Type>()),
				("ReequipFeet", Array.Empty<Type>()),
				("UnequipAll", Array.Empty<Type>())
			};
			MethodInfo method = typeof(AdvancedCompanyCompatibility).GetMethod("AfterEquipmentChange", BindingFlags.Static | BindingFlags.NonPublic);
			(string, Type[])[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				(string, Type[]) tuple = array2[i];
				string item = tuple.Item1;
				Type[] item2 = tuple.Item2;
				MethodInfo method2 = typeFromHandle.GetMethod(item, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, item2, null);
				if ((object)method2 == null)
				{
					Plugin.Instance.Logger.LogWarning((object)("Failed to find " + typeFromHandle.FullName + "." + item + " to apply postfix."));
					return false;
				}
				harmony.CreateProcessor((MethodBase)method2).AddPostfix(method).Patch();
			}
			harmony.CreateProcessor((MethodBase)typeof(LightShoeRGB).GetMethod("LiftCurse", BindingFlags.Instance | BindingFlags.NonPublic)).AddPostfix(typeof(AdvancedCompanyCompatibility).GetMethod("UpdateCosmeticsAfterCoroutine", BindingFlags.Static | BindingFlags.NonPublic)).Patch();
			return true;
		}

		private static void AddChildren(IEnumerable<GameObject> objects, List<GameObject> toList)
		{
			foreach (GameObject @object in objects)
			{
				if (!((Object)(object)@object == (Object)null))
				{
					Cosmetics.CollectChildCosmetics(@object, toList);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void CollectCosmetics(PlayerControllerB player, List<GameObject> thirdPersonCosmetics)
		{
			Player player2 = Player.GetPlayer(player);
			AddChildren(player2.AppliedCosmetics.Values, thirdPersonCosmetics);
			thirdPersonCosmetics.AddRange(player2.AppliedCosmetics.Values);
			GameObject[] equipmentItemsHead = player2.EquipmentItemsHead;
			if (equipmentItemsHead != null)
			{
				AddChildren(equipmentItemsHead, thirdPersonCosmetics);
			}
			GameObject[] equipmentItemsBody = player2.EquipmentItemsBody;
			if (equipmentItemsBody != null)
			{
				AddChildren(equipmentItemsBody, thirdPersonCosmetics);
			}
			GameObject[] equipmentItemsFeet = player2.EquipmentItemsFeet;
			if (equipmentItemsFeet != null)
			{
				AddChildren(equipmentItemsFeet, thirdPersonCosmetics);
			}
			if (Object.op_Implicit((Object)(object)player2.HeadMount))
			{
				Cosmetics.CollectChildCosmetics(player2.HeadMount, thirdPersonCosmetics);
			}
		}

		private static void AfterEquipmentChange()
		{
			BodyCamComponent.MarkTargetDirtyUntilRenderForAllBodyCams();
		}

		[IteratorStateMachine(typeof(<UpdateCosmeticsAfterCoroutine>d__5))]
		private static IEnumerator UpdateCosmeticsAfterCoroutine(IEnumerator __result)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateCosmeticsAfterCoroutine>d__5(0)
			{
				__result = __result
			};
		}
	}
	internal static class GeneralImprovementsCompatibility
	{
		internal readonly struct GeneralImprovementsMonitorSpecification
		{
			internal readonly Renderer Renderer;

			internal readonly int MaterialIndex;

			internal readonly Material OriginalMaterial;

			public GeneralImprovementsMonitorSpecification(Renderer renderer, int materialIndex, Material originalMaterial)
			{
				Renderer = renderer;
				MaterialIndex = materialIndex;
				OriginalMaterial = originalMaterial;
			}
		}

		internal static bool GeneralImprovementsEnabled => Chainloader.PluginInfos.ContainsKey("ShaosilGaming.GeneralImprovements");

		internal static bool BetterMonitorsEnabled
		{
			get
			{
				if (GeneralImprovementsEnabled && BetterMonitorsEnabledWithAPI())
				{
					return true;
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool BetterMonitorsEnabledWithAPI()
		{
			MonitorInfo monitorAtIndex = MonitorsAPI.GetMonitorAtIndex(0);
			return (Object)(object)((monitorAtIndex != null) ? monitorAtIndex.MeshRenderer : null) != (Object)null;
		}

		internal static GeneralImprovementsMonitorSpecification? GetMonitorForID(int id)
		{
			if (!BetterMonitorsEnabled)
			{
				return null;
			}
			if (id < 0)
			{
				GeneralImprovementsMonitorSpecification? result = null;
				int num = 0;
				while (true)
				{
					GeneralImprovementsMonitorSpecification? monitorForIDWithAPI = GetMonitorForIDWithAPI(num);
					if (!monitorForIDWithAPI.HasValue)
					{
						break;
					}
					result = monitorForIDWithAPI;
					num++;
				}
				return result;
			}
			return GetMonitorForIDWithAPI(id);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static GeneralImprovementsMonitorSpecification? GetMonitorForIDWithAPI(int id)
		{
			MonitorInfo monitorAtIndex = MonitorsAPI.GetMonitorAtIndex(id);
			if (monitorAtIndex == null)
			{
				return null;
			}
			return new GeneralImprovementsMonitorSpecification((Renderer)(object)monitorAtIndex.MeshRenderer, monitorAtIndex.ScreenMaterialIndex, monitorAtIndex.AssignedMaterial);
		}
	}
	internal static class LethalVRMCompatibility
	{
		private static IEnumerable vrmInstances;

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool Initialize(Harmony harmony)
		{
			try
			{
				return InitializeImpl(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)ex);
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool InitializeImpl(Harmony harmony)
		{
			GameObject obj = GameObject.Find("LethalVRM Manager");
			LethalVRMManager val = ((obj != null) ? obj.GetComponent<LethalVRMManager>() : null);
			if (val == null)
			{
				Plugin.Instance.Logger.LogWarning((object)"Failed to find the LethalVRMManager instance.");
				return false;
			}
			vrmInstances = val.instances;
			if (vrmInstances == null)
			{
				Plugin.Instance.Logger.LogWarning((object)"Failed to get the value of the LethalVRMManager.instances field.");
				return false;
			}
			MethodInfo method = typeof(LethalVRMManager).GetMethod("LoadModelToPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo method2 = method.GetCustomAttribute<AsyncStateMachineAttribute>().StateMachineType.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.NonPublic);
			harmony.CreateProcessor((MethodBase)method2).AddTranspiler(typeof(LethalVRMCompatibility).GetMethod("LoadModelToPlayerTranspiler", BindingFlags.Static | BindingFlags.NonPublic)).Patch();
			return true;
		}

		private static IEnumerable<CodeInstruction> LoadModelToPlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			MethodInfo method = typeof(BodyCamComponent).GetMethod("MarkTargetDirtyUntilRenderForAllBodyCams", Array.Empty<Type>());
			list.Insert(list.Count() - 2, new CodeInstruction(OpCodes.Call, (object)method));
			return list;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static IEnumerable<GameObject> CollectCosmetics(PlayerControllerB player, List<GameObject> thirdPersonCosmetics)
		{
			foreach (LethalVRMInstance item in (ICollection<LethalVRMInstance>)vrmInstances)
			{
				if (item == null || item.PlayerControllerB != player)
				{
					continue;
				}
				foreach (Renderer renderer in item.renderers)
				{
					thirdPersonCosmetics.Add(((Component)renderer).gameObject);
				}
			}
			return Array.Empty<GameObject>();
		}
	}
	internal static class ModelReplacementAPICompatibility
	{
		private static MethodInfo m_UpdateModelReplacement;

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool Initialize(Harmony harmony)
		{
			try
			{
				return InitializeImpl(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)ex);
				return false;
			}
		}

		internal static bool InitializeImpl(Harmony harmony)
		{
			MethodInfo method = typeof(ViewStateManager).GetMethod("ReportBodyReplacementAddition", new Type[1] { typeof(BodyReplacementBase) });
			if ((object)method == null)
			{
				Plugin.Instance.Logger.LogInfo((object)"ModelReplacementAPI is installed, but the `ViewStateManager.ReportBodyReplacementAddition()` method was not found.");
				return false;
			}
			MethodInfo method2 = typeof(ModelReplacementAPI).GetMethod("RemovePlayerModelReplacement", new Type[1] { typeof(PlayerControllerB) });
			if ((object)method2 == null)
			{
				Plugin.Instance.Logger.LogInfo((object)"ModelReplacementAPI is installed, but the `ModelReplacementAPI.RemovePlayerModelReplacement()` method was not found.");
				return false;
			}
			m_UpdateModelReplacement = typeof(ModelReplacementAPICompatibility).GetMethod("UpdateModelReplacement", new Type[1] { typeof(ViewStateManager) });
			harmony.CreateProcessor((MethodBase)method).AddPostfix(m_UpdateModelReplacement).Patch();
			MethodInfo method3 = typeof(ModelReplacementAPICompatibility).GetMethod("RemoveModelReplacementTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			harmony.CreateProcessor((MethodBase)method2).AddTranspiler(method3).Patch();
			m_UpdateModelReplacement = null;
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void CollectCosmetics(PlayerControllerB player, List<GameObject> thirdPersonCosmetics, List<GameObject> firstPersonCosmetics, ref bool hasViewmodelReplacement)
		{
			BodyReplacementBase val = ((ManagerBase)(((Component)player).GetComponent<ViewStateManager>()?)).bodyReplacement;
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)val.replacementModel != (Object)null)
				{
					Cosmetics.CollectChildCosmetics(val.replacementModel, thirdPersonCosmetics);
				}
				if ((Object)(object)val.replacementViewModel != (Object)null)
				{
					Cosmetics.CollectChildCosmetics(val.replacementViewModel, firstPersonCosmetics);
					hasViewmodelReplacement = true;
				}
			}
		}

		public static void UpdateModelReplacement(ViewStateManager __instance)
		{
			BodyCamComponent.MarkTargetDirtyUntilRenderForAllBodyCams(((Component)((ManagerBase)__instance).controller).transform);
		}

		private static IEnumerable<CodeInstruction> RemoveModelReplacementTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo m_Object_Destroy = typeof(Object).GetMethod("Destroy", new Type[1] { typeof(Object) });
			MethodInfo methodInfo = typeof(Component).GetMethods().First((MethodInfo method) => method.Name == "GetComponent" && method.IsGenericMethod).MakeGenericMethod(typeof(ViewStateManager));
			MethodInfo method2 = typeof(ViewStateManager).GetMethod("ReportBodyReplacementRemoval", Array.Empty<Type>());
			int num = list.FindIndex((CodeInstruction insn) => CodeInstructionExtensions.Calls(insn, m_Object_Destroy));
			list.InsertRange(num + 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)methodInfo),
				new CodeInstruction(OpCodes.Dup, (object)null),
				new CodeInstruction(OpCodes.Call, (object)method2),
				new CodeInstruction(OpCodes.Call, (object)m_UpdateModelReplacement)
			}));
			return list;
		}
	}
	internal static class ModGUIDs
	{
		public const string AdvancedCompany = "com.potatoepet.AdvancedCompany";

		public const string GeneralImprovements = "ShaosilGaming.GeneralImprovements";

		public const string LethalLib = "evaisa.lethallib";

		public const string LethalVRM = "Ooseykins.LethalVRM";

		public const string ModelReplacementAPI = "meow.ModelReplacementAPI";

		public const string MoreCompany = "me.swipez.melonloader.morecompany";

		public const string ReservedItemSlotCore = "FlipMods.ReservedItemSlotCore";
	}
	internal static class MoreCompanyCompatibility
	{
		private static readonly MethodInfo m_CosmeticApplication_UpdateAllCosmeticVisibilities = typeof(CosmeticApplication).GetMethod("UpdateAllCosmeticVisibilities", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool Initialize(Harmony harmony)
		{
			try
			{
				if (Chainloader.PluginInfos["me.swipez.melonloader.morecompany"].Metadata.Version < new Version(1, 11, 0))
				{
					Plugin.Instance.Logger.LogError((object)"The MoreCompany cosmetics compatibility mode requires v1.11.0+. Please upgrade MoreCompany.");
					return false;
				}
				return InitializeImpl(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)ex);
				return true;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool InitializeImpl(Harmony harmony)
		{
			try
			{
				ApplyLocalCosmeticsPatch(harmony);
				Plugin.Instance.Logger.LogInfo((object)"Patched MoreCompany to spawn cosmetics on the local player.");
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)"Failed to patch MoreCompany to spawn cosmetics on the local player.");
				Plugin.Instance.Logger.LogError((object)"The MoreCompany cosmetics compatibility will continue to function, but only other clients' cosmetics will be visible.");
				Plugin.Instance.Logger.LogError((object)ex);
			}
			harmony.CreateProcessor((MethodBase)m_CosmeticApplication_UpdateAllCosmeticVisibilities).AddPostfix(typeof(MoreCompanyCompatibility).GetMethod("UpdateCosmetics", BindingFlags.Static | BindingFlags.NonPublic)).Patch();
			return true;
		}

		private static void UpdateCosmetics(Component __instance)
		{
			BodyCamComponent.MarkAnyParentDirtyUntilRenderForAllBodyCams(__instance.transform);
		}

		private static void ApplyLocalCosmeticsPatch(Harmony harmony)
		{
			harmony.CreateProcessor((MethodBase)m_CosmeticApplication_UpdateAllCosmeticVisibilities).AddTranspiler(typeof(MoreCompanyCompatibility).GetMethod("UpdateAllCosmeticVisibilitiesPostfix", BindingFlags.Static | BindingFlags.NonPublic)).Patch();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(CosmeticApplication), "UpdateAllCosmeticVisibilities")]
		private static IEnumerable<CodeInstruction> UpdateAllCosmeticVisibilitiesPostfix(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase method)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			int num = method.GetParameterIndex("isLocalPlayer") + 1;
			if (num == 0)
			{
				throw new Exception("Failed to find the 'isLocalPlayer' parameter of UpdateAllCosmeticVisibilities");
			}
			ILInjector iLInjector = new ILInjector(instructions).Find(ILMatcher.Opcode(OpCodes.Brfalse), ILMatcher.Ldarg(num), ILMatcher.Ldc(0), ILMatcher.Opcode(OpCodes.Ceq), ILMatcher.Opcode(OpCodes.Br), ILMatcher.Ldc(0));
			if (!iLInjector.IsValid)
			{
				throw new Exception("Failed to find check for local player when spawning cosmetics");
			}
			iLInjector.RemoveLastMatch();
			iLInjector.Find(ILMatcher.Ldloc(), ILMatcher.Callvirt(AccessTools.DeclaredPropertyGetter(typeof(Component), "gameObject"), "UpdateAllCosmeticVisibilitiesPostfix", "./Compatibility/MoreCompanyCompatibility.cs", 109), ILMatcher.Ldloc(), ILMatcher.Callvirt(typeof(GameObject).GetMethod("SetActive"), "UpdateAllCosmeticVisibilitiesPostfix", "./Compatibility/MoreCompanyCompatibility.cs", 111));
			if (!iLInjector.IsValid)
			{
				throw new Exception("Failed to find setting active state of cosmetics");
			}
			CodeInstruction item = iLInjector.Instruction.Clone();
			Label label = generator.DefineLabel();
			return iLInjector.GoToMatchEnd().AddLabel(label).InsertInPlace(new List<CodeInstruction>(4)
			{
				InstructionUtilities.MakeLdarg(num),
				new CodeInstruction(OpCodes.Brfalse, (object)label),
				item,
				new CodeInstruction(OpCodes.Call, (object)typeof(MoreCompanyCompatibility).GetMethod("SetLocalCosmeticsLayers", BindingFlags.Static | BindingFlags.NonPublic))
			})
				.ReleaseInstructions();
		}

		private static void SetLocalCosmeticsLayers(Component root)
		{
			Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>();
			foreach (Transform val in componentsInChildren)
			{
				((Component)val).gameObject.layer = 23;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void CollectCosmetics(PlayerControllerB player, List<GameObject> thirdPersonCosmetics)
		{
			CosmeticApplication[] componentsInChildren = ((Component)player).GetComponentsInChildren<CosmeticApplication>();
			foreach (CosmeticApplication val in componentsInChildren)
			{
				foreach (CosmeticInstance spawnedCosmetic in val.spawnedCosmetics)
				{
					if (!((Object)(object)spawnedCosmetic == (Object)null))
					{
						Cosmetics.CollectChildCosmetics(((Component)spawnedCosmetic).gameObject, thirdPersonCosmetics);
					}
				}
			}
		}
	}
	internal static class ReservedItemSlotsCompatibility
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool Initialize(Harmony harmony)
		{
			try
			{
				return InitializeImpl(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Instance.Logger.LogError((object)ex);
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool InitializeImpl(Harmony harmony)
		{
			Type typeFromHandle = typeof(ReservedItemsPatcher);
			(string, Type[])[] array = new(string, Type[])[3]
			{
				("OnEquipReservedItem", new Type[1] { typeof(GrabbableObject) }),
				("OnPocketReservedItem", new Type[1] { typeof(GrabbableObject) }),
				("ResetReservedItemLayer", new Type[1] { typeof(GrabbableObject) })
			};
			MethodInfo method = typeof(ReservedItemSlotsCompatibility).GetMethod("MarkDirtyAtEndOfMethod", BindingFlags.Static | BindingFlags.NonPublic);
			(string, Type[])[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				(string, Type[]) tuple = array2[i];
				string item = tuple.Item1;
				Type[] item2 = tuple.Item2;
				MethodInfo method2 = typeFromHandle.GetMethod(item, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, item2, null);
				if ((object)method2 == null)
				{
					Plugin.Instance.Logger.LogWarning((object)("Failed to find " + typeFromHandle.FullName + "." + item + " to apply postfix."));
					return false;
				}
				harmony.CreateProcessor((MethodBase)method2).AddTranspiler(method).Patch();
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> MarkDirtyAtEndOfMethod(IEnumerable<CodeInstruction> instructions, MethodBase method)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			return new ILInjector(instructions).GoToEnd().ReverseFind(ILMatcher.Opcode(OpCodes.Ret)).ReverseFind(ILMatcher.Not(ILMatcher.Opcode(OpCodes.Nop)))
				.GoToMatchEnd()
				.InsertInPlace(new List<CodeInstruction>(2)
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)typeof(ReservedItemSlotsCompatibility).GetMethod("MarkCosmeticsDirty", BindingFlags.Static | BindingFlags.NonPublic))
				})
				.ReleaseInstructions();
		}

		private static void MarkCosmeticsDirty(GrabbableObject item)
		{
			if ((Object)(object)item.playerHeldBy != (Object)null)
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams(((Component)item.playerHeldBy).transform);
			}
			else
			{
				BodyCamComponent.MarkTargetStatusChangedForAllBodyCams();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void CollectCosmetics(PlayerControllerB player, List<GameObject> thirdPersonCosmetics)
		{
			if (!ReservedPlayerData.allPlayerData.TryGetValue(player, out var value))
			{
				return;
			}
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if (player.currentItemSlot == i || !value.IsReservedItemSlot(i))
				{
					continue;
				}
				GrabbableObject val = player.ItemSlots[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				MeshRenderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val2 in componentsInChildren)
				{
					GameObject gameObject = ((Component)val2).gameObject;
					if (!gameObject.CompareTag("DoNotSet") && !gameObject.CompareTag("InteractTrigger"))
					{
						int layer = gameObject.layer;
						if (layer != 14 && layer != 22)
						{
							thirdPersonCosmetics.Add(gameObject);
						}
					}
				}
			}
		}
	}
}
namespace OpenBodyCams.API
{
	public static class BodyCam
	{
		public delegate void MainBodyCamStatusUpdate();

		public delegate void BodyCamStatusUpdate(MonoBehaviour bodyCam);

		public delegate GameObject[] GetPlayerFirstPersonCosmetics(PlayerControllerB player, out bool hasViewmodelReplacement);

		public delegate GameObject[] GetPlayerThirdPersonCosmetics(PlayerControllerB player);

		public static bool BodyCamsAreAvailable
		{
			get
			{
				if (ShipUpgrades.BodyCamUnlockable == null)
				{
					return true;
				}
				return ShipUpgrades.BodyCamUnlockableIsPlaced;
			}
		}

		public static BodyCamComponent? MainBodyCam => ShipObjects.MainBodyCam;

		public static event MainBodyCamStatusUpdate? OnBodyCamReceiverBecameEnabled;

		public static event MainBodyCamStatusUpdate? OnBodyCamReceiverBecameDisabled;

		public static event BodyCamStatusUpdate? OnBodyCamInstantiated;

		public static event BodyCamStatusUpdate? OnBodyCamDestroyed;

		public static event GetPlayerFirstPersonCosmetics? PlayerFirstPersonCosmeticsGetters;

		public static event GetPlayerThirdPersonCosmetics? PlayerThirdPersonCosmeticsGetters;

		public static BodyCamComponent CreateBodyCam(GameObject objectToAttachComponentTo, Renderer? displayedOnRenderer, int displayMaterialIndex, ManualCameraRenderer? mapRendererToSyncTo = null)
		{
			if ((Object)(object)mapRendererToSyncTo != (Object)null && (Object)(object)mapRendererToSyncTo.cam != (Object)(object)mapRendererToSyncTo.mapCamera)
			{
				throw new ArgumentException("The camera must be a map renderer", "mapRendererToSyncTo");
			}
			BodyCamComponent bodyCamComponent = objectToAttachComponentTo.AddComponent<BodyCamComponent>();
			if ((Object)(object)displayedOnRenderer != (Object)null)
			{
				bodyCamComponent.MonitorRenderer = displayedOnRenderer;
				bodyCamComponent.MonitorMaterialIndex = displayMaterialIndex;
				bodyCamComponent.MonitorOffMaterial = displayedOnRenderer.sharedMaterials[displayMaterialIndex];
			}
			bodyCamComponent.SetTargetToPlayer(((IEnumerable<PlayerControllerB>)StartOfRound.Instance?.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB player) => player.isPlayerControlled)));
			if ((Object)(object)mapRendererToSyncTo != (Object)null)
			{
				SyncBodyCamToRadarMap syncBodyCamToRadarMap = objectToAttachComponentTo.AddComponent<SyncBodyCamToRadarMap>();
				syncBodyCamToRadarMap.BodyCam = bodyCamComponent;
				syncBodyCamToRadarMap.MapRenderer = mapRendererToSyncTo;
			}
			return bodyCamComponent;
		}

		public static BodyCamComponent CreateBodyCam(GameObject objectToAttachComponentTo, Material screenMaterial, ManualCameraRenderer? mapRendererToSyncTo = null)
		{
			BodyCamComponent bodyCamComponent = CreateBodyCam(objectToAttachComponentTo, null, -1, mapRendererToSyncTo);
			bodyCamComponent.MonitorOnMaterial = screenMaterial;
			return bodyCamComponent;
		}

		internal static void BodyCamReceiverBecameEnabled()
		{
			BodyCam.OnBodyCamReceiverBecameEnabled?.Invoke();
		}

		internal static void BodyCamReceiverBecameDisabled()
		{
			BodyCam.OnBodyCamReceiverBecameDisabled?.Invoke();
		}

		internal static void BodyCamInstantiated(BodyCamComponent bodyCam)
		{
			BodyCam.OnBodyCamInstantiated?.Invoke((MonoBehaviour)(object)bodyCam);
		}

		internal static void BodyCamDestroyed(BodyCamComponent bodyCam)
		{
			BodyCam.OnBodyCamDestroyed?.Invoke((MonoBehaviour)(object)bodyCam);
		}

		internal static void CollectPlayerFirstPersonCosmetics(PlayerControllerB player, List<GameObject> cosmetics, ref bool hasViewmodelReplacement)
		{
			if (BodyCam.PlayerFirstPersonCosmeticsGetters == null)
			{
				return;
			}
			Delegate[] invocationList = BodyCam.PlayerFirstPersonCosmeticsGetters.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				bool hasViewmodelReplacement2;
				GameObject[] array = ((GetPlayerFirstPersonCosmetics)@delegate)(player, out hasViewmodelReplacement2);
				if (array != null)
				{
					cosmetics.AddRange(array);
				}
				hasViewmodelReplacement |= hasViewmodelReplacement2;
			}
		}

		internal static void CollectPlayerThirdPersonCosmetics(PlayerControllerB player, List<GameObject> cosmetics)
		{
			if (BodyCam.PlayerThirdPersonCosmeticsGetters == null)
			{
				return;
			}
			Delegate[] invocationList = BodyCam.PlayerThirdPersonCosmeticsGetters.GetInvocationList();
			foreach (Delegate @delegate in invocationList)
			{
				GameObject[] array = ((GetPlayerThirdPersonCosmetics)@delegate)(player);
				if (array != null)
				{
					cosmetics.AddRange(array);
				}
			}
		}
	}
	public class Commands
	{
		public bool IsPiPBodyCamDisplayed => TerminalCommands.TerminalIsDisplayingBodyCam();
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}