using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Photon.Pun;
using REPODebbysCase.Config;
using REPODebbysCase.NetcodePatcher;
using REPODebbysCase.Utilities;
using REPOLib.Modules;
using REPOLib.Objects;
using REPOLib.Objects.Sdk;
using TMPro;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("REPODebbysCase")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Scan Computers")]
[assembly: AssemblyProduct("REPODebbysCase")]
[assembly: AssemblyCopyright("Copyright © Scan Computers 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a4fd09a5-2078-4f37-ae81-44c02af535da")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: NetcodePatchedAssembly]
namespace REPODebbysCase
{
	[BepInPlugin("deB.DebbysCase", "Debbys Case", "0.0.8")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class DebbysCase : BaseUnityPlugin
	{
		internal const string modGUID = "deB.DebbysCase";

		internal const string modName = "Debbys Case";

		internal const string modVersion = "0.0.8";

		internal ManualLogSource log = null;

		public static DebbysCase instance;

		public Utils utils;

		public List<EnemyContent> enemiesList = new List<EnemyContent>();

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

		internal DebbysCaseConfig ModConfig { get; private set; } = null;


		public void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			utils = new Utils();
			log = ((BaseUnityPlugin)this).Logger;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				MethodInfo[] methods = types[i].GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				for (int j = 0; j < methods.Length; j++)
				{
					object[] customAttributes;
					try
					{
						customAttributes = methods[j].GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					}
					catch
					{
						continue;
					}
					if (customAttributes.Length != 0)
					{
						methods[j].Invoke(null, null);
					}
				}
			}
			PropogateLists();
			ModConfig = new DebbysCaseConfig(((BaseUnityPlugin)this).Config, enemiesList, itemsList);
			HandleContent();
			log.LogInfo((object)"Debbys Case Successfully Loaded");
		}

		public void PropogateLists()
		{
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "debbyscase"));
			string[] allAssetNames = val.GetAllAssetNames();
			for (int i = 0; i < allAssetNames.Length; i++)
			{
				string text = allAssetNames[i].Substring(0, allAssetNames[i].LastIndexOf("/"));
				string text2 = text;
				string text3 = text2;
				if (!(text3 == "assets/debbys case/resources/items"))
				{
					if (text3 == "assets/debbys case/resources/enemies")
					{
						enemiesList.Add(val.LoadAsset<EnemyContent>(allAssetNames[i]));
					}
					else
					{
						log.LogWarning((object)("\"" + text + "\" is not a known asset path, skipping."));
					}
				}
				else
				{
					itemsList.Add(val.LoadAsset<GameObject>(allAssetNames[i]));
				}
			}
		}

		public void HandleContent()
		{
			HandleItems();
			HandleEnemies();
		}

		public void HandleItems()
		{
			for (int i = 0; i < itemsList.Count; i++)
			{
				if (ModConfig.isItemEnabled[i].Value)
				{
					Items.RegisterItem(itemsList[i].GetComponent<ItemAttributes>());
					log.LogDebug((object)(((Object)itemsList[i]).name + " item was loaded!"));
				}
				else
				{
					log.LogInfo((object)(((Object)itemsList[i]).name + " item was disabled!"));
				}
			}
		}

		public void HandleEnemies()
		{
			for (int i = 0; i < enemiesList.Count; i++)
			{
				if (ModConfig.isEnemyEnabled[i].Value)
				{
					Enemies.RegisterEnemy(enemiesList[i]);
					log.LogDebug((object)(((Object)enemiesList[i]).name + " enemy was loaded!"));
				}
				else
				{
					log.LogInfo((object)(((Object)enemiesList[i]).name + " enemy was disabled!"));
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "REPODebbysCase";

		public const string PLUGIN_NAME = "REPOWildCardMod";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace REPODebbysCase.Utilities
{
	public class Utils
	{
		public bool RegisterPrefab(string path, GameObject prefab)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			PrefabRefResponse val = NetworkPrefabs.RegisterNetworkPrefabInternal($"{char.ToUpper(path[0])}{path.Substring(1, path.Length - 1)}/{((Object)prefab).name}", prefab);
			PrefabRef prefabRef = ((PrefabRefResponse)(ref val)).PrefabRef;
			if ((int)((PrefabRefResponse)(ref val)).Result != 0 || prefabRef == null)
			{
				DebbysCase.instance.log.LogWarning((object)$"Failed to register prefab \"{((Object)prefab).name}\", result: \"{val}\"");
				return false;
			}
			Utilities.FixAudioMixerGroups(prefab);
			return true;
		}
	}
}
namespace REPODebbysCase.Items
{
	public class PlayerTracker : MonoBehaviour
	{
		private readonly ManualLogSource log = DebbysCase.instance.log;

		public PhotonView photonView;

		public PhysGrabObject physGrabObject;

		public int trackerID;

		public ItemToggle itemToggle;

		public ItemEquippable itemEquippable;

		public TextMeshPro trackingNumberText;

		public TextMeshPro idNumberText;

		public Transform rotatorTransform;

		public float rotatorTargetRot;

		public Transform pegTransform;

		public float pegTargetPos;

		public Sound trackingLoop;

		public Sound clickSound;

		public bool movingNext = false;

		public float nextTimer = 0f;

		public Vector3 forceRotation = new Vector3(110f, 0f, 180f);

		public PlayerTracker trackingPlayer;

		public int lastID = 0;

		public PlayerAvatar equippingPlayer;

		public void Awake()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer() && !SemiFunc.RunIsLevel())
			{
				PhotonNetwork.Destroy(((Component)this).gameObject);
				return;
			}
			MotherTracker.activeTrackers.Add(this);
			itemEquippable = ((Component)this).GetComponent<ItemEquippable>();
			((TMP_Text)trackingNumberText).text = "X";
		}

		public void FixedUpdate()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || !LevelGenerator.Instance.Generated || !physGrabObject.grabbed)
			{
				return;
			}
			int num = physGrabObject.playerGrabbing.Count;
			for (int i = 0; i < physGrabObject.playerGrabbing.Count; i++)
			{
				if (physGrabObject.playerGrabbing[i].isRotating)
				{
					num--;
				}
			}
			if (num == physGrabObject.playerGrabbing.Count)
			{
				physGrabObject.TurnXYZ(Quaternion.Euler(forceRotation.x, 0f, 0f), Quaternion.Euler(0f, forceRotation.y, 0f), Quaternion.Euler(0f, 0f, forceRotation.z));
			}
		}

		public void Initialize()
		{
			List<int> list = new List<int>();
			for (int i = 0; i < MotherTracker.activeTrackers.Count; i++)
			{
				list.Add(MotherTracker.activeTrackers[i].trackerID);
			}
			int num = 1;
			int num2 = 0;
			while (list.Contains(num))
			{
				num++;
				num2++;
				if (num2 > list.Count)
				{
					num = 1;
					break;
				}
			}
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("InitializeRPC", (RpcTarget)0, new object[1] { num });
			}
			else
			{
				InitializeRPC(num);
			}
		}

		[PunRPC]
		public void InitializeRPC(int newID)
		{
			trackerID = newID;
			((TMP_Text)idNumberText).text = trackerID.ToString();
			log.LogDebug((object)$"Spawned new Player Tracker with id: \"{trackerID}\"");
		}

		public void Update()
		{
			//IL_0044: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelGenerator.Instance.Generated)
			{
				return;
			}
			if (movingNext)
			{
				nextTimer -= Time.deltaTime * 2f;
				rotatorTransform.localRotation = Quaternion.Lerp(Quaternion.identity, Quaternion.Euler(0f, 0f, rotatorTargetRot), nextTimer);
				pegTransform.localPosition = Vector3.Lerp(Vector3.zero, new Vector3(pegTargetPos, 0f, 0f), nextTimer);
			}
			else if ((Object)(object)trackingPlayer != (Object)null)
			{
				Vector3 val3;
				if (trackingPlayer.itemEquippable.isEquipped)
				{
					if ((Object)(object)equippingPlayer == (Object)null)
					{
						PlayerAvatar val = null;
						if (SemiFunc.IsMultiplayer())
						{
							PhotonView val2 = PhotonView.Find(trackingPlayer.itemEquippable.ownerPlayerId);
							if ((Object)(object)val2 != (Object)null)
							{
								val = ((Component)val2).GetComponent<PlayerAvatar>();
								if ((Object)(object)val == (Object)null)
								{
									val = ((Component)val2).GetComponent<PhysGrabber>().playerAvatar;
								}
							}
						}
						else
						{
							val = PlayerAvatar.instance;
						}
						equippingPlayer = val;
					}
					val3 = rotatorTransform.parent.InverseTransformPoint(((Component)equippingPlayer).transform.position);
				}
				else
				{
					if ((Object)(object)equippingPlayer != (Object)null)
					{
						equippingPlayer = null;
					}
					val3 = rotatorTransform.parent.InverseTransformPoint(trackingPlayer.rotatorTransform.position);
				}
				rotatorTargetRot = Mathf.Atan2(val3.y, val3.x) * 57.29578f;
				rotatorTransform.localRotation = Quaternion.Euler(0f, 0f, rotatorTargetRot);
				pegTargetPos = Mathf.InverseLerp(5f, 25f, Vector3.Distance(((Component)this).transform.position, rotatorTransform.parent.TransformPoint(val3))) * 0.8f;
				pegTransform.localPosition = new Vector3(pegTargetPos, 0f, 0f);
			}
			trackingLoop.PlayLoop((Object)(object)trackingPlayer != (Object)null && physGrabObject.grabbed, 1f, 2f, Mathf.Lerp(0.5f, 4f, 0.8f - pegTargetPos));
			if (physGrabObject.grabbedLocal)
			{
				PhysGrabber.instance.OverrideGrabDistance(0.8f);
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			if (!movingNext)
			{
				if (itemToggle.toggleState)
				{
					NextTracker(goingNext: true);
				}
			}
			else if (nextTimer <= 0f)
			{
				itemToggle.ToggleItem(false, -1);
				NextTracker(goingNext: false);
			}
		}

		public void NextTracker(bool goingNext)
		{
			int num = 0;
			if (!goingNext)
			{
				List<int> list = new List<int>();
				for (int i = 0; i < MotherTracker.activeTrackers.Count; i++)
				{
					list.Add(MotherTracker.activeTrackers[i].trackerID);
				}
				num = lastID + 1;
				if (num > Mathf.Max(list.ToArray()))
				{
					num = 1;
				}
				if (num == trackerID)
				{
					num++;
				}
				int num2 = 0;
				while (!list.Contains(num))
				{
					num++;
					if (num2 > list.Count)
					{
						num = lastID;
						break;
					}
				}
			}
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("NextTrackerRPC", (RpcTarget)0, new object[2] { num, goingNext });
			}
			else
			{
				NextTrackerRPC(num, goingNext);
			}
		}

		[PunRPC]
		public void NextTrackerRPC(int id, bool goingNext)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (goingNext)
			{
				nextTimer = 1f;
				trackingPlayer = null;
				((TMP_Text)trackingNumberText).text = "X";
			}
			else
			{
				lastID = id;
				trackingPlayer = MotherTracker.activeTrackers.Find((PlayerTracker x) => x.trackerID == id);
				((TMP_Text)trackingNumberText).text = id.ToString();
				log.LogDebug((object)$"Player Tracker with id: \"{trackerID}\" began tracking Player Tracker with id: \"{trackingPlayer.trackerID}\"");
				clickSound.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			}
			movingNext = goingNext;
		}

		public void OnDestroy()
		{
			MotherTracker.activeTrackers.Remove(this);
		}
	}
	public class MotherTracker : MonoBehaviour
	{
		private readonly ManualLogSource log = DebbysCase.instance.log;

		public static List<PlayerTracker> activeTrackers = new List<PlayerTracker>();

		public PhotonView photonView;

		public PhysGrabObject physGrabObject;

		public ItemAttributes itemAttributes;

		public ItemEquippable itemEquippable;

		public ItemToggle itemToggle;

		public Item trackerItem;

		public GameObject[] toDisable;

		public Transform[] toSpawnPositions;

		public Transform rayStart;

		public Sound useSound;

		public Sound floatLoop;

		public float balanceForce = 4f;

		public float floatPower = 5f;

		public float floatHeight = 0.5f;

		public float glidePower = 0.5f;

		public Animator animator;

		public ParticleSystem flameParticles;

		public Vector3 randomTorque;

		public float torqueTimer = 0f;

		public float torqueMultiplier = 1f;

		public float floatTimer = 0f;

		public bool released = false;

		public void FixedUpdate()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: 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_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			if (!LevelGenerator.Instance.Generated || released)
			{
				return;
			}
			Vector3 val = ((Component)this).transform.InverseTransformDirection(((Component)this).transform.up - Vector3.up);
			animator.SetFloat("Flap One Normal", Mathf.InverseLerp(-0.25f, 0.75f, val.z));
			animator.SetFloat("Flap Two Normal", Mathf.InverseLerp(-0.25f, 0.75f, val.x));
			animator.SetFloat("Flap Three Normal", Mathf.InverseLerp(0.25f, -0.75f, 0f - val.z));
			animator.SetFloat("Flap Four Normal", Mathf.InverseLerp(0.25f, -0.75f, 0f - val.x));
			if (SemiFunc.IsMasterClientOrSingleplayer() && !physGrabObject.grabbed)
			{
				Quaternion val2 = Quaternion.FromToRotation(((Component)this).transform.up, Vector3.up);
				physGrabObject.rb.AddTorque(new Vector3(val2.x, val2.y, val2.z) * balanceForce);
				RaycastHit val3 = default(RaycastHit);
				if (Physics.Raycast(rayStart.position, -Vector3.up, ref val3, floatHeight, LayerMask.GetMask(new string[6] { "Default", "PhysGrabObject", "PhysGrabObjectCart", "PhysGrabObjectHinge", "Enemy", "Player" }), (QueryTriggerInteraction)1) && !physGrabObject.colliders.Contains(((Component)((RaycastHit)(ref val3)).collider).transform))
				{
					physGrabObject.rb.AddForce(((Component)this).transform.up * (floatPower / ((RaycastHit)(ref val3)).distance) * (1.1f - Quaternion.Angle(Quaternion.identity, val2) / 360f));
				}
				else
				{
					physGrabObject.rb.AddForce(((Component)this).transform.up * floatPower * glidePower * (1.1f - Quaternion.Angle(Quaternion.identity, val2) / 360f));
				}
				if (floatTimer > 0f)
				{
					floatTimer -= Time.deltaTime;
				}
				else if (torqueTimer > 0f)
				{
					torqueTimer -= Time.deltaTime;
					physGrabObject.rb.AddTorque(randomTorque * torqueMultiplier);
				}
				else if (Random.Range(0, 2) == 0)
				{
					floatTimer = Random.Range(2.5f, 7.5f);
				}
				else
				{
					torqueTimer = Random.Range(1f, 5f);
					randomTorque = new Vector3(Random.Range(-0.5f, 0.5f), Random.Range(-1f, 1f), Random.Range(-0.5f, 0.5f));
				}
			}
		}

		public void Update()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			floatLoop.PlayLoop(!released, 1f, 1f, Mathf.Min(1.5f, Mathf.Max(1f, ((Vector3)(ref physGrabObject.rbVelocity)).magnitude - 1f)));
			if (!released && SemiFunc.IsMasterClientOrSingleplayer() && SemiFunc.RunIsLevel() && itemToggle.toggleState)
			{
				itemToggle.ToggleItem(false, -1);
				for (int i = 0; i < toSpawnPositions.Length; i++)
				{
					Items.SpawnItem(trackerItem, toSpawnPositions[i].position, toSpawnPositions[i].rotation);
				}
				for (int j = 0; j < activeTrackers.Count; j++)
				{
					activeTrackers[j].Initialize();
				}
				Release();
			}
		}

		public void Release()
		{
			physGrabObject.impactDetector.indestructibleBreakEffects = true;
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("ReleaseRPC", (RpcTarget)0, Array.Empty<object>());
			}
			else
			{
				ReleaseRPC();
			}
		}

		[PunRPC]
		public void ReleaseRPC()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			log.LogDebug((object)"Releasing Player Trackers");
			itemToggle.ToggleDisable(true);
			itemAttributes.DisableUI(true);
			Object.Destroy((Object)(object)itemEquippable);
			for (int i = 0; i < toDisable.Length; i++)
			{
				toDisable[i].SetActive(false);
			}
			flameParticles.Stop();
			animator.SetBool("Disabled", true);
			useSound.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			released = true;
		}
	}
}
namespace REPODebbysCase.Enemies
{
	public class EnemyMinesweeper : MonoBehaviour
	{
		public enum State
		{
			Spawn,
			Idle,
			Roam,
			Investigate,
			Stalk,
			Attack,
			Leave,
			Stun,
			Despawn
		}

		private readonly ManualLogSource log = DebbysCase.instance.log;

		public State currentState;

		public bool stateImpulse;

		public float stateTimer;

		public Enemy enemyBase;

		public Rigidbody rigidbody;

		public PhotonView photonView;

		public EnemyNavMeshAgent navAgent;

		public PlayerAvatar targetPlayer;

		public PhysGrabObject targetObject;

		public HurtCollider hurtCollider;

		public Vector3 newPosition;

		public List<GameObject> objectContainer;

		public Dictionary<PlayerAvatar, bool> playersTumbled;

		public EnemyMinesweeperAnim animator;

		public Transform visuals;

		public Vector3 deathLocation;

		public float visionTimer;

		public float playerVisionTimer;

		public float objectVisionTimer;

		public bool stalkObject;

		public float stalkNewPointTimer;

		public bool respawnItems;

		public float respawnItemsTimer = 0f;

		public int containedAmount;

		public Vector3 originalScale;

		public float stalkAttackCooldown = 0f;

		public bool dead = false;

		public void Awake()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			log.LogDebug((object)"An Enemy Minesweeper has spawned!");
			originalScale = visuals.localScale;
		}

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

		[PunRPC]
		public void UpdateStateRPC(State newState)
		{
			currentState = newState;
		}

		public void Update()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			if (LevelGenerator.Instance.Generated && !SemiFunc.IsNotMasterClient())
			{
				RespawnSuckedItems();
				SelectPlayerGrabbed();
				if ((int)enemyBase.CurrentState == 11)
				{
					UpdateState(State.Despawn);
				}
				else if (enemyBase.IsStunned())
				{
					UpdateState(State.Stun);
				}
				switch (currentState)
				{
				case State.Spawn:
					StateSpawn();
					break;
				case State.Idle:
					StateIdle();
					break;
				case State.Roam:
					StateRoam();
					break;
				case State.Investigate:
					StateInvestigate();
					break;
				case State.Stalk:
					StateStalk();
					break;
				case State.Attack:
					StateAttack();
					break;
				case State.Leave:
					StateLeave();
					break;
				case State.Stun:
					StateStun();
					break;
				case State.Despawn:
					StateDespawn();
					break;
				}
			}
		}

		public void FixedUpdate()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || currentState != State.Attack || playersTumbled == null)
			{
				return;
			}
			List<PlayerAvatar> list = SemiFunc.PlayerGetAllPlayerAvatarWithinRange(5f, ((Component)hurtCollider).transform.position, true, LayerMask.op_Implicit(LayerMask.GetMask(new string[2] { "Default", "StaticGrabObject" })));
			List<PhysGrabObject> list2 = SemiFunc.PhysGrabObjectGetAllWithinRange(5f, ((Component)hurtCollider).transform.position, true, LayerMask.op_Implicit(0), enemyBase.Rigidbody.physGrabObject);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].isTumbling)
				{
					list[i].tumble.OverrideEnemyHurt(0.5f);
					if (!list2.Contains(list[i].tumble.physGrabObject))
					{
						list2.Add(list[i].tumble.physGrabObject);
					}
				}
				else if (!list[i].isDisabled && playersTumbled.ContainsKey(list[i]) && !playersTumbled[list[i]])
				{
					playersTumbled[list[i]] = true;
					list[i].tumble.TumbleRequest(true, false);
					list[i].tumble.TumbleOverrideTime(2f);
					list[i].tumble.OverrideEnemyHurt(0.5f);
				}
			}
			EnemyRigidbody val = default(EnemyRigidbody);
			ItemToggle val2 = default(ItemToggle);
			ItemGrenade val3 = default(ItemGrenade);
			for (int j = 0; j < list2.Count; j++)
			{
				if (list2[j].isCart || list2[j].isKinematic || (((Component)list2[j]).TryGetComponent<EnemyRigidbody>(ref val) && (Object)(object)val == (Object)(object)enemyBase.Rigidbody))
				{
					continue;
				}
				if (((Component)list2[j]).TryGetComponent<ItemToggle>(ref val2))
				{
					if (((Component)list2[j]).TryGetComponent<ItemGrenade>(ref val3))
					{
						if (SemiFunc.IsMultiplayer())
						{
							photonView.RPC("GrenadeResetRPC", (RpcTarget)0, new object[1] { val3.photonView.ViewID });
						}
						else
						{
							val3.GrenadeReset();
						}
					}
					else
					{
						val2.ToggleItem(false, -1);
					}
				}
				list2[j].OverrideBreakEffects(0.25f);
				list2[j].OverrideZeroGravity(0.25f);
				list2[j].OverrideIndestructible(0.25f);
				Vector3 val4 = ((Component)hurtCollider).transform.position - ((Component)list2[j]).transform.position;
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				if (((Component)list2[j]).transform.position.y < ((Component)hurtCollider).transform.position.y)
				{
					normalized.y += 0.1f;
				}
				list2[j].rb.AddForce(normalized * 2500f * Time.fixedDeltaTime, (ForceMode)0);
				list2[j].rb.AddForce(SemiFunc.PhysFollowDirection(((Component)list2[j].rb).transform, normalized, list2[j].rb, 10f) * 2f / list2[j].rb.mass, (ForceMode)0);
			}
		}

		[PunRPC]
		public void GrenadeResetRPC(int id)
		{
			((Component)PhotonView.Find(id)).GetComponent<ItemGrenade>().GrenadeReset();
		}

		public void SelectPlayerGrabbed()
		{
			if ((Object)(object)targetPlayer != (Object)null && (Object)(object)targetObject != (Object)(object)targetPlayer.physGrabber.grabbedPhysGrabObject && (Object)(object)targetPlayer.physGrabber.grabbedPhysGrabObject != (Object)null && targetPlayer.physGrabber.grabbedPhysGrabObject.playerGrabbing.Contains(targetPlayer.physGrabber))
			{
				UpdateTarget(targetPlayer.photonView.ViewID, targetPlayer.physGrabber.grabbedPhysGrabObject.photonView.ViewID, targetPlayer, targetPlayer.physGrabber.grabbedPhysGrabObject);
			}
		}

		public void AttackOrIdle()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.EnemyGetNearestPhysObject(enemyBase) != Vector3.zero)
			{
				UpdateState(State.Attack);
			}
			else
			{
				UpdateState(State.Idle);
			}
		}

		public void StateSpawn()
		{
			//IL_002b: 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)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Spawn\"");
				visuals.localScale = originalScale;
				UpdateTarget(-1, -1);
				stateTimer = 2f;
				navAgent.Warp(((Component)rigidbody).transform.position, false);
				navAgent.ResetPath();
				SetImpulses(340);
				dead = false;
			}
			if (stateTimer > 0f)
			{
				stateTimer -= Time.deltaTime;
			}
			else
			{
				UpdateState(State.Idle);
			}
		}

		public void StateIdle()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Idle\"");
				UpdateTarget(-1, -1);
				stateTimer = Random.Range(5f, 10f);
				navAgent.Warp(((Component)rigidbody).transform.position, false);
				navAgent.ResetPath();
				SetImpulses(340);
			}
			if (!SemiFunc.EnemySpawnIdlePause())
			{
				stateTimer -= Time.deltaTime;
				if (SemiFunc.EnemyForceLeave(enemyBase))
				{
					UpdateState(State.Leave);
				}
				else if (stateTimer <= 0f)
				{
					UpdateState(State.Roam);
				}
			}
		}

		public void StateRoam()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Roam\"");
				UpdateTarget(-1, -1);
				stateTimer = Random.Range(7.5f, 15f);
				LevelPoint val = SemiFunc.LevelPointGet(((Component)enemyBase).transform.position, 7.5f, 30f) ?? SemiFunc.LevelPointGet(((Component)enemyBase).transform.position, 0f, float.MaxValue);
				NavMeshHit val2 = default(NavMeshHit);
				if (!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" })))
				{
					stateImpulse = true;
					return;
				}
				newPosition = ((NavMeshHit)(ref val2)).position;
				enemyBase.Rigidbody.notMovingTimer = 0f;
				SetImpulses(372);
			}
			if (SemiFunc.EnemyForceLeave(enemyBase))
			{
				UpdateState(State.Leave);
				return;
			}
			navAgent.SetDestination(newPosition);
			if (enemyBase.Rigidbody.notMovingTimer > 2f)
			{
				stateTimer -= Time.deltaTime;
			}
			if (stateTimer <= 0f || Vector3.Distance(((Component)enemyBase).transform.position, newPosition) < 1f)
			{
				AttackOrIdle();
			}
		}

		public void StateInvestigate()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Investigate\"");
				UpdateTarget(-1, -1);
				stateTimer = Random.Range(10f, 25f);
				enemyBase.Rigidbody.notMovingTimer = 0f;
				SetImpulses(373);
			}
			if (SemiFunc.EnemyForceLeave(enemyBase))
			{
				UpdateState(State.Leave);
			}
			navAgent.SetDestination(newPosition);
			navAgent.OverrideAgent(navAgent.DefaultSpeed * 2f, navAgent.DefaultAcceleration, 0.2f);
			enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed * 2f, -1f);
			enemyBase.Vision.StandOverride(0.25f);
			if (enemyBase.Rigidbody.notMovingTimer > 2f)
			{
				stateTimer -= Time.deltaTime;
			}
			NavMeshHit val = default(NavMeshHit);
			if (Vector3.Distance(((Component)enemyBase).transform.position, newPosition) < 1f)
			{
				UpdateState(State.Idle);
			}
			else if (navAgent.CanReach(newPosition, 1f) && !NavMesh.SamplePosition(newPosition, ref val, 0.5f, -1))
			{
				UpdateState(State.Roam);
			}
			else if (stateTimer <= 0f)
			{
				AttackOrIdle();
			}
		}

		public void StateStalk()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stalkAttackCooldown = 4f;
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Stalk\"");
				stateTimer = Random.Range(7.5f, 17.5f);
				enemyBase.Rigidbody.notMovingTimer = 0f;
				SetImpulses(502);
			}
			if (SemiFunc.EnemyForceLeave(enemyBase))
			{
				UpdateState(State.Leave);
				return;
			}
			VisionCheck();
			if ((Object)(object)targetPlayer != (Object)null && !stalkObject)
			{
				if (!enemyBase.OnScreen.GetOnScreen(targetPlayer))
				{
					newPosition = Vector3.Lerp(((Component)enemyBase).transform.position, ((Component)targetPlayer).transform.position, 0.8f);
					navAgent.OverrideAgent(navAgent.DefaultSpeed / 2f, navAgent.DefaultAcceleration, 0.2f);
					enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed / 2f, -1f);
				}
				else if (stalkNewPointTimer <= 0f || Vector3.Distance(((Component)enemyBase).transform.position, newPosition) < 0.25f)
				{
					LevelPoint val = null;
					if (Vector3.Distance(((Component)enemyBase).transform.position, ((Component)targetPlayer).transform.position) > 10f)
					{
						List<LevelPoint> list = SemiFunc.LevelPointGetWithinDistance(((Component)targetPlayer).transform.position, 5f, 10f);
						float num = float.MaxValue;
						for (int i = 0; i < list.Count; i++)
						{
							float num2 = Vector3.Distance(((Component)enemyBase).transform.position, ((Component)list[i]).transform.position);
							if (num2 < num)
							{
								num = num2;
								val = list[i];
							}
						}
						if ((Object)(object)val != (Object)null)
						{
							newPosition = ((Component)val).transform.position;
						}
						else
						{
							List<LevelPoint> list2 = SemiFunc.LevelPointGetWithinDistance(((Component)targetPlayer).transform.position, 10f, 20f);
							val = list2[Random.Range(0, list2.Count)];
							newPosition = ((Component)val).transform.position;
						}
						navAgent.OverrideAgent(navAgent.DefaultSpeed, navAgent.DefaultAcceleration, 0.2f);
						enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed, -1f);
					}
					else if ((Object)(object)targetObject == (Object)null)
					{
						val = SemiFunc.LevelPointInTargetRoomGet(targetPlayer.RoomVolumeCheck, 5f, 10f, (LevelPoint)null);
						if ((Object)(object)val != (Object)null)
						{
							newPosition = ((Component)val).transform.position;
						}
						else
						{
							List<LevelPoint> list3 = SemiFunc.LevelPointGetWithinDistance(((Component)targetPlayer).transform.position, 10f, 20f);
							val = list3[Random.Range(0, list3.Count)];
							newPosition = ((Component)val).transform.position;
						}
						navAgent.OverrideAgent(navAgent.DefaultSpeed, navAgent.DefaultAcceleration, 0.2f);
						enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed, -1f);
					}
					else
					{
						newPosition = Vector3.Lerp(((Component)enemyBase).transform.position, ((Component)targetObject).transform.position, 0.8f);
						navAgent.OverrideAgent(navAgent.DefaultSpeed / 2f, navAgent.DefaultAcceleration, 0.2f);
						enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed / 2f, -1f);
					}
					stalkNewPointTimer = Random.Range(1f, 4f);
				}
				else
				{
					stalkNewPointTimer -= Time.deltaTime;
				}
			}
			else
			{
				if (!((Object)(object)targetObject != (Object)null) || !stalkObject)
				{
					UpdateState(State.Investigate);
					return;
				}
				newPosition = Vector3.Lerp(((Component)enemyBase).transform.position, ((Component)targetObject).transform.position, 0.8f);
				navAgent.OverrideAgent(navAgent.DefaultSpeed / 2f, navAgent.DefaultAcceleration, 0.2f);
				enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed / 2f, -1f);
			}
			if (Vector3.Distance(newPosition, ((Component)enemyBase).transform.position) > 0.5f)
			{
				navAgent.SetDestination(newPosition);
			}
			enemyBase.Vision.StandOverride(0.25f);
			stateTimer -= Time.deltaTime;
			if (stalkAttackCooldown > 0f)
			{
				stalkAttackCooldown -= Time.deltaTime;
			}
			if (stateTimer <= 0f || enemyBase.Rigidbody.touchingCartTimer > 0f || (stateTimer <= 5f && (Object)(object)targetPlayer != (Object)null && Vector3.Distance(((Component)enemyBase).transform.position, ((Component)targetPlayer).transform.position) < 2.5f) || ((Object)(object)targetObject != (Object)null && Vector3.Distance(((Component)enemyBase).transform.position, ((Component)targetObject).transform.position) < 2.5f))
			{
				UpdateState(State.Attack);
			}
		}

		public void StateAttack()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Attack\"");
				UpdateTarget(-1, -1);
				navAgent.ResetPath();
				navAgent.Warp(((Component)enemyBase.Rigidbody).transform.position, false);
				playersTumbled = new Dictionary<PlayerAvatar, bool>();
				stateTimer = 10f;
				List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
				for (int i = 0; i < list.Count; i++)
				{
					playersTumbled.Add(list[i], value: false);
				}
				SetImpulses(350);
			}
			stateTimer -= Time.deltaTime;
			enemyBase.Rigidbody.physGrabObject.OverrideMass(20f, 0.1f);
			enemyBase.Rigidbody.physGrabObject.OverrideDrag(5f, 0.1f);
			enemyBase.Rigidbody.physGrabObject.OverrideAngularDrag(10f, 0.1f);
			if (stateTimer <= 0f)
			{
				UpdateState(State.Leave);
			}
		}

		public void StateLeave()
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Leave\"");
				UpdateTarget(-1, -1);
				stateTimer = Random.Range(5f, 15f);
				LevelPoint val = SemiFunc.LevelPointGetFurthestFromPlayer(((Component)this).transform.position, 5f);
				NavMeshHit val2 = default(NavMeshHit);
				if (!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" })))
				{
					log.LogDebug((object)"Minesweeper: Trying to Leave Again");
					stateImpulse = true;
					return;
				}
				newPosition = ((NavMeshHit)(ref val2)).position;
				SetImpulses(373);
			}
			enemyBase.Vision.DisableVision(0.25f);
			navAgent.SetDestination(newPosition);
			navAgent.OverrideAgent(navAgent.DefaultSpeed * 2f, navAgent.DefaultAcceleration, 0.2f);
			enemyBase.Rigidbody.OverrideFollowPosition(1f, navAgent.DefaultSpeed * 2f, -1f);
			stateTimer -= Time.deltaTime;
			if (Vector3.Distance(((Component)enemyBase).transform.position, newPosition) <= 1f || stateTimer <= 0f)
			{
				UpdateState(State.Idle);
			}
		}

		public void StateStun()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				stateImpulse = false;
				log.LogDebug((object)"Minesweeper State: \"Stun\"");
				navAgent.ResetPath();
				navAgent.Warp(((Component)rigidbody).transform.position, false);
				SetImpulses(340);
			}
			else if (!enemyBase.IsStunned())
			{
				UpdateState(State.Idle);
			}
		}

		public void StateDespawn()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (stateImpulse)
			{
				navAgent.ResetPath();
				navAgent.Warp(((Component)enemyBase.Rigidbody).transform.position, false);
				UpdateTarget(-1, -1);
				SetImpulses(340);
				stateImpulse = false;
				dead = true;
			}
		}

		public void OnSpawn()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer() && SemiFunc.EnemySpawn(enemyBase))
			{
				SetImpulses(470);
				UpdateState(State.Spawn);
			}
		}

		public void OnInvestigate()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && (currentState == State.Idle || currentState == State.Roam || currentState == State.Investigate))
			{
				log.LogDebug((object)"Minesweeper: On Investigate");
				newPosition = enemyBase.StateInvestigate.onInvestigateTriggeredPosition;
				UpdateState(State.Investigate);
			}
		}

		public void OnVision()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || (currentState != State.Idle && currentState != State.Roam && currentState != State.Investigate))
			{
				return;
			}
			log.LogDebug((object)"Minesweeper: Vision Triggered");
			int id = -1;
			int idObj = -1;
			if (SemiFunc.IsMultiplayer())
			{
				if ((Object)(object)enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject != (Object)null && enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject.playerGrabbing.Contains(enemyBase.Vision.onVisionTriggeredPlayer.physGrabber))
				{
					idObj = enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject.photonView.ViewID;
				}
				id = enemyBase.Vision.onVisionTriggeredPlayer.photonView.ViewID;
			}
			if ((Object)(object)enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject != (Object)null && enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject.playerGrabbing.Contains(enemyBase.Vision.onVisionTriggeredPlayer.physGrabber))
			{
				UpdateTarget(id, idObj, enemyBase.Vision.onVisionTriggeredPlayer, enemyBase.Vision.onVisionTriggeredPlayer.physGrabber.grabbedPhysGrabObject);
			}
			else
			{
				UpdateTarget(id, idObj, enemyBase.Vision.onVisionTriggeredPlayer);
			}
			UpdateState(State.Stalk);
		}

		public void OnGrabbed()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer() && (currentState == State.Idle || currentState == State.Roam || currentState == State.Investigate || currentState == State.Leave || currentState == State.Stalk))
			{
				log.LogDebug((object)"Minesweeper: Grabbed");
				UpdateState(State.Attack);
			}
		}

		public void OnTouchPlayer()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || currentState == State.Attack)
			{
				return;
			}
			log.LogDebug((object)"Minesweeper: Touch Player");
			if (currentState == State.Stalk && stalkAttackCooldown <= 0f)
			{
				UpdateState(State.Attack);
				return;
			}
			int id = -1;
			int idObj = -1;
			if (SemiFunc.IsMultiplayer())
			{
				id = enemyBase.Rigidbody.onTouchPlayerAvatar.photonView.ViewID;
				if ((Object)(object)enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject != (Object)null && enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject.playerGrabbing.Contains(enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber))
				{
					idObj = enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject.photonView.ViewID;
				}
			}
			if ((Object)(object)enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject != (Object)null && enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject.playerGrabbing.Contains(enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber))
			{
				UpdateTarget(id, idObj, enemyBase.Rigidbody.onTouchPlayerAvatar, enemyBase.Rigidbody.onTouchPlayerAvatar.physGrabber.grabbedPhysGrabObject);
			}
			else
			{
				UpdateTarget(id, idObj, enemyBase.Rigidbody.onTouchPlayerAvatar);
			}
			UpdateState(State.Stalk);
		}

		public void OnTouchPlayerPhys()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || (currentState != State.Idle && currentState != State.Roam && currentState != State.Investigate && currentState != State.Leave && currentState != State.Stalk))
			{
				return;
			}
			log.LogDebug((object)"Minesweeper: Touch Player Phys");
			if (currentState == State.Stalk && stalkAttackCooldown <= 0f)
			{
				UpdateState(State.Attack);
			}
			else if (!((Object)(object)((Component)enemyBase.Rigidbody.onTouchPlayerGrabbedObjectPhysObject).GetComponent<PhysGrabHinge>() != (Object)null))
			{
				int id = -1;
				int idObj = -1;
				if (SemiFunc.IsMultiplayer())
				{
					id = enemyBase.Rigidbody.onTouchPlayerGrabbedObjectPhysObject.playerGrabbing[0].playerAvatar.photonView.ViewID;
					idObj = enemyBase.Rigidbody.onTouchPlayerGrabbedObjectPhysObject.photonView.ViewID;
				}
				UpdateTarget(id, idObj, enemyBase.Rigidbody.onTouchPlayerGrabbedObjectPhysObject.playerGrabbing[0].playerAvatar, enemyBase.Rigidbody.onTouchPlayerGrabbedObjectPhysObject);
				UpdateState(State.Stalk);
			}
		}

		public void OnTouchPhys()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || (currentState != State.Roam && currentState != State.Investigate && currentState != State.Stalk))
			{
				return;
			}
			log.LogDebug((object)"Minesweeper: Touch Phys");
			if (currentState == State.Stalk && (Object)(object)enemyBase.Rigidbody.onTouchPhysObjectPhysObject == (Object)(object)targetObject && stalkAttackCooldown <= 0f)
			{
				UpdateState(State.Attack);
			}
			else if (!((Object)(object)((Component)enemyBase.Rigidbody.onTouchPhysObjectPhysObject).GetComponent<PhysGrabHinge>() != (Object)null))
			{
				int idObj = -1;
				if (SemiFunc.IsMultiplayer())
				{
					idObj = enemyBase.Rigidbody.onTouchPhysObjectPhysObject.photonView.ViewID;
				}
				UpdateTarget(-1, idObj, null, enemyBase.Rigidbody.onTouchPhysObjectPhysObject);
				UpdateState(State.Stalk);
			}
		}

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

		public void OnDeath()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_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_00b7: 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)
			log.LogDebug((object)"Minesweeper: Death");
			visuals.localScale = Vector3.zero;
			GameDirector.instance.CameraShake.ShakeDistance(3f, 3f, 10f, ((Component)this).transform.position, 0.5f);
			GameDirector.instance.CameraImpact.ShakeDistance(3f, 3f, 10f, ((Component)this).transform.position, 0.05f);
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				enemyBase.EnemyParent.SpawnedTimerSet(0f);
				deathLocation = ((Component)this).transform.position + Vector3.up / 5f;
				containedAmount = objectContainer.Count;
				ListExtension.Shuffle<GameObject>((IList<GameObject>)objectContainer);
				respawnItems = true;
				dead = true;
			}
		}

		public void RespawnSuckedItems()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (!respawnItems)
			{
				return;
			}
			if (objectContainer.Count == 0)
			{
				enemyBase.EnemyParent.Despawn();
				respawnItems = false;
				return;
			}
			respawnItemsTimer -= Time.deltaTime;
			if (respawnItemsTimer <= 0f)
			{
				respawnItemsTimer = 5f / (float)containedAmount;
				GameObject val = objectContainer[0];
				PhysGrabObject component = val.GetComponent<PhysGrabObject>();
				Vector3 val2 = ItemTeleportPosition(val);
				if (SemiFunc.IsMultiplayer())
				{
					val.GetComponent<PhotonTransformView>().Teleport(val2, val.transform.rotation);
					photonView.RPC("SetActiveSuckedItemRPC", (RpcTarget)0, new object[3]
					{
						true,
						val.GetComponent<PhotonView>().ViewID,
						val2
					});
				}
				else
				{
					val.transform.position = val2;
					val.SetActive(true);
					Object.Instantiate<GameObject>(AssetManager.instance.prefabTeleportEffect, val2, Quaternion.identity).transform.localScale = Vector3.one;
					animator.respawnItemSound.Play(val2, 1f, 1f, 1f, 1f);
				}
				component.OverrideBreakEffects(0.5f);
				component.OverrideIndestructible(0.5f);
				objectContainer.RemoveAt(0);
			}
		}

		public Vector3 ItemTeleportPosition(GameObject item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0055: 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_0061: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_00d2: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			for (int i = 0; i < 10; i++)
			{
				Vector3 val2 = deathLocation + new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f));
				RaycastHit[] array = Physics.RaycastAll(val2, deathLocation - val2, Mathf.Max(0f, Vector3.Distance(val2, deathLocation) - 0.2f), LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct()));
				bool flag = false;
				for (int j = 0; j < array.Length; j++)
				{
					if ((Object)(object)((RaycastHit)(ref array[j])).transform != (Object)(object)item.transform)
					{
						flag = true;
						break;
					}
				}
				if (!flag && Physics.OverlapBox(val2, item.GetComponent<PhysGrabObject>().boundingBox / 2f, item.transform.rotation, LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct())).Length == 0)
				{
					val = val2;
					break;
				}
			}
			if (val == Vector3.zero)
			{
				val = deathLocation;
			}
			return val;
		}

		public void OnPhysVortex()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			for (int i = 0; i < hurtCollider.hits.Count; i++)
			{
				if ((int)hurtCollider.hits[i].hitType == 1 && hurtCollider.hits[i].hitObject.activeSelf && !((Object)(object)hurtCollider.hits[i].hitObject.GetComponent<PhysGrabHinge>() != (Object)null))
				{
					GameObject hitObject = hurtCollider.hits[i].hitObject;
					objectContainer.Add(hitObject);
					Vector3 position = hitObject.transform.position;
					if (SemiFunc.IsMultiplayer())
					{
						hitObject.GetComponent<PhotonTransformView>().Teleport(new Vector3(0f, 1000f, 0f), hitObject.transform.rotation);
						photonView.RPC("SetActiveSuckedItemRPC", (RpcTarget)0, new object[3]
						{
							false,
							hitObject.GetComponent<PhotonView>().ViewID,
							position
						});
					}
					else
					{
						hitObject.transform.position = new Vector3(0f, 1000f, 0f);
						hitObject.SetActive(false);
						Object.Instantiate<GameObject>(AssetManager.instance.prefabTeleportEffect, position, Quaternion.identity).transform.localScale = Vector3.one;
					}
					stateTimer -= 0.5f;
				}
			}
		}

		public void VisionCheck()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			visionTimer -= Time.deltaTime;
			if (!(visionTimer <= 0f))
			{
				return;
			}
			visionTimer = 0.1f;
			if ((Object)(object)targetPlayer != (Object)null)
			{
				Vector3 val = targetPlayer.PlayerVisionTarget.VisionTransform.position - animator.eyeTransform.position;
				if (Physics.Raycast(animator.eyeTransform.position, val, ((Vector3)(ref val)).magnitude, LayerMask.GetMask(new string[1] { "Default" })))
				{
					playerVisionTimer -= 0.1f;
					if (playerVisionTimer <= 0f)
					{
						if ((Object)(object)targetObject != (Object)null)
						{
							UpdateTarget(-1, targetObject.photonView.ViewID, null, targetObject);
						}
						else
						{
							UpdateTarget(-1, -1);
						}
					}
				}
				else if (playerVisionTimer != 1f)
				{
					playerVisionTimer = 1f;
				}
			}
			if ((Object)(object)targetObject != (Object)null)
			{
				Vector3 val2 = ((Component)targetObject).transform.position - animator.eyeTransform.position;
				if (Physics.Raycast(animator.eyeTransform.position, val2, ((Vector3)(ref val2)).magnitude, LayerMask.GetMask(new string[1] { "Default" })))
				{
					objectVisionTimer -= 0.1f;
					if (objectVisionTimer <= 0f)
					{
						if ((Object)(object)targetPlayer != (Object)null)
						{
							UpdateTarget(targetPlayer.photonView.ViewID, -1, targetPlayer);
						}
						else
						{
							UpdateTarget(-1, -1);
						}
					}
				}
				else if (objectVisionTimer != 1f)
				{
					objectVisionTimer = 1f;
				}
			}
			if ((Object)(object)targetObject != (Object)null && !targetObject.grabbed)
			{
				stalkObject = true;
			}
			else
			{
				stalkObject = false;
			}
		}

		[PunRPC]
		public void SetActiveSuckedItemRPC(bool active, int id, Vector3 pos)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			((Component)PhotonView.Find(id)).gameObject.SetActive(active);
			Object.Instantiate<GameObject>(AssetManager.instance.prefabTeleportEffect, pos, Quaternion.identity).transform.localScale = Vector3.one;
			if (active)
			{
				animator.respawnItemSound.Play(pos, 1f, 1f, 1f, 1f);
			}
		}

		public void UpdateTarget(int id, int idObj, PlayerAvatar player = null, PhysGrabObject physGrabObject = null)
		{
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("UpdateTargetRPC", (RpcTarget)0, new object[4] { id, idObj, null, null });
			}
			else
			{
				UpdateTargetRPC(-1, -1, player, physGrabObject);
			}
		}

		[PunRPC]
		public void UpdateTargetRPC(int id, int idObj, PlayerAvatar player = null, PhysGrabObject physGrabObject = null)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			PlayerAvatar val;
			PhysGrabObject val2;
			if (SemiFunc.IsMultiplayer())
			{
				val = SemiFunc.PlayerAvatarGetFromPhotonID(id);
				val2 = ((idObj == -1) ? null : ((Component)PhotonView.Find(idObj)).GetComponent<PhysGrabObject>());
			}
			else
			{
				val = player;
				val2 = physGrabObject;
			}
			if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).GetComponent<PhysGrabHinge>() != (Object)null)
			{
				val2 = targetObject;
			}
			if ((Object)(object)val == (Object)null)
			{
				log.LogDebug((object)"Minesweeper: New target player is \"null\"!");
			}
			else
			{
				log.LogDebug((object)("Minesweeper: New target player is \"" + val.playerName + "\"!"));
			}
			if ((Object)(object)val2 == (Object)null)
			{
				log.LogDebug((object)"Minesweeper: New target object is \"null\"!");
			}
			else
			{
				log.LogDebug((object)("Minesweeper: New target object is \"" + ((Object)val2).name + "\"!"));
			}
			if ((Object)(object)targetPlayer != (Object)(object)val && (Object)(object)val != (Object)null)
			{
				animator.noticeSound.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			}
			else if ((Object)(object)targetObject != (Object)(object)val2 && (Object)(object)val2 != (Object)null)
			{
				animator.interestSound.Play(((Component)this).transform.position, 1f, 1f, 1f, 1f);
			}
			targetPlayer = val;
			targetObject = val2;
		}

		public void SetImpulses(int integer = 0)
		{
			if (SemiFunc.IsMultiplayer())
			{
				photonView.RPC("SetImpulsesRPC", (RpcTarget)0, new object[1] { integer });
			}
			else
			{
				SetImpulsesRPC(integer);
			}
		}

		[PunRPC]
		public void SetImpulsesRPC(int integer = 0)
		{
			string text = Convert.ToString(integer, 2);
			while (text.Length < 9)
			{
				text = "0" + text;
			}
			bool[] array = text.Select((char x) => x == '1').ToArray();
			if (array[0])
			{
				if (array[1])
				{
					animator.stalkEmergeImpulse = true;
				}
				else
				{
					animator.stalkDisappearImpulse = true;
				}
			}
			if (array[2])
			{
				if (array[3])
				{
					animator.bounceStartImpulse = true;
				}
				else
				{
					animator.bounceStopImpulse = true;
				}
			}
			if (array[4])
			{
				if (array[5])
				{
					animator.vortexEmergeImpulse = true;
				}
				else
				{
					animator.vortexLeaveImpulse = true;
				}
			}
			if (array[6])
			{
				if (array[7])
				{
					animator.lidOpenImpulse = true;
				}
				else
				{
					animator.lidCloseImpulse = true;
				}
			}
			if (array[8])
			{
				animator.fireImpulse = true;
			}
		}
	}
	public class EnemyMinesweeperAnim : MonoBehaviour
	{
		private readonly ManualLogSource log = DebbysCase.instance.log;

		public EnemyMinesweeper minesweeperMain;

		public SpringQuaternion mainSpring;

		public Quaternion mainRotation;

		public SpringQuaternion stalkSpring;

		public Transform eyeTransform;

		public Animator animator;

		public ParticleSystem[] vortexParticles;

		public ParticleSystem[] smokeParticles;

		public ParticleSystem[] fireParticles;

		public Sound fireBurstSound;

		public Sound engineSoundLoop;

		public Sound vortexSoundLoop;

		public Sound laughSoundLoop;

		public Sound stunSoundLoop;

		public Sound mumbleSoundLoop;

		public Sound noticeSound;

		public Sound interestSound;

		public Sound hurtSound;

		public Sound respawnItemSound;

		public Sound squelchSound;

		public bool fireImpulse;

		public float fireTimer;

		public bool boostOn;

		public Light[] fireLights;

		public float randomPeerTimer = Random.Range(1f, 4f);

		public bool stalkEmergeImpulse;

		public bool stalkDisappearImpulse;

		public bool bounceStartImpulse;

		public bool bounceStopImpulse;

		public bool vortexEmergeImpulse;

		public bool vortexLeaveImpulse;

		public bool lidOpenImpulse;

		public bool lidCloseImpulse;

		public void Awake()
		{
			for (int i = 0; i < fireLights.Length; i++)
			{
				((Component)fireLights[i]).gameObject.SetActive(true);
				((Behaviour)fireLights[i]).enabled = false;
			}
		}

		public void Update()
		{
			//IL_00fb: 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_03af: Unknown result type (might be due to invalid IL or missing references)
			if (minesweeperMain.currentState == EnemyMinesweeper.State.Stun || minesweeperMain.currentState == EnemyMinesweeper.State.Attack)
			{
				if (animator.GetFloat("Override Speed") != 3f)
				{
					log.LogDebug((object)"Minesweeper: Animation Override Speed: \"3f\"");
					animator.SetFloat("Override Speed", 3f);
				}
			}
			else if (animator.GetFloat("Override Speed") != 1f)
			{
				log.LogDebug((object)"Minesweeper: Animation Override Speed: \"1f\"");
				animator.SetFloat("Override Speed", 1f);
			}
			RandomPeeps();
			CalculateTrackSpeeds();
			CalculateRotators();
			if (stalkEmergeImpulse)
			{
				stalkEmergeImpulse = false;
				animator.SetBool("Stalk Emerge", true);
				squelchSound.Play(eyeTransform.position, 1f, 1f, 1f, 1f);
			}
			if (stalkDisappearImpulse)
			{
				stalkDisappearImpulse = false;
				animator.SetBool("Stalk Emerge", false);
				squelchSound.Play(eyeTransform.position, 1f, 1f, 1f, 1f);
			}
			if (bounceStartImpulse)
			{
				bounceStartImpulse = false;
				animator.SetBool("Engine Bounce", true);
				for (int i = 0; i < smokeParticles.Length; i++)
				{
					smokeParticles[i].Play();
				}
			}
			if (bounceStopImpulse)
			{
				bounceStopImpulse = false;
				animator.SetBool("Engine Bounce", false);
				for (int j = 0; j < smokeParticles.Length; j++)
				{
					smokeParticles[j].Stop();
				}
			}
			if (vortexEmergeImpulse)
			{
				vortexEmergeImpulse = false;
				animator.SetBool("Vortex", true);
				for (int k = 0; k < vortexParticles.Length; k++)
				{
					vortexParticles[k].Play();
				}
			}
			if (vortexLeaveImpulse)
			{
				vortexLeaveImpulse = false;
				animator.SetBool("Vortex", false);
				for (int l = 0; l < vortexParticles.Length; l++)
				{
					vortexParticles[l].Stop();
				}
			}
			if (lidOpenImpulse)
			{
				lidOpenImpulse = false;
				animator.SetBool("Lid Open", true);
			}
			if (lidCloseImpulse)
			{
				lidCloseImpulse = false;
				animator.SetBool("Lid Open", false);
			}
			if (fireImpulse)
			{
				log.LogDebug((object)"Minesweeper: Start Fire");
				fireImpulse = false;
				fireTimer = Random.Range(0.2f, 0.6f);
				boostOn = true;
				for (int m = 0; m < fireParticles.Length; m++)
				{
					fireParticles[m].Play();
				}
				for (int n = 0; n < fireLights.Length; n++)
				{
					fireLights[n].intensity = 2.5f;
					fireBurstSound.Play(((Component)fireLights[n]).transform.position, 1f, 1f, 1f, 1f);
				}
			}
			if (fireTimer >= 0f)
			{
				fireTimer -= Time.deltaTime;
			}
			else if (boostOn)
			{
				boostOn = false;
				log.LogDebug((object)"Minesweeper: Stop Fire");
				for (int num = 0; num < fireParticles.Length; num++)
				{
					fireParticles[num].Stop();
				}
				for (int num2 = 0; num2 < fireLights.Length; num2++)
				{
					fireLights[num2].intensity = 0f;
				}
			}
			engineSoundLoop.PlayLoop(animator.GetBool("Engine Bounce"), 1f, 1f, 1f);
			vortexSoundLoop.PlayLoop(animator.GetBool("Vortex"), 1f, 0.5f, 1f);
			laughSoundLoop.PlayLoop(animator.GetBool("Vortex"), 0.5f, 2f, 1f);
			stunSoundLoop.PlayLoop(minesweeperMain.currentState == EnemyMinesweeper.State.Stun, 2f, 2f, 1f);
			mumbleSoundLoop.PlayLoop(!animator.GetBool("Stalk Emerge") && !animator.GetBool("Vortex"), 1f, 1f, 1f);
		}

		public void RandomPeeps()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (!animator.GetBool("Stalk Emerge"))
			{
				if (randomPeerTimer > 0f)
				{
					randomPeerTimer -= Time.deltaTime;
					return;
				}
				int num = Random.Range(0, 4);
				animator.SetInteger("Random Peer", num);
				animator.SetTrigger("Peer");
				log.LogDebug((object)$"Minesweeper: Peering \"{num}\"");
				randomPeerTimer = Random.Range(1f, 4f);
				squelchSound.Play(eyeTransform.position, 1f, 1f, 1f, 1f);
			}
		}

		public void CalculateTrackSpeeds()
		{
			//IL_0016: 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)
			float num = Mathf.InverseLerp(-5f, 5f, minesweeperMain.rigidbody.angularVelocity.y) * 2f - 1f;
			if (Mathf.Abs(num) > 0.1f)
			{
				animator.SetFloat("Right Track Speed", num * -1f);
				animator.SetFloat("Left Track Speed", num);
				return;
			}
			Vector3 velocity = minesweeperMain.rigidbody.velocity;
			if (((Vector3)(ref velocity)).magnitude >= 0.1f)
			{
				animator.SetFloat("Right Track Speed", 0.5f);
				animator.SetFloat("Left Track Speed", 0.5f);
			}
			else
			{
				animator.SetFloat("Right Track Speed", 0f);
				animator.SetFloat("Left Track Speed", 0f);
			}
		}

		public void CalculateRotators()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_007b: 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_01aa: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if (minesweeperMain.currentState != EnemyMinesweeper.State.Attack)
			{
				Vector3 normalized = ((Vector3)(ref minesweeperMain.navAgent.AgentVelocity)).normalized;
				if (((Vector3)(ref normalized)).magnitude > 0.1f)
				{
					mainRotation = Quaternion.LookRotation(((Vector3)(ref minesweeperMain.navAgent.AgentVelocity)).normalized);
					((Quaternion)(ref mainRotation)).eulerAngles = new Vector3(0f, ((Quaternion)(ref mainRotation)).eulerAngles.y, 0f);
				}
			}
			((Component)minesweeperMain).transform.rotation = SemiFunc.SpringQuaternionGet(mainSpring, mainRotation, -1f);
			if (((Component)eyeTransform).gameObject.activeSelf)
			{
				Quaternion val = (((Object)(object)minesweeperMain.targetPlayer != (Object)null) ? Quaternion.LookRotation(((Component)minesweeperMain.targetPlayer.PlayerVisionTarget.VisionTransform).transform.position - eyeTransform.position) : ((!((Object)(object)minesweeperMain.targetObject != (Object)null)) ? Quaternion.identity : Quaternion.LookRotation(((Component)minesweeperMain.targetObject).transform.position - eyeTransform.position)));
				Quaternion rotation = SemiFunc.SpringQuaternionGet(stalkSpring, val, -1f);
				eyeTransform.rotation = rotation;
			}
			else if (eyeTransform.localRotation != Quaternion.identity)
			{
				eyeTransform.localRotation = Quaternion.identity;
			}
		}
	}
}
namespace REPODebbysCase.Config
{
	public class DebbysCaseConfig
	{
		private readonly ManualLogSource log = DebbysCase.instance.log;

		internal readonly List<ConfigEntry<bool>> isItemEnabled = new List<ConfigEntry<bool>>();

		internal readonly List<ConfigEntry<bool>> isEnemyEnabled = new List<ConfigEntry<bool>>();

		public DebbysCaseConfig(ConfigFile cfg, List<EnemyContent> enemiesList, List<GameObject> itemsList)
		{
			cfg.SaveOnConfigSet = false;
			for (int i = 0; i < itemsList.Count; i++)
			{
				isItemEnabled.Add(cfg.Bind<bool>("Items", "Enable " + ((Object)itemsList[i]).name + "?", true, (ConfigDescription)null));
				log.LogDebug((object)("Added config for " + ((Object)itemsList[i]).name));
			}
			for (int j = 0; j < enemiesList.Count; j++)
			{
				isEnemyEnabled.Add(cfg.Bind<bool>("Enemies", "Enable " + ((Object)enemiesList[j]).name + "?", true, (ConfigDescription)null));
				log.LogDebug((object)("Added config for " + ((Object)enemiesList[j]).name));
			}
			PropertyInfo propertyInfo = AccessTools.Property(typeof(ConfigFile), "OrphanedEntries");
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(cfg);
			dictionary.Clear();
			cfg.Save();
			cfg.SaveOnConfigSet = true;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace REPODebbysCase.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}