using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCThirdPerson;
using Microsoft.CodeAnalysis;
using MoreCompany;
using MoreCompany.Cosmetics;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.InputSystem;
using _3rdPerson.Helper;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("ModelReplacementAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ModelReplacementAPI")]
[assembly: AssemblyTitle("ModelReplacementAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ModelReplacement
{
	internal class AvatarBodyUpdater : MonoBehaviour
	{
		private void LateUpdate()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0038: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			Animator val = new Animator();
			Animator val2 = new Animator();
			Array values = Enum.GetValues(typeof(HumanBodyBones));
			foreach (object item in values)
			{
				Transform boneTransform = val.GetBoneTransform((HumanBodyBones)item);
				Transform boneTransform2 = val.GetBoneTransform((HumanBodyBones)item);
				if (!((Object)(object)boneTransform == (Object)null) && !((Object)(object)boneTransform2 == (Object)null))
				{
					boneTransform2.rotation = new Quaternion(boneTransform.rotation.x, boneTransform.rotation.y, boneTransform.rotation.z, boneTransform.rotation.w);
				}
			}
			Dictionary<string, HumanBodyBones> dictionary = new Dictionary<string, HumanBodyBones>
			{
				{
					"spine",
					(HumanBodyBones)0
				},
				{
					"spine.001",
					(HumanBodyBones)7
				},
				{
					"spine.002",
					(HumanBodyBones)8
				},
				{
					"spine.003",
					(HumanBodyBones)54
				},
				{
					"shoulder.L",
					(HumanBodyBones)11
				},
				{
					"arm.L_upper",
					(HumanBodyBones)13
				},
				{
					"arm.L_lower",
					(HumanBodyBones)15
				},
				{
					"hand.L",
					(HumanBodyBones)17
				},
				{
					"finger5.L",
					(HumanBodyBones)36
				},
				{
					"finger5.L.001",
					(HumanBodyBones)37
				},
				{
					"finger4.L",
					(HumanBodyBones)33
				},
				{
					"finger4.L.001",
					(HumanBodyBones)34
				},
				{
					"finger3.L",
					(HumanBodyBones)30
				},
				{
					"finger3.L.001",
					(HumanBodyBones)31
				},
				{
					"finger2.L",
					(HumanBodyBones)27
				},
				{
					"finger2.L.001",
					(HumanBodyBones)28
				},
				{
					"finger1.L",
					(HumanBodyBones)24
				},
				{
					"finger1.L.001",
					(HumanBodyBones)26
				},
				{
					"shoulder.R",
					(HumanBodyBones)12
				},
				{
					"arm.R_upper",
					(HumanBodyBones)14
				},
				{
					"arm.R_lower",
					(HumanBodyBones)16
				},
				{
					"hand.R",
					(HumanBodyBones)18
				},
				{
					"finger5.R",
					(HumanBodyBones)51
				},
				{
					"finger5.R.001",
					(HumanBodyBones)52
				},
				{
					"finger4.R",
					(HumanBodyBones)48
				},
				{
					"finger4.R.001",
					(HumanBodyBones)49
				},
				{
					"finger3.R",
					(HumanBodyBones)45
				},
				{
					"finger3.R.001",
					(HumanBodyBones)46
				},
				{
					"finger2.R",
					(HumanBodyBones)42
				},
				{
					"finger2.R.001",
					(HumanBodyBones)43
				},
				{
					"finger1.R",
					(HumanBodyBones)39
				},
				{
					"finger1.R.001",
					(HumanBodyBones)41
				},
				{
					"spine.004",
					(HumanBodyBones)10
				},
				{
					"thigh.L",
					(HumanBodyBones)1
				},
				{
					"shin.L",
					(HumanBodyBones)3
				},
				{
					"foot.L",
					(HumanBodyBones)5
				},
				{
					"toe.L",
					(HumanBodyBones)19
				},
				{
					"thigh.R",
					(HumanBodyBones)2
				},
				{
					"shin.R",
					(HumanBodyBones)4
				},
				{
					"foot.R",
					(HumanBodyBones)6
				},
				{
					"toe.R",
					(HumanBodyBones)20
				}
			};
		}
	}
	public class Blinker : MonoBehaviour
	{
		public bool Blink = true;

		[Tooltip("Minimum seconds between blinks")]
		public float MinTime = 5f;

		[Tooltip("Maximum seconds between blinks")]
		public float MaxTime = 15f;

		[Tooltip("Duration of a single blink")]
		public float BlinkDuration = 0.1f;

		private SkinnedMeshRenderer thisMesh;

		private Material instanceMaterial;

		private Vector2 originalOffset;

		private bool isBlinking = false;

		private void Start()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			thisMesh = ((Component)this).GetComponent<SkinnedMeshRenderer>();
			if (((Renderer)thisMesh).materials.Length != 0)
			{
				instanceMaterial = ((Renderer)thisMesh).materials[0];
				originalOffset = instanceMaterial.mainTextureOffset;
				((MonoBehaviour)this).StartCoroutine(BlinkRoutine());
			}
			else
			{
				Blink = false;
			}
		}

		public void DeadEyes()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			((MonoBehaviour)this).StopCoroutine(BlinkRoutine());
			thisMesh = ((Component)this).GetComponent<SkinnedMeshRenderer>();
			Blink = false;
			if (((Renderer)thisMesh).materials.Length != 0)
			{
				instanceMaterial = ((Renderer)thisMesh).materials[0];
				instanceMaterial.mainTextureOffset = new Vector2(0.01469f, 0.53901f);
			}
			else
			{
				Debug.LogError((object)"Didn't find heawd after attaching for dead eyes method");
			}
		}

		private IEnumerator BlinkRoutine()
		{
			while (Blink)
			{
				yield return (object)new WaitForSeconds(Random.Range(MinTime, MaxTime));
				isBlinking = true;
				instanceMaterial.mainTextureOffset = new Vector2(0.01469f, 0.53901f);
				yield return (object)new WaitForSeconds(BlinkDuration);
				isBlinking = false;
				instanceMaterial.mainTextureOffset = originalOffset;
			}
		}
	}
	public abstract class BodyReplacementBase : MonoBehaviour
	{
		public bool renderLocalDebug = false;

		public bool renderBase = false;

		public bool renderModel = false;

		private bool isCoroutineRunning = false;

		private PlayerDeathTracker playerDeathTracker;

		private Blinker blinker;

		private CosmeticApplication[] applications;

		private bool runConnectHairOnce = false;

		private InputAction f12Action;

		public string boneMapJsonStr;

		public string jsonPath;

		public BoneMap Map;

		private PlayerControllerB controller;

		public GameObject replacementModel;

		public GameObject deadBody = null;

		public GameObject replacementDeadBody = null;

		public BoneMap ragDollMap;

		private MeshRenderer nameTagObj = null;

		private MeshRenderer nameTagObj2 = null;

		public bool flagReparentObject = false;

		public bool moreCompanyCosmeticsReparented = false;

		internal bool ragdollEnabled = true;

		internal bool bloodDecalsEnabled = true;

		public bool localPlayer => (ulong)StartOfRound.Instance.thisClientPlayerId == controller.playerClientId;

		public abstract string boneMapFileName { get; }

		public bool DangerousViewState()
		{
			return ThirdPersonCamera.ViewState;
		}

		public bool DangerousLCViewState()
		{
			return ThirdPersonPlugin.Instance.Enabled;
		}

		public bool RenderBodyReplacement()
		{
			if (!localPlayer)
			{
				return true;
			}
			if (ModelReplacementAPI.thirdPersonPresent)
			{
				return DangerousViewState();
			}
			if (ModelReplacementAPI.LCthirdPersonPresent)
			{
				return DangerousLCViewState();
			}
			return false;
		}

		public abstract GameObject LoadAssetsAndReturnModel();

		public abstract void AddModelScripts();

		public virtual Transform[] GetMappedBones()
		{
			List<Transform> list = new List<Transform>();
			SkinnedMeshRenderer[] componentsInChildren = replacementModel.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				list.AddRange(val.bones);
			}
			return list.ToArray();
		}

		private void CreateAndParentRagdoll(DeadBodyInfo bodyinfo)
		{
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			deadBody = ((Component)bodyinfo).gameObject;
			SkinnedMeshRenderer componentInChildren = deadBody.GetComponentInChildren<SkinnedMeshRenderer>();
			replacementDeadBody = Object.Instantiate<GameObject>(replacementModel);
			Renderer[] componentsInChildren = replacementDeadBody.GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.enabled = true;
			}
			((Renderer)componentInChildren).enabled = false;
			Blinker blinker = ((Component)replacementDeadBody.transform.Find("Head")).gameObject.AddComponent<Blinker>();
			blinker.Blink = false;
			blinker.DeadEyes();
			List<Transform> list = new List<Transform>();
			SkinnedMeshRenderer[] componentsInChildren2 = replacementDeadBody.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				list.AddRange(val2.bones);
			}
			Transform[] originalMappedBones = GetMappedBones();
			Transform[] array = (Transform[])(object)new Transform[originalMappedBones.Length];
			int i;
			for (i = 0; i < originalMappedBones.Length; i++)
			{
				array[i] = list.Where((Transform bone) => ((Object)bone).name == ((Object)originalMappedBones[i]).name).First();
			}
			ragDollMap = BoneMap.DeserializeFromJson(boneMapJsonStr);
			ragDollMap.MapBones(componentInChildren.bones, array);
			ragDollMap.RootBone().parent = componentInChildren.rootBone;
			ragDollMap.RootBone().localPosition = Vector3.zero + Map.PositionOffset();
			GameObject[] bodyBloodDecals = bodyinfo.bodyBloodDecals;
			foreach (GameObject val3 in bodyBloodDecals)
			{
				Transform parent = val3.transform.parent;
				Transform mappedTransform = ragDollMap.GetMappedTransform(((Object)parent).name);
				if (Object.op_Implicit((Object)(object)mappedTransform))
				{
					Object.Instantiate<GameObject>(val3, mappedTransform);
				}
			}
			if (localPlayer)
			{
				ConnectClientToPlayerObjectPatch.Postfix(controller);
			}
			playerDeathTracker.Died = true;
		}

		public virtual void AfterAwake()
		{
			AttemptReparentMoreCompanyCosmetics();
		}

		public void RepairModel()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)controller == (Object)null)
			{
				ModelReplacementAPI.Instance.Logger.LogFatal((object)$" {((object)this).GetType()} PlayerControllerB is null");
			}
			if ((Object)(object)controller.thisPlayerModel == (Object)null)
			{
				ModelReplacementAPI.Instance.Logger.LogFatal((object)$"{((Object)controller).name} {((object)this).GetType()} base player model is null");
			}
			if ((Object)(object)replacementModel == (Object)null)
			{
				ModelReplacementAPI.Instance.Logger.LogFatal((object)$"{((Object)controller).name} {((object)this).GetType()} replacementModel is null");
				replacementModel = LoadAssetsAndReturnModel();
				replacementModel = Object.Instantiate<GameObject>(replacementModel);
				replacementModel.transform.localPosition = new Vector3(0f, 0f, 0f);
				replacementModel.SetActive(true);
				blinker = ((Component)replacementModel.transform.Find("Head")).gameObject.AddComponent<Blinker>();
				Bounds bounds = ((Renderer)controller.thisPlayerModel).bounds;
				Vector3 extents = ((Bounds)(ref bounds)).extents;
				float y = extents.y;
				bounds = GetBounds();
				float num = y / ((Bounds)(ref bounds)).extents.y;
				Transform transform = replacementModel.transform;
				transform.localScale *= num;
			}
			Map = BoneMap.DeserializeFromJson(boneMapJsonStr);
			Map.MapBones(controller.thisPlayerModel.bones, GetMappedBones());
			Map.SetBodyReplacement(this);
			ReparentModel();
			moreCompanyCosmeticsReparented = false;
		}

		internal void Awake()
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			controller = ((Component)this).GetComponent<PlayerControllerB>();
			replacementModel = LoadAssetsAndReturnModel();
			if ((Object)(object)replacementModel == (Object)null)
			{
				Console.WriteLine("LoadAssetsAndReturnModel returned null");
			}
			Renderer[] componentsInChildren = replacementModel.GetComponentsInChildren<Renderer>();
			Material material = ((Renderer)((Component)controller.thisPlayerModel).GetComponent<SkinnedMeshRenderer>()).material;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (((Object)((Component)val).gameObject).name != "Suit")
				{
					List<Material> list = new List<Material>();
					Material[] materials = val.materials;
					foreach (Material val2 in materials)
					{
						Material val3 = new Material(material);
						val3.mainTexture = val2.mainTexture;
						list.Add(val3);
					}
					val.SetMaterials(list);
				}
			}
			try
			{
				AddModelScripts();
			}
			catch (Exception ex)
			{
				ModelReplacementAPI.Instance.Logger.LogError((object)("Could not set all model scripts.\n Error: " + ex.Message));
			}
			replacementModel = Object.Instantiate<GameObject>(replacementModel);
			SetRenderers(enabled: false);
			replacementModel.transform.localPosition = new Vector3(0f, 0f, 0f);
			replacementModel.SetActive(true);
			blinker = ((Component)replacementModel.transform.Find("Head")).gameObject.AddComponent<Blinker>();
			Bounds bounds = ((Renderer)controller.thisPlayerModel).bounds;
			Vector3 extents = ((Bounds)(ref bounds)).extents;
			float y = extents.y;
			bounds = GetBounds();
			float num = y / ((Bounds)(ref bounds)).extents.y;
			Transform transform = replacementModel.transform;
			transform.localScale *= num;
			string text = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			while (true)
			{
				string name = new DirectoryInfo(text).Name;
				if (name == "plugins")
				{
					break;
				}
				text = Path.Combine(text, "..");
			}
			string[] files = Directory.GetFiles(text, "*.json", SearchOption.AllDirectories);
			jsonPath = files.Where((string f) => string.Equals(Path.GetFileName(f), boneMapFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
			boneMapJsonStr = File.ReadAllText(jsonPath);
			Map = BoneMap.DeserializeFromJson(boneMapJsonStr);
			controller = ((Component)this).GetComponent<PlayerControllerB>();
			Map.MapBones(controller.thisPlayerModel.bones, GetMappedBones());
			Map.SetBodyReplacement(this);
			ReparentModel();
			MeshRenderer[] componentsInChildren2 = ((Component)controller).gameObject.GetComponentsInChildren<MeshRenderer>();
			nameTagObj = componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "LevelSticker").First();
			nameTagObj2 = componentsInChildren2.Where((MeshRenderer x) => ((Object)((Component)x).gameObject).name == "BetaBadge").First();
			Console.WriteLine("AwakeEnd " + controller.playerUsername);
			if (((Component)this).gameObject.GetComponents<PlayerDeathTracker>().Length == 0)
			{
				Console.WriteLine("Player death tracker component added");
				playerDeathTracker = ((Component)this).gameObject.AddComponent<PlayerDeathTracker>();
			}
			else
			{
				Console.WriteLine("Player death tracker re-connected");
				playerDeathTracker = ((Component)this).gameObject.GetComponent<PlayerDeathTracker>();
			}
			AfterAwake();
		}

		public void ReparentModel()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Map.RootBone().parent = controller.thisPlayerModel.rootBone;
			Map.RootBone().localPosition = Vector3.zero + Map.PositionOffset();
		}

		public virtual void AfterStart()
		{
		}

		private void Start()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			f12Action = new InputAction((string)null, (InputActionType)0, "<Keyboard>/f11", (string)null, (string)null, (string)null);
			f12Action.performed += OnF12Pressed;
			f12Action.Enable();
			AfterStart();
		}

		private void OnF12Pressed(CallbackContext context)
		{
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			if ((Object)(object)controller.deadBody == (Object)null)
			{
				playerDeathTracker.Died = true;
				RepairModel();
				AttemptReparentMoreCompanyCosmetics();
				Console.WriteLine(controller.playerUsername + " player model reset");
				return;
			}
			GameObject gameObject = ((Component)controller.deadBody).gameObject;
			if (!applications.Any())
			{
				gameObject.AddComponent<CosmeticApplication>();
				applications = gameObject.GetComponents<CosmeticApplication>();
			}
			Console.WriteLine("Telling all other clients we have hair " + controller.playerUsername);
			if (localPlayer)
			{
				ConnectClientToPlayerObjectPatch.Postfix(controller);
			}
			applications = gameObject.GetComponents<CosmeticApplication>();
			if (!applications.Any())
			{
				return;
			}
			Console.WriteLine("Setting up applications for " + controller.playerUsername);
			CosmeticApplication[] array = applications;
			foreach (CosmeticApplication val in array)
			{
				foreach (CosmeticInstance spawnedCosmetic in val.spawnedCosmetics)
				{
					Renderer[] componentsInChildren = ((Component)spawnedCosmetic).GetComponentsInChildren<Renderer>();
					Material material = ((Renderer)((Component)controller.thisPlayerModel).GetComponent<SkinnedMeshRenderer>()).material;
					Renderer[] array2 = componentsInChildren;
					foreach (Renderer val2 in array2)
					{
						List<Material> list = new List<Material>();
						Material[] materials = val2.materials;
						foreach (Material val3 in materials)
						{
							Material val4 = new Material(material);
							val4.mainTexture = val3.mainTexture;
							list.Add(val4);
						}
						val2.SetMaterials(list);
					}
				}
			}
		}

		public virtual void AfterUpdate()
		{
		}

		private void AttemptUnparentMoreCompanyCosmetics()
		{
			if (ModelReplacementAPI.moreCompanyPresent && moreCompanyCosmeticsReparented)
			{
				DangerousUnparent();
			}
		}

		private IEnumerator AttemptReparentMoreCompanyCosmeticsCoroutine()
		{
			if (isCoroutineRunning)
			{
				yield break;
			}
			isCoroutineRunning = true;
			if (!ModelReplacementAPI.moreCompanyPresent || moreCompanyCosmeticsReparented)
			{
				yield break;
			}
			PlayerControllerB hair_controller_source = ((Component)this).GetComponent<PlayerControllerB>();
			Console.WriteLine("Hair Controller player" + hair_controller_source.playerUsername);
			bool childrenFound = false;
			for (int j = 0; j < 5; j++)
			{
				CosmeticApplication[] cosmeticAppsChilds3 = ((Component)hair_controller_source).GetComponentsInChildren<CosmeticApplication>();
				int numberOfChildren2 = cosmeticAppsChilds3.Length;
				Console.WriteLine("Updated number of children: " + numberOfChildren2);
				if (numberOfChildren2 != 0)
				{
					childrenFound = true;
					break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			if (!childrenFound && playerDeathTracker.Died)
			{
				hair_controller_source = ((Component)this).GetComponent<PlayerControllerB>();
				ConnectClientToPlayerObjectPatch.Postfix(hair_controller_source);
				runConnectHairOnce = true;
				for (int i = 0; i < 5; i++)
				{
					CosmeticInstance[] cosmeticAppsChilds2 = ((Component)hair_controller_source).GetComponentsInChildren<CosmeticInstance>();
					int numberOfChildren = cosmeticAppsChilds2.Length;
					Console.WriteLine("Updated number of children: " + numberOfChildren);
					if (numberOfChildren != 0)
					{
						break;
					}
					Console.WriteLine("None found. COmmence grabbin " + numberOfChildren);
					cosmeticAppsChilds2 = ((Component)hair_controller_source).GetComponentsInChildren<CosmeticInstance>();
					Console.WriteLine("Updated number of children: " + cosmeticAppsChilds2.Length);
					yield return (object)new WaitForSeconds(0.1f);
				}
			}
			DangerousParent();
			isCoroutineRunning = false;
		}

		private void StartReparentCoroutine()
		{
			((MonoBehaviour)this).StartCoroutine(AttemptReparentMoreCompanyCosmeticsCoroutine());
		}

		private void AttemptReparentMoreCompanyCosmetics()
		{
			if (ModelReplacementAPI.moreCompanyPresent && !moreCompanyCosmeticsReparented)
			{
				DangerousParent();
			}
		}

		private void DangerousUnparent()
		{
			CosmeticApplication[] componentsInChildren = ((Component)controller).gameObject.GetComponentsInChildren<CosmeticApplication>();
			if (componentsInChildren.Any())
			{
				CosmeticApplication[] array = componentsInChildren;
				foreach (CosmeticApplication val in array)
				{
					Object.Destroy((Object)(object)val);
					moreCompanyCosmeticsReparented = false;
				}
			}
			Console.WriteLine(" unparent done");
		}

		private void DangerousParent()
		{
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected I4, but got Unknown
			controller = ((Component)this).gameObject.GetComponent<PlayerControllerB>();
			PlayerControllerB component = ((Component)controller).gameObject.GetComponent<PlayerControllerB>();
			if (!playerDeathTracker.Died)
			{
				applications = ((Component)controller).gameObject.GetComponentsInChildren<CosmeticApplication>();
			}
			else if (playerDeathTracker.Died)
			{
				if (localPlayer)
				{
					Console.WriteLine("Executing hair fix on " + controller.playerUsername);
					ConnectClientToPlayerObjectPatch.Postfix(controller);
				}
				applications = ((Component)component).GetComponentsInChildren<CosmeticApplication>();
			}
			if (!applications.Any())
			{
				return;
			}
			Console.WriteLine("Setting up applications for " + controller.playerUsername);
			CosmeticApplication[] array = applications;
			foreach (CosmeticApplication val in array)
			{
				Console.WriteLine(((object)val).GetType().Name + " parent");
				Transform mappedTransform = Map.GetMappedTransform("spine.004");
				Console.WriteLine("CurrentHead:" + (object)mappedTransform);
				Transform mappedTransform2 = Map.GetMappedTransform("spine.003");
				Transform mappedTransform3 = Map.GetMappedTransform("arm.R_lower");
				Transform mappedTransform4 = Map.GetMappedTransform("spine");
				Transform mappedTransform5 = Map.GetMappedTransform("shin.L");
				Transform mappedTransform6 = Map.GetMappedTransform("shin.R");
				val.head = mappedTransform;
				val.chest = mappedTransform2;
				val.lowerArmRight = mappedTransform3;
				val.hip = mappedTransform4;
				val.shinLeft = mappedTransform5;
				val.shinRight = mappedTransform6;
				foreach (CosmeticInstance spawnedCosmetic in val.spawnedCosmetics)
				{
					Transform val2 = null;
					if ((Object)(object)spawnedCosmetic != (Object)null)
					{
						CosmeticType cosmeticType = spawnedCosmetic.cosmeticType;
						CosmeticType val3 = cosmeticType;
						switch ((int)val3)
						{
						case 0:
							val2 = val.head;
							break;
						case 2:
							val2 = val.chest;
							break;
						case 3:
							val2 = val.lowerArmRight;
							break;
						case 4:
							val2 = val.hip;
							break;
						case 5:
							val2 = val.shinLeft;
							break;
						case 6:
							val2 = val.shinRight;
							break;
						}
					}
					((Component)spawnedCosmetic).transform.position = val2.position;
					((Component)spawnedCosmetic).transform.rotation = val2.rotation;
					((Component)spawnedCosmetic).transform.parent = val2;
				}
			}
			if (playerDeathTracker.Died)
			{
				CosmeticInstance[] componentsInChildren = ((Component)this).GetComponentsInChildren<CosmeticInstance>();
				int num = componentsInChildren.Length;
				if (num > 0)
				{
					playerDeathTracker.Died = false;
					moreCompanyCosmeticsReparented = true;
				}
			}
			else
			{
				moreCompanyCosmeticsReparented = true;
			}
		}

		private void Update()
		{
			if (Map.CompletelyDestroyed())
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			if (!renderLocalDebug)
			{
				if (RenderBodyReplacement())
				{
					SetRenderers(enabled: true);
					((Renderer)controller.thisPlayerModel).enabled = false;
					((Renderer)controller.thisPlayerModelLOD1).enabled = false;
					((Renderer)controller.thisPlayerModelLOD2).enabled = false;
					((Renderer)nameTagObj).enabled = false;
					((Renderer)nameTagObj2).enabled = false;
				}
				else
				{
					SetRenderers(enabled: false);
				}
			}
			else
			{
				SkinnedMeshRenderer[] componentsInChildren = ((Component)controller).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Renderer val = (Renderer)(object)componentsInChildren[i];
					val.enabled = renderBase;
				}
				SetRenderers(renderModel);
			}
			Map.UpdateModelbones();
			if (controller.isPlayerDead || !localPlayer)
			{
			}
			if (ragdollEnabled)
			{
				GameObject val2 = null;
				try
				{
					val2 = ((Component)controller.deadBody).gameObject;
				}
				catch
				{
				}
				if (Object.op_Implicit((Object)(object)val2) && (Object)(object)replacementDeadBody == (Object)null)
				{
					CreateAndParentRagdoll(controller.deadBody);
				}
				if (Object.op_Implicit((Object)(object)replacementDeadBody))
				{
					if ((Object)(object)val2 == (Object)null)
					{
						Object.Destroy((Object)(object)replacementDeadBody);
						replacementDeadBody = null;
						ragDollMap = null;
					}
					else
					{
						ragDollMap.UpdateModelbones();
					}
				}
			}
			AfterUpdate();
		}

		private void OnDestroy()
		{
			f12Action.Disable();
			Console.WriteLine("Destroy body component for " + controller.playerUsername);
			((Renderer)controller.thisPlayerModel).enabled = true;
			((Renderer)controller.thisPlayerModelLOD1).enabled = true;
			((Renderer)controller.thisPlayerModelLOD2).enabled = true;
			((Renderer)nameTagObj).enabled = true;
			((Renderer)nameTagObj2).enabled = true;
			AttemptUnparentMoreCompanyCosmetics();
			Object.Destroy((Object)(object)replacementModel);
			Object.Destroy((Object)(object)replacementDeadBody);
		}

		private void SetRenderers(bool enabled)
		{
			if ((Object)(object)replacementModel != (Object)null)
			{
				Renderer[] componentsInChildren = replacementModel.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = enabled;
				}
			}
		}

		private Bounds GetBounds()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			Bounds result = default(Bounds);
			IEnumerable<Bounds> source = from r in replacementModel.GetComponentsInChildren<SkinnedMeshRenderer>()
				select ((Renderer)r).bounds;
			Bounds val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.x).First();
			float x2 = ((Bounds)(ref val)).max.x;
			val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.y).First();
			float y = ((Bounds)(ref val)).max.y;
			val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.z).First();
			float z = ((Bounds)(ref val)).max.z;
			val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.x).First();
			float x3 = ((Bounds)(ref val)).min.x;
			val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.y).First();
			float y2 = ((Bounds)(ref val)).min.y;
			val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.z).First();
			float z2 = ((Bounds)(ref val)).min.z;
			((Bounds)(ref result)).SetMinMax(new Vector3(x3, y2, z2), new Vector3(z, y, z));
			return result;
		}
	}
	[JsonObject]
	public class BoneMap
	{
		public class MappedBone
		{
			public string playerBoneString;

			public string modelBoneString;

			public Quaternion rotationOffset = Quaternion.identity;

			public Transform playerTransform;

			public Transform modelTransform;

			public List<string> additionalVars = new List<string>();

			public MappedBone(string playerBoneString, string modelBoneString, Quaternion rotationOffset, Transform playerTransform, Transform modelTransform)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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)
				this.playerBoneString = playerBoneString;
				this.modelBoneString = modelBoneString;
				this.rotationOffset = rotationOffset;
				this.playerTransform = playerTransform;
				this.modelTransform = modelTransform;
			}

			public MappedBone(List<string> vars, Transform player, Transform model)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				playerTransform = player;
				modelTransform = model;
				int count = vars.Count;
				if (count >= 2)
				{
					playerBoneString = vars[0];
					modelBoneString = vars[1];
				}
				if (count >= 6)
				{
					try
					{
						float num = float.Parse(vars[2]);
						float num2 = float.Parse(vars[3]);
						float num3 = float.Parse(vars[4]);
						float num4 = float.Parse(vars[5]);
						rotationOffset = new Quaternion(num, num2, num3, num4);
					}
					catch (Exception)
					{
						ModelReplacementAPI.Instance.Logger.LogError((object)("could not parse rotation offset for player bone " + playerBoneString + " xyzw(" + vars[2] + "," + vars[3] + "," + vars[4] + "," + vars[5] + ")"));
					}
				}
				if (count > 6)
				{
					for (int i = 6; i < count; i++)
					{
						additionalVars.Add(vars[i]);
					}
				}
			}

			public bool Update()
			{
				//IL_005d: 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_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: 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_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)modelTransform == (Object)null || (Object)(object)playerTransform == (Object)null)
				{
					ModelReplacementAPI.Instance.Logger.LogError((object)("Could not Update bone, model or player transform is null. Destroying MappedBone (" + modelBoneString + ")"));
					return true;
				}
				try
				{
					modelTransform.rotation = new Quaternion(playerTransform.rotation.x, playerTransform.rotation.y, playerTransform.rotation.z, playerTransform.rotation.w);
					Transform obj = modelTransform;
					obj.rotation *= rotationOffset;
				}
				catch
				{
					ModelReplacementAPI.Instance.Logger.LogError((object)("Could not Update bones for " + ((Object)playerTransform).name + " to " + ((Object)modelTransform).name + " "));
					return true;
				}
				return false;
			}
		}

		[JsonProperty]
		private List<List<string>> boneMap = new List<List<string>>();

		[JsonIgnore]
		private List<MappedBone> mappedBones = new List<MappedBone>();

		[JsonProperty]
		private List<float> _positionOffSet = new List<float>();

		[JsonIgnore]
		private Vector3 positionOffset = Vector3.zero;

		[JsonProperty]
		private List<float> _itemHolderPositionOffset = new List<float>();

		[JsonIgnore]
		private Vector3 itemHolderPositionOffset = Vector3.zero;

		[JsonProperty]
		private string itemHolderBone = "";

		[JsonIgnore]
		private Transform itemHolderTransform = null;

		[JsonProperty]
		private string rootBone = "";

		[JsonIgnore]
		private Transform rootBoneTransform = null;

		[JsonIgnore]
		public Transform[] playerBoneList = null;

		[JsonIgnore]
		public Transform[] modelBoneList = null;

		[JsonIgnore]
		public BodyReplacementBase replacementBase;

		public static BoneMap DeserializeFromJson(string jsonStr)
		{
			return JsonConvert.DeserializeObject<BoneMap>(jsonStr);
		}

		public string SerializeToJsonString()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			_positionOffSet = new List<float> { positionOffset.x, positionOffset.y, positionOffset.z };
			_itemHolderPositionOffset = new List<float> { itemHolderPositionOffset.x, itemHolderPositionOffset.y, itemHolderPositionOffset.z };
			boneMap.Clear();
			foreach (MappedBone mappedBone in mappedBones)
			{
				List<string> list = new List<string>();
				list.Add(mappedBone.playerBoneString);
				list.Add(mappedBone.modelBoneString);
				if (mappedBone.rotationOffset != Quaternion.identity)
				{
					list.Add(mappedBone.rotationOffset.x.ToString());
					list.Add(mappedBone.rotationOffset.y.ToString());
					list.Add(mappedBone.rotationOffset.z.ToString());
					list.Add(mappedBone.rotationOffset.w.ToString());
					if (mappedBone.additionalVars.Count > 0)
					{
						foreach (string additionalVar in mappedBone.additionalVars)
						{
							list.Add(additionalVar);
						}
					}
				}
				boneMap.Add(list);
			}
			return JsonConvert.SerializeObject((object)this);
		}

		public void SetBodyReplacement(BodyReplacementBase body)
		{
			replacementBase = body;
		}

		public void MapBones(Transform[] playerBones, Transform[] modelBones)
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			playerBoneList = playerBones;
			modelBoneList = modelBones;
			if (!boneMap.Where((List<string> x) => x[0] == "PlayerRagdoll(Clone)").Any() && boneMap.Where((List<string> x) => x[0] == "spine").Any())
			{
				List<string> list = new List<string>();
				List<string> list2 = boneMap.Where((List<string> x) => x[0] == "spine").First();
				for (int i = 0; i < list2.Count(); i++)
				{
					if (i == 0)
					{
						list.Add("PlayerRagdoll(Clone)");
					}
					else
					{
						list.Add(list2[i]);
					}
				}
				boneMap.Add(list);
			}
			mappedBones.Clear();
			itemHolderTransform = null;
			if (_positionOffSet.Count == 3)
			{
				positionOffset = new Vector3(_positionOffSet[0], _positionOffSet[1], _positionOffSet[2]);
			}
			if (_itemHolderPositionOffset.Count == 3)
			{
				itemHolderPositionOffset = new Vector3(_itemHolderPositionOffset[0], _itemHolderPositionOffset[1], _itemHolderPositionOffset[2]);
			}
			foreach (List<string> item in boneMap)
			{
				string playerBone = item[0];
				string modelBone = item[1];
				if (modelBone == "")
				{
					continue;
				}
				if (!modelBones.Any((Transform x) => ((Object)x).name == modelBone))
				{
					ModelReplacementAPI.Instance.Logger.LogWarning((object)("No bone in model with name (" + modelBone + ")"));
					continue;
				}
				if (!playerBones.Any((Transform x) => ((Object)x).name == playerBone))
				{
					ModelReplacementAPI.Instance.Logger.LogWarning((object)("No bone in player with name (" + playerBone + ")"));
					continue;
				}
				Transform player = playerBones.Where((Transform x) => ((Object)x).name == playerBone).First();
				Transform model = modelBones.Where((Transform x) => ((Object)x).name == modelBone).First();
				mappedBones.Add(new MappedBone(item, player, model));
			}
			itemHolderTransform = modelBones.Where((Transform x) => ((Object)x).name == itemHolderBone).First();
			rootBoneTransform = modelBones.Where((Transform x) => ((Object)x).name == rootBone).First();
		}

		public void UpdateModelbones()
		{
			mappedBones.ForEach(delegate(MappedBone x)
			{
				bool flag = x.Update();
			});
			List<MappedBone> destroyBones = new List<MappedBone>();
			mappedBones.ForEach(delegate(MappedBone x)
			{
				if (x.Update())
				{
					destroyBones.Add(x);
				}
			});
			destroyBones.ForEach(delegate(MappedBone x)
			{
				mappedBones.Remove(x);
			});
		}

		public bool CompletelyDestroyed()
		{
			if (mappedBones.Count() == 0 || (Object)(object)rootBoneTransform == (Object)null)
			{
				Console.WriteLine("bone Map destroyed");
				return true;
			}
			return false;
		}

		public Vector3 PositionOffset()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return positionOffset;
		}

		public Vector3 ItemHolderPositionOffset()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return itemHolderPositionOffset;
		}

		public Transform ItemHolder()
		{
			return itemHolderTransform;
		}

		public Transform RootBone()
		{
			return rootBoneTransform;
		}

		public Transform GetMappedTransform(string playerTransformName)
		{
			string playerTransformName2 = playerTransformName;
			IEnumerable<MappedBone> source = mappedBones.Where((MappedBone x) => x.playerBoneString == playerTransformName2);
			if (source.Any())
			{
				return source.First().modelTransform;
			}
			ModelReplacementAPI.Instance.Logger.LogWarning((object)("No mapped bone with player bone name " + playerTransformName2));
			return null;
		}

		public MappedBone GetMappedBoneWithPlayerName(string playerTransformName)
		{
			string playerTransformName2 = playerTransformName;
			IEnumerable<MappedBone> source = mappedBones.Where((MappedBone x) => x.playerBoneString == playerTransformName2);
			if (source.Any())
			{
				return source.First();
			}
			ModelReplacementAPI.Instance.Logger.LogWarning((object)("No mapped bone with player bone name " + playerTransformName2));
			return null;
		}

		public List<MappedBone> GetMappedBones()
		{
			return mappedBones;
		}

		public void UpdateMappedBone(string playerBoneString, string modelBoneString, Quaternion rotationOffset)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			string playerBoneString2 = playerBoneString;
			string modelBoneString2 = modelBoneString;
			IEnumerable<MappedBone> source = mappedBones.Where((MappedBone x) => x.playerBoneString == playerBoneString2);
			if (source.Any())
			{
				MappedBone mappedBoneWithPlayerName = GetMappedBoneWithPlayerName(playerBoneString2);
				mappedBoneWithPlayerName.modelBoneString = modelBoneString2;
				mappedBoneWithPlayerName.rotationOffset = rotationOffset;
				IEnumerable<Transform> source2 = modelBoneList.Where((Transform x) => ((Object)x).name == modelBoneString2);
				if (source2.Any())
				{
					mappedBoneWithPlayerName.modelTransform = source2.First();
				}
				return;
			}
			IEnumerable<Transform> source3 = playerBoneList.Where((Transform x) => ((Object)x).name == playerBoneString2);
			IEnumerable<Transform> source4 = modelBoneList.Where((Transform x) => ((Object)x).name == modelBoneString2);
			Transform playerTransform = null;
			Transform modelTransform = null;
			if (source3.Any())
			{
				playerTransform = source3.First();
			}
			if (source4.Any())
			{
				modelTransform = source4.First();
			}
			MappedBone item = new MappedBone(playerBoneString2, modelBoneString2, rotationOffset, playerTransform, modelTransform);
			mappedBones.Add(item);
		}

		public void UpdateRootBoneAndOffset(Transform newRootBone, Vector3 offset)
		{
			//IL_0034: 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)
			if ((Object)(object)newRootBone != (Object)(object)rootBoneTransform)
			{
				rootBoneTransform.parent = null;
				rootBoneTransform = newRootBone;
				rootBone = ((Object)newRootBone).name;
			}
			positionOffset = offset;
			replacementBase.ReparentModel();
		}

		public void UpdateItemHolderBoneAndOffset(Transform newRootBone, Vector3 offset)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			itemHolderTransform = newRootBone;
			itemHolderBone = ((Object)newRootBone).name;
			itemHolderPositionOffset = offset;
			replacementBase.flagReparentObject = true;
		}
	}
	[BepInPlugin("meow.ModelReplacementAPI", "ModelReplacementAPI", "1.2.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ModelReplacementAPI : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(GrabbableObject))]
		public class LocateHeldObjectsOnModelReplacementPatch
		{
			[HarmonyPatch(typeof(StartOfRound))]
			public class RepairBrokenBodyReplacementsPatch
			{
				[HarmonyPatch("ReviveDeadPlayers")]
				[HarmonyPostfix]
				public static void ReviveDeadPlayersPatch(ref StartOfRound __instance)
				{
					PlayerControllerB[] allPlayerScripts = __instance.allPlayerScripts;
					foreach (PlayerControllerB val in allPlayerScripts)
					{
						if (val.isPlayerDead && !((Object)(object)((Component)val).gameObject.GetComponent<BodyReplacementBase>() == (Object)null))
						{
							Console.WriteLine("Reinstantiating model replacement for " + val.playerUsername + " ");
							Type type = ((object)((Component)val).gameObject.GetComponent<BodyReplacementBase>()).GetType();
							Object.Destroy((Object)(object)((Component)val).gameObject.GetComponent<BodyReplacementBase>());
							((Component)val).gameObject.AddComponent(type);
						}
					}
				}
			}

			[HarmonyPatch(typeof(PlayerControllerB))]
			public class SetRegisteredBodyReplacements
			{
				private static InputAction f11Action;

				[HarmonyPatch("Update")]
				[HarmonyPostfix]
				public static void UpdatePatch(ref PlayerControllerB __instance)
				{
					try
					{
						if (__instance.playerSteamId == 0)
						{
							return;
						}
						if (RegisteredModelReplacementOverride != null)
						{
							SetPlayerModelReplacement(__instance, RegisteredModelReplacementOverride);
							return;
						}
						int currentSuitID = __instance.currentSuitID;
						string unlockableName = StartOfRound.Instance.unlockablesList.unlockables[currentSuitID].unlockableName;
						unlockableName = unlockableName.ToLower().Replace(" ", "");
						if (RegisteredModelReplacements.ContainsKey(unlockableName))
						{
							Type type = RegisteredModelReplacements[unlockableName];
							SetPlayerModelReplacement(__instance, type);
						}
						else
						{
							RemovePlayerModelReplacement(__instance);
						}
					}
					catch (Exception)
					{
					}
				}

				[HarmonyPatch("Awake")]
				[HarmonyPostfix]
				public static void Awake(ref PlayerControllerB __instance)
				{
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_0023: Expected O, but got Unknown
					PlayerControllerB localInstance = __instance;
					f11Action = new InputAction((string)null, (InputActionType)0, "<Keyboard>/f11", (string)null, (string)null, (string)null);
					f11Action.performed += delegate
					{
						OnF11Pressed(localInstance);
					};
					f11Action.Enable();
				}

				private static void OnF11Pressed(PlayerControllerB __instance)
				{
					try
					{
						if (__instance.playerSteamId != 0)
						{
							Console.WriteLine("Reset player");
							int currentSuitID = __instance.currentSuitID;
							string unlockableName = StartOfRound.Instance.unlockablesList.unlockables[currentSuitID].unlockableName;
							unlockableName = unlockableName.ToLower().Replace(" ", "");
							if (RegisteredModelReplacements.ContainsKey(unlockableName))
							{
								Type type = RegisteredModelReplacements[unlockableName];
								SetPlayerModelReplacement(__instance, type);
							}
							else
							{
								RemovePlayerModelReplacement(__instance);
							}
						}
					}
					catch (Exception)
					{
					}
				}
			}

			[HarmonyPatch("LateUpdate")]
			[HarmonyPostfix]
			public static void LateUpdatePatch(ref GrabbableObject __instance)
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance.parentObject == (Object)null) && !((Object)(object)__instance.playerHeldBy == (Object)null))
				{
					BodyReplacementBase component = ((Component)__instance.playerHeldBy).gameObject.GetComponent<BodyReplacementBase>();
					if (!((Object)(object)component == (Object)null) && component.RenderBodyReplacement() && (!component.renderLocalDebug || component.renderModel))
					{
						Transform val = component.Map.ItemHolder();
						Vector3 val2 = component.Map.ItemHolderPositionOffset();
						((Component)__instance).transform.rotation = val.rotation;
						((Component)__instance).transform.Rotate(__instance.itemProperties.rotationOffset);
						((Component)__instance).transform.position = val.position;
						Vector3 val3 = __instance.itemProperties.positionOffset + val2;
						val3 = val.rotation * val3;
						Transform transform = ((Component)__instance).transform;
						transform.position += val3;
					}
				}
			}
		}

		public static bool moreCompanyPresent;

		public static bool thirdPersonPresent;

		public static bool LCthirdPersonPresent;

		public static ModelReplacementAPI Instance;

		public ManualLogSource Logger;

		private static Dictionary<string, Type> RegisteredModelReplacements = new Dictionary<string, Type>();

		private static Type RegisteredModelReplacementOverride = null;

		private void Awake()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			Logger = Logger.CreateLogSource("ModelReplacementAPI");
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			moreCompanyPresent = Chainloader.PluginInfos.ContainsKey("me.swipez.melonloader.morecompany");
			thirdPersonPresent = Chainloader.PluginInfos.ContainsKey("verity.3rdperson");
			LCthirdPersonPresent = Chainloader.PluginInfos.ContainsKey("LCThirdPerson");
			Harmony val = new Harmony("meow.ModelReplacementAPI");
			val.PatchAll();
			Logger.LogInfo((object)"Plugin meow.ModelReplacementAPI is loaded!");
		}

		public static void RegisterModelReplacementOverride(Type type)
		{
			if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
			{
				Instance.Logger.LogError((object)$"Cannot register body replacement override type {type.GetType()}, must inherit from BodyReplacementBase");
				return;
			}
			if (RegisteredModelReplacementOverride != null)
			{
				Instance.Logger.LogError((object)$"Cannot register body replacement override, already registered to {RegisteredModelReplacementOverride.GetType()}.");
				return;
			}
			Instance.Logger.LogInfo((object)$"Registering body replacement override type {type.GetType()}.");
			RegisteredModelReplacementOverride = type;
		}

		public static void RegisterSuitModelReplacement(string suitNameToReplace, Type type)
		{
			suitNameToReplace = suitNameToReplace.ToLower().Replace(" ", "");
			if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
			{
				Instance.Logger.LogError((object)$"Cannot register body replacement type {type.GetType()}, must inherit from BodyReplacementBase");
				return;
			}
			if (RegisteredModelReplacements.ContainsKey(suitNameToReplace))
			{
				Instance.Logger.LogError((object)$"Cannot register body replacement type {type.GetType()}, suit name to replace {suitNameToReplace} is already registered.");
				return;
			}
			Instance.Logger.LogInfo((object)$"Registering body replacement type {type.GetType()} to suit name {suitNameToReplace}.");
			RegisteredModelReplacements.Add(suitNameToReplace, type);
		}

		public static void SetPlayerModelReplacement(PlayerControllerB player, Type type)
		{
			if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
			{
				Instance.Logger.LogError((object)("Cannot set body replacement of type " + type.Name + ", must inherit from BodyReplacementBase"));
				return;
			}
			BodyReplacementBase component = ((Component)player.thisPlayerBody).gameObject.GetComponent<BodyReplacementBase>();
			if ((Object)(object)component != (Object)null)
			{
				if (((object)component).GetType() == type)
				{
					return;
				}
				if (Object.op_Implicit((Object)(object)component))
				{
					Object.Destroy((Object)(object)component);
				}
			}
			((Component)player.thisPlayerBody).gameObject.AddComponent(type);
		}

		public static void RemovePlayerModelReplacement(PlayerControllerB player)
		{
			BodyReplacementBase component = ((Component)player.thisPlayerBody).gameObject.GetComponent<BodyReplacementBase>();
			if (Object.op_Implicit((Object)(object)component))
			{
				Object.Destroy((Object)(object)component);
			}
		}
	}
	public class PlayerDeathTracker : MonoBehaviour
	{
		private bool _died;

		public bool Died
		{
			get
			{
				return _died;
			}
			set
			{
				_died = value;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}