using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
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 System.Threading;
using AdvancedCompany.Game;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterEmote.AssetScripts;
using BetterEmote.Patches;
using BetterEmote.Utils;
using EmotesAPI;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using LethalCompanyInputUtils.Api;
using LethalEmotesAPI;
using LethalEmotesAPI.Core;
using LethalEmotesAPI.Data;
using LethalEmotesAPI.ImportV2;
using LethalEmotesAPI.NetcodePatcher;
using LethalEmotesAPI.Patches;
using LethalEmotesAPI.Patches.ModCompat;
using LethalEmotesAPI.Utils;
using LethalEmotesApi.Ui;
using LethalEmotesApi.Ui.Data;
using LethalEmotesApi.Ui.Db;
using LethalEmotesApi.Ui.Dmca;
using LethalInternship.AI;
using LethalVRM;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using MonoMod.RuntimeDetour;
using MoreCompany.Cosmetics;
using Newtonsoft.Json;
using TMPro;
using TooManyEmotes;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Rendering;
using UnityEngine.UI;

[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 = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("BetterEmotes")]
[assembly: IgnoresAccessChecksTo("LethalInternship")]
[assembly: IgnoresAccessChecksTo("LethalVRM")]
[assembly: IgnoresAccessChecksTo("MToon")]
[assembly: IgnoresAccessChecksTo("UniGLTF")]
[assembly: IgnoresAccessChecksTo("UniGLTF.Utils")]
[assembly: IgnoresAccessChecksTo("UniHumanoid")]
[assembly: IgnoresAccessChecksTo("VRM10")]
[assembly: IgnoresAccessChecksTo("VrmLib")]
[assembly: IgnoresAccessChecksTo("VRMShaders.GLTF.IO.Runtime")]
[assembly: IgnoresAccessChecksTo("VRMShaders.VRM.IO.Runtime")]
[assembly: IgnoresAccessChecksTo("VRMShaders.VRM10.Format.Runtime")]
[assembly: IgnoresAccessChecksTo("VRMShaders.VRM10.MToon10.Runtime")]
[assembly: AssemblyCompany("LethalEmotesAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c1359ee9f69fcd2b410710abf3f6ec5d934b9532")]
[assembly: AssemblyProduct("LethalEmotesAPI")]
[assembly: AssemblyTitle("LethalEmotesAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
internal static class AnimationReplacements
{
	internal static GameObject g;

	internal static bool setup;

	internal static void RunAll()
	{
		ChangeAnims();
	}

	internal static BoneMapper Import(GameObject prefab, string skeleton, int[] pos, bool hidemesh = true)
	{
		GameObject val = Object.Instantiate<GameObject>(Assets.Load<GameObject>("@CustomEmotesAPI_customemotespackage:assets/animationreplacements/commando.prefab"));
		GameObject val2 = Object.Instantiate<GameObject>(Assets.Load<GameObject>(skeleton));
		val2.GetComponent<Animator>().runtimeAnimatorController = val.GetComponent<Animator>().runtimeAnimatorController;
		BoneMapper result = ApplyAnimationStuff(prefab, val2, pos, hidemesh, jank: false, revertBonePositions: true);
		val.transform.SetParent(val2.transform);
		return result;
	}

	public static void DebugBones(GameObject fab)
	{
		SkinnedMeshRenderer[] componentsInChildren = fab.GetComponentsInChildren<SkinnedMeshRenderer>();
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append($"rendererererer: {componentsInChildren[0]}\n");
		stringBuilder.Append($"bone count: {componentsInChildren[0].bones.Length}\n");
		stringBuilder.Append($"mesh count: {componentsInChildren.Length}\n");
		stringBuilder.Append("root bone: " + ((Object)componentsInChildren[0].rootBone).name + "\n");
		stringBuilder.Append(((object)fab).ToString() + ":\n");
		SkinnedMeshRenderer[] array = componentsInChildren;
		foreach (SkinnedMeshRenderer val in array)
		{
			if (val.bones.Length == 0)
			{
				stringBuilder.Append("No bones");
			}
			else
			{
				stringBuilder.Append("[");
				Transform[] bones = val.bones;
				foreach (Transform val2 in bones)
				{
					stringBuilder.Append("'" + ((Object)val2).name + "', ");
				}
				stringBuilder.Remove(stringBuilder.Length - 2, 2);
				stringBuilder.Append("]");
			}
			stringBuilder.Append("\n\n");
			DebugClass.Log(stringBuilder.ToString());
		}
	}

	internal static void ChangeAnims()
	{
	}

	internal static void ApplyAnimationStuff(GameObject bodyPrefab, string resource, int[] pos)
	{
		GameObject animcontroller = Assets.Load<GameObject>(resource);
		ApplyAnimationStuff(bodyPrefab, animcontroller, pos);
	}

	internal static BoneMapper ApplyAnimationStuff(GameObject bodyPrefab, GameObject animcontroller, int[] pos, bool hidemeshes = true, bool jank = false, bool revertBonePositions = false)
	{
		//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_020d: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		//IL_0298: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!animcontroller.GetComponentInChildren<Animator>().avatar.isHuman)
			{
				DebugClass.Log($"{animcontroller}'s avatar isn't humanoid, please fix it in unity!");
				return null;
			}
		}
		catch (Exception arg)
		{
			DebugClass.Log($"Had issue checking if avatar was humanoid: {arg}");
			throw;
		}
		try
		{
			if (hidemeshes)
			{
				SkinnedMeshRenderer[] componentsInChildren = animcontroller.GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer val in componentsInChildren)
				{
					val.sharedMesh = null;
				}
				MeshFilter[] componentsInChildren2 = animcontroller.GetComponentsInChildren<MeshFilter>();
				foreach (MeshFilter val2 in componentsInChildren2)
				{
					val2.sharedMesh = null;
				}
			}
		}
		catch (Exception arg2)
		{
			DebugClass.Log($"Had trouble while hiding meshes: {arg2}");
			throw;
		}
		Transform transform = ((Component)bodyPrefab.GetComponentInChildren<Animator>()).transform;
		SkinnedMeshRenderer[] array = (SkinnedMeshRenderer[])(object)new SkinnedMeshRenderer[pos.Length];
		SkinnedMeshRenderer emoteSkeletonSMR;
		try
		{
			emoteSkeletonSMR = animcontroller.GetComponentsInChildren<SkinnedMeshRenderer>()[0];
		}
		catch (Exception arg3)
		{
			DebugClass.Log($"Had trouble setting emote skeletons SkinnedMeshRenderer: {arg3}");
			throw;
		}
		try
		{
			for (int k = 0; k < pos.Length; k++)
			{
				array[k] = bodyPrefab.GetComponentsInChildren<SkinnedMeshRenderer>()[pos[k]];
			}
		}
		catch (Exception arg4)
		{
			DebugClass.Log($"Had trouble setting the original skeleton's skinned mesh renderer: {arg4}");
			throw;
		}
		BoneMapper boneMapper = animcontroller.AddComponent<BoneMapper>();
		try
		{
			boneMapper.jank = jank;
			boneMapper.emoteSkeletonSMR = emoteSkeletonSMR;
			boneMapper.basePlayerModelSMR = array;
			boneMapper.bodyPrefab = bodyPrefab;
			boneMapper.basePlayerModelAnimator = ((Component)transform).GetComponentInChildren<Animator>();
			boneMapper.emoteSkeletonAnimator = animcontroller.GetComponentInChildren<Animator>();
		}
		catch (Exception arg5)
		{
			DebugClass.Log($"Had issue when setting up BoneMapper settings 1: {arg5}");
			throw;
		}
		try
		{
			GameObject val3 = Assets.Load<GameObject>("assets/customstuff/scavEmoteSkeleton.prefab");
			val3.transform.localScale = new Vector3(1.1216f, 1.1216f, 1.1216f);
			float num = Vector3.Distance(val3.GetComponentInChildren<Animator>().GetBoneTransform((HumanBodyBones)10).position, val3.GetComponentInChildren<Animator>().GetBoneTransform((HumanBodyBones)5).position);
			float num2 = Vector3.Distance(animcontroller.GetComponentInChildren<Animator>().GetBoneTransform((HumanBodyBones)10).position, animcontroller.GetComponentInChildren<Animator>().GetBoneTransform((HumanBodyBones)5).position);
			boneMapper.scale = num2 / num;
			boneMapper.model = ((Component)transform).gameObject;
		}
		catch (Exception arg6)
		{
			DebugClass.Log($"Had issue when setting up BoneMapper settings 2: {arg6}");
			throw;
		}
		try
		{
			animcontroller.transform.parent = transform;
			animcontroller.transform.localPosition = Vector3.zero;
			animcontroller.transform.eulerAngles = bodyPrefab.transform.eulerAngles;
			animcontroller.transform.localScale = Vector3.one;
		}
		catch (Exception arg7)
		{
			DebugClass.Log($"Had trouble setting emote skeletons parent: {arg7}");
			throw;
		}
		boneMapper.revertTransform = revertBonePositions;
		return boneMapper;
	}
}
public struct WorldProp
{
	internal GameObject prop;

	internal JoinSpot[] joinSpots;

	public WorldProp(GameObject _prop, JoinSpot[] _joinSpots)
	{
		prop = _prop;
		joinSpots = _joinSpots;
	}
}
public enum TempThirdPerson
{
	none,
	on,
	off
}
public class BoneMapper : MonoBehaviour
{
	public static List<AudioClip[]> primaryAudioClips = new List<AudioClip[]>();

	public static List<AudioClip[]> secondaryAudioClips = new List<AudioClip[]>();

	public static List<AudioClip[]> primaryDMCAFreeAudioClips = new List<AudioClip[]>();

	public static List<AudioClip[]> secondaryDMCAFreeAudioClips = new List<AudioClip[]>();

	public GameObject audioObject;

	public SkinnedMeshRenderer emoteSkeletonSMR;

	public SkinnedMeshRenderer[] basePlayerModelSMR;

	public Animator basePlayerModelAnimator;

	public Animator emoteSkeletonAnimator;

	public int h;

	public List<BonePair> pairs = new List<BonePair>();

	public float timer = 0f;

	public GameObject model;

	private bool twopart = false;

	public static Dictionary<string, CustomAnimationClip> animClips = new Dictionary<string, CustomAnimationClip>();

	public CustomAnimationClip currentClip = null;

	public string currentClipName = "none";

	public string prevClipName = "none";

	public CustomAnimationClip prevClip = null;

	internal static float Current_MSX = 69f;

	internal static List<BoneMapper> allMappers = new List<BoneMapper>();

	internal static List<WorldProp> allWorldProps = new List<WorldProp>();

	public bool local = false;

	internal static bool moving = false;

	internal static bool attacking = false;

	public bool jank = false;

	public List<GameObject> props = new List<GameObject>();

	public float scale = 1f;

	internal int desiredEvent = 0;

	public int currEvent = 0;

	public float autoWalkSpeed = 0f;

	public bool overrideMoveSpeed = false;

	public bool autoWalk = false;

	public GameObject currentEmoteSpot = null;

	public GameObject reservedEmoteSpot = null;

	public bool worldProp = false;

	public bool ragdolling = false;

	public GameObject bodyPrefab;

	public int uniqueSpot = -1;

	public bool preserveProps = false;

	public bool preserveParent = false;

	internal bool useSafePositionReset = false;

	public List<EmoteLocation> emoteLocations = new List<EmoteLocation>();

	private List<string> dontAnimateUs = new List<string>();

	public bool enableAnimatorOnDeath = true;

	public bool revertTransform = false;

	public bool oneFrameAnimatorLeeWay = false;

	public GameObject mapperBody;

	public PlayerControllerB playerController;

	public EnemyAI enemyController;

	public Transform mapperBodyTransform;

	public static bool firstMapperSpawn = true;

	public static List<List<AudioSource>> listOfCurrentEmoteAudio = new List<List<AudioSource>>();

	public List<EmoteConstraint> cameraConstraints = new List<EmoteConstraint>();

	public List<EmoteConstraint> itemHolderConstraints = new List<EmoteConstraint>();

	public Transform itemHolderPosition;

	public List<EmoteConstraint> additionalConstraints = new List<EmoteConstraint>();

	public EmoteConstraint thirdPersonConstraint;

	public static Dictionary<string, string> customNamePairs = new Dictionary<string, string>();

	public Vector3 positionBeforeRootMotion = new Vector3(69f, 69f, 69f);

	public Quaternion rotationBeforeRootMotion = Quaternion.identity;

	public float currentAudioLevel = 0f;

	public TempThirdPerson temporarilyThirdPerson = TempThirdPerson.none;

	internal int originalCullingMask;

	internal bool needToTurnOffRenderingThing = false;

	public BoneMapper currentlyLockedBoneMapper;

	public static Dictionary<GameObject, BoneMapper> playersToMappers = new Dictionary<GameObject, BoneMapper>();

	public AudioSource personalAudioSource;

	public InteractTrigger personalTrigger;

	public string currentJoinButton;

	public bool isServer = false;

	public int networkId;

	public bool joined = false;

	public bool canThirdPerson = true;

	internal bool canEmote = false;

	public bool isValidPlayer = false;

	internal bool canStop = true;

	internal List<EmoteConstraint> cosmeticConstraints = new List<EmoteConstraint>();

	internal GameObject originalCosmeticPosition;

	public GameObject parentGameObject;

	public bool positionLock;

	public bool rotationLock;

	public bool scaleLock;

	private Vector3 ogScale = new Vector3(-69f, -69f, -69f);

	private Vector3 ogVisorScale = Vector3.zeroVector;

	private Vector3 scaleDiff = Vector3.one;

	public GameObject rotationPoint;

	public GameObject desiredCameraPos;

	public GameObject realCameraPos;

	private bool ranSinceLastAnim = false;

	public Vector3 deltaPos = new Vector3(0f, 0f, 0f);

	public Quaternion deltaRot = Quaternion.identity;

	public Vector3 prevPosition = Vector3.zero;

	public Quaternion prevRotation = Quaternion.identity;

	public Vector3 prevMapperPos = new Vector3(69f, 69f, 69f);

	public Vector3 prevMapperRot = default(Vector3);

	public bool justSwitched = false;

	public bool isEnemy = false;

	public bool isInThirdPerson = false;

	public int originalLayer = -1;

	internal bool needToTurnOffShadows = true;

	internal bool needToTurnOffCosmetics = true;

	private Renderer helmetRenderer = null;

	public static string GetRealAnimationName(string animationName)
	{
		if (customNamePairs.ContainsKey(animationName))
		{
			return customNamePairs[animationName];
		}
		return animationName;
	}

	private IEnumerator lockBonesAfterAFrame()
	{
		yield return (object)new WaitForEndOfFrame();
		LockBones();
	}

	public void PlayAnim(string s, int pos, int eventNum)
	{
		desiredEvent = eventNum;
		s = GetRealAnimationName(s);
		PlayAnim(s, pos);
	}

	public void PlayAnim(string s, int pos)
	{
		//IL_058d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0593: Expected O, but got Unknown
		ranSinceLastAnim = false;
		s = GetRealAnimationName(s);
		prevClipName = currentClipName;
		if (s != "none")
		{
			if (!animClips.ContainsKey(s))
			{
				DebugClass.Log("No emote bound to the name [" + s + "]");
				return;
			}
			if (animClips[s] == null || !animClips[s].animates)
			{
				CustomEmotesAPI.Changed(s, this);
				return;
			}
		}
		((Behaviour)emoteSkeletonAnimator).enabled = true;
		dontAnimateUs.Clear();
		if (currentClip != null)
		{
			try
			{
				if (currentClip.syncronizeAnimation || currentClip.syncronizeAudio)
				{
					CustomAnimationClip.syncPlayerCount[currentClip.syncPos]--;
				}
				audioObject.GetComponent<AudioManager>().Stop();
			}
			catch (Exception arg)
			{
				DebugClass.Log($"had issue turning off audio before new audio played step 1: {arg}");
			}
			try
			{
				if ((Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null && currentClip.syncronizeAudio)
				{
					try
					{
						listOfCurrentEmoteAudio[currentClip.syncPos].Remove(audioObject.GetComponent<AudioSource>());
					}
					catch (Exception arg2)
					{
						DebugClass.Log($"had issue turning off audio before new audio played step 2: {arg2}");
						try
						{
							DebugClass.Log($"{prevClip.syncPos}");
							DebugClass.Log($"{currentClip.syncPos}");
							DebugClass.Log(listOfCurrentEmoteAudio[currentClip.syncPos]);
						}
						catch (Exception)
						{
						}
						try
						{
							DebugClass.Log("going to try a brute force method to avoid audio desync issues");
							foreach (List<AudioSource> item in listOfCurrentEmoteAudio)
							{
								if (item.Contains(audioObject.GetComponent<AudioSource>()))
								{
									item.Remove(audioObject.GetComponent<AudioSource>());
								}
							}
						}
						catch (Exception arg3)
						{
							DebugClass.Log($"wow {arg3}");
						}
					}
				}
			}
			catch (Exception ex2)
			{
				DebugClass.Log($"had issue turning off audio before new audio played step 3: {primaryAudioClips[currentClip.syncPos]} {currentClip.syncPos} {currEvent} {ex2}");
			}
			try
			{
				if (uniqueSpot != -1 && CustomAnimationClip.uniqueAnimations[currentClip.syncPos][uniqueSpot])
				{
					CustomAnimationClip.uniqueAnimations[currentClip.syncPos][uniqueSpot] = false;
					uniqueSpot = -1;
				}
			}
			catch (Exception arg4)
			{
				DebugClass.Log($"had issue turning off audio before new audio played step 4: {arg4}");
			}
		}
		currEvent = 0;
		currentClipName = s;
		if (s == "none")
		{
			UnlockBones();
			emoteSkeletonAnimator.Play("none", -1, 0f);
			twopart = false;
			prevClip = currentClip;
			currentClip = null;
			NewAnimation(null);
			CustomEmotesAPI.Changed(s, this);
		}
		else
		{
			if (BlacklistSettings.emotesDisabled.Contains(s))
			{
				return;
			}
			if (s != "none")
			{
				prevClip = currentClip;
				currentClip = animClips[s];
				if (currentClip == null)
				{
					return;
				}
				if (pos == -2)
				{
					pos = ((CustomAnimationClip.syncPlayerCount[animClips[s].syncPos] != 0) ? animClips[s].joinPref : animClips[s].startPref);
				}
				if (pos == -2)
				{
					for (int i = 0; i < CustomAnimationClip.uniqueAnimations[currentClip.syncPos].Count; i++)
					{
						if (!CustomAnimationClip.uniqueAnimations[currentClip.syncPos][i])
						{
							pos = i;
							uniqueSpot = pos;
							CustomAnimationClip.uniqueAnimations[currentClip.syncPos][uniqueSpot] = true;
							break;
						}
					}
					if (uniqueSpot == -1)
					{
						pos = -1;
					}
				}
				if (pos == -1)
				{
					pos = Random.Range(0, currentClip.clip.Length);
				}
				((MonoBehaviour)this).StartCoroutine(lockBonesAfterAFrame());
			}
			AnimatorOverrideController animController = new AnimatorOverrideController(emoteSkeletonAnimator.runtimeAnimatorController);
			if (currentClip.syncronizeAnimation || currentClip.syncronizeAudio)
			{
				CustomAnimationClip.syncPlayerCount[currentClip.syncPos]++;
				if (CustomAnimationClip.syncPlayerCount[currentClip.syncPos] == 1)
				{
					CustomAnimationClip.syncTimer[currentClip.syncPos] = 0f;
				}
			}
			if ((Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null)
			{
				if (CustomAnimationClip.syncPlayerCount[currentClip.syncPos] == 1 && currentClip.syncronizeAudio)
				{
					if (desiredEvent != -1)
					{
						currEvent = desiredEvent;
					}
					else
					{
						currEvent = Random.Range(0, primaryAudioClips[currentClip.syncPos].Length);
					}
					foreach (BoneMapper allMapper in allMappers)
					{
						allMapper.currEvent = currEvent;
					}
					if (currentClip.customPostEventCodeSync != null)
					{
						currentClip.customPostEventCodeSync(this);
					}
				}
				else if (!currentClip.syncronizeAudio)
				{
					currEvent = Random.Range(0, primaryAudioClips[currentClip.syncPos].Length);
					if (currentClip.customPostEventCodeNoSync != null)
					{
						currentClip.customPostEventCodeNoSync(this);
					}
				}
				currentAudioLevel = currentClip.audioLevel;
				audioObject.GetComponent<AudioManager>().Play(currentClip.syncPos, currEvent, currentClip.looping, currentClip.syncronizeAudio, currentClip.willGetClaimed);
				if (currentClip.syncronizeAudio && (Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null)
				{
					listOfCurrentEmoteAudio[currentClip.syncPos].Add(audioObject.GetComponent<AudioSource>());
				}
			}
			SetAnimationSpeed(1f);
			StartAnimations(animController, pos, emoteSkeletonAnimator);
			if (local && CustomEmotesAPI.hudObject != null)
			{
				if (currentClip.displayName != "")
				{
					((TMP_Text)CustomEmotesAPI.currentEmoteText).text = currentClip.displayName;
				}
				else if (currentClip.customInternalName != "")
				{
					((TMP_Text)CustomEmotesAPI.currentEmoteText).text = currentClip.customInternalName;
				}
				else if (!currentClip.visibility)
				{
					((TMP_Text)CustomEmotesAPI.currentEmoteText).text = "";
				}
				else
				{
					((TMP_Text)CustomEmotesAPI.currentEmoteText).text = currentClipName;
				}
			}
			twopart = false;
			NewAnimation(currentClip.joinSpots);
			if (currentClip.usesNewImportSystem)
			{
				CustomEmotesAPI.Changed(currentClip.customInternalName, this);
			}
			else
			{
				CustomEmotesAPI.Changed(s, this);
			}
		}
	}

	public void StartAnimations(AnimatorOverrideController animController, int pos, Animator animator)
	{
		if (currentClip.secondaryClip != null && currentClip.secondaryClip.Length != 0)
		{
			bool flag = true;
			if (CustomAnimationClip.syncTimer[currentClip.syncPos] > currentClip.clip[pos].length)
			{
				animController["Floss"] = currentClip.secondaryClip[pos];
				animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)animController;
				animator.Play("Loop", -1, (CustomAnimationClip.syncTimer[currentClip.syncPos] - currentClip.clip[pos].length) % currentClip.secondaryClip[pos].length / currentClip.secondaryClip[pos].length);
			}
			else
			{
				animController["Dab"] = currentClip.clip[pos];
				animController["nobones"] = currentClip.secondaryClip[pos];
				animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)animController;
				animator.Play("PoopToLoop", -1, CustomAnimationClip.syncTimer[currentClip.syncPos] % currentClip.clip[pos].length / currentClip.clip[pos].length);
			}
		}
		else if (((Motion)currentClip.clip[0]).isLooping)
		{
			animController["Floss"] = currentClip.clip[pos];
			animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)animController;
			if (currentClip.clip[pos].length != 0f)
			{
				animator.Play("Loop", -1, CustomAnimationClip.syncTimer[currentClip.syncPos] % currentClip.clip[pos].length / currentClip.clip[pos].length);
			}
			else
			{
				animator.Play("Loop", -1, 0f);
			}
		}
		else
		{
			animController["Default Dance"] = currentClip.clip[pos];
			animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)animController;
			animator.Play("Poop", -1, CustomAnimationClip.syncTimer[currentClip.syncPos] % currentClip.clip[pos].length / currentClip.clip[pos].length);
		}
	}

	public static void PreviewAnimations(Animator animator, string animation)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		AnimatorOverrideController val = new AnimatorOverrideController(animator.runtimeAnimatorController);
		animation = GetRealAnimationName(animation);
		if (!animClips.ContainsKey(animation))
		{
			return;
		}
		CustomAnimationClip customAnimationClip = animClips[animation];
		if (customAnimationClip != null && customAnimationClip.clip != null && customAnimationClip.clip[0] != null)
		{
			int num = 0;
			if (customAnimationClip.secondaryClip != null && customAnimationClip.secondaryClip.Length != 0)
			{
				val["Dab"] = customAnimationClip.clip[num];
				val["nobones"] = customAnimationClip.secondaryClip[num];
				animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)val;
				animator.Play("PoopToLoop", -1, 0f);
			}
			else if (((Motion)customAnimationClip.clip[0]).isLooping)
			{
				val["Floss"] = customAnimationClip.clip[num];
				animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)val;
				animator.Play("Loop", -1, 0f);
			}
			else
			{
				val["Default Dance"] = customAnimationClip.clip[num];
				animator.runtimeAnimatorController = (RuntimeAnimatorController)(object)val;
				animator.Play("Poop", -1, 0f);
			}
		}
	}

	public void SetAnimationSpeed(float speed)
	{
		emoteSkeletonAnimator.speed = speed;
	}

	internal void NewAnimation(JoinSpot[] locations)
	{
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: 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_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0189: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: 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)
		try
		{
			try
			{
				if (local)
				{
					((Component)itemHolderPosition).gameObject.GetComponent<EmoteConstraint>().DeactivateConstraints();
				}
			}
			catch (Exception)
			{
			}
			try
			{
				emoteLocations.Clear();
				autoWalkSpeed = 0f;
				autoWalk = false;
				overrideMoveSpeed = false;
				if (Object.op_Implicit((Object)(object)parentGameObject) && !preserveParent)
				{
					parentGameObject = null;
				}
			}
			catch (Exception)
			{
			}
			try
			{
				useSafePositionReset = currentClip.useSafePositionReset;
			}
			catch (Exception)
			{
				useSafePositionReset = true;
			}
			try
			{
				if (preserveParent)
				{
					preserveParent = false;
				}
				else
				{
					mapperBody.gameObject.transform.localEulerAngles = new Vector3(0f, mapperBody.gameObject.transform.localEulerAngles.y, 0f);
					if (ogScale != new Vector3(-69f, -69f, -69f))
					{
						mapperBody.transform.localScale = ogScale;
						if (local)
						{
							playerController.localVisor.localScale = ogVisorScale;
						}
						ogScale = new Vector3(-69f, -69f, -69f);
						if (CustomEmotesAPI.ModelReplacementAPIPresent)
						{
							ModelReplacementAPICompat.ScaleModelAsMapper(Vector3.one, Vector3.one, playerController);
						}
						if (CustomEmotesAPI.VRMPresent)
						{
							VRMCompat.ScaleModelAsMapper(Vector3.one, Vector3.one, playerController);
						}
					}
					Collider[] componentsInChildren = mapperBody.GetComponentsInChildren<Collider>();
					foreach (Collider val in componentsInChildren)
					{
						val.enabled = true;
					}
					if (Object.op_Implicit((Object)(object)mapperBody.GetComponent<CharacterController>()))
					{
						((Collider)mapperBody.GetComponent<CharacterController>()).enabled = true;
					}
				}
			}
			catch (Exception)
			{
			}
			if (preserveProps)
			{
				preserveProps = false;
			}
			else
			{
				foreach (GameObject prop in props)
				{
					if (Object.op_Implicit((Object)(object)prop))
					{
						Object.Destroy((Object)(object)prop);
					}
				}
				props.Clear();
			}
			if (locations != null)
			{
				for (int j = 0; j < locations.Length; j++)
				{
					SpawnJoinSpot(locations[j]);
				}
			}
		}
		catch (Exception arg)
		{
			DebugClass.Log($"error during new animation: {arg}");
		}
	}

	public void ScaleProps()
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		foreach (GameObject prop in props)
		{
			if (Object.op_Implicit((Object)(object)prop))
			{
				Transform parent = prop.transform.parent;
				prop.transform.SetParent((Transform)null);
				prop.transform.localScale = new Vector3(scale * 1.15f, scale * 1.15f, scale * 1.15f);
				prop.transform.SetParent(parent);
			}
		}
	}

	public void UpdateHoverTip(string emoteName)
	{
		//IL_001d: 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)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		if (personalTrigger != null)
		{
			InputBinding val = EmotesInputSettings.Instance.JoinEmote.bindings[0];
			currentJoinButton = InputControlPath.ToHumanReadableString(((InputBinding)(ref val)).effectivePath, (HumanReadableStringOptions)2, (InputControl)null);
			personalTrigger.hoverTip = "Press [" + currentJoinButton + "] to join " + emoteName;
		}
	}

	internal IEnumerator preventEmotesInSpawnAnimation()
	{
		yield return (object)new WaitForSeconds(3f);
		foreach (EmoteConstraint item in cosmeticConstraints)
		{
			item.ActivateConstraints();
		}
		canEmote = true;
	}

	private void Start()
	{
		//IL_0544: Unknown result type (might be due to invalid IL or missing references)
		//IL_0591: Unknown result type (might be due to invalid IL or missing references)
		//IL_0598: Expected O, but got Unknown
		//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0607: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		if (worldProp)
		{
			return;
		}
		PlayerControllerB componentInParent = ((Component)((Component)this).transform).GetComponentInParent<PlayerControllerB>();
		if (Object.op_Implicit((Object)(object)((Component)((Component)this).transform).GetComponentInParent<EnemyAI>()) || (componentInParent != null && Object.op_Implicit((Object)(object)((Component)componentInParent).GetComponentInChildren<EnemyAI>())))
		{
			EnemyAI val = ((Component)((Component)this).transform).GetComponentInParent<EnemyAI>();
			if (val == null)
			{
				val = ((Component)componentInParent).GetComponentInChildren<EnemyAI>();
			}
			mapperBody = ((Component)val).gameObject;
			networkId = -1;
			isEnemy = CustomEmotesAPI.localMapper.isServer;
			enemyController = val;
		}
		else if (Object.op_Implicit((Object)(object)componentInParent))
		{
			mapperBody = ((Component)componentInParent).gameObject;
			networkId = (int)((NetworkBehaviour)mapperBody.GetComponent<PlayerControllerB>()).NetworkObjectId;
		}
		else
		{
			networkId = -1;
			mapperBody = ((Component)this).gameObject;
		}
		if (enemyController == null)
		{
			playerController = mapperBody.GetComponent<PlayerControllerB>();
		}
		isValidPlayer = playerController != null;
		if (playersToMappers.ContainsKey(mapperBody))
		{
			playersToMappers[mapperBody] = this;
		}
		else
		{
			playersToMappers.Add(mapperBody, this);
		}
		mapperBodyTransform = mapperBody.transform;
		allMappers.Add(this);
		if (playerController != null)
		{
			GameObject gameObject = ((Component)mapperBody.gameObject.transform.Find("PlayerPhysicsBox")).gameObject;
			gameObject.tag = "InteractTrigger";
			personalTrigger = gameObject.AddComponent<InteractTrigger>();
			personalTrigger.interactable = false;
			personalTrigger.hoverIcon = Object.Instantiate<Sprite>(Assets.Load<Sprite>("assets/fineilldoitmyself/nothing.png"));
			personalTrigger.disabledHoverIcon = Object.Instantiate<Sprite>(Assets.Load<Sprite>("assets/fineilldoitmyself/nothing.png"));
			personalTrigger.disabledHoverTip = "";
			UpdateHoverTip("none");
		}
		GameObject val2 = Object.Instantiate<GameObject>(Assets.Load<GameObject>("assets/source1.prefab"));
		((Object)val2).name = ((Object)this).name + "_AudioObject";
		val2.transform.SetParent(mapperBody.transform);
		val2.transform.localPosition = Vector3.zero;
		SphereCollider val3 = val2.AddComponent<SphereCollider>();
		val3.radius = 0.01f;
		((Collider)val3).isTrigger = true;
		val2.layer = 6;
		personalAudioSource = val2.GetComponent<AudioSource>();
		val2.AddComponent<AudioManager>().Setup(personalAudioSource, this);
		personalAudioSource.playOnAwake = false;
		personalAudioSource.volume = Settings.EmotesVolume.Value / 100f;
		audioObject = val2;
		int num = 0;
		if (true)
		{
			SkinnedMeshRenderer[] array = basePlayerModelSMR;
			foreach (SkinnedMeshRenderer val4 in array)
			{
				int num2 = 0;
				for (int j = 0; j < emoteSkeletonSMR.bones.Length; j++)
				{
					for (int k = num2; k < val4.bones.Length; k++)
					{
						if (emoteSkeletonSMR.bones[j] != null && ((Object)emoteSkeletonSMR.bones[j]).name == ((Object)val4.bones[k]).name && !Object.op_Implicit((Object)(object)((Component)val4.bones[k]).gameObject.GetComponent<EmoteConstraint>()))
						{
							num2 = k;
							EmoteConstraint emoteConstraint = ((Component)val4.bones[k]).gameObject.GetComponent<EmoteConstraint>();
							if (emoteConstraint == null)
							{
								emoteConstraint = ((Component)val4.bones[k]).gameObject.AddComponent<EmoteConstraint>();
							}
							else
							{
								emoteConstraint.Reset();
							}
							emoteConstraint.AddSource(ref val4.bones[k], ref emoteSkeletonSMR.bones[j]);
							emoteConstraint.revertTransform = revertTransform;
							break;
						}
						if (k == num2 - 1)
						{
							break;
						}
						if (num2 > 0 && k == val4.bones.Length - 1)
						{
							k = -1;
						}
					}
				}
			}
		}
		if (jank)
		{
			SkinnedMeshRenderer[] array2 = basePlayerModelSMR;
			foreach (SkinnedMeshRenderer val5 in array2)
			{
				for (int m = 0; m < val5.bones.Length; m++)
				{
					try
					{
						if (Object.op_Implicit((Object)(object)((Component)val5.bones[m]).gameObject.GetComponent<EmoteConstraint>()))
						{
							((Component)val5.bones[m]).gameObject.GetComponent<EmoteConstraint>().ActivateConstraints();
						}
					}
					catch (Exception arg)
					{
						DebugClass.Log($"{arg}");
					}
				}
			}
		}
		((Component)this).transform.localPosition = Vector3.zero;
		CustomEmotesAPI.MapperCreated(this);
		if (playerController != null)
		{
			((MonoBehaviour)this).StartCoroutine(SetupHandConstraint());
		}
		((MonoBehaviour)this).StartCoroutine(preventEmotesInSpawnAnimation());
		((MonoBehaviour)this).StartCoroutine(GetLocal());
		GameObject val6 = new GameObject();
		((Object)val6).name = "BoneMapperHolder";
		val6.transform.SetParent(mapperBody.transform);
		val6.transform.localEulerAngles = ((Component)this).transform.localEulerAngles;
		val6.transform.position = ((Component)this).transform.position;
		((Component)this).transform.SetParent(val6.transform);
		val6.transform.localPosition = Vector3.zero;
	}

	public IEnumerator SetupHandConstraint()
	{
		while (!Object.op_Implicit((Object)(object)CustomEmotesAPI.localMapper))
		{
			yield return (object)new WaitForEndOfFrame();
		}
		itemHolderPosition = ((Component)this).GetComponentInChildren<Animator>().GetBoneTransform((HumanBodyBones)18).Find("ServerItemHolder");
		itemHolderConstraints.Add(EmoteConstraint.AddConstraint(((Component)playerController.serverItemHolder).gameObject, this, itemHolderPosition, needToFix: true));
		itemHolderConstraints.Add(EmoteConstraint.AddConstraint(((Component)playerController.localItemHolder).gameObject, this, itemHolderPosition, needToFix: true));
		((Component)itemHolderPosition).gameObject.AddComponent<EmoteConstraint>();
	}

	public void AssignParentGameObject(GameObject youAreTheFather, bool lockPosition, bool lockRotation, bool lockScale, bool scaleAsScavenger = true, bool disableCollider = true)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: 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_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)parentGameObject))
		{
			NewAnimation(null);
		}
		ogScale = mapperBody.transform.localScale;
		if (local)
		{
			ogVisorScale = playerController.localVisor.localScale;
		}
		if (scaleAsScavenger)
		{
			scaleDiff = ogScale / scale;
		}
		else
		{
			scaleDiff = ogScale;
		}
		parentGameObject = youAreTheFather;
		positionLock = lockPosition;
		rotationLock = lockRotation;
		scaleLock = lockScale;
		Collider[] componentsInChildren = mapperBody.GetComponentsInChildren<Collider>();
		foreach (Collider val in componentsInChildren)
		{
			val.enabled = !disableCollider;
		}
		if (Object.op_Implicit((Object)(object)mapperBody.GetComponent<CharacterController>()))
		{
			((Collider)mapperBody.GetComponent<CharacterController>()).enabled = !disableCollider;
		}
		if (disableCollider && Object.op_Implicit((Object)(object)currentEmoteSpot))
		{
			if (currentEmoteSpot.GetComponent<EmoteLocation>().validPlayers != 0)
			{
				currentEmoteSpot.GetComponent<EmoteLocation>().validPlayers--;
			}
			currentEmoteSpot.GetComponent<EmoteLocation>().SetColor();
			currentEmoteSpot = null;
		}
	}

	private void LocalFunctions()
	{
		if (!((Behaviour)emoteSkeletonAnimator).enabled)
		{
			return;
		}
		try
		{
			if (moving && currentClip != null && currentClip.stopOnMove)
			{
				CustomEmotesAPI.PlayAnimation("none");
			}
		}
		catch (Exception)
		{
		}
	}

	private IEnumerator GetLocal()
	{
		yield return (object)new WaitForEndOfFrame();
		try
		{
			if (!Object.op_Implicit((Object)(object)CustomEmotesAPI.localMapper) && (Object)(object)playerController == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				CustomEmotesAPI.localMapper = this;
				local = true;
				originalCosmeticPosition = new GameObject();
				originalCosmeticPosition.transform.parent = playerController.headCostumeContainerLocal.parent;
				originalCosmeticPosition.transform.position = playerController.headCostumeContainerLocal.position;
				originalCosmeticPosition.transform.localEulerAngles = playerController.headCostumeContainerLocal.localEulerAngles;
				EmoteConstraint e2 = ((Component)playerController.headCostumeContainerLocal).gameObject.AddComponent<EmoteConstraint>();
				e2.AddSource(playerController.headCostumeContainerLocal, emoteSkeletonAnimator.GetBoneTransform((HumanBodyBones)10));
				cosmeticConstraints.Add(e2);
				foreach (EmoteConstraint item in cosmeticConstraints)
				{
					item.emoteBone = originalCosmeticPosition.transform;
				}
				((Component)this).gameObject.AddComponent<NearestEmoterChecker>().self = this;
				isServer = ((NetworkBehaviour)playerController).IsServer && ((NetworkBehaviour)playerController).IsOwner;
				HealthbarAnimator.Setup(this);
				FixLocalArms();
				Camera c = playerController.gameplayCamera;
				if (c != null)
				{
					rotationPoint = new GameObject();
					rotationPoint.transform.SetParent(((Component)c).transform.parent.parent.parent.parent);
					rotationPoint.transform.localPosition = new Vector3(0f, 0.8f, 0f);
					rotationPoint.transform.localEulerAngles = Vector3.zero;
					desiredCameraPos = new GameObject();
					desiredCameraPos.transform.SetParent(rotationPoint.transform);
					desiredCameraPos.transform.localPosition = new Vector3(0.3f, 1f, -3f);
					desiredCameraPos.transform.localEulerAngles = Vector3.zero;
					realCameraPos = new GameObject();
					realCameraPos.transform.SetParent(desiredCameraPos.transform);
					realCameraPos.transform.localPosition = Vector3.zero;
					realCameraPos.transform.localEulerAngles = Vector3.zero;
					thirdPersonConstraint = EmoteConstraint.AddConstraint(((Component)((Component)c).transform.parent).gameObject, this, realCameraPos.transform, needToFix: false);
					thirdPersonConstraint.debug = true;
					if (((Object)basePlayerModelSMR[0].bones[32]).name == "spine.004")
					{
						GameObject camHolder = new GameObject();
						((Object)camHolder).name = "EmotesAPICameraHolderThing";
						camHolder.transform.parent = basePlayerModelSMR[0].bones[32];
						camHolder.transform.localEulerAngles = Vector3.zero;
						camHolder.transform.position = ((Component)c).transform.parent.position;
						Transform transform = camHolder.transform;
						transform.localPosition += new Vector3(0f, 0.045f, 0f);
						cameraConstraints.Add(EmoteConstraint.AddConstraint(((Component)((Component)c).transform.parent).gameObject, this, camHolder.transform, needToFix: false));
					}
					else
					{
						cameraConstraints.Add(EmoteConstraint.AddConstraint(((Component)((Component)c).transform.parent).gameObject, this, emoteSkeletonAnimator.GetBoneTransform((HumanBodyBones)10), needToFix: false));
					}
					GameObject cameraRotationObjectLmao = new GameObject();
					cameraRotationObjectLmao.transform.SetParent(((Component)c).transform);
					cameraRotationObjectLmao.transform.localPosition = new Vector3(0.01f, -0.048f, -0.053f);
					cameraRotationObjectLmao.transform.localEulerAngles = new Vector3(270f, 0f, 0f);
					cameraConstraints.Add(EmoteConstraint.AddConstraint(((Component)StartOfRound.Instance.localPlayerController.localVisor).gameObject, this, cameraRotationObjectLmao.transform, needToFix: false));
				}
			}
		}
		catch (Exception e)
		{
			DebugClass.Log(e);
		}
		if (!Object.op_Implicit((Object)(object)CustomEmotesAPI.localMapper))
		{
			((MonoBehaviour)this).StartCoroutine(GetLocal());
		}
	}

	internal void FixLocalArms()
	{
		int i = 0;
		for (int j = 0; j < basePlayerModelSMR[1].bones.Length; j++)
		{
			EmoteConstraint component = ((Component)basePlayerModelSMR[1].bones[j]).GetComponent<EmoteConstraint>();
			if (component == null)
			{
				continue;
			}
			int num = i;
			for (; i < basePlayerModelSMR[0].bones.Length; i++)
			{
				if (((Object)basePlayerModelSMR[1].bones[j]).name == ((Object)basePlayerModelSMR[0].bones[i]).name)
				{
					component.AddSource(basePlayerModelSMR[1].bones[j], basePlayerModelSMR[0].bones[i]);
					component.forceGlobalTransforms = true;
					break;
				}
				if (i == num - 1)
				{
					break;
				}
				if (num > 0 && i == basePlayerModelSMR[0].bones.Length - 1)
				{
					i = -1;
				}
			}
		}
	}

	private void TwoPartThing()
	{
		//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)
		if (ranSinceLastAnim)
		{
			return;
		}
		AnimatorStateInfo currentAnimatorStateInfo = emoteSkeletonAnimator.GetCurrentAnimatorStateInfo(0);
		if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("none"))
		{
			if (twopart)
			{
				ranSinceLastAnim = true;
				if (((Behaviour)emoteSkeletonAnimator).enabled && !jank)
				{
					UnlockBones();
				}
				if (!ragdolling)
				{
					oneFrameAnimatorLeeWay = true;
				}
				((Behaviour)emoteSkeletonAnimator).enabled = false;
				try
				{
					if (currentClip == null)
					{
						return;
					}
					CustomEmotesAPI.Changed("none", this);
					NewAnimation(null);
					if (currentClip.syncronizeAnimation || currentClip.syncronizeAudio)
					{
						CustomAnimationClip.syncPlayerCount[currentClip.syncPos]--;
					}
					if ((Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null)
					{
						audioObject.GetComponent<AudioManager>().Stop();
						if ((Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null && currentClip.syncronizeAudio)
						{
							listOfCurrentEmoteAudio[currentClip.syncPos].Remove(audioObject.GetComponent<AudioSource>());
						}
					}
					prevClip = currentClip;
					currentClip = null;
					return;
				}
				catch (Exception)
				{
					return;
				}
			}
			twopart = true;
		}
		else
		{
			twopart = false;
		}
	}

	private void Health()
	{
		if (!isValidPlayer || !playerController.isPlayerDead || !local || currentClip == null)
		{
			return;
		}
		UnlockBones();
		CustomEmotesAPI.PlayAnimation("none");
		foreach (GameObject prop in props)
		{
			if (Object.op_Implicit((Object)(object)prop))
			{
				Object.Destroy((Object)(object)prop);
			}
		}
		props.Clear();
	}

	private void WorldPropAndParent()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: 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_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: 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_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		if (!Object.op_Implicit((Object)(object)parentGameObject))
		{
			return;
		}
		if (positionLock)
		{
			mapperBody.gameObject.transform.position = parentGameObject.transform.position + new Vector3(0f, 1f, 0f);
			mapperBody.transform.position = parentGameObject.transform.position;
			PlayerControllerB obj = playerController;
			if (obj != null)
			{
				obj.ResetFallGravity();
			}
		}
		if (rotationLock)
		{
			mapperBody.transform.rotation = parentGameObject.transform.rotation;
		}
		if (scaleLock)
		{
			mapperBody.transform.localScale = new Vector3(parentGameObject.transform.localScale.x * scaleDiff.x, parentGameObject.transform.localScale.y * scaleDiff.y, parentGameObject.transform.localScale.z * scaleDiff.z);
			if (local)
			{
				playerController.localVisor.localScale = ogVisorScale * (mapperBody.transform.localScale.x / ogScale.x);
			}
			if (CustomEmotesAPI.ModelReplacementAPIPresent)
			{
				ModelReplacementAPICompat.ScaleModelAsMapper(mapperBody.transform.localScale, ogScale, playerController);
			}
			if (CustomEmotesAPI.VRMPresent)
			{
				VRMCompat.ScaleModelAsMapper(Vector3.one, Vector3.one, playerController);
			}
		}
	}

	private void Update()
	{
		if (!worldProp)
		{
			WorldPropAndParent();
			if (local)
			{
				LocalFunctions();
			}
			TwoPartThing();
			Health();
			SetDeltaPosition();
			RootMotion();
			CameraControls();
		}
	}

	internal bool ThirdPersonCheck()
	{
		return !CustomEmotesAPI.LCThirdPersonPresent && currentClip != null && (((currentClip.thirdPerson || Settings.thirdPersonType.Value == ThirdPersonType.All) && Settings.thirdPersonType.Value != ThirdPersonType.None) || temporarilyThirdPerson == TempThirdPerson.on) && canThirdPerson && temporarilyThirdPerson != TempThirdPerson.off;
	}

	public void CameraControls()
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: 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_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_00e6: 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_0110: Unknown result type (might be due to invalid IL or missing references)
		if (local && isInThirdPerson)
		{
			Vector3 val = mapperBodyTransform.position + new Vector3(0f, 1.75f * scale, 0f);
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(val, desiredCameraPos.transform.position - val);
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val2, ref val3, 10f, 268437761, (QueryTriggerInteraction)1))
			{
				realCameraPos.transform.position = ((Ray)(ref val2)).GetPoint(((RaycastHit)(ref val3)).distance - 0.25f);
			}
			else
			{
				realCameraPos.transform.position = ((Ray)(ref val2)).GetPoint(10f);
			}
			if (Vector3.Distance(realCameraPos.transform.position, val) > Vector3.Distance(desiredCameraPos.transform.position, val))
			{
				realCameraPos.transform.position = desiredCameraPos.transform.position;
			}
		}
	}

	private void SetDeltaPosition()
	{
		//IL_0008: 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_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)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		deltaPos = ((Component)this).transform.position - prevPosition;
		deltaRot = ((Component)this).transform.rotation * Quaternion.Inverse(prevRotation);
		prevPosition = ((Component)this).transform.position;
		prevRotation = ((Component)this).transform.rotation;
	}

	public void RootMotion()
	{
		//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: 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)
		//IL_00f1: 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_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_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: 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_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: 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_025f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!((Behaviour)emoteSkeletonAnimator).enabled)
			{
				return;
			}
			if (justSwitched)
			{
				justSwitched = false;
			}
			else
			{
				if (currentClip == null || currentClip.lockType != AnimationClipParams.LockType.rootMotion)
				{
					return;
				}
				if (local || isEnemy)
				{
					if (Settings.rootMotionType.Value != RootMotionType.None || isEnemy)
					{
						Vector3 position = ((Component)this).transform.position;
						Quaternion rotation = ((Component)this).transform.rotation;
						mapperBody.transform.position = new Vector3(emoteSkeletonAnimator.GetBoneTransform((HumanBodyBones)7).position.x, mapperBody.transform.position.y, emoteSkeletonAnimator.GetBoneTransform((HumanBodyBones)7).position.z);
						if (isEnemy || !isInThirdPerson)
						{
							mapperBody.transform.eulerAngles = new Vector3(mapperBody.transform.eulerAngles.x, emoteSkeletonAnimator.GetBoneTransform((HumanBodyBones)10).eulerAngles.y, mapperBody.transform.eulerAngles.z);
						}
						((Component)this).transform.position = position;
						((Component)this).transform.rotation = rotation;
						if (positionBeforeRootMotion != new Vector3(69f, 69f, 69f))
						{
							mapperBody.transform.position = positionBeforeRootMotion;
							mapperBody.transform.rotation = rotationBeforeRootMotion;
							positionBeforeRootMotion = new Vector3(69f, 69f, 69f);
						}
					}
					if (deltaPos != Vector3.zero || deltaRot != Quaternion.identity)
					{
						if (isEnemy)
						{
							EmoteNetworker.instance.SyncBoneMapperPos(((NetworkBehaviour)enemyController).NetworkObjectId, ((Component)this).transform.position, ((Component)this).transform.eulerAngles);
						}
						else
						{
							EmoteNetworker.instance.SyncBoneMapperPos(((NetworkBehaviour)playerController).NetworkObjectId, ((Component)this).transform.position, ((Component)this).transform.eulerAngles);
						}
					}
				}
				else
				{
					((Component)this).transform.position = prevMapperPos;
					((Component)this).transform.eulerAngles = prevMapperRot;
				}
			}
		}
		catch (Exception)
		{
		}
	}

	public int SpawnJoinSpot(JoinSpot joinSpot)
	{
		props.Add(Object.Instantiate<GameObject>(Assets.Load<GameObject>("@CustomEmotesAPI_customemotespackage:assets/emotejoiner/JoinVisual.prefab")));
		props[props.Count - 1].transform.SetParent(((Component)this).transform);
		((Object)props[props.Count - 1]).name = joinSpot.name;
		EmoteLocation emoteLocation = props[props.Count - 1].AddComponent<EmoteLocation>();
		emoteLocation.joinSpot = joinSpot;
		emoteLocation.owner = this;
		emoteLocations.Add(emoteLocation);
		return props.Count - 1;
	}

	public void JoinEmoteSpot()
	{
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: 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)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_015a: 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_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: 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)
		if (Object.op_Implicit((Object)(object)reservedEmoteSpot))
		{
			if (Object.op_Implicit((Object)(object)currentEmoteSpot))
			{
				if (currentEmoteSpot.GetComponent<EmoteLocation>().validPlayers != 0)
				{
					currentEmoteSpot.GetComponent<EmoteLocation>().validPlayers--;
				}
				currentEmoteSpot.GetComponent<EmoteLocation>().SetColor();
			}
			currentEmoteSpot = reservedEmoteSpot;
			reservedEmoteSpot = null;
		}
		int i;
		for (i = 0; i < ((Component)currentEmoteSpot.transform.parent).GetComponentsInChildren<EmoteLocation>().Length && !((Object)(object)((Component)currentEmoteSpot.transform.parent).GetComponentsInChildren<EmoteLocation>()[i] == (Object)(object)currentEmoteSpot.GetComponent<EmoteLocation>()); i++)
		{
		}
		if (!currentEmoteSpot.GetComponent<EmoteLocation>().owner.worldProp && currentEmoteSpot.GetComponent<EmoteLocation>().joinSpot.requireRaycastToJoin)
		{
			Vector3 val = mapperBodyTransform.position + new Vector3(0f, 1.75f * scale, 0f);
			BoneMapper owner = currentEmoteSpot.GetComponent<EmoteLocation>().owner;
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(val, owner.mapperBodyTransform.position - val);
			float num = Vector3.Distance(owner.mapperBodyTransform.position, mapperBodyTransform.position) + 2f;
			RaycastHit[] array = Physics.RaycastAll(val2, num, 8);
			RaycastHit[] array2 = array;
			RaycastHit val4 = default(RaycastHit);
			for (int j = 0; j < array2.Length; j++)
			{
				RaycastHit val3 = array2[j];
				if (Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref val3)).collider).gameObject.GetComponent<PlayerControllerB>()) && (Object)(object)playersToMappers[((Component)((RaycastHit)(ref val3)).collider).gameObject] == (Object)(object)owner)
				{
					if (Physics.Raycast(val2, ref val4, num, StartOfRound.Instance.allPlayersCollideWithMask, (QueryTriggerInteraction)1) && ((RaycastHit)(ref val4)).distance < ((RaycastHit)(ref val3)).distance)
					{
						return;
					}
					break;
				}
			}
		}
		EmoteNetworker.instance.SyncJoinSpot(mapperBody.GetComponent<NetworkObject>().NetworkObjectId, currentEmoteSpot.GetComponentInParent<NetworkObject>().NetworkObjectId, currentEmoteSpot.GetComponent<EmoteLocation>().owner.worldProp, i);
	}

	public void RemoveProp(int propPos)
	{
		Object.Destroy((Object)(object)props[propPos]);
	}

	public void SetAutoWalk(float speed, bool overrideBaseMovement, bool autoWalk)
	{
		autoWalkSpeed = speed;
		overrideMoveSpeed = overrideBaseMovement;
		this.autoWalk = autoWalk;
	}

	public void SetAutoWalk(float speed, bool overrideBaseMovement)
	{
		autoWalkSpeed = speed;
		overrideMoveSpeed = overrideBaseMovement;
		autoWalk = true;
	}

	internal IEnumerator waitForTwoFramesThenDisableA1()
	{
		yield return (object)new WaitForEndOfFrame();
	}

	private void OnDestroy()
	{
		if (playerController == null)
		{
			return;
		}
		playersToMappers.Remove(((Component)playerController).gameObject);
		if (worldProp)
		{
			return;
		}
		playersToMappers.Remove(mapperBody);
		PlayAnim("none", -1);
		try
		{
			if (currentClip != null)
			{
				((object)currentClip.clip[0]).ToString();
				NewAnimation(null);
				if ((currentClip.syncronizeAnimation || currentClip.syncronizeAudio) && CustomAnimationClip.syncPlayerCount[currentClip.syncPos] > 0)
				{
					CustomAnimationClip.syncPlayerCount[currentClip.syncPos]--;
				}
				if ((Object)(object)primaryAudioClips[currentClip.syncPos][currEvent] != (Object)null)
				{
					audioObject.GetComponent<AudioManager>().Stop();
					if (currentClip.syncronizeAudio)
					{
						listOfCurrentEmoteAudio[currentClip.syncPos].Remove(audioObject.GetComponent<AudioSource>());
					}
				}
				if (uniqueSpot != -1 && CustomAnimationClip.uniqueAnimations[currentClip.syncPos][uniqueSpot])
				{
					CustomAnimationClip.uniqueAnimations[currentClip.syncPos][uniqueSpot] = false;
					uniqueSpot = -1;
				}
				prevClip = currentClip;
				currentClip = null;
			}
		}
		catch (Exception)
		{
		}
		allMappers.Remove(this);
	}

	public void UnlockBones(bool animatorEnabled = true)
	{
		//IL_0007: 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)
		((Component)this).transform.localPosition = Vector3.zero;
		((Component)this).transform.eulerAngles = bodyPrefab.transform.eulerAngles;
		SkinnedMeshRenderer[] array = basePlayerModelSMR;
		foreach (SkinnedMeshRenderer val in array)
		{
			for (int j = 0; j < val.bones.Length; j++)
			{
				try
				{
					if (Object.op_Implicit((Object)(object)((Component)val.bones[j]).gameObject.GetComponent<EmoteConstraint>()))
					{
						((Component)val.bones[j]).gameObject.GetComponent<EmoteConstraint>().DeactivateConstraints();
					}
				}
				catch (Exception)
				{
					break;
				}
			}
		}
		foreach (EmoteConstraint cameraConstraint in cameraConstraints)
		{
			cameraConstraint.DeactivateConstraints();
		}
		foreach (EmoteConstraint itemHolderConstraint in itemHolderConstraints)
		{
			itemHolderConstraint.DeactivateConstraints();
		}
		foreach (EmoteConstraint additionalConstraint in additionalConstraints)
		{
			additionalConstraint.DeactivateConstraints();
		}
		if (thirdPersonConstraint != null)
		{
			thirdPersonConstraint.DeactivateConstraints();
		}
		DeThirdPerson();
	}

	public void LockBones()
	{
		//IL_000f: 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)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
		UnlockBones();
		((Component)this).transform.localPosition = Vector3.zero;
		bool flag = true;
		if (currentClip != null)
		{
			foreach (HumanBodyBones soloIgnoredBone in currentClip.soloIgnoredBones)
			{
				if (Object.op_Implicit((Object)(object)emoteSkeletonAnimator.GetBoneTransform(soloIgnoredBone)))
				{
					dontAnimateUs.Add(((Object)emoteSkeletonAnimator.GetBoneTransform(soloIgnoredBone)).name);
				}
			}
			foreach (HumanBodyBones rootIgnoredBone in currentClip.rootIgnoredBones)
			{
				if (Object.op_Implicit((Object)(object)emoteSkeletonAnimator.GetBoneTransform(rootIgnoredBone)))
				{
					dontAnimateUs.Add(((Object)emoteSkeletonAnimator.GetBoneTransform(rootIgnoredBone)).name);
				}
				Transform[] componentsInChildren = ((Component)emoteSkeletonAnimator.GetBoneTransform(rootIgnoredBone)).GetComponentsInChildren<Transform>();
				foreach (Transform val in componentsInChildren)
				{
					dontAnimateUs.Add(((Object)val).name);
				}
			}
			flag = !currentClip.forceCameraMode || (currentClip.forceCameraMode && currentClip.thirdPerson);
		}
		if (!jank)
		{
			((Renderer)emoteSkeletonSMR).enabled = true;
			SkinnedMeshRenderer[] array = basePlayerModelSMR;
			foreach (SkinnedMeshRenderer val2 in array)
			{
				for (int k = 0; k < val2.bones.Length; k++)
				{
					try
					{
						if (Object.op_Implicit((Object)(object)((Component)val2.bones[k]).gameObject.GetComponent<EmoteConstraint>()) && !dontAnimateUs.Contains(((Object)val2.bones[k]).name))
						{
							EmoteConstraint component = ((Component)val2.bones[k]).gameObject.GetComponent<EmoteConstraint>();
							component.ActivateConstraints();
							if ((Object)(object)val2 == (Object)(object)basePlayerModelSMR.First() && currentClip != null)
							{
								component.SetLocalTransforms(currentClip.localTransforms);
							}
						}
						else if (dontAnimateUs.Contains(((Object)val2.bones[k]).name))
						{
							((Component)val2.bones[k]).gameObject.GetComponent<EmoteConstraint>().DeactivateConstraints();
						}
					}
					catch (Exception arg)
					{
						DebugClass.Log($"{arg}");
					}
				}
			}
			foreach (EmoteConstraint itemHolderConstraint in itemHolderConstraints)
			{
				itemHolderConstraint.ActivateConstraints();
			}
			foreach (EmoteConstraint additionalConstraint in additionalConstraints)
			{
				additionalConstraint.ActivateConstraints();
			}
			LockCameraStuff(local && ThirdPersonCheck() && flag);
		}
		else
		{
			((MonoBehaviour)this).StartCoroutine(waitForTwoFramesThenDisableA1());
		}
	}

	public void LockCameraStuff(bool thirdPersonLock)
	{
		bool flag = false;
		if (currentClip != null)
		{
			flag = currentClip.allowThirdPerson && !currentClip.customInternalName.Contains("TooManyEmotes__");
		}
		if (thirdPersonLock && flag)
		{
			TurnOnThirdPerson();
		}
		else if (currentClip != null)
		{
			if (Settings.rootMotionType.Value != RootMotionType.None && (currentClip.lockType == AnimationClipParams.LockType.rootMotion || Settings.rootMotionType.Value == RootMotionType.All || currentClip.lockType == AnimationClipParams.LockType.lockHead))
			{
				((MonoBehaviour)this).StartCoroutine(ActivateCameraConstraintsAfterFrame(onlyY: false));
			}
			else if (currentClip.lockType == AnimationClipParams.LockType.headBobbing && Settings.rootMotionType.Value != RootMotionType.None)
			{
				((MonoBehaviour)this).StartCoroutine(ActivateCameraConstraintsAfterFrame(onlyY: true));
			}
		}
	}

	private IEnumerator ActivateCameraConstraintsAfterFrame(bool onlyY)
	{
		yield return (object)new WaitForEndOfFrame();
		foreach (EmoteConstraint item2 in cameraConstraints)
		{
			((Behaviour)item2).enabled = true;
			item2.ActivateConstraints();
			if (onlyY && (Object)(object)item2 != (Object)(object)cameraConstraints[cameraConstraints.Count - 1])
			{
				item2.onlyY = true;
			}
		}
		yield return (object)new WaitForEndOfFrame();
		foreach (EmoteConstraint item in cameraConstraints)
		{
			if (!((Behaviour)item).enabled)
			{
				((Behaviour)item).enabled = true;
				item.ActivateConstraints();
				if (onlyY && (Object)(object)item != (Object)(object)cameraConstraints[cameraConstraints.Count - 1])
				{
					item.onlyY = true;
				}
			}
		}
	}

	public void UnlockCameraStuff()
	{
		foreach (EmoteConstraint cameraConstraint in cameraConstraints)
		{
			cameraConstraint.DeactivateConstraints();
		}
		thirdPersonConstraint.DeactivateConstraints();
		DeThirdPerson();
	}

	public void TurnOnThirdPerson()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		if (helmetRenderer == null)
		{
			helmetRenderer = ((Component)((Component)playerController.localVisor).transform.GetChild(0)).GetComponent<Renderer>();
		}
		helmetRenderer.enabled = false;
		if ((int)((Renderer)playerController.thisPlayerModel).shadowCastingMode == 1)
		{
			needToTurnOffShadows = false;
		}
		((Renderer)playerController.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
		((Renderer)playerController.thisPlayerModelArms).shadowCastingMode = (ShadowCastingMode)3;
		((Component)playerController.thisPlayerModelLOD1).gameObject.SetActive(false);
		((Component)playerController.thisPlayerModelLOD2).gameObject.SetActive(false);
		if (originalLayer == -1)
		{
			originalLayer = ((Component)playerController.thisPlayerModel).gameObject.layer;
			originalCullingMask = playerController.gameplayCamera.cullingMask;
		}
		((Component)playerController.thisPlayerModel).gameObject.layer = 1;
		playerController.grabDistance = 5.65f;
		playerController.gameplayCamera.cullingMask = StartOfRound.Instance.spectateCamera.cullingMask;
		thirdPersonConstraint.ActivateConstraints();
		isInThirdPerson = true;
		foreach (EmoteConstraint cosmeticConstraint in cosmeticConstraints)
		{
			cosmeticConstraint.emoteBone = playerController.playerGlobalHead;
		}
		if (CustomEmotesAPI.MoreCompanyPresent)
		{
			try
			{
				needToTurnOffCosmetics = true;
				MoreCompanyCompat.TurnOnCosmetics(this);
			}
			catch (Exception arg)
			{
				DebugClass.Log($"couldn't turn on cosmetics: {arg}");
			}
		}
		if (CustomEmotesAPI.BetterEmotesPresent)
		{
			Transform val = ((Component)playerController).transform.Find("ScavengerModel/LEGS");
			if (val != null)
			{
				((Component)val).gameObject.layer = 31;
			}
		}
	}

	public void DeThirdPerson()
	{
		if (!isInThirdPerson)
		{
			return;
		}
		playerController.gameplayCamera.cullingMask = originalCullingMask;
		if (needToTurnOffShadows)
		{
			((Renderer)playerController.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)3;
		}
		needToTurnOffShadows = true;
		((Renderer)playerController.thisPlayerModelArms).shadowCastingMode = (ShadowCastingMode)0;
		((Component)playerController.thisPlayerModelLOD1).gameObject.SetActive(true);
		((Component)playerController.thisPlayerModelLOD2).gameObject.SetActive(true);
		helmetRenderer.enabled = true;
		((Component)playerController.thisPlayerModel).gameObject.layer = originalLayer;
		playerController.grabDistance = 3f;
		isInThirdPerson = false;
		foreach (EmoteConstraint cosmeticConstraint in cosmeticConstraints)
		{
			cosmeticConstraint.emoteBone = originalCosmeticPosition.transform;
		}
		if (CustomEmotesAPI.MoreCompanyPresent && needToTurnOffCosmetics)
		{
			try
			{
				MoreCompanyCompat.TurnOffCosmetics(this);
			}
			catch (Exception arg)
			{
				DebugClass.Log($"couldn't clear cosmetics: {arg}");
			}
		}
		if (CustomEmotesAPI.BetterEmotesPresent)
		{
			Transform val = ((Component)playerController).transform.Find("ScavengerModel/LEGS");
			if (val != null)
			{
				((Component)val).gameObject.layer = 0;
			}
		}
	}

	public void AttachItemHolderToTransform(Transform target)
	{
		((Component)itemHolderPosition).gameObject.GetComponent<EmoteConstraint>().AddSource(itemHolderPosition, target);
		((Component)itemHolderPosition).gameObject.GetComponent<EmoteConstraint>().ActivateConstraints();
	}
}
public class CustomAnimationClip : MonoBehaviour
{
	public AnimationClip[] clip;

	public AnimationClip[] secondaryClip;

	public bool looping;

	public string wwiseEvent;

	public bool syncronizeAudio;

	public List<HumanBodyBones> soloIgnoredBones;

	public List<HumanBodyBones> rootIgnoredBones;

	public bool dimAudioWhenClose;

	public bool stopOnAttack;

	public bool stopOnMove;

	public bool visibility;

	public int startPref;

	public int joinPref;

	public JoinSpot[] joinSpots;

	public bool useSafePositionReset;

	public string customInternalName;

	public Action<BoneMapper> customPostEventCodeSync;

	public Action<BoneMapper> customPostEventCodeNoSync;

	public bool syncronizeAnimation;

	public int syncPos;

	public static List<float> syncTimer = new List<float>();

	public static List<int> syncPlayerCount = new List<int>();

	public static List<List<bool>> uniqueAnimations = new List<List<bool>>();

	public bool vulnerableEmote = false;

	public AnimationClipParams.LockType lockType = AnimationClipParams.LockType.none;

	public bool willGetClaimed = false;

	public float audioLevel = 0.5f;

	public bool thirdPerson = false;

	public string displayName = "";

	public bool localTransforms = false;

	public BepInPlugin ownerPlugin;

	public bool usesNewImportSystem = false;

	public bool animates = true;

	public bool preventsMovement = false;

	public bool allowJoining = true;

	public string joinEmote = "";

	public bool forceCameraMode = false;

	public bool allowThirdPerson = true;

	public bool animateHealthbar = true;

	internal CustomAnimationClip(AnimationClip[] _clip, bool _loop, AudioClip[] primaryAudioClips = null, AudioClip[] secondaryAudioClips = null, HumanBodyBones[] rootBonesToIgnore = null, HumanBodyBones[] soloBonesToIgnore = null, AnimationClip[] _secondaryClip = null, bool dimWhenClose = false, bool stopWhenMove = false, bool stopWhenAttack = false, bool visible = true, bool syncAnim = false, bool syncAudio = false, int startPreference = -1, int joinPreference = -1, JoinSpot[] _joinSpots = null, bool safePositionReset = false, string customName = "", Action<BoneMapper> _customPostEventCodeSync = null, Action<BoneMapper> _customPostEventCodeNoSync = null, AnimationClipParams.LockType lockType = AnimationClipParams.LockType.none, AudioClip[] primaryDMCAFreeAudioClips = null, AudioClip[] secondaryDMCAFreeAudioClips = null, bool willGetClaimed = false, float audioLevel = 0.5f, bool thirdPerson = false, string displayName = "", BepInPlugin ownerPlugin = null, bool localTransforms = false, bool usesNewImportSystem = false, bool animates = true, bool preventsMovement = false, bool allowJoining = true, string joinEmote = "", bool forceCameraMode = false, bool allowThirdPerson = true, bool animateHealthbar = true)
	{
		if (rootBonesToIgnore == null)
		{
			rootBonesToIgnore = (HumanBodyBones[])(object)new HumanBodyBones[0];
		}
		if (soloBonesToIgnore == null)
		{
			soloBonesToIgnore = (HumanBodyBones[])(object)new HumanBodyBones[0];
		}
		clip = _clip;
		secondaryClip = _secondaryClip;
		looping = _loop;
		dimAudioWhenClose = dimWhenClose;
		stopOnAttack = stopWhenAttack;
		stopOnMove = stopWhenMove;
		visibility = visible;
		joinPref = joinPreference;
		startPref = startPreference;
		customPostEventCodeSync = _customPostEventCodeSync;
		customPostEventCodeNoSync = _customPostEventCodeNoSync;
		if (primaryAudioClips == null)
		{
			BoneMapper.primaryAudioClips.Add((AudioClip[])(object)new AudioClip[1]);
		}
		else
		{
			BoneMapper.primaryAudioClips.Add(primaryAudioClips);
		}
		if (secondaryAudioClips == null)
		{
			BoneMapper.secondaryAudioClips.Add((AudioClip[])(object)new AudioClip[1]);
		}
		else
		{
			BoneMapper.secondaryAudioClips.Add(secondaryAudioClips);
		}
		if (primaryDMCAFreeAudioClips == null)
		{
			BoneMapper.primaryDMCAFreeAudioClips.Add((AudioClip[])(object)new AudioClip[1]);
		}
		else
		{
			BoneMapper.primaryDMCAFreeAudioClips.Add(primaryDMCAFreeAudioClips);
		}
		if (secondaryDMCAFreeAudioClips == null)
		{
			BoneMapper.secondaryDMCAFreeAudioClips.Add((AudioClip[])(object)new AudioClip[1]);
		}
		else
		{
			BoneMapper.secondaryDMCAFreeAudioClips.Add(secondaryDMCAFreeAudioClips);
		}
		if (soloBonesToIgnore.Length != 0)
		{
			soloIgnoredBones = new List<HumanBodyBones>(soloBonesToIgnore);
		}
		else
		{
			soloIgnoredBones = new List<HumanBodyBones>();
		}
		if (rootBonesToIgnore.Length != 0)
		{
			rootIgnoredBones = new List<HumanBodyBones>(rootBonesToIgnore);
		}
		else
		{
			rootIgnoredBones = new List<HumanBodyBones>();
		}
		syncronizeAnimation = syncAnim;
		syncronizeAudio = syncAudio;
		syncPos = syncTimer.Count;
		syncTimer.Add(0f);
		syncPlayerCount.Add(0);
		if (_clip != null)
		{
			List<bool> list = new List<bool>();
			for (int i = 0; i < _clip.Length; i++)
			{
				list.Add(item: false);
			}
			uniqueAnimations.Add(list);
		}
		if (_joinSpots == null)
		{
			_joinSpots = new JoinSpot[0];
		}
		joinSpots = _joinSpots;
		useSafePositionReset = safePositionReset;
		customInternalName = customName;
		this.usesNewImportSystem = usesNewImportSystem;
		if (!usesNewImportSystem && customName != "")
		{
			BoneMapper.customNamePairs.Add(customName, ((Object)_clip[0]).name);
		}
		BoneMapper.listOfCurrentEmoteAudio.Add(new List<AudioSource>());
		this.lockType = lockType;
		this.willGetClaimed = willGetClaimed;
		this.audioLevel = audioLevel;
		this.thirdPerson = thirdPerson;
		this.displayName = displayName;
		if (displayName == "")
		{
			DebugClass.Log("display name wasn't set, using " + customInternalName);
			this.displayName = customInternalName;
		}
		this.ownerPlugin = ownerPlugin;
		this.localTransforms = localTransforms;
		this.animates = animates;
		this.preventsMovement = preventsMovement;
		this.allowJoining = allowJoining;
		if (string.IsNullOrEmpty(customInternalName))
		{
			return;
		}
		Keybinds.DisableKeybinds();
		if (usesNewImportSystem)
		{
			InputActionReference orCreateInputRef = Keybinds.GetOrCreateInputRef(customInternalName);
			orCreateInputRef.action.Enable();
			orCreateInputRef.action.started += EmoteAction_started;
			if (Keybinds.keyBindOverrideStorage.TryGetValue(customInternalName, out var value))
			{
				InputActionRebindingExtensions.ApplyBindingOverride(orCreateInputRef.action, value, (string)null, (string)null);
			}
		}
		else
		{
			InputActionReference orCreateInputRef2 = Keybinds.GetOrCreateInputRef(((Object)clip[0]).name);
			orCreateInputRef2.action.Enable();
			orCreateInputRef2.action.started += EmoteAction_started;
			if (Keybinds.keyBindOverrideStorage.TryGetValue(((Object)clip[0]).name, out var value2))
			{
				InputActionRebindingExtensions.ApplyBindingOverride(orCreateInputRef2.action, value2, (string)null, (string)null);
			}
		}
		Keybinds.EnableKeybinds();
		if (joinEmote == "")
		{
			joinEmote = customInternalName;
		}
		this.joinEmote = joinEmote;
		if (EmoteDmcaVerificationStatusDb.IsNonDmcaCompliant(ownerPlugin.GUID))
		{
			this.willGetClaimed = true;
		}
		this.forceCameraMode = forceCameraMode;
		this.allowThirdPerson = allowThirdPerson;
		this.animateHealthbar = animateHealthbar;
	}

	private static void EmoteAction_started(CallbackContext obj)
	{
		if (EmoteUiManager.CanOpenEmoteWheels() && CustomEmotesAPI.localMapper != null)
		{
			CustomEmotesAPI.PlayAnimation(((CallbackContext)(ref obj)).action.name);
		}
	}
}
[DefaultExecutionOrder(-2)]
public class EmoteConstraint : MonoBehaviour
{
	public Transform originalBone;

	public Transform emoteBone;

	private Vector3 originalPosition;

	private Quaternion originalRotation;

	public bool constraintActive = false;

	public bool revertTransform;

	private bool firstTime = true;

	private bool firstTime2 = true;

	private bool hasEverActivatedConstraints = false;

	public bool onlyY = false;

	public bool debug = false;

	public bool forceGlobalTransforms = false;

	internal bool needToFix = true;

	public bool localTransforms { get; private set; } = false;


	public bool SetLocalTransforms(bool input)
	{
		localTransforms = !forceGlobalTransforms && input;
		return localTransforms;
	}

	private void LateUpdate()
	{
		ActUponConstraints();
	}

	public void ActUponConstraints()
	{
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: 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)
		//IL_0034: 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_0054: 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)
		if (!constraintActive)
		{
			return;
		}
		if (localTransforms)
		{
			if (onlyY)
			{
				originalBone.localPosition = new Vector3(originalBone.localPosition.x, emoteBone.localPosition.y, originalBone.localPosition.z);
				return;
			}
			originalBone.localPosition = emoteBone.localPosition;
			originalBone.localRotation = emoteBone.localRotation;
		}
		else if (onlyY)
		{
			originalBone.position = new Vector3(originalBone.position.x, emoteBone.position.y, originalBone.position.z);
		}
		else
		{
			originalBone.position = emoteBone.position;
			originalBone.rotation = emoteBone.rotation;
		}
	}

	public void ActivateConstraints()
	{
		//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_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		if (!constraintActive && emoteBone != null)
		{
			if (firstTime2)
			{
				firstTime2 = false;
				((Component)this).gameObject.GetComponent<MonoBehaviour>().StartCoroutine(FirstTimeActiveFix(this));
				return;
			}
			originalPosition = originalBone.localPosition;
			originalRotation = originalBone.localRotation;
			hasEverActivatedConstraints = true;
			constraintActive = true;
			onlyY = false;
		}
	}

	internal IEnumerator FirstTimeActiveFix(EmoteConstraint e)
	{
		((Behaviour)e).enabled = false;
		yield return (object)new WaitForEndOfFrame();
		((Behaviour)e).enabled = true;
		if (e.onlyY)
		{
			e.ActivateConstraints();
			e.onlyY = true;
		}
		else
		{
			e.ActivateConstraints();
		}
	}

	public void DeactivateConstraints()
	{
		//IL_003b: 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)
		constraintActive = false;
		if (firstTime || !revertTransform || !hasEverActivatedConstraints)
		{
			firstTime = false;
			return;
		}
		originalBone.localPosition = originalPosition;
		originalBone.localRotation = originalRotation;
	}

	internal void AddSource(ref Transform originalBone, ref Transform emoteBone)
	{
		this.originalBone = originalBone;
		this.emoteBone = emoteBone;
		if (((Component)emoteBone).GetComponent<BoneRef>() != null)
		{
			((Component)emoteBone).GetComponent<BoneRef>().target = originalBone;
		}
		else
		{
			((Component)emoteBone).gameObject.AddComponent<BoneRef>().target = originalBone;
		}
	}

	internal void AddSource(Transform originalBone, Transform emoteBone)
	{
		this.originalBone = originalBone;
		this.emoteBone = emoteBone;
		if (((Component)emoteBone).GetComponent<BoneRef>() != null)
		{
			((Component)emoteBone).GetComponent<BoneRef>().target = originalBone;
		}
		else
		{
			((Component)emoteBone).gameObject.AddComponent<BoneRef>().target = originalBone;
		}
	}

	internal static EmoteConstraint AddConstraint(GameObject gameObject, BoneMapper mapper, Transform target, bool needToFix)
	{
		EmoteConstraint emoteConstraint = gameObject.AddComponent<EmoteConstraint>();
		emoteConstraint.AddSource(gameObject.transform, target);
		emoteConstraint.revertTransform = mapper.revertTransform;
		emoteConstraint.needToFix = needToFix;
		return emoteConstraint;
	}

	private void Start()
	{
		((MonoBehaviour)this).StartCoroutine(FixConstraints());
	}

	private IEnumerator FixConstraints()
	{
		yield return (object)new WaitForEndOfFrame();
		if (needToFix)
		{
			ActivateConstraints();
			yield return (object)new WaitForEndOfFrame();
			DeactivateConstraints();
		}
	}

	internal void Reset()
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		originalBone = null;
		emoteBone = null;
		originalPosition = Vector3.zero;
		originalRotation = Quaternion.identity;
		constraintActive = false;
		revertTransform = false;
		firstTime = true;
		firstTime2 = true;
		hasEverActivatedConstraints = false;
		onlyY = false;
		debug = false;
		localTransforms = false;
		forceGlobalTransforms = false;
		needToFix = true;
	}
}
public struct JoinSpot
{
	public string name;

	public Vector3 position;

	public Vector3 rotation;

	public Vector3 scale;

	public bool requireRaycastToJoin;

	public JoinSpot(string _name, Vector3 _position, Vector3 _rotation, Vector3 _scale, bool _requireRaycastToJoin)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		name = _name;
		position = _position;
		rotation = _rotation;
		scale = _scale;
		requireRaycastToJoin = _requireRaycastToJoin;
	}

	public JoinSpot(string _name, Vector3 _position, Vector3 _rotation, Vector3 _scale)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		name = _name;
		position = _position;
		rotation = _rotation;
		scale = _scale;
		requireRaycastToJoin = false;
	}

	public JoinSpot(string _name, Vector3 _position)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		name = _name;
		position = _position;
		rotation = Vector3.zero;
		scale = Vector3.one;
		requireRaycastToJoin = false;
	}
}
public class EmoteLocation : MonoBehaviour
{
	public static List<EmoteLocation> emoteLocations = new List<EmoteLocation>();

	public static bool visibile = true;

	public int spot;

	public int validPlayers = 0;

	public BoneMapper owner;

	public BoneMapper emoter;

	public JoinSpot joinSpot;

	private InteractTrigger personalTrigger;

	public static void HideAllSpots()
	{
		visibile = false;
		foreach (EmoteLocation emoteLocation in emoteLocations)
		{
			try
			{
				Renderer[] componentsInChildren = ((Component)emoteLocation).GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = false;
				}
				ParticleSystemRenderer[] componentsInChildren2 = ((Component)emoteLocation).GetComponentsInChildren<ParticleSystemRenderer>();
				foreach (ParticleSystemRenderer val2 in componentsInChildren2)
				{
					((Renderer)val2).enabled = false;
				}
			}
			catch (Exception)
			{
			}
		}
	}

	public static void ShowAllSpots()
	{
		visibile = true;
		foreach (EmoteLocation emoteLocation in emoteLocations)
		{
			try
			{
				Renderer[] componentsInChildren = ((Component)emoteLocation).GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = true;
				}
				ParticleSystemRenderer[] componentsInChildren2 = ((Component)emoteLocation).GetComponentsInChildren<ParticleSystemRenderer>();
				foreach (ParticleSystemRenderer val2 in componentsInChildren2)
				{
					((Renderer)val2).enabled = true;
				}
			}
			catch (Exception)
			{
			}
		}
	}

	private void Start()
	{
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		SetColor();
		emoteLocations.Add(this);
		((MonoBehaviour)this).StartCoroutine(setScale());
		if (!visibile)
		{
			Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.enabled = false;
			}
			ParticleSystemRenderer[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<ParticleSystemRenderer>();
			foreach (ParticleSystemRenderer val2 in componentsInChildren2)
			{
				((Renderer)val2).enabled = false;
			}
		}
		personalTrigger = ((Component)this).gameObject.AddComponent<InteractTrigger>();
		((Component)this).gameObject.tag = "InteractTrigger";
		((Component)this).gameObject.layer = LayerMask.NameToLayer("InteractableObject");
		personalTrigger.interactable = true;
		personalTrigger.hoverIcon = Object.Instantiate<Sprite>(Assets.Load<Sprite>("assets/fineilldoitmyself/nothing.png"));
		personalTrigger.disabledHoverIcon = Object.Instantiate<Sprite>(Assets.Load<Sprite>("assets/fineilldoitmyself/nothing.png"));
		personalTrigger.disabledHoverTip = "";
		InputBinding val3 = EmotesInputSettings.Instance.JoinEmote.bindings[0];
		string text = InputControlPath.ToHumanReadableString(((InputBinding)(ref val3)).effectivePath, (HumanReadableStringOptions)2, (InputControl)null);
		personalTrigger.hoverTip = "Press [" + text + "] to join";
	}

	private void OnDestroy()
	{
		emoteLocations.Remove(this);
	}

	public void SetEmoterAndHideLocation(BoneMapper boneMapper)
	{
		if (!Object.op_Implicit((Object)(object)emoter))
		{
			emoter = boneMapper;
			SetVisible(visibility: false);
		}
	}

	public IEnumerator setScale()
	{
		yield return (object)new WaitForSeconds(0.1f);
		_ = Vector3.one;
		Vector3 scal = ((!Object.op_Implicit((Object)(object)owner.emoteSkeletonSMR)) ? ((Component)owner).transform.lossyScale : ((Component)owner).transform.parent.lossyScale);
		((Component)this).transform.localPosition = new Vector3(joinSpot.position.x / scal.x, joinSpot.position.y / scal.y, joinSpot.position.z / scal.z);
		((Component)this).transform.localEulerAngles = joinSpot.rotation;
		((Component)this).transform.localScale = new Vector3(joinSpot.scale.x / scal.x, joinSpot.scale.y / scal.y, joinSpot.scale.z / scal.z);
	}

	internal void SetVisible(bool visibility)
	{
		//IL_0044: 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_005d: 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_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		if (visibility)
		{
			Transform transform = ((Component)this).gameObject.transform;
			transform.localPosition += new Vector3(5000f, 5000f, 5000f);
		}
		else
		{
			Transform transform2 = ((Component)this).gameObject.transform;
			transform2.localPosition -= new Vector3(5000f, 5000f, 5000f);
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		if (!Object.op_Implicit((Object)(object)((Component)other).GetComponentInChildren<BoneMapper>()) || !((Object)(object)((Component)other).GetComponentInChildren<BoneMapper>() != (Object)(object)owner))
		{
			return;
		}
		BoneMapper componentInChildren = ((Component)other).GetComponentInChildren<BoneMapper>();
		if (Object.op_Implicit((Object)(object)componentInChildren))
		{
			validPlayers++;
			SetColor();
			if (componentInChildren.local)
			{
				personalTrigger.interactable = true;
			}
			componentInChildren.currentEmoteSpot = ((Component)this).gameObject;
			CustomEmotesAPI.JoinSpotEntered(componentInChildren, owner);
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (!Object.op_Implicit((Object)(object)((Component)other).GetComponentInChildren<BoneMapper>()) || !((Object)(object)((Component)other).GetComponentInChildren<BoneMapper>() != (Object)(object)owner))
		{
			return;
		}
		BoneMapper componentInChildren = ((Component)other).GetComponentInChildren<BoneMapper>();
		if (Object.op_Implicit((Object)(object)componentInChildren))
		{
			if (validPlayers != 0)
			{
				validPlayers--;
			}
			if (componentInChildren.local)
			{
				personalTrigger.interactable = false;
			}
			SetColor();
			if ((Object)(object)componentInChildren.currentEmoteSpot == (Object)(object)((Component)this).gameObject)
			{
				componentInChildren.currentEmoteSpot = null;
			}
		}
	}

	internal void SetColor()
	{
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: 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_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: 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)
		//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		if (validPlayers > 0)
		{
			((Component)this).GetComponentsInChildren<Renderer>()[((Component)this).GetComponentsInChildren<Renderer>().Length - 1].material.color = Color.green;
			Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.material.SetColor("_EmissionColor", Color.green);
			}
			ParticleSystemRenderer[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<ParticleSystemRenderer>();
			foreach (ParticleSystemRenderer val2 in componentsInChildren2)
			{
				((Renderer)val2).material.SetColor("_EmissionColor", Color.green);
			}
			ParticleSystem[] componentsInChildren3 = ((Component)this).GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val3 in componentsInChildren3)
			{
				TrailModule trails = val3.trails;
				((TrailModule)(ref trails)).colorOverTrail = MinMaxGradient.op_Implicit(Color.green);
			}
		}
		else
		{
			((Component)this).GetComponentsInChildren<Renderer>()[((Component)this).GetComponentsInChildren<Renderer>().Length - 1].material.color = new Color(0.003921569f, 52f / 85f, 38f / 51f);
			Renderer[] componentsInChildren4 = ((Component)this).GetComponentsInChildren<Renderer>();
			foreach (Renderer val4 in componentsInChildren4)
			{
				val4.material.SetColor("_EmissionColor", new Color(0.003921569f, 52f / 85f, 38f / 51f));
			}
			ParticleSystemRenderer[] componentsInChildren5 = ((Component)this).GetComponentsInChildren<ParticleSystemRenderer>();
			foreach (ParticleSystemRenderer val5 in componentsInChildren5)
			{
				((Renderer)val5).material.SetColor("_EmissionColor", new Color(0.003921569f, 52f / 85f, 38f / 51f));
			}
			ParticleSystem[] componentsInChildren6 = ((Component)this).GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val6 in componentsInChildren6)
			{
				TrailModule trails2 = val6.trails;
				((TrailModule)(ref trails2)).colorOverTrail = MinMaxGradient.op_Implicit(new Color(0.003921569f, 52f / 85f, 38f / 51f));
			}
		}
	}
}
public class AudioContainer : MonoBehaviour
{
	internal List<GameObject> playingObjects = new List<GameObject>();
}
public class AudioObject : MonoBehaviour
{
	internal int spot;

	internal int playerCount;

	internal GameObject audioObject;

	internal int activeObjectsSpot;
}
public class BonePair
{
	public Transform original;

	public Transform newiginal;

	public BonePair(Transform n, Transform o)
	{
		newiginal = n;
		original = o;
	}

	public void test()
	{
	}
}
public static class DebugClass
{
	private static ManualLogSource Logger;

	public static void SetLogger(ManualLogSource logSource)
	{
		Logger = logSource;
	}

	public static void Log(object message)
	{
		Logger.Log((LogLevel)16, (object)$"{message}");
	}
}
public class EmoteNetworker : NetworkBehaviour
{
	public static EmoteNetworker instance;

	private void Awake()
	{
		((Object)this).name = "Bigma Lalls";
		instance = this;
	}

	public void SyncEmote(ulong playerId, string animation, int pos)
	{
		if (((NetworkBehaviour)this).IsOwner && ((NetworkBehaviour)this).IsServer)
		{
			SyncEmoteToClients(playerId, animation, pos);
		}
		else
		{
			SyncEmoteToServerRpc(playerId, animation, pos);
		}
	}

	public void SyncEmoteToClients(ulong playerId, string animation, int pos)
	{
		GameObject gameObject = ((Component)((NetworkBehaviour)this).GetNetworkObject(playerId)).gameObject;
		if (!Object.op_Implicit((Object)(object)gameObject))
		{
			DebugClass.Log("Body is null!!!");
		}
		int eventNum = -1;
		CustomAnimationClip customAnimationClip = BoneMapper.animClips[animation];
		try
		{
			if (customAnimationClip != null)
			{
				eventNum = Random.Range(0, BoneMapper.primaryAudioClips[customAnimationClip.syncPos].Length);
			}
		}
		catch (Exception)
		{
		}
		SyncEmoteToClientRpc(playerId, animation, pos, eventNum);
	}

	[ClientRpc]
	public void SyncEmoteToClientRpc(ulong playerId, string animation, int pos, int eventNum)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1218916340u, val, (RpcDelivery)0);
			BytePacker.WriteValueBitPacked(val2, playerId);
			bool flag = animation != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((