using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using REPOLib.Modules;
using REPOLib.Objects.Sdk;
using Sirenix.Utilities;
using UnityEngine;
using UnityEngine.AI;
using WintryMonstrosities.NetworkPrefabs;

[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("")]
[assembly: AssemblyCompany("BLOKBUSTR")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+07bef5e3dc19d21a4b8eb7e102091187dc6739b4")]
[assembly: AssemblyProduct("WintryMonstrosities")]
[assembly: AssemblyTitle("WintryMonstrosities")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace WintryMonstrosities
{
	public class DebugHelperPatches
	{
	}
	[ExecuteInEditMode]
	public class EditorElfMeshHelper : MonoBehaviour
	{
		public EnemyElfAnim enemyElfAnim;

		public bool enableDecoratorMeshes;

		public bool enableTrumpeterMeshes;

		public bool enableToymakerMeshes;

		private void Awake()
		{
			if (!Application.isEditor)
			{
				WintryMonstrosities.DebugElf("Destroyed EditorElfMeshHelper");
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnValidate()
		{
			if (!Object.op_Implicit((Object)(object)enemyElfAnim))
			{
				return;
			}
			GameObject[] decoratorObjects = enemyElfAnim.decoratorObjects;
			foreach (GameObject val in decoratorObjects)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					val.SetActive(enableDecoratorMeshes);
				}
			}
			GameObject[] trumpeterObjects = enemyElfAnim.trumpeterObjects;
			foreach (GameObject val2 in trumpeterObjects)
			{
				if (Object.op_Implicit((Object)(object)val2))
				{
					val2.SetActive(enableTrumpeterMeshes);
				}
			}
			GameObject[] toymakerObjects = enemyElfAnim.toymakerObjects;
			foreach (GameObject val3 in toymakerObjects)
			{
				if (Object.op_Implicit((Object)(object)val3))
				{
					val3.SetActive(enableToymakerMeshes);
				}
			}
		}
	}
	public class EnemyElf : MonoBehaviour
	{
		public enum State
		{
			Spawn,
			Idle,
			IdleBreaker,
			Move,
			Investigate,
			Notice,
			Flee,
			WeaponPrepare,
			WeaponDeploy,
			GunLoad,
			GunChase,
			GunShoot,
			GunUnload,
			Stun,
			Despawn
		}

		public enum Role
		{
			Decorator,
			Trumpeter,
			Toymaker
		}

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

			private object <>2__current;

			public EnemyElf <>4__this;

			private bool[] <array>5__1;

			private List<PlayerAvatar> <chaseVisionList>5__2;

			private int <num2>5__3;

			private float <closest>5__4;

			private float <radius>5__5;

			private Collider[] <array2>5__6;

			private Collider[] <>s__7;

			private int <>s__8;

			private Collider <collider>5__9;

			private PhysGrabObject <componentInParent>5__10;

			private Vector3 <direction>5__11;

			private RaycastHit[] <array3>5__12;

			private bool <flag>5__13;

			private int <num>5__14;

			private RaycastHit[] <array4>5__15;

			private int <j>5__16;

			private RaycastHit <raycastHit>5__17;

			private PhysGrabObject <componentInParent2>5__18;

			private List<PlayerAvatar>.Enumerator <>s__19;

			private PlayerAvatar <player2>5__20;

			private List<PlayerAvatar>.Enumerator <>s__21;

			private PlayerAvatar <player3>5__22;

			private bool <flag2>5__23;

			private int <viewID2>5__24;

			private float <num3>5__25;

			private bool <flag3>5__26;

			private bool <flag4>5__27;

			private Transform <transform1>5__28;

			private Transform <transform2>5__29;

			private Vector3 <direction2>5__30;

			private Collider[] <array5>5__31;

			private Collider[] <array2>5__32;

			private Collider[] <>s__33;

			private int <>s__34;

			private Collider <collider2>5__35;

			private RaycastHit[] <array6>5__36;

			private float <num4>5__37;

			private RaycastHit[] <array4>5__38;

			private int <i>5__39;

			private RaycastHit <raycastHit2>5__40;

			private float <num5>5__41;

			private float <num6>5__42;

			private bool <flag5>5__43;

			private bool <flag6>5__44;

			private bool <flag7>5__45;

			private List<PlayerAvatar>.Enumerator <>s__46;

			private PlayerAvatar <p>5__47;

			private float <sqrMagnitude>5__48;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<array>5__1 = null;
				<chaseVisionList>5__2 = null;
				<array2>5__6 = null;
				<>s__7 = null;
				<collider>5__9 = null;
				<componentInParent>5__10 = null;
				<array3>5__12 = null;
				<array4>5__15 = null;
				<componentInParent2>5__18 = null;
				<>s__19 = default(List<PlayerAvatar>.Enumerator);
				<player2>5__20 = null;
				<>s__21 = default(List<PlayerAvatar>.Enumerator);
				<player3>5__22 = null;
				<transform1>5__28 = null;
				<transform2>5__29 = null;
				<array5>5__31 = null;
				<array2>5__32 = null;
				<>s__33 = null;
				<collider2>5__35 = null;
				<array6>5__36 = null;
				<array4>5__38 = null;
				<>s__46 = default(List<PlayerAvatar>.Enumerator);
				<p>5__47 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0f4a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0f54: Expected O, but got Unknown
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_05df: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e78: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e88: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e8d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e92: 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_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0253: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ee7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0eec: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_0702: Unknown result type (might be due to invalid IL or missing references)
				//IL_0717: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0889: Unknown result type (might be due to invalid IL or missing references)
				//IL_088f: Unknown result type (might be due to invalid IL or missing references)
				//IL_08af: Unknown result type (might be due to invalid IL or missing references)
				//IL_08f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a86: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a91: Unknown result type (might be due to invalid IL or missing references)
				//IL_09af: Unknown result type (might be due to invalid IL or missing references)
				//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b5a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0b61: Invalid comparison between Unknown and I4
				//IL_0bb3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0bba: Invalid comparison between Unknown and I4
				//IL_0c66: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c6d: Invalid comparison between Unknown and I4
				//IL_0ccf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0cd6: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (GameManager.Multiplayer() && !PhotonNetwork.IsMasterClient)
					{
						return false;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (<>4__this.enemyVision.DisableTimer > 0f || EnemyDirector.instance.debugNoVision)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (<>4__this.currentState != State.GunChase)
				{
					return false;
				}
				if (<>4__this.currentState == State.GunChase && <>4__this.gunTimer > 0f)
				{
					<array>5__1 = new bool[GameDirector.instance.PlayerList.Count];
					if (<>4__this.enemyVision.PhysObjectVision)
					{
						<radius>5__5 = <>4__this.enemyVision.PhysObjectVisionRadius;
						if (<>4__this.enemyVision.PhysObjectVisionRadiusOverride > 0f)
						{
							<radius>5__5 = <>4__this.enemyVision.PhysObjectVisionRadiusOverride;
						}
						<array2>5__6 = Physics.OverlapSphere(<>4__this.enemyVision.VisionTransform.position, <radius>5__5, LayerMask.op_Implicit(SemiFunc.LayerMaskGetPhysGrabObject()));
						<>s__7 = <array2>5__6;
						for (<>s__8 = 0; <>s__8 < <>s__7.Length; <>s__8++)
						{
							<collider>5__9 = <>s__7[<>s__8];
							if (((Component)<collider>5__9).CompareTag("Phys Grab Object"))
							{
								<componentInParent>5__10 = ((Component)<collider>5__9).GetComponentInParent<PhysGrabObject>();
								if (Object.op_Implicit((Object)(object)<componentInParent>5__10) && <componentInParent>5__10.playerGrabbing.Count > 0)
								{
									<direction>5__11 = <componentInParent>5__10.centerPoint - <>4__this.enemyVision.VisionTransform.position;
									<array3>5__12 = Physics.RaycastAll(<>4__this.enemyVision.VisionTransform.position, <direction>5__11, ((Vector3)(ref <direction>5__11)).magnitude, LayerMask.op_Implicit(<>4__this.enemy.VisionMask), (QueryTriggerInteraction)1);
									<flag>5__13 = true;
									if (<array3>5__12.Length != 0)
									{
										<array4>5__15 = <array3>5__12;
										for (<j>5__16 = 0; <j>5__16 < <array4>5__15.Length; <j>5__16++)
										{
											<raycastHit>5__17 = <array4>5__15[<j>5__16];
											if (((Component)((RaycastHit)(ref <raycastHit>5__17)).transform).CompareTag("Phys Grab Object") || ((Component)((RaycastHit)(ref <raycastHit>5__17)).transform).CompareTag("Enemy"))
											{
												<componentInParent2>5__18 = ((Component)((RaycastHit)(ref <raycastHit>5__17)).transform).GetComponentInParent<PhysGrabObject>();
												if (Object.op_Implicit((Object)(object)<componentInParent2>5__18) && ((Object)(object)<componentInParent2>5__18 == (Object)(object)<componentInParent>5__10 || (<>4__this.enemy.HasRigidbody && (Object)(object)((Component)((RaycastHit)(ref <raycastHit>5__17)).transform).GetComponentInParent<EnemyRigidbody>() == (Object)(object)<>4__this.enemy.Rigidbody)))
												{
													continue;
												}
												<componentInParent2>5__18 = null;
											}
											<flag>5__13 = false;
										}
										<array4>5__15 = null;
									}
									if (<flag>5__13 && Vector3.Dot(<>4__this.enemyVision.VisionTransform.forward, ((Vector3)(ref <direction>5__11)).normalized) >= <>4__this.enemyVision.PhysObjectVisionDot)
									{
										<num>5__14 = 0;
										<>s__19 = GameDirector.instance.PlayerList.GetEnumerator();
										try
										{
											while (<>s__19.MoveNext())
											{
												<player2>5__20 = <>s__19.Current;
												if ((Object)(object)<player2>5__20 == (Object)(object)<componentInParent>5__10.playerGrabbing[0].playerAvatar)
												{
													<array>5__1[<num>5__14] = true;
												}
												<num>5__14++;
												<player2>5__20 = null;
											}
										}
										finally
										{
											((IDisposable)<>s__19).Dispose();
										}
										<>s__19 = default(List<PlayerAvatar>.Enumerator);
										<componentInParent>5__10 = null;
										<array3>5__12 = null;
										<collider>5__9 = null;
									}
								}
							}
						}
						<>s__7 = null;
						<array2>5__6 = null;
					}
					<chaseVisionList>5__2 = new List<PlayerAvatar>();
					<num2>5__3 = 0;
					<>s__21 = GameDirector.instance.PlayerList.GetEnumerator();
					try
					{
						while (<>s__21.MoveNext())
						{
							<player3>5__22 = <>s__21.Current;
							<flag2>5__23 = false;
							if (<player3>5__22.isDisabled)
							{
								continue;
							}
							<viewID2>5__24 = <player3>5__22.photonView.ViewID;
							if (<player3>5__22.enemyVisionFreezeTimer > 0f)
							{
								<num2>5__3++;
								continue;
							}
							<>4__this.VisionTriggered[<viewID2>5__24] = false;
							<num3>5__25 = Vector3.Distance(<>4__this.enemyVision.VisionTransform.position, <player3>5__22.PlayerVisionTarget.VisionTransform.position);
							if (!<array>5__1[<num2>5__3] && <num3>5__25 > <>4__this.enemyVision.VisionDistance)
							{
								continue;
							}
							<flag3>5__26 = <player3>5__22.isCrawling;
							<flag4>5__27 = <player3>5__22.isCrouching;
							if (<player3>5__22.isTumbling)
							{
								<flag4>5__27 = true;
								<flag3>5__26 = false;
							}
							if (<>4__this.enemyVision.StandOverrideTimer > 0f)
							{
								<flag4>5__27 = false;
								<flag3>5__26 = false;
							}
							<transform1>5__28 = null;
							<transform2>5__29 = null;
							<direction2>5__30 = ((Component)<player3>5__22.PlayerVisionTarget.VisionTransform).transform.position - <>4__this.enemyVision.VisionTransform.position;
							<array5>5__31 = Physics.OverlapSphere(<>4__this.enemyVision.VisionTransform.position, 0.01f, LayerMask.op_Implicit(<>4__this.enemy.VisionMask));
							if (<array5>5__31.Length != 0)
							{
								<array2>5__32 = <array5>5__31;
								<>s__33 = <array2>5__32;
								for (<>s__34 = 0; <>s__34 < <>s__33.Length; <>s__34++)
								{
									<collider2>5__35 = <>s__33[<>s__34];
									if (!((Component)((Component)<collider2>5__35).transform).CompareTag("Enemy"))
									{
										if (((Component)((Component)<collider2>5__35).transform).CompareTag("Player"))
										{
											<transform1>5__28 = ((Component)<collider2>5__35).transform;
										}
										if (Object.op_Implicit((Object)(object)((Component)((Component)<collider2>5__35).transform).GetComponentInParent<PlayerTumble>()))
										{
											<transform1>5__28 = ((Component)<collider2>5__35).transform;
										}
										if (!Object.op_Implicit((Object)(object)((Component)((Component)<collider2>5__35).transform).GetComponentInParent<EnemyRigidbody>()))
										{
											<transform2>5__29 = ((Component)<collider2>5__35).transform;
										}
									}
									<collider2>5__35 = null;
								}
								<>s__33 = null;
								<array2>5__32 = null;
							}
							if (!Object.op_Implicit((Object)(object)<transform2>5__29))
							{
								<array6>5__36 = Physics.RaycastAll(<>4__this.enemyVision.VisionTransform.position, <direction2>5__30, <>4__this.enemyVision.VisionDistance, LayerMask.op_Implicit(<>4__this.enemy.VisionMask), (QueryTriggerInteraction)1);
								<num4>5__37 = 1000f;
								<array4>5__38 = <array6>5__36;
								<i>5__39 = 0;
								while (<i>5__39 < <array4>5__38.Length)
								{
									<raycastHit2>5__40 = <array4>5__38[<i>5__39];
									if (!((Component)((RaycastHit)(ref <raycastHit2>5__40)).transform).CompareTag("Enemy"))
									{
										if (((Component)((RaycastHit)(ref <raycastHit2>5__40)).transform).CompareTag("Player"))
										{
											<transform1>5__28 = ((RaycastHit)(ref <raycastHit2>5__40)).transform;
										}
										if (!Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref <raycastHit2>5__40)).transform).GetComponentInParent<EnemyRigidbody>()))
										{
											if (Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref <raycastHit2>5__40)).transform).GetComponentInParent<PlayerTumble>()))
											{
												<transform1>5__28 = ((RaycastHit)(ref <raycastHit2>5__40)).transform;
											}
											<num5>5__41 = Vector3.Distance(<>4__this.enemyVision.VisionTransform.position, ((RaycastHit)(ref <raycastHit2>5__40)).point);
											if (<num5>5__41 < <num4>5__37)
											{
												<num4>5__37 = <num5>5__41;
												<transform2>5__29 = ((RaycastHit)(ref <raycastHit2>5__40)).transform;
											}
										}
									}
									<i>5__39++;
								}
								<array6>5__36 = null;
								<array4>5__38 = null;
							}
							if (<array>5__1[<num2>5__3] || (Object.op_Implicit((Object)(object)<transform1>5__28) && (Object)(object)<transform1>5__28 == (Object)(object)<transform2>5__29))
							{
								<num6>5__42 = Vector3.Dot(<>4__this.enemyVision.VisionTransform.forward, ((Vector3)(ref <direction2>5__30)).normalized);
								<flag5>5__43 = false;
								if (<flag4>5__27)
								{
									if (<num3>5__25 <= <>4__this.enemyVision.VisionDistanceCloseCrouch)
									{
										<flag5>5__43 = true;
									}
								}
								else if (<num3>5__25 <= <>4__this.enemyVision.VisionDistanceClose)
								{
									<flag5>5__43 = true;
								}
								if (<flag5>5__43)
								{
									<>4__this.VisionsTriggered[<viewID2>5__24] = <>4__this.enemyVision.VisionsToTrigger;
								}
								<flag6>5__44 = false;
								if (<flag3>5__26 && (int)<>4__this.enemy.CurrentState != 10)
								{
									if (<num6>5__42 >= <>4__this.enemyVision.VisionDotCrawl)
									{
										<flag6>5__44 = true;
									}
								}
								else if (<flag4>5__27 && (int)<>4__this.enemy.CurrentState != 10)
								{
									if (<num6>5__42 >= <>4__this.enemyVision.VisionDotCrouch)
									{
										<flag6>5__44 = true;
									}
								}
								else if (<num6>5__42 >= <>4__this.enemyVision.VisionDotStanding)
								{
									<flag6>5__44 = true;
								}
								if (<array>5__1[<num2>5__3] | <flag6>5__44 | <flag5>5__43)
								{
									<flag2>5__23 = true;
									<flag7>5__45 = false;
									if (<flag3>5__26 && (int)<>4__this.enemy.CurrentState != 10)
									{
										if (<>4__this.VisionsTriggered[<viewID2>5__24] >= <>4__this.enemyVision.VisionsToTriggerCrawl)
										{
											<flag7>5__45 = true;
										}
									}
									else if (<flag4>5__27 && (int)<>4__this.enemy.CurrentState != 10)
									{
										if (<>4__this.VisionsTriggered[<viewID2>5__24] >= <>4__this.enemyVision.VisionsToTriggerCrouch)
										{
											<flag7>5__45 = true;
										}
									}
									else if (<>4__this.VisionsTriggered[<viewID2>5__24] >= <>4__this.enemyVision.VisionsToTrigger)
									{
										<flag7>5__45 = true;
									}
									if (<flag7>5__45 | <flag5>5__43)
									{
										<chaseVisionList>5__2.Add(<player3>5__22);
									}
								}
							}
							if (<flag2>5__23)
							{
								<>4__this.VisionsTriggered[<viewID2>5__24]++;
							}
							else
							{
								<>4__this.VisionsTriggered[<viewID2>5__24] = 0;
							}
							<num2>5__3++;
							<transform1>5__28 = null;
							<transform2>5__29 = null;
							<array5>5__31 = null;
							<player3>5__22 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__21).Dispose();
					}
					<>s__21 = default(List<PlayerAvatar>.Enumerator);
					<closest>5__4 = float.MaxValue;
					<>s__46 = <chaseVisionList>5__2.GetEnumerator();
					try
					{
						while (<>s__46.MoveNext())
						{
							<p>5__47 = <>s__46.Current;
							Vector3 val = ((Component)<>4__this).transform.position - ((Component)<p>5__47).transform.position;
							<sqrMagnitude>5__48 = ((Vector3)(ref val)).sqrMagnitude;
							if (!(<sqrMagnitude>5__48 >= <closest>5__4))
							{
								<closest>5__4 = <sqrMagnitude>5__48;
								<>4__this.playerTarget = <p>5__47;
								<>4__this.playerTargetKnownPosition = ((Component)<p>5__47).transform.position;
								<p>5__47 = null;
							}
						}
					}
					finally
					{
						((IDisposable)<>s__46).Dispose();
					}
					<>s__46 = default(List<PlayerAvatar>.Enumerator);
					<array>5__1 = null;
					<chaseVisionList>5__2 = null;
				}
				<>2__current = (object)new WaitForSeconds(<>4__this.enemyVision.VisionCheckTime);
				<>1__state = 2;
				return true;
			}

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

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

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

			private object <>2__current;

			public ItemGrenadeOrnament grenade;

			public EnemyElf <>4__this;

			private Vector3 <vector>5__1;

			private float <throwForce>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (!grenade.physGrabObject.spawned || grenade.rb.isKinematic)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				grenade.itemToggle.ToggleItem(true, -1);
				grenade.tickTime = Random.Range(1f, 3f);
				<vector>5__1 = <>4__this.bodyRotationTarget * Vector3.forward + Vector3.up * Random.Range(0.3f, 0.5f);
				<throwForce>5__2 = 5f;
				grenade.rb.AddForce(((Vector3)(ref <vector>5__1)).normalized * <throwForce>5__2, (ForceMode)1);
				return false;
			}

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

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

		[Space]
		public State currentState;

		public Role currentRole;

		private bool stateImpulse = true;

		private float stateTimer;

		private bool visionPrevious;

		private float visionTimer;

		private float idleBreakerTimer;

		private bool idleBreakerImpulse;

		private float eyelidTwitchTimer;

		private bool notifyDelay;

		private float notifyDelayTimer;

		private bool gunPrimed;

		private float gunTimer;

		[Space]
		public Enemy enemy;

		public EnemyElfAnim anim;

		public EnemyElfAlwaysActive enemyElfAlwaysActive;

		private EnemyHealth enemyHealth;

		private EnemyStateStunned stateStunned;

		private EnemyVision enemyVision;

		internal PhotonView photonView;

		internal int directorIndex;

		private Vector3 agentDestination;

		internal PlayerAvatar playerTarget;

		private Vector3 playerTargetKnownPosition;

		public Dictionary<int, int> VisionsTriggered = new Dictionary<int, int>();

		public Dictionary<int, bool> VisionTriggered = new Dictionary<int, bool>();

		[Space]
		private Quaternion bodyRotationTarget;

		public SpringQuaternion bodyRotationSpring;

		[Space]
		public Transform headTransform;

		public Transform headOriginalRotation;

		public SpringQuaternion headRotationSpring;

		[Space]
		public GameObject leftEye;

		public GameObject rightEye;

		[Space]
		public Transform gunAimTransform;

		public Transform gunTipTransform;

		public GameObject gunHurtCollider;

		public GameObject gunHurtColliderWave;

		public float gunRecoilForce = 25f;

		private float gunHurtColliderTimer;

		private float gunHurtColliderWaveTimer;

		public Transform gunShootParticlesTransform;

		public List<ParticleSystem> gunShootParticles;

		private float shootInvincibilityTimer;

		[Space]
		[SerializeField]
		private List<NetworkPrefabContent> ornamentNetworkPrefabs;

		[SerializeField]
		private List<NetworkPrefabContent> toyCarNetworkPrefabs;

		private void Awake()
		{
			photonView = ((Component)this).GetComponent<PhotonView>();
			enemyHealth = ((Component)this).GetComponent<EnemyHealth>();
			stateStunned = ((Component)this).GetComponent<EnemyStateStunned>();
			enemyVision = ((Component)this).GetComponent<EnemyVision>();
		}

		private void Start()
		{
			if (EnemyElfDirector.instance.setup)
			{
				EnemyElfDirector.instance.SetupSingle(this);
			}
		}

		private void Update()
		{
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Invalid comparison between Unknown and I4
			BodyRotationLogic();
			HeadRotationLogic();
			State state;
			if (notifyDelay && notifyDelayTimer > 0f)
			{
				notifyDelayTimer -= Time.deltaTime;
				if (notifyDelayTimer <= 0f)
				{
					notifyDelay = false;
					state = currentState;
					if ((uint)(state - 1) <= 3u)
					{
						UpdateState(State.Notice);
					}
				}
			}
			if (currentState != State.GunShoot)
			{
				if (gunHurtColliderTimer > 0f)
				{
					gunHurtColliderTimer -= Time.deltaTime;
					if (gunHurtColliderTimer <= 0f)
					{
						gunHurtCollider.gameObject.SetActive(false);
					}
				}
				if (gunHurtColliderWaveTimer > 0f)
				{
					gunHurtColliderWaveTimer -= Time.deltaTime;
					if (gunHurtColliderWaveTimer <= 0f)
					{
						gunHurtColliderWave.gameObject.SetActive(false);
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)EnemyElfDirector.instance) || !EnemyElfDirector.instance.setup || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			if ((int)enemy.CurrentState == 11)
			{
				UpdateState(State.Despawn);
			}
			if (enemy.IsStunned())
			{
				UpdateState(State.Stun);
			}
			EyelidTwitchLogic();
			if (gunPrimed)
			{
				GunLogic();
			}
			if (visionTimer > 0f)
			{
				visionTimer -= Time.deltaTime;
			}
			if (shootInvincibilityTimer > 0f)
			{
				shootInvincibilityTimer -= Time.deltaTime;
				if (shootInvincibilityTimer <= 0f)
				{
					enemyHealth.impactHurt = true;
				}
			}
			switch (currentState)
			{
			case State.Spawn:
				StateSpawn();
				break;
			case State.Idle:
				StateIdle();
				IdleBreakerLogic();
				break;
			case State.IdleBreaker:
				StateIdleBreaker();
				break;
			case State.Move:
				StateMove();
				break;
			case State.Investigate:
				StateInvestigate();
				break;
			case State.Notice:
				StateNotice();
				break;
			case State.Flee:
				StateFlee();
				break;
			case State.WeaponPrepare:
				StateWeaponPrepare();
				break;
			case State.WeaponDeploy:
				StateWeaponDeploy();
				break;
			case State.GunLoad:
				StateGunLoad();
				break;
			case State.GunChase:
				StateGunChase();
				GunAimLogic();
				break;
			case State.GunShoot:
				StateGunShoot();
				break;
			case State.Stun:
				StateStun();
				break;
			case State.Despawn:
				StateDespawn();
				break;
			}
			state = currentState;
			if ((uint)(state - 7) <= 3u)
			{
				EnemyElfDirector.instance.PauseSpawnedTimers();
			}
		}

		private void StateSpawn()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 1f;
			}
			stateTimer -= Time.deltaTime;
			if (stateTimer <= 0f)
			{
				UpdateState(State.Idle);
			}
		}

		private void StateIdle()
		{
			//IL_0046: 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)
			//IL_0060: 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)
			if (stateImpulse)
			{
				stateImpulse = false;
				ResetNavMeshAgent();
			}
			if (EnemyElfDirector.instance.currentState == EnemyElfDirector.State.AllInvestigate)
			{
				UpdateState(State.Investigate);
			}
			Vector3 val = ((Component)enemy.Rigidbody).transform.position - EnemyElfDirector.instance.destinations[directorIndex];
			if (((Vector3)(ref val)).sqrMagnitude > 4f)
			{
				UpdateState(State.Move);
			}
		}

		private void StateIdleBreaker()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = Random.Range(1f, 2f);
				anim.EventNeckCrack();
			}
			stateTimer -= Time.deltaTime;
			if (stateTimer <= 0f)
			{
				anim.EventNeckCrack();
				UpdateState(State.Idle);
			}
		}

		private void StateMove()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 2f;
			}
			agentDestination = EnemyElfDirector.instance.destinations[directorIndex];
			enemy.NavMeshAgent.SetDestination(agentDestination);
			SemiFunc.EnemyCartJump(enemy);
			Vector3 val = ((Component)enemy.Rigidbody).transform.position - agentDestination;
			if (((Vector3)(ref val)).sqrMagnitude <= 0.25f)
			{
				UpdateState(State.Idle);
				return;
			}
			val = ((Component)enemy.Rigidbody).transform.position - agentDestination;
			if (((Vector3)(ref val)).sqrMagnitude <= 4f)
			{
				stateTimer -= Time.deltaTime;
				if (stateTimer <= 0f)
				{
					UpdateState(State.Idle);
				}
			}
		}

		private void StateInvestigate()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0081: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 2f;
			}
			agentDestination = ((EnemyElfDirector.instance.currentState == EnemyElfDirector.State.AllInvestigate) ? EnemyElfDirector.instance.allInvestigatePosition : enemy.StateInvestigate.onInvestigateTriggeredPosition);
			enemy.NavMeshAgent.SetDestination(agentDestination);
			SemiFunc.EnemyCartJump(enemy);
			Vector3 val = ((Component)enemy.Rigidbody).transform.position - agentDestination;
			if (((Vector3)(ref val)).sqrMagnitude <= 0.25f)
			{
				UpdateState(State.IdleBreaker);
				idleBreakerTimer += 10f;
				return;
			}
			val = ((Component)enemy.Rigidbody).transform.position - agentDestination;
			if (((Vector3)(ref val)).sqrMagnitude <= 4f)
			{
				stateTimer -= Time.deltaTime;
				if (stateTimer <= 0f)
				{
					UpdateState(State.IdleBreaker);
					idleBreakerTimer += 10f;
				}
			}
		}

		private void StateNotice()
		{
			//IL_0051: 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)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = Random.Range(0.4f, 0.8f);
				ResetNavMeshAgent();
				anim.EventNotice();
				EnemyElfDirector.instance.NotifyNearby(playerTarget, ((Component)enemy).transform.position);
				playerTargetKnownPosition = ((Component)playerTarget).transform.position;
			}
			stateTimer -= Time.deltaTime;
			if (!(stateTimer > 0f))
			{
				switch (currentRole)
				{
				case Role.Decorator:
				case Role.Toymaker:
					UpdateState(State.WeaponPrepare);
					break;
				case Role.Trumpeter:
					UpdateState(State.Flee);
					break;
				}
			}
		}

		private void StateFlee()
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateTimer = Random.Range(3f, 6f);
				bool flag = false;
				LevelPoint val = SemiFunc.LevelPointGetFurthestFromPlayer(((Component)this).transform.position, 5f);
				NavMeshHit val2 = default(NavMeshHit);
				if (Object.op_Implicit((Object)(object)val) && NavMesh.SamplePosition(((Component)val).transform.position + Random.insideUnitSphere * 3f, ref val2, 5f, -1) && Physics.Raycast(((NavMeshHit)(ref val2)).position, Vector3.down, 5f, LayerMask.GetMask(new string[1] { "Default" })))
				{
					agentDestination = ((NavMeshHit)(ref val2)).position;
					flag = true;
				}
				if (!flag)
				{
					return;
				}
				stateImpulse = false;
				if (currentRole == Role.Trumpeter)
				{
					EnemyDirector.instance.SetInvestigate(((Component)playerTarget).transform.position, 35f, false);
					EnemyElfDirector.instance.Investigate(((Component)playerTarget).transform.position);
					anim.EventTrumpetAlert();
				}
			}
			enemy.NavMeshAgent.SetDestination(agentDestination);
			enemy.NavMeshAgent.OverrideAgent(5f, 15f, 0.25f);
			SemiFunc.EnemyCartJump(enemy);
			stateTimer -= Time.deltaTime;
			Vector3 val3 = ((Component)this).transform.position - agentDestination;
			if (((Vector3)(ref val3)).sqrMagnitude <= 4f || stateTimer <= 0f)
			{
				switch (currentRole)
				{
				case Role.Decorator:
				case Role.Toymaker:
					UpdateState(State.IdleBreaker);
					idleBreakerTimer += 10f;
					break;
				case Role.Trumpeter:
					UpdateState(State.GunLoad);
					break;
				}
			}
		}

		private void StateWeaponPrepare()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = Random.Range(3f, 5f);
			}
			stateTimer -= Time.deltaTime;
			if (stateTimer <= 0f)
			{
				UpdateState(State.WeaponDeploy);
			}
		}

		private void StateWeaponDeploy()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 2f;
				switch (currentRole)
				{
				case Role.Decorator:
				case Role.Toymaker:
					if (SemiFunc.IsMasterClientOrSingleplayer() && !LinqExtensions.IsNullOrEmpty<NetworkPrefabContent>((IList<NetworkPrefabContent>)ornamentNetworkPrefabs))
					{
						Vector3 position = ((Component)this).transform.position + Vector3.up * 0.5f + bodyRotationTarget * Vector3.forward * 0.3f;
						int num = Random.Range(0, ornamentNetworkPrefabs.Count);
						WintryMonstrosities.DebugElf($"Chosen random grenade: {num}", this);
						NetworkPrefabContent networkPrefabContent = ornamentNetworkPrefabs[num];
						GameObject val = networkPrefabContent.SpawnNetworkPrefab(position, bodyRotationTarget);
						if ((Object)(object)val != (Object)null)
						{
							ItemGrenadeOrnament component = val.GetComponent<ItemGrenadeOrnament>();
							((MonoBehaviour)this).StartCoroutine(GrenadeThrowLogic(component));
						}
					}
					else
					{
						WintryMonstrosities.Logger.LogWarning((object)"ornamentNetworkPrefabs is empty!");
					}
					break;
				}
			}
			stateTimer -= Time.deltaTime;
			if (stateTimer <= 0f)
			{
				UpdateState(State.Flee);
			}
		}

		private void StateGunLoad()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 3f;
				ResetNavMeshAgent();
			}
			stateTimer -= Time.deltaTime;
			if (stateTimer <= 0f)
			{
				UpdateState(State.GunChase);
			}
		}

		private void StateGunChase()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 0f;
				agentDestination = playerTargetKnownPosition;
				((MonoBehaviour)this).StartCoroutine(ChaseVision());
			}
			agentDestination = playerTargetKnownPosition;
			if (enemy.Jump.jumping)
			{
				enemy.NavMeshAgent.Disable(0.1f);
				((Component)this).transform.position = Vector3.MoveTowards(((Component)this).transform.position, agentDestination, 5f * Time.deltaTime);
			}
			else
			{
				enemy.NavMeshAgent.SetDestination(agentDestination);
			}
			enemy.NavMeshAgent.OverrideAgent(5f, 15f, 0.25f);
			SemiFunc.EnemyCartJump(enemy);
			Vector3 val = ((Component)this).transform.position - agentDestination;
			if (((Vector3)(ref val)).sqrMagnitude <= 225f && !gunPrimed)
			{
				gunPrimed = true;
				gunTimer = 5f;
				WintryMonstrosities.DebugElf("Started gun countdown", this);
			}
			val = ((Component)this).transform.position - ((Component)playerTarget).transform.position;
			if (!(((Vector3)(ref val)).sqrMagnitude > 4f))
			{
				if (((Component)playerTarget).transform.position.y > ((Component)enemy.Rigidbody).transform.position.y + 0.3f)
				{
					enemy.Jump.StuckTrigger(playerTarget.PlayerVisionTarget.VisionTransform.position - enemy.Vision.VisionTransform.position);
				}
				val = ((Component)this).transform.position - ((Component)playerTarget).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude < 1f)
				{
					gunTimer = 0f;
				}
			}
		}

		[IteratorStateMachine(typeof(<ChaseVision>d__61))]
		private IEnumerator ChaseVision()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ChaseVision>d__61(0)
			{
				<>4__this = this
			};
		}

		private void StateGunShoot()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = 0f;
				ResetNavMeshAgent();
				if (SemiFunc.IsMultiplayer())
				{
					photonView.RPC("ShootGunRPC", (RpcTarget)0, Array.Empty<object>());
				}
				else
				{
					ShootGunRPC();
				}
			}
			enemyHealth.impactHurt = false;
			shootInvincibilityTimer = 1f;
			enemy.Rigidbody.GrabRelease(true, 0.1f);
			enemy.Rigidbody.rb.AddForce(-gunTipTransform.forward * gunRecoilForce, (ForceMode)1);
			if (stateStunned.stunTimer < 3f)
			{
				stateStunned.stunTimer = 3f;
			}
			UpdateState(State.Stun);
		}

		private void StateStun()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				ResetNavMeshAgent();
			}
			if (!enemy.IsStunned())
			{
				UpdateState(State.Idle);
			}
		}

		private void StateDespawn()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				ResetNavMeshAgent();
				gunPrimed = false;
				gunTimer = 0f;
				WintryMonstrosities.DebugElf("StateDespawn has been called", this);
			}
		}

		public void UpdateState(State nextState)
		{
			if (currentState != nextState)
			{
				WintryMonstrosities.DebugElf($"{currentState} to {nextState}", this);
				currentState = nextState;
				stateImpulse = true;
				stateTimer = 0f;
				if (SemiFunc.IsMultiplayer())
				{
					photonView.RPC("UpdateStateRPC", (RpcTarget)1, new object[1] { nextState });
				}
			}
		}

		[PunRPC]
		private void UpdateStateRPC(State nextState, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info))
			{
				WintryMonstrosities.DebugElf($"RPC {currentState} to {nextState}", this);
				currentState = nextState;
			}
		}

		public void OnSpawn()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer() && SemiFunc.EnemySpawn(enemy))
			{
				EnemyElfDirector.instance.OnSpawn(this);
				UpdateState(State.Spawn);
			}
			anim.OnSpawn();
		}

		public void OnInvestigate()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				State state = currentState;
				if ((uint)(state - 1) <= 2u)
				{
					UpdateState(State.Investigate);
				}
			}
		}

		public void OnVision()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			State state = currentState;
			if ((uint)(state - 1) <= 3u)
			{
				UpdatePlayerTarget(enemy.Vision.onVisionTriggeredPlayer);
				WintryMonstrosities.DebugElf($"playerTarget? {Object.op_Implicit((Object)(object)playerTarget)}: {playerTarget}", this);
				if (Object.op_Implicit((Object)(object)playerTarget))
				{
					UpdateState(State.Notice);
				}
			}
		}

		public void OnHurt()
		{
			anim.EventHurt();
		}

		public void OnDeath()
		{
			//IL_002c: 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)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			anim.EventDeath();
			GameDirector.instance.CameraShake.ShakeDistance(5f, 3f, 8f, ((Component)this).transform.position, 0.5f);
			GameDirector.instance.CameraImpact.ShakeDistance(5f, 3f, 8f, ((Component)this).transform.position, 0.1f);
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			gunPrimed = false;
			gunTimer = 0f;
			UpdateState(State.Despawn);
			enemy.EnemyParent.Despawn();
			enemy.EnemyParent.SpawnedTimerSet(0f);
			if (enemy.Health.spawnValuableCurrent < enemy.Health.spawnValuableMax)
			{
				GameObject enemyValuableSmall = AssetManager.instance.enemyValuableSmall;
				if (SemiFunc.IsMultiplayer())
				{
					PhotonNetwork.Instantiate("Valuables/" + ((Object)enemyValuableSmall).name, enemy.CenterTransform.position, Quaternion.identity, (byte)0, (object[])null);
				}
				else
				{
					Object.Instantiate<GameObject>(enemyValuableSmall, enemy.CenterTransform.position, Quaternion.identity);
				}
				EnemyHealth health = enemy.Health;
				health.spawnValuableCurrent++;
			}
		}

		private void IdleBreakerLogic()
		{
			if (idleBreakerTimer > 0f)
			{
				idleBreakerTimer -= Time.deltaTime;
				if (idleBreakerTimer <= 0f)
				{
					SemiFunc.EnemyCartJumpReset(enemy);
					UpdateState(State.IdleBreaker);
					idleBreakerTimer = Random.Range(15f, 30f);
				}
			}
		}

		private void BodyRotationLogic()
		{
			//IL_0030: 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_004f: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val;
			if (Object.op_Implicit((Object)(object)playerTarget) && currentState == State.WeaponDeploy)
			{
				val = Quaternion.LookRotation(((Component)playerTarget).transform.position - ((Component)enemy.Rigidbody).transform.position);
				bodyRotationTarget = Quaternion.Euler(0f, ((Quaternion)(ref val)).eulerAngles.y, 0f);
			}
			else if (((Vector3)(ref enemy.NavMeshAgent.AgentVelocity)).magnitude > 0.1f)
			{
				val = Quaternion.LookRotation(((Vector3)(ref enemy.NavMeshAgent.AgentVelocity)).normalized);
				bodyRotationTarget = Quaternion.Euler(0f, ((Quaternion)(ref val)).eulerAngles.y, 0f);
			}
			((Component)this).transform.rotation = SemiFunc.SpringQuaternionGet(bodyRotationSpring, bodyRotationTarget, -1f);
		}

		private void HeadRotationLogic()
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (currentState == State.IdleBreaker)
			{
				if (!idleBreakerImpulse)
				{
					idleBreakerImpulse = true;
				}
			}
			else
			{
				idleBreakerImpulse = false;
			}
			float num = ((currentState == State.Notice) ? 135f : 75f);
			bool flag = Object.op_Implicit((Object)(object)playerTarget);
			bool flag2 = flag;
			if (flag2)
			{
				bool flag3;
				switch (currentState)
				{
				case State.Notice:
				case State.WeaponPrepare:
				case State.WeaponDeploy:
				case State.GunChase:
					flag3 = true;
					break;
				default:
					flag3 = false;
					break;
				}
				flag2 = flag3;
			}
			if (flag2)
			{
				Vector3 val = playerTarget.PlayerVisionTarget.VisionTransform.position - headOriginalRotation.position;
				val = SemiFunc.ClampDirection(val, headOriginalRotation.forward, num);
				headTransform.rotation = SemiFunc.SpringQuaternionGet(headRotationSpring, Quaternion.LookRotation(val), -1f);
			}
			else
			{
				headTransform.rotation = SemiFunc.SpringQuaternionGet(headRotationSpring, headOriginalRotation.rotation, -1f);
			}
		}

		public void NoticeDelay()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				notifyDelay = true;
				notifyDelayTimer = Random.Range(0.02f, 0.5f);
			}
		}

		private void GunLogic()
		{
			if (gunTimer >= 0f)
			{
				gunTimer -= Time.deltaTime;
				WintryMonstrosities.DebugElf($"gunTimer: {gunTimer}", this);
				if (gunTimer <= 0f)
				{
					gunPrimed = false;
					UpdateState(State.GunShoot);
					WintryMonstrosities.DebugElf("BOOM", this);
				}
			}
		}

		[IteratorStateMachine(typeof(<GrenadeThrowLogic>d__77))]
		private IEnumerator GrenadeThrowLogic(ItemGrenadeOrnament grenade)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GrenadeThrowLogic>d__77(0)
			{
				<>4__this = this,
				grenade = grenade
			};
		}

		private void GunAimLogic()
		{
		}

		[PunRPC]
		private void ShootGunRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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)
			if (!SemiFunc.MasterOnlyRPC(info))
			{
				return;
			}
			gunHurtCollider.gameObject.SetActive(true);
			gunHurtColliderTimer = 0.05f;
			gunHurtColliderWave.gameObject.SetActive(true);
			gunHurtColliderWaveTimer = 0.2f;
			gunShootParticlesTransform.position = gunTipTransform.position;
			gunShootParticlesTransform.rotation = gunTipTransform.rotation;
			foreach (ParticleSystem gunShootParticle in gunShootParticles)
			{
				gunShootParticle.Play();
			}
			enemyElfAlwaysActive.TriggerGunEffect();
			anim.EventGunShoot(gunTipTransform.position);
			GameDirector.instance.CameraShake.ShakeDistance(5f, 3f, 15f, gunTipTransform.position, 0.5f);
			GameDirector.instance.CameraImpact.ShakeDistance(5f, 3f, 15f, gunTipTransform.position, 0.5f);
		}

		private void EyelidTwitchLogic()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!(eyelidTwitchTimer >= 0f))
			{
				return;
			}
			eyelidTwitchTimer -= Time.deltaTime;
			if (eyelidTwitchTimer <= 0f)
			{
				if (SemiFunc.IsMultiplayer())
				{
					photonView.RPC("EyelidTwitchRPC", (RpcTarget)0, Array.Empty<object>());
				}
				else
				{
					EyelidTwitchRPC();
				}
				eyelidTwitchTimer = Random.Range(1f, 60f);
			}
		}

		[PunRPC]
		private void EyelidTwitchRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info))
			{
				anim.EventEyelidTwitch();
				WintryMonstrosities.DebugElf("Triggered eyelid twitch", this);
			}
		}

		private void ResetNavMeshAgent()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			enemy.NavMeshAgent.ResetPath();
			enemy.NavMeshAgent.Warp(((Component)enemy.Rigidbody).transform.position, false);
		}

		internal bool IsVisionBlocked()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)playerTarget))
			{
				return true;
			}
			if (visionTimer <= 0f)
			{
				visionTimer = 0.25f;
				Vector3 val = playerTarget.PlayerVisionTarget.VisionTransform.position - enemy.CenterTransform.position;
				visionPrevious = Physics.Raycast(enemy.CenterTransform.position, val, ((Vector3)(ref val)).magnitude, LayerMask.GetMask(new string[1] { "Default" }), (QueryTriggerInteraction)1);
			}
			return visionPrevious;
		}

		internal void UpdatePlayerTarget(PlayerAvatar player)
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)player) && (Object)(object)player != (Object)(object)playerTarget)
				{
					photonView.RPC("UpdatePlayerTargetRPC", (RpcTarget)1, new object[1] { player.photonView.ViewID });
				}
				playerTarget = player;
				WintryMonstrosities.DebugElf($"playerTarget: {playerTarget}", this);
			}
		}

		[PunRPC]
		private void UpdatePlayerTargetRPC(int photonViewID, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info))
			{
				playerTarget = SemiFunc.PlayerAvatarGetFromPhotonID(photonViewID);
				WintryMonstrosities.DebugElf($"playerTarget: {playerTarget} (from RPC)", this);
			}
		}

		[PunRPC]
		public void EnemySetupRPC(int role, float pitch, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info))
			{
				currentRole = (Role)role;
				anim.SetRoleAnimStates();
				anim.SetVoicePitch(pitch);
				WintryMonstrosities.DebugElf($"Elf {directorIndex} Role: {currentRole}");
			}
		}

		[PunRPC]
		public void SetupEyesRPC(Vector3 rotation, bool applyToLeftEye, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.MasterOnlyRPC(info))
			{
				return;
			}
			if (applyToLeftEye)
			{
				if (Random.Range(0, 10) == 0)
				{
					leftEye.SetActive(false);
					WintryMonstrosities.DebugElf("He lost his left eye!", this);
				}
				else
				{
					leftEye.transform.rotation = Quaternion.Euler(rotation);
					WintryMonstrosities.DebugElf($"Applied rotation offset to left eye {rotation}", this);
				}
			}
			else if (Random.Range(0, 10) == 0)
			{
				rightEye.SetActive(false);
				WintryMonstrosities.DebugElf("He lost his right eye!", this);
			}
			else
			{
				rightEye.transform.rotation = Quaternion.Euler(rotation);
				WintryMonstrosities.DebugElf($"Applied rotation offset to right eye {rotation}", this);
			}
		}
	}
	public class EnemyElfAlwaysActive : MonoBehaviour
	{
		public PropLight shootLight;

		private bool shootEffectActive;

		private float shootLightIntensity;

		private void Start()
		{
			shootLightIntensity = shootLight.lightComponent.intensity;
		}

		private void Update()
		{
			if (shootEffectActive)
			{
				Light lightComponent = shootLight.lightComponent;
				lightComponent.intensity -= Time.deltaTime * 20f;
				shootLight.originalIntensity = shootLightIntensity;
				if (!(shootLight.lightComponent.intensity > 0f))
				{
					((Behaviour)shootLight.lightComponent).enabled = false;
					shootEffectActive = false;
				}
			}
		}

		public void TriggerGunEffect()
		{
			shootEffectActive = true;
			((Behaviour)shootLight.lightComponent).enabled = true;
			shootLight.lightComponent.intensity = shootLightIntensity;
			shootLight.originalIntensity = shootLightIntensity;
		}
	}
	public class EnemyElfAnim : MonoBehaviour
	{
		public EnemyElf controller;

		internal readonly MaterialTrigger materialTrigger = new MaterialTrigger();

		private Animator anim;

		[Space]
		public GameObject[] decoratorObjects;

		public GameObject[] trumpeterObjects;

		public GameObject[] toymakerObjects;

		private readonly int boolIsDecorator = Animator.StringToHash("isDecorator");

		private readonly int boolIsTrumpeter = Animator.StringToHash("isTrumpeter");

		private readonly int boolIsToymaker = Animator.StringToHash("isToymaker");

		private readonly int boolDespawn = Animator.StringToHash("despawn");

		private readonly int boolMoving = Animator.StringToHash("moving");

		private readonly int boolFalling = Animator.StringToHash("falling");

		private readonly int boolStunned = Animator.StringToHash("stunned");

		private readonly int triggerSpawn = Animator.StringToHash("Spawn");

		private readonly int triggerJump = Animator.StringToHash("Jump");

		private readonly int triggerLand = Animator.StringToHash("Land");

		private readonly int triggerNotice = Animator.StringToHash("Notice");

		private readonly int triggerStun = Animator.StringToHash("Stun");

		private readonly int triggerDespawn = Animator.StringToHash("Despawn");

		private float moveTimer;

		private bool spawnImpulse = true;

		private bool jumpImpulse = true;

		private bool landImpulse = true;

		private bool noticeImpulse = true;

		private bool stunImpulse = true;

		private bool despawnImpulse = true;

		[Space]
		public ParticleSystem particleBits;

		public ParticleSystem particleDirectionalBits;

		public ParticleSystem particleImpact;

		public ParticleSystem particleSmoke;

		[Space]
		public GenericEyeLookAt eyeLookAt;

		[Space]
		public Transform voiceTransform;

		[Header("Generic Sounds")]
		public Sound soundSpawn;

		public Sound soundDespawn;

		[Space]
		public Sound soundFootstepLight;

		public Sound soundFootstepHeavy;

		public Sound soundMoveShort;

		public Sound soundMoveLong;

		[Space]
		public Sound soundJump;

		public Sound soundLand;

		[Space]
		public Sound soundNeckCrack;

		public Sound soundEyeTwitch;

		[Space]
		public Sound soundNotice;

		[Space]
		public Sound soundHurt;

		public Sound soundStunLoop;

		public Sound soundStunOutro;

		public Sound soundDeath;

		[Header("Trumpeter Sounds")]
		public Sound soundTrumpetAlert;

		public Sound soundTrumpetAlertGlobal;

		public Sound soundTrumpeterChaseLoop;

		public Sound soundTrumpeterGunShoot;

		public Sound soundTrumpeterGunShootGlobal;

		public void Awake()
		{
			anim = ((Component)this).GetComponent<Animator>();
			anim.keepAnimatorStateOnDisable = true;
		}

		private void Update()
		{
			AnimatorLogic();
			EyeLookAtLogic();
			SoundLoopLogic();
		}

		private void AnimatorLogic()
		{
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			anim.speed = ((!controller.enemy.Rigidbody.frozen) ? 1 : 0);
			if (controller.currentState == EnemyElf.State.Spawn)
			{
				if (spawnImpulse)
				{
					anim.SetTrigger(triggerSpawn);
					spawnImpulse = false;
				}
			}
			else if (!spawnImpulse)
			{
				spawnImpulse = true;
			}
			bool flag;
			switch (controller.currentState)
			{
			case EnemyElf.State.Move:
			case EnemyElf.State.Investigate:
			case EnemyElf.State.Flee:
			case EnemyElf.State.WeaponPrepare:
			case EnemyElf.State.GunChase:
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag && (((Vector3)(ref controller.enemy.Rigidbody.velocity)).magnitude > 1f || ((Vector3)(ref controller.enemy.Rigidbody.physGrabObject.rbAngularVelocity)).magnitude > 1f))
			{
				moveTimer = 0.1f;
			}
			if (moveTimer > 0f)
			{
				moveTimer -= Time.deltaTime;
				anim.SetBool(boolMoving, true);
			}
			else
			{
				anim.SetBool(boolMoving, false);
			}
			if (controller.enemy.Jump.jumping || controller.enemy.Jump.jumpingDelay)
			{
				if (jumpImpulse)
				{
					if (!controller.enemy.IsStunned())
					{
						anim.SetTrigger(triggerJump);
						anim.SetBool(boolFalling, false);
					}
					jumpImpulse = false;
					landImpulse = true;
				}
				else if (controller.enemy.Rigidbody.physGrabObject.rbVelocity.y < -0.5f)
				{
					anim.SetBool(boolFalling, true);
				}
			}
			else
			{
				if (landImpulse)
				{
					if (!controller.enemy.IsStunned())
					{
						anim.SetTrigger(triggerLand);
					}
					moveTimer = 0f;
					landImpulse = false;
				}
				anim.SetBool(boolFalling, false);
				jumpImpulse = true;
			}
			if (controller.currentState == EnemyElf.State.Notice)
			{
				if (noticeImpulse)
				{
					anim.SetTrigger(triggerNotice);
					noticeImpulse = false;
				}
			}
			else if (!noticeImpulse)
			{
				noticeImpulse = true;
			}
			if (controller.currentState == EnemyElf.State.Stun)
			{
				if (stunImpulse)
				{
					anim.SetBool(boolStunned, true);
					anim.SetTrigger(triggerStun);
					stunImpulse = false;
				}
			}
			else if (!stunImpulse)
			{
				anim.SetBool(boolStunned, false);
				soundStunOutro.Play(voiceTransform.position, 1f, 1f, 1f, 1f);
				stunImpulse = true;
			}
			if (controller.currentState == EnemyElf.State.Despawn)
			{
				if (despawnImpulse)
				{
					anim.SetBool(boolDespawn, true);
					anim.SetTrigger(triggerDespawn);
					despawnImpulse = false;
					WintryMonstrosities.DebugElf("Anim despawn", controller);
				}
			}
			else if (!despawnImpulse)
			{
				anim.SetBool(boolDespawn, false);
				despawnImpulse = true;
				WintryMonstrosities.DebugElf("Respawned", controller);
			}
		}

		private void EyeLookAtLogic()
		{
			bool flag;
			switch (controller.currentState)
			{
			case EnemyElf.State.Notice:
			case EnemyElf.State.WeaponPrepare:
			case EnemyElf.State.WeaponDeploy:
			case EnemyElf.State.GunChase:
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag && Object.op_Implicit((Object)(object)controller.playerTarget) && !controller.playerTarget.isDisabled && !controller.IsVisionBlocked())
			{
				eyeLookAt.SetTargetPlayer(controller.playerTarget, 0.5f);
			}
		}

		private void SoundLoopLogic()
		{
			soundStunLoop.PlayLoop(controller.currentState == EnemyElf.State.Stun, 0.5f, 0.5f, 1f);
			soundTrumpeterChaseLoop.PlayLoop(controller.currentState == EnemyElf.State.GunChase, 0.5f, 0.5f, 1f);
		}

		public void EventSpawn()
		{
		}

		public void EventDespawn()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				controller.enemy.EnemyParent.Despawn();
			}
		}

		public void EventTeleport()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (controller.currentState == EnemyElf.State.Despawn)
			{
				soundDespawn.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			}
			else
			{
				soundSpawn.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			}
			GameDirector.instance.CameraShake.ShakeDistance(3f, 3f, 8f, controller.enemy.CenterTransform.position, 0.5f);
			GameDirector.instance.CameraImpact.ShakeDistance(3f, 3f, 8f, controller.enemy.CenterTransform.position, 0.5f);
			particleSmoke.Play();
		}

		public void EventFootstepLight()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (controller.enemy.Grounded.grounded)
			{
				soundFootstepLight.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
				MaterialImpulse((SoundType)0);
			}
		}

		public void EventFootstepHeavy()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (controller.enemy.Grounded.grounded)
			{
				soundFootstepHeavy.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
				MaterialImpulse((SoundType)1);
			}
		}

		public void EventMoveShort()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			soundMoveShort.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventMoveLong()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			soundMoveLong.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventJump()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			soundJump.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			MaterialImpulse((SoundType)1);
		}

		public void EventLand()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			soundLand.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			MaterialImpulse((SoundType)1);
		}

		public void EventNeckCrack()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			soundNeckCrack.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventEyelidTwitch()
		{
			//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)
			soundEyeTwitch.Play(((Component)voiceTransform).transform.position + new Vector3(0f, 0.2f, 0f), 1f, 1f, 1f, 1f);
		}

		public void EventNotice()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			soundNotice.Play(((Component)voiceTransform).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventHurt()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			soundHurt.Play(((Component)voiceTransform).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventDeath()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			soundDeath.Play(((Component)voiceTransform).transform.position, 1f, 1f, 1f, 1f);
			particleImpact.Play();
			particleBits.Play();
			((Component)particleDirectionalBits).transform.rotation = Quaternion.LookRotation(-((Vector3)(ref controller.enemy.Health.hurtDirection)).normalized);
			particleDirectionalBits.Play();
			particleSmoke.Play();
		}

		public void EventTrumpetAlert()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			soundTrumpetAlert.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			soundTrumpetAlertGlobal.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
		}

		public void EventGunShoot(Vector3 pos)
		{
			//IL_0007: 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)
			soundTrumpeterGunShoot.Play(pos, 1f, 1f, 1f, 1f);
			soundTrumpeterGunShootGlobal.Play(pos, 1f, 1f, 1f, 1f);
		}

		public void OnSpawn()
		{
			anim.SetTrigger(triggerSpawn);
			particleSmoke.Play();
		}

		public void SetRoleAnimStates()
		{
			switch (controller.currentRole)
			{
			case EnemyElf.Role.Decorator:
			{
				anim.SetBool(boolIsDecorator, true);
				GameObject[] array2 = decoratorObjects;
				foreach (GameObject val2 in array2)
				{
					val2.SetActive(true);
				}
				break;
			}
			case EnemyElf.Role.Trumpeter:
			{
				anim.SetBool(boolIsTrumpeter, true);
				GameObject[] array3 = trumpeterObjects;
				foreach (GameObject val3 in array3)
				{
					val3.SetActive(true);
				}
				break;
			}
			case EnemyElf.Role.Toymaker:
			{
				anim.SetBool(boolIsToymaker, true);
				GameObject[] array = toymakerObjects;
				foreach (GameObject val in array)
				{
					val.SetActive(true);
				}
				break;
			}
			}
			WintryMonstrosities.DebugElf($"Elf {controller.directorIndex}:\n" + $"-   -   -   -   -   -   -   - isDecorator anim state: {anim.GetBool(boolIsDecorator)}\n" + $"-   -   -   -   -   -   -   - isTrumpeter anim state: {anim.GetBool(boolIsTrumpeter)}\n" + $"-   -   -   -   -   -   -   - isToymaker anim state: {anim.GetBool(boolIsToymaker)}");
		}

		public void SetVoicePitch(float pitch)
		{
			soundNotice.Pitch = pitch;
			soundHurt.Pitch = pitch;
			soundDeath.Pitch = pitch;
		}

		public void MaterialImpulse(SoundType type, bool footstep = true)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Materials.Instance.Impulse(controller.enemy.CenterTransform.position, Vector3.down, type, footstep, true, materialTrigger, (HostType)2);
		}
	}
	public class EnemyElfDirector : MonoBehaviour
	{
		public enum State
		{
			Idle,
			Leave,
			ChangeDestination,
			SplitUp,
			AllInvestigate
		}

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

			private object <>2__current;

			public EnemyElfDirector <>4__this;

			private List<EnemyParent>.Enumerator <>s__1;

			private EnemyParent <e>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<EnemyParent>.Enumerator);
				<e>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!LevelGenerator.Instance.Generated)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				<>s__1 = EnemyDirector.instance.enemiesSpawned.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<e>5__2 = <>s__1.Current;
						EnemyElfDirector enemyElfDirector = <>4__this;
						EnemyParent obj = <e>5__2;
						enemyElfDirector.SetupSingle((obj != null) ? ((Component)obj.Enemy).GetComponent<EnemyElf>() : null);
						<e>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<EnemyParent>.Enumerator);
				<>4__this.setup = true;
				return false;
			}

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

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

		internal static EnemyElfDirector instance;

		[Space]
		public List<EnemyElf> elves = new List<EnemyElf>();

		private int roleIndex = -1;

		internal readonly List<Vector3> destinations = new List<Vector3>();

		[Space]
		public State currentState = State.Idle;

		private bool stateImpulse;

		private float stateTimer;

		internal bool setup;

		internal Vector3 allInvestigatePosition;

		private void Awake()
		{
			if (!Object.op_Implicit((Object)(object)instance))
			{
				instance = this;
				((Component)this).transform.parent = LevelGenerator.Instance.EnemyParent.transform;
				((MonoBehaviour)this).StartCoroutine(Setup());
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		[IteratorStateMachine(typeof(<Setup>d__11))]
		private IEnumerator Setup()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Setup>d__11(0)
			{
				<>4__this = this
			};
		}

		internal void SetupSingle(EnemyElf elf)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: 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_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)elf) || elves.Contains(elf))
			{
				return;
			}
			elves.Add(elf);
			destinations.Add(Vector3.zero);
			elf.directorIndex = elves.IndexOf(elf);
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			WintryMonstrosities.DebugElf("- - - - - - - - - - - - - - - - - - - - - - - - -");
			if (roleIndex == -1)
			{
				roleIndex = Random.Range(0, Enum.GetValues(typeof(EnemyElf.Role)).Length);
				WintryMonstrosities.DebugElf($"Starting on roleIndex {roleIndex}: {(EnemyElf.Role)roleIndex}");
			}
			float num = Random.Range(0.9f, 1.1f);
			if (SemiFunc.IsMultiplayer())
			{
				elf.photonView.RPC("EnemySetupRPC", (RpcTarget)0, new object[2] { roleIndex, num });
			}
			else
			{
				elf.EnemySetupRPC(roleIndex, num);
			}
			roleIndex++;
			if (roleIndex >= Enum.GetValues(typeof(EnemyElf.Role)).Length)
			{
				roleIndex = 0;
			}
			if (Random.value < 0.3f)
			{
				WintryMonstrosities.DebugElf("Skipped eye setup", elf);
				return;
			}
			WintryMonstrosities.DebugElf("Setting up eyes", elf);
			int num2 = roleIndex;
			if (1 == 0)
			{
			}
			float num3 = num2 switch
			{
				0 => 8f, 
				1 => 4f, 
				2 => 12f, 
				_ => 8f, 
			};
			if (1 == 0)
			{
			}
			float num4 = num3;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(Random.Range(0f - num4, num4), Random.Range(0f - num4, num4), 0f);
			bool flag = Random.Range(0, 2) == 0;
			if (SemiFunc.IsMultiplayer())
			{
				elf.photonView.RPC("SetupEyesRPC", (RpcTarget)0, new object[2] { val, flag });
			}
			else
			{
				elf.SetupEyesRPC(val, flag);
			}
		}

		private void Update()
		{
			if (setup && SemiFunc.IsMasterClientOrSingleplayer())
			{
				switch (currentState)
				{
				case State.Idle:
					StateIdle();
					break;
				case State.Leave:
					StateLeave();
					break;
				case State.ChangeDestination:
					StateChangeDestination();
					break;
				case State.SplitUp:
					StateSplitUp();
					break;
				case State.AllInvestigate:
					StateAllInvestigate();
					break;
				}
			}
		}

		private void StateIdle()
		{
			if (SemiFunc.EnemySpawnIdlePause())
			{
				return;
			}
			if (stateImpulse)
			{
				stateImpulse = false;
				stateTimer = Random.Range(10f, 20f);
			}
			if (!SemiFunc.EnemySpawnIdlePause())
			{
				stateTimer -= Time.deltaTime;
				if (stateTimer <= 0f)
				{
					UpdateState((Random.value < 0.25f) ? State.SplitUp : State.ChangeDestination);
				}
				LeaveCheck();
			}
		}

		private void StateLeave()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				bool flag = false;
				LevelPoint val = SemiFunc.LevelPointGetFurthestFromPlayer(((Component)this).transform.position, 5f);
				if (Object.op_Implicit((Object)(object)val))
				{
					flag = SetPosition(((Component)val).transform.position);
				}
				if (flag)
				{
					stateImpulse = false;
					UpdateState(State.Idle);
				}
			}
		}

		private void StateChangeDestination()
		{
			//IL_001b: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				bool flag = false;
				LevelPoint val = SemiFunc.LevelPointGet(((Component)this).transform.position, 10f, 25f);
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = SemiFunc.LevelPointGet(((Component)this).transform.position, 0f, 999f);
				}
				if (Object.op_Implicit((Object)(object)val))
				{
					flag = SetPosition(((Component)val).transform.position);
				}
				if (flag)
				{
					stateImpulse = false;
					UpdateState(State.Idle);
				}
			}
		}

		private void StateSplitUp()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				UpdateState(State.Idle);
			}
		}

		private void StateAllInvestigate()
		{
			if (stateImpulse)
			{
				stateImpulse = false;
				UpdateState(State.Idle);
			}
		}

		private void UpdateState(State state)
		{
			WintryMonstrosities.DebugElf($"Director: {currentState} to {state}");
			currentState = state;
			stateImpulse = true;
			stateTimer = 0f;
		}

		public void OnSpawn(EnemyElf elfSpawn)
		{
			bool flag = true;
			foreach (EnemyElf elf in elves)
			{
				if (Object.op_Implicit((Object)(object)elf))
				{
					if ((Object)(object)elfSpawn != (Object)(object)elf && elf.enemy.EnemyParent.Spawned)
					{
						flag = false;
					}
					elf.enemy.EnemyParent.DespawnedTimerSet(elf.enemy.EnemyParent.DespawnedTimer - 30f, false);
				}
			}
			if (flag)
			{
				UpdateState(State.ChangeDestination);
			}
		}

		public void Investigate(Vector3 position)
		{
			//IL_0011: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			if (currentState != State.AllInvestigate)
			{
				allInvestigatePosition = position;
				UpdateState(State.AllInvestigate);
				SetPosition(position);
			}
		}

		public void NotifyNearby(PlayerAvatar player, Vector3 position)
		{
			//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_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)
			List<EnemyElf> list = new List<EnemyElf>();
			foreach (EnemyElf elf in elves)
			{
				EnemyElf.State state = elf.currentState;
				bool flag = (uint)(state - 1) <= 3u;
				if (flag && !list.Contains(elf))
				{
					Vector3 val = ((Component)elf).transform.position - position;
					if (((Vector3)(ref val)).sqrMagnitude < 20.25f)
					{
						list.Add(elf);
					}
				}
			}
			foreach (EnemyElf item in list)
			{
				item.UpdatePlayerTarget(player);
				item.NoticeDelay();
			}
		}

		private bool SetPosition(Vector3 initialPos)
		{
			//IL_0001: 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_003e: 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_0074: 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_00c1: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(initialPos, ref val, 10f, -1) || !Physics.Raycast(((NavMeshHit)(ref val)).position, Vector3.down, 10f, LayerMask.GetMask(new string[1] { "Default" })) || SemiFunc.EnemyPhysObjectSphereCheck(((NavMeshHit)(ref val)).position, 1f))
			{
				return false;
			}
			((Component)this).transform.position = ((NavMeshHit)(ref val)).position;
			((Component)this).transform.rotation = Quaternion.identity;
			float num = 360f / (float)elves.Count;
			NavMeshHit val3 = default(NavMeshHit);
			foreach (EnemyElf elf in elves)
			{
				float num2 = 0f;
				Vector3 value = ((Component)this).transform.position;
				Vector3 val2 = ((Component)this).transform.position;
				for (; num2 < 2f; num2 += 0.1f)
				{
					value = val2;
					val2 = ((NavMeshHit)(ref val)).position + ((Component)this).transform.forward * num2;
					if (!NavMesh.SamplePosition(val2, ref val3, 10f, 1) || !Physics.Raycast(val2, Vector3.down, 10f, LayerMask.GetMask(new string[1] { "Default" })))
					{
						break;
					}
					Vector3 val4 = val2 + Vector3.up * 0.5f - (((NavMeshHit)(ref val)).position + Vector3.up * 0.5f);
					Vector3 normalized = ((Vector3)(ref val4)).normalized;
					if (Physics.Raycast(val2 + Vector3.up * 0.5f, normalized, ((Vector3)(ref normalized)).magnitude, LayerMask.GetMask(new string[2] { "Default", "PhysGrabObjectHinge" })) || (num2 > 0.5f && Random.Range(0, 100) < 15))
					{
						break;
					}
				}
				destinations[elves.IndexOf(elf)] = value;
				Transform transform = ((Component)this).transform;
				Quaternion rotation = ((Component)this).transform.rotation;
				transform.rotation = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y + num, 0f);
			}
			return true;
		}

		private void LeaveCheck()
		{
			bool flag = false;
			foreach (EnemyElf elf in elves)
			{
				if (Object.op_Implicit((Object)(object)elf) && SemiFunc.EnemyForceLeave(elf.enemy))
				{
					flag = true;
				}
			}
			if (flag)
			{
				UpdateState(State.Leave);
			}
		}

		public void PauseSpawnedTimers()
		{
			foreach (EnemyElf elf in elves)
			{
				if (elf != null)
				{
					elf.enemy.EnemyParent.SpawnedTimerPause(0.1f);
				}
			}
		}
	}
	public class ItemGrenadeOrnament : MonoBehaviour
	{
		private readonly int emissionColor = Shader.PropertyToID("_EmissionColor");

		private ItemEquippable itemEquippable;

		internal ItemToggle itemToggle;

		private PhotonView photonView;

		internal PhysGrabObject physGrabObject;

		private PhysGrabObjectImpactDetector physGrabObjectImpactDetector;

		[Space]
		public GameObject ornamentPrefabExplosion;

		private ParticlePrefabExplosion particlePrefabExplosion;

		public GameObject ornamentGrenadeEnable;

		public GameObject mesh;

		public Color blinkColor;

		private Material grenadeEmissionMaterial;

		public float tickTime = 3f;

		private float grenadeTimer;

		public Transform splinterTransform;

		public AnimationCurve splinterAnimationCurve;

		private float splinterAnimationProgress;

		public GameObject throwLine;

		private TrailRenderer throwLineTrail;

		private float throwLineTimer;

		[Space]
		public float explosionSize = 1.5f;

		public int playerDamage = 10;

		public int enemyDamage = 20;

		[Space]
		public Sound soundSplinter;

		public Sound soundTick;

		public Sound soundExplosion;

		public Sound soundExplosionGlobal;

		private bool detonated;

		private float nullCheckTimer;

		internal bool isActive;

		private Vector3 prevPosition;

		internal Rigidbody rb;

		private void Start()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			itemEquippable = ((Component)this).GetComponent<ItemEquippable>();
			itemToggle = ((Component)this).GetComponent<ItemToggle>();
			photonView = ((Component)this).GetComponent<PhotonView>();
			physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
			physGrabObjectImpactDetector = ((Component)this).GetComponent<PhysGrabObjectImpactDetector>();
			particlePrefabExplosion = ornamentPrefabExplosion.GetComponent<ParticlePrefabExplosion>();
			particlePrefabExplosion.explosionSize = explosionSize;
			particlePrefabExplosion.explosionDamage = playerDamage;
			particlePrefabExplosion.explosionDamageEnemy = enemyDamage;
			grenadeEmissionMaterial = mesh.GetComponent<Renderer>().material;
			throwLineTrail = throwLine.GetComponent<TrailRenderer>();
			rb = ((Component)this).GetComponent<Rigidbody>();
			prevPosition = rb.position;
		}

		private void FixedUpdate()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (detonated)
			{
				return;
			}
			if (itemEquippable.isEquipped || itemEquippable.wasEquippedTimer > 0f)
			{
				prevPosition = rb.position;
				return;
			}
			Vector3 val = (rb.position - prevPosition) / Time.fixedDeltaTime;
			Vector3 val2 = rb.position - prevPosition;
			_ = ((Vector3)(ref val2)).normalized;
			prevPosition = rb.position;
			if (!physGrabObject.grabbed && !physGrabObjectImpactDetector.inCart && ((Vector3)(ref val)).magnitude > 2f)
			{
				throwLineTimer = 0.2f;
			}
			if (throwLineTimer > 0f)
			{
				throwLineTrail.emitting = true;
				throwLineTimer -= Time.fixedDeltaTime;
			}
			else
			{
				throwLineTrail.emitting = false;
			}
		}

		private void Update()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			soundTick.PlayLoop(isActive && !detonated, 1f, 1f, 1f);
			if (itemEquippable.isEquipped)
			{
				if (isActive)
				{
					isActive = false;
					grenadeTimer = 0f;
					splinterAnimationProgress = 0f;
					itemToggle.ToggleItem(false, -1);
					splinterTransform.localEulerAngles = Vector3.zero;
					grenadeEmissionMaterial.SetColor(emissionColor, Color.black);
				}
				return;
			}
			if (isActive && !detonated)
			{
				if (splinterAnimationProgress < 1f)
				{
					splinterAnimationProgress += 5f * Time.deltaTime;
					float num = splinterAnimationCurve.Evaluate(splinterAnimationProgress);
					splinterTransform.localEulerAngles = new Vector3(num * 90f, 0f, 0f);
				}
				float num2 = Mathf.PingPong(Time.time * 8f, 1f);
				Color val = blinkColor * Mathf.LinearToGammaSpace(num2);
				grenadeEmissionMaterial.SetColor(emissionColor, val);
			}
			if (detonated)
			{
				if (nullCheckTimer < 5f)
				{
					nullCheckTimer += Time.deltaTime;
					return;
				}
				if (!Object.op_Implicit((Object)(object)ornamentPrefabExplosion))
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
					WintryMonstrosities.DebugElf("Destroyed Ornament Grenade entirely");
				}
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				if (itemToggle.toggleState && !isActive)
				{
					isActive = true;
					TickStart();
				}
				if (!isActive)
				{
					grenadeTimer = 0f;
				}
				else if (grenadeTimer < tickTime)
				{
					grenadeTimer += Time.deltaTime;
				}
				else if (!detonated)
				{
					TickEnd();
				}
			}
		}

		private void TickStart()
		{
			//IL_0029: 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)
			if (SemiFunc.IsMasterClient())
			{
				photonView.RPC("TickStartRPC", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				TickStartRPC();
			}
		}

		private void TickEnd()
		{
			//IL_0029: 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)
			if (SemiFunc.IsMasterClient())
			{
				photonView.RPC("TickEndRPC", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				TickEndRPC();
			}
		}

		[PunRPC]
		private void TickStartRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info))
			{
				soundSplinter.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
				isActive = true;
			}
		}

		[PunRPC]
		private void TickEndRPC(PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.MasterOnlyRPC(info) && !itemEquippable.isEquipped)
			{
				Explode();
			}
		}

		public void Explode()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			foreach (PhysGrabber item in physGrabObject.playerGrabbing.ToList())
			{
				if (SemiFunc.IsMultiplayer())
				{
					item.photonView.RPC("ReleaseObjectRPC", (RpcTarget)0, new object[3] { false, 0.1f, photonView.ViewID });
				}
				else
				{
					item.ReleaseObject(photonView.ViewID, 0.1f);
				}
			}
			soundExplosion.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			soundExplosionGlobal.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			ornamentPrefabExplosion.SetActive(true);
			Object.Destroy((Object)(object)ornamentGrenadeEnable.gameObject);
			rb.velocity = Vector3.zero;
			rb.useGravity = false;
			detonated = true;
		}
	}
	[BepInPlugin("BLOKBUSTR.WintryMonstrosities", "WintryMonstrosities", "0.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class WintryMonstrosities : BaseUnityPlugin
	{
		private static ConfigEntry<bool> configEnableDebugElf;

		internal static WintryMonstrosities Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			configEnableDebugElf = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "EnableDebugElf", false, new ConfigDescription("