using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using EyeMonster.AI;
using EyeMonster.NetcodePatcher;
using EyeMonster.Utils;
using GameNetcodeStuff;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using Y4NGZMonsters.Shared;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EyeMonster")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c64a155fd64c47528940e53659e5b5ada665b9d4")]
[assembly: AssemblyProduct("EyeMonster")]
[assembly: AssemblyTitle("EyeMonster")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EyeMonster
{
	public sealed class EyeMonsterConfig
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<float> SpawnWeightMultiplier { get; }

		public ConfigEntry<string> MoonWeightOverrides { get; }

		public ConfigEntry<int> MaxCount { get; }

		public ConfigEntry<float> PowerLevel { get; }

		public ConfigEntry<int> Health { get; }

		public ConfigEntry<float> NoticeRange { get; }

		public ConfigEntry<float> GazeAngle { get; }

		public ConfigEntry<float> FlashlightRange { get; }

		public ConfigEntry<float> RoamSpeed { get; }

		public ConfigEntry<float> ChaseSpeed { get; }

		public ConfigEntry<float> FleeSpeed { get; }

		public ConfigEntry<int> AttackDamage { get; }

		public ConfigEntry<float> AttackCooldown { get; }

		public ConfigEntry<float> FleeDuration { get; }

		public ConfigEntry<bool> DebugLogs { get; }

		public EyeMonsterConfig(ConfigFile config)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			using (ConfigPersistence.BeginBinding(config, Plugin.Log, "Eye Monster"))
			{
				EyeMonsterConfigMigration.TryMigrate(config, Plugin.Log);
				ConfigSectionNameMigration.TryMigrate(config, Plugin.Log, "Eye Monster");
				Enabled = config.Bind<bool>("General", "Enabled", true, "Enable the Eye Monster encounter. Host-only: the host's value decides whether it spawns; every install still registers the creature so clients stay in sync.");
				SpawnWeightMultiplier = config.Bind<float>("Spawning", "SpawnWeightMultiplier", 1f, new ConfigDescription("Multiplier applied to Eye Monster's contextual moon/interior spawn policy. 0 disables natural spawns.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
				MoonWeightOverrides = config.Bind<string>("Spawning", "MoonWeightOverrides", string.Empty, "Optional comma-separated base moon weights, e.g. Experimentation:8,Offense:15 or namespace:moon=12. Use 0 to disable a moon; unlisted moons keep authored defaults.");
				MaxCount = config.Bind<int>("Spawning", "MaxCount", 2, new ConfigDescription("Maximum number of living Eye Monsters at once.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), Array.Empty<object>()));
				PowerLevel = config.Bind<float>("Spawning", "PowerLevel", 2f, new ConfigDescription("Indoor enemy power budget cost for each Eye Monster.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), Array.Empty<object>()));
				Health = config.Bind<int>("Core Stats", "Health", 5, new ConfigDescription("Hits the Eye Monster can take before dying.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
				NoticeRange = config.Bind<float>("Detection", "NoticeRange", 12f, new ConfigDescription("Maximum range at which an Eye Monster facing a player can begin investigating.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 80f), Array.Empty<object>()));
				GazeAngle = config.Bind<float>("Detection", "GazeAngle", 28f, new ConfigDescription("Half-angle within which looking at its eye confirms aggression.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 90f), Array.Empty<object>()));
				FlashlightRange = config.Bind<float>("Detection", "FlashlightRange", 15f, new ConfigDescription("Maximum range at which a direct flashlight beam makes the Eye Monster flee.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 80f), Array.Empty<object>()));
				RoamSpeed = config.Bind<float>("Movement", "RoamSpeed", 2f, new ConfigDescription("Movement speed while roaming.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
				ChaseSpeed = config.Bind<float>("Movement", "ChaseSpeed", 5f, new ConfigDescription("Movement speed after a player confirms aggression through eye contact.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 15f), Array.Empty<object>()));
				FleeSpeed = config.Bind<float>("Movement", "FleeSpeed", 7f, new ConfigDescription("Movement speed while fleeing a direct flashlight beam.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), Array.Empty<object>()));
				AttackDamage = config.Bind<int>("Combat", "AttackDamage", 35, new ConfigDescription("Damage dealt by a successful attack.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200), Array.Empty<object>()));
				AttackCooldown = config.Bind<float>("Combat", "AttackCooldown", 1.5f, new ConfigDescription("Seconds between attack attempts.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 30f), Array.Empty<object>()));
				FleeDuration = config.Bind<float>("Abilities", "FleeDuration", 6f, new ConfigDescription("Seconds the Eye Monster flees after being directly lit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f), Array.Empty<object>()));
				DebugLogs = config.Bind<bool>("Diagnostics", "DebugLogs", false, "Log detailed Eye Monster targeting and setup diagnostics.");
			}
		}
	}
	internal static class EyeMonsterConfigMigration
	{
		private static readonly ConfigDefinition LegacySpawnWeight = new ConfigDefinition("Spawning", "SpawnWeight");

		private static readonly LegacyMigrationSpec Spec = new LegacyMigrationSpec("Eye Monster", (IReadOnlyList<ConfigDefinition>)(object)new ConfigDefinition[6]
		{
			LegacySpawnWeight,
			new ConfigDefinition("Combat", "EnemyHP"),
			new ConfigDefinition("Detection", "AggroRange"),
			new ConfigDefinition("Detection", "PlayerGazeAngle"),
			new ConfigDefinition("Detection", "FlashlightDetectionRange"),
			new ConfigDefinition("Behavior", "FleeDuration")
		}, null, new Dictionary<ConfigDefinition, string>
		{
			{
				new ConfigDefinition("Movement", "InvestigateSpeed"),
				"2.6"
			},
			{
				new ConfigDefinition("Combat", "AttackRange"),
				"2.5"
			},
			{
				new ConfigDefinition("Detection", "NoticeViewAngle"),
				"52"
			},
			{
				new ConfigDefinition("Behavior", "InvestigationStopDistance"),
				"4.5"
			},
			{
				new ConfigDefinition("Behavior", "InvestigationDecisionDelay"),
				"0.8"
			},
			{
				new ConfigDefinition("Detection", "FlashlightDetectionAngle"),
				"25"
			},
			{
				new ConfigDefinition("Behavior", "LoseTargetSeconds"),
				"3.5"
			},
			{
				new ConfigDefinition("Behavior", "FailedNoticeCooldown"),
				"4"
			}
		}, Build);

		internal static bool TryMigrate(ConfigFile config, ManualLogSource log)
		{
			return LegacyConfigMigrator.TryMigrate(config, log, Spec);
		}

		private static void Build(LegacyConfigValues values, MigratedConfigWriter output)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			output.Carry("General", "Enabled");
			output.CarrySpawnWeightMultiplier(LegacySpawnWeight, 40f);
			output.Carry("Spawning", "MoonWeightOverrides");
			output.Carry("Spawning", "MaxCount");
			output.Carry("Spawning", "PowerLevel");
			output.Carry("Core Stats", "Health", new ConfigDefinition("Combat", "EnemyHP"));
			output.Carry("Detection", "NoticeRange", new ConfigDefinition("Detection", "AggroRange"));
			output.Carry("Detection", "GazeAngle", new ConfigDefinition("Detection", "PlayerGazeAngle"));
			output.Carry("Detection", "FlashlightRange", new ConfigDefinition("Detection", "FlashlightDetectionRange"));
			output.Carry("Movement", "RoamSpeed");
			output.Carry("Movement", "ChaseSpeed");
			output.Carry("Movement", "FleeSpeed");
			output.Carry("Combat", "AttackDamage");
			output.Carry("Combat", "AttackCooldown");
			output.Carry("Abilities", "FleeDuration", new ConfigDefinition("Behavior", "FleeDuration"));
			output.Carry("Diagnostics", "DebugLogs");
		}
	}
	internal sealed class EyeMonsterSpawnWeights : ContextualSpawnWeights
	{
		internal EyeMonsterSpawnWeights(Func<float> multiplier, Func<string> moonOverrides, Action<string> logWarning)
			: base(SpawnWeightTable.EyeMonster, "Eye Monster", multiplier, moonOverrides, logWarning)
		{
		}
	}
	internal static class EyeMonsterTuning
	{
		internal const float InvestigateSpeed = 2.6f;

		internal const float AttackRange = 2.5f;

		internal const float NoticeViewAngle = 52f;

		internal const float InvestigationStopDistance = 4.5f;

		internal const float InvestigationDecisionDelay = 0.8f;

		internal const float InvestigationTimeout = 8f;

		internal const float FlashlightDetectionAngle = 25f;

		internal const float LoseTargetSeconds = 3.5f;

		internal const float FailedNoticeCooldown = 4f;

		internal const float AgentAngularSpeed = 180f;

		internal const float AgentAcceleration = 12f;

		internal const float AgentRadius = 0.42f;

		internal const float AgentHeight = 2.45f;
	}
	[BepInPlugin("y4ngz.lethalcompany.eyemonster", "Y4NGZ Eye Monster", "1.2.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal const string DawnNamespace = "y4ngz_monsters";

		internal const string DawnEnemyKey = "eye_monster";

		internal const string ScanNodeSubtitle = "Avoid its gaze";

		internal const string BestiaryText = "Eye Monster\n\nDanger level: high\n\nA roaming ocular predator that approaches cautiously until a worker meets its gaze. Avoid eye contact to make it lose interest, or drive it away with a direct flashlight beam.\n\n";

		internal static ManualLogSource Log;

		internal static EyeMonsterConfig ModConfig;

		internal static AssetBundle ModAssets;

		internal static EnemyType EyeMonsterEnemy;

		private static bool _netcodeInitialized;

		private static bool _loggedScanNodeLayer;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				InitializeNetcodeRPCs();
				ModConfig = new EyeMonsterConfig(((BaseUnityPlugin)this).Config);
				string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "eyemonster.bundle");
				ModAssets = AssetBundle.LoadFromFile(text);
				if ((Object)(object)ModAssets == (Object)null)
				{
					Log.LogError((object)("Failed to load asset bundle at: " + text));
					return;
				}
				GameObject val = ModAssets.LoadAsset<GameObject>("EyeMonster");
				if ((Object)(object)val == (Object)null)
				{
					Log.LogError((object)"Failed to load EyeMonster prefab from bundle.");
					return;
				}
				SetupPrefabComponents(val);
				EyeMonsterEnemy = CreateEnemyType(val);
				EyeMonsterAI component = val.GetComponent<EyeMonsterAI>();
				if ((Object)(object)component == (Object)null)
				{
					Log.LogError((object)"EyeMonster prefab does not contain EyeMonsterAI.");
					return;
				}
				((EnemyAI)component).enemyType = EyeMonsterEnemy;
				RegisterWithDawn(val);
				if (!ModConfig.Enabled.Value)
				{
					Log.LogInfo((object)"Y4NGZ Eye Monster: registered network prefab; spawning disabled by config.");
				}
				Log.LogInfo((object)"Y4NGZ Eye Monster v1.2.1 loaded.");
			}
			catch (Exception arg)
			{
				Log.LogError((object)string.Format("Failed to initialize {0}: {1}", "Y4NGZ Eye Monster", arg));
			}
		}

		private static void RegisterWithDawn(GameObject prefab)
		{
			EyeMonsterSpawnWeights spawnWeights = new EyeMonsterSpawnWeights(() => (!ModConfig.Enabled.Value) ? 0f : ModConfig.SpawnWeightMultiplier.Value, () => ModConfig.MoonWeightOverrides.Value, delegate(string message)
			{
				Log.LogWarning((object)message);
			});
			DawnLib.RegisterNetworkPrefab(prefab);
			DawnLib.DefineEnemy(NamespacedKey<DawnEnemyInfo>.From("y4ngz_monsters", "eye_monster"), EyeMonsterEnemy, (Action<EnemyInfoBuilder>)delegate(EnemyInfoBuilder builder)
			{
				((BaseInfoBuilder<DawnEnemyInfo, EnemyType, EnemyInfoBuilder>)(object)builder.DefineInside((Action<EnemyLocationBuilder>)delegate(EnemyLocationBuilder location)
				{
					location.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> table)
					{
						table.SetGlobalWeight((IWeighted)(object)spawnWeights);
					});
				}).CreateBestiaryNode("Eye Monster\n\nDanger level: high\n\nA roaming ocular predator that approaches cautiously until a worker meets its gaze. Avoid eye contact to make it lose interest, or drive it away with a direct flashlight beam.\n\n").CreateNameKeyword("eye monster")).AddTags((IEnumerable<NamespacedKey>)(object)new NamespacedKey[4]
				{
					Tags.Hostile,
					Tags.Organic,
					Tags.Killable,
					Tags.Medium
				});
			});
		}

		private static void InitializeNetcodeRPCs()
		{
			if (_netcodeInitialized)
			{
				return;
			}
			_netcodeInitialized = true;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods;
				try
				{
					methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				catch
				{
					continue;
				}
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length == 0)
					{
						continue;
					}
					try
					{
						methodInfo.Invoke(null, null);
					}
					catch (Exception ex)
					{
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogWarning((object)("[NetcodeInit] " + type.Name + "." + methodInfo.Name + " failed: " + ex.Message));
						}
					}
				}
			}
		}

		private static void SetupPrefabComponents(GameObject prefab)
		{
			TrySetTag(prefab, "Enemy");
			TrySetLayer(prefab, "Enemies");
			EyeMonsterAI component = prefab.GetComponent<EyeMonsterAI>();
			if ((Object)(object)component == (Object)null)
			{
				Log.LogError((object)"[EyeMon] EyeMonsterAI is missing from the bundled prefab.");
				return;
			}
			NavMeshAgent val = prefab.GetComponent<NavMeshAgent>();
			if ((Object)(object)val == (Object)null)
			{
				val = prefab.AddComponent<NavMeshAgent>();
			}
			ConfigureAgent(val);
			((EnemyAI)component).agent = val;
			Animator animator = ResolveAnimator(prefab, component);
			EnsureAnimationRelay(prefab, component, animator);
			EnsureEyeAnchor(prefab, component);
			EnsureScanNode(prefab);
			EnsureMapDot(prefab);
			EnsureCollision(prefab, component);
			EnsureExclusiveAudio(prefab, component);
			EnsureSlimeTrail(prefab, component);
			EnsureBehaviourStates(component);
			WireAudioClips(component);
		}

		private static void ConfigureAgent(NavMeshAgent agent)
		{
			agent.speed = ModConfig.RoamSpeed.Value;
			agent.angularSpeed = 180f;
			agent.acceleration = 12f;
			agent.stoppingDistance = 0f;
			agent.radius = 0.42f;
			agent.height = 2.45f;
			agent.baseOffset = 0f;
			agent.autoRepath = true;
			agent.autoTraverseOffMeshLink = true;
		}

		private static Animator ResolveAnimator(GameObject prefab, EyeMonsterAI ai)
		{
			Transform val = prefab.transform.Find("VisualRoot");
			Animator val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Animator>() : prefab.GetComponent<Animator>());
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = prefab.GetComponentInChildren<Animator>(true);
			}
			((EnemyAI)ai).creatureAnimator = val2;
			return val2;
		}

		private static void EnsureAnimationRelay(GameObject prefab, EyeMonsterAI ai, Animator animator)
		{
			if (!((Object)(object)animator == (Object)null) && !((Object)(object)((Component)animator).gameObject == (Object)(object)prefab))
			{
				EyeMonsterAnimationRelay eyeMonsterAnimationRelay = ((Component)animator).GetComponent<EyeMonsterAnimationRelay>();
				if ((Object)(object)eyeMonsterAnimationRelay == (Object)null)
				{
					eyeMonsterAnimationRelay = ((Component)animator).gameObject.AddComponent<EyeMonsterAnimationRelay>();
				}
				eyeMonsterAnimationRelay.owner = ai;
			}
		}

		private static void EnsureEyeAnchor(GameObject prefab, EyeMonsterAI ai)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Transform val = FindOrCreateChild(prefab.transform, "Eye", new Vector3(0f, 1.45f, 0.45f));
			TrySetLayer(((Component)val).gameObject, "Enemies");
			((EnemyAI)ai).eye = val;
		}

		internal static void EnsureScanNode(GameObject prefab)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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)
			ScanNodeProperties val = null;
			ScanNodeProperties[] componentsInChildren = prefab.GetComponentsInChildren<ScanNodeProperties>(true);
			foreach (ScanNodeProperties val2 in componentsInChildren)
			{
				bool flag = val2.creatureScanID >= 0;
				bool flag2 = (Object)(object)val != (Object)null && val.creatureScanID >= 0;
				bool flag3 = string.Equals(((Object)((Component)val2).gameObject).name, "ScanNode", StringComparison.Ordinal);
				bool flag4 = (Object)(object)val != (Object)null && string.Equals(((Object)((Component)val).gameObject).name, "ScanNode", StringComparison.Ordinal);
				if ((Object)(object)val == (Object)null || (flag && !flag2) || (flag == flag2 && flag3 && !flag4))
				{
					val = val2;
				}
			}
			if (componentsInChildren.Length > 1)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[EyeMon] Found {componentsInChildren.Length} scan nodes; retiring every duplicate.");
				}
			}
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				if ((Object)(object)componentsInChildren[j] != (Object)(object)val)
				{
					RetireExtraScanNode(componentsInChildren[j], val, prefab);
				}
			}
			Transform val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : FindOrCreateChild(prefab.transform, "ScanNode", new Vector3(0f, 1.45f, 0f)));
			((Object)((Component)val3).gameObject).name = "ScanNode";
			TrySetTag(((Component)val3).gameObject, "DoNotSet");
			TrySetLayer(((Component)val3).gameObject, "ScanNode");
			EnsureHierarchyActive(val3, prefab.transform);
			((Component)val3).gameObject.SetActive(true);
			if (!_loggedScanNodeLayer)
			{
				_loggedScanNodeLayer = true;
				Log.LogInfo((object)($"[EyeMon] Scan node layer resolved to {((Component)val3).gameObject.layer} " + string.Format("(NameToLayer(\"ScanNode\")={0}, fallback 22); ", LayerMask.NameToLayer("ScanNode")) + $"active={((Component)val3).gameObject.activeInHierarchy}."));
			}
			BoxCollider val4 = ((Component)val3).GetComponent<BoxCollider>();
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = ((Component)val3).gameObject.AddComponent<BoxCollider>();
			}
			((Collider)val4).enabled = true;
			((Collider)val4).isTrigger = true;
			val4.center = Vector3.zero;
			val4.size = new Vector3(1.8f, 2.2f, 1.8f);
			val = val ?? ((Component)val3).gameObject.AddComponent<ScanNodeProperties>();
			val.headerText = "Eye Monster";
			val.subText = "Avoid its gaze";
			val.maxRange = 25;
			val.minRange = 1;
			val.nodeType = 1;
			val.requiresLineOfSight = true;
		}

		private static void RetireExtraScanNode(ScanNodeProperties extra, ScanNodeProperties preferred, GameObject root)
		{
			//IL_0035: 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)
			//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)
			if ((Object)(object)extra == (Object)null)
			{
				return;
			}
			Scene scene;
			if ((Object)(object)((Component)extra).gameObject == (Object)(object)root || ((Object)(object)preferred != (Object)null && (Object)(object)((Component)extra).gameObject == (Object)(object)((Component)preferred).gameObject))
			{
				scene = root.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					Object.Destroy((Object)(object)extra);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)extra, true);
				}
				return;
			}
			GameObject gameObject = ((Component)extra).gameObject;
			gameObject.SetActive(false);
			Collider[] components = gameObject.GetComponents<Collider>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].enabled = false;
			}
			scene = root.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				Object.Destroy((Object)(object)gameObject);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)gameObject, true);
			}
		}

		private static void EnsureMapDot(GameObject prefab)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = FindOrCreateChild(prefab.transform, "MapDot", new Vector3(0f, 1.2f, 0f));
			TrySetTag(((Component)obj).gameObject, "DoNotSet");
			TrySetLayer(((Component)obj).gameObject, "MapRadar");
		}

		private static void EnsureCollision(GameObject prefab, EyeMonsterAI ai)
		{
			//IL_0035: 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_0064: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			BoxCollider val = prefab.GetComponent<BoxCollider>();
			if ((Object)(object)val == (Object)null)
			{
				val = prefab.AddComponent<BoxCollider>();
			}
			((Collider)val).enabled = true;
			((Collider)val).isTrigger = false;
			val.center = new Vector3(0f, 1.4f, 0f);
			val.size = new Vector3(2.05f, 2.8f, 2.05f);
			Transform val2 = FindOrCreateChild(prefab.transform, "Collision", Vector3.zero);
			TrySetTag(((Component)val2).gameObject, "Enemy");
			TrySetLayer(((Component)val2).gameObject, "Enemies");
			BoxCollider val3 = ((Component)val2).GetComponent<BoxCollider>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)val2).gameObject.AddComponent<BoxCollider>();
			}
			((Collider)val3).enabled = true;
			((Collider)val3).isTrigger = true;
			val3.center = new Vector3(0f, 1.45f, 0f);
			val3.size = new Vector3(2.3f, 2.9f, 2.3f);
			Rigidbody val4 = ((Component)val2).GetComponent<Rigidbody>();
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = ((Component)val2).gameObject.AddComponent<Rigidbody>();
			}
			val4.isKinematic = true;
			val4.useGravity = false;
			val4.detectCollisions = true;
			WireHitDetector(((Component)val2).gameObject, ai);
		}

		private static void WireHitDetector(GameObject host, EyeMonsterAI ai)
		{
			EnemyAICollisionDetect val = host.GetComponent<EnemyAICollisionDetect>();
			if ((Object)(object)val == (Object)null)
			{
				val = host.AddComponent<EnemyAICollisionDetect>();
			}
			val.mainScript = (EnemyAI)(object)ai;
			val.alwaysAllowHitting = true;
			val.canCollideWithEnemies = false;
			val.onlyCollideWhenGrounded = false;
		}

		private static void EnsureExclusiveAudio(GameObject prefab, EyeMonsterAI ai)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Transform val = FindOrCreateChild(prefab.transform, "CreatureAudio", new Vector3(0f, 1.35f, 0f));
			TrySetLayer(((Component)val).gameObject, "Enemies");
			AudioSource val2 = ((Component)val).GetComponent<AudioSource>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)val).gameObject.AddComponent<AudioSource>();
			}
			ConfigureSpatialAudio(val2);
			ai.exclusiveAudioSource = val2;
			((EnemyAI)ai).creatureSFX = val2;
			((EnemyAI)ai).creatureVoice = val2;
			DisableLegacyAudio(prefab.transform.Find("CreatureSFX"), val2);
			DisableLegacyAudio(prefab.transform.Find("CreatureVoice"), val2);
			DisableLegacyAudio(prefab.transform.Find("LoopSource"), val2);
		}

		private static void DisableLegacyAudio(Transform legacyTransform, AudioSource retainedSource)
		{
			if (!((Object)(object)legacyTransform == (Object)null))
			{
				AudioSource component = ((Component)legacyTransform).GetComponent<AudioSource>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)retainedSource))
				{
					component.Stop();
					component.playOnAwake = false;
					component.loop = false;
					component.clip = null;
					((Behaviour)component).enabled = false;
				}
			}
		}

		private static void ConfigureSpatialAudio(AudioSource source)
		{
			source.playOnAwake = false;
			source.loop = false;
			source.spatialBlend = 1f;
			source.rolloffMode = (AudioRolloffMode)1;
			source.minDistance = 1f;
			source.maxDistance = 25f;
		}

		private static void EnsureSlimeTrail(GameObject prefab, EyeMonsterAI ai)
		{
			EyeMonsterSlimeTrail eyeMonsterSlimeTrail = prefab.GetComponent<EyeMonsterSlimeTrail>();
			if ((Object)(object)eyeMonsterSlimeTrail == (Object)null)
			{
				eyeMonsterSlimeTrail = prefab.AddComponent<EyeMonsterSlimeTrail>();
			}
			eyeMonsterSlimeTrail.slimeMaterial = LoadMaterial("EyeMonsterSlime");
			ai.slimeTrail = eyeMonsterSlimeTrail;
			if ((Object)(object)eyeMonsterSlimeTrail.slimeMaterial == (Object)null)
			{
				Log.LogWarning((object)"[EyeMon] EyeMonsterSlime material is missing from the bundle.");
			}
		}

		private static void EnsureBehaviourStates(EyeMonsterAI ai)
		{
			((EnemyAI)ai).enemyBehaviourStates = (EnemyBehaviourState[])(object)new EnemyBehaviourState[5]
			{
				WalkingState("Roaming", walking: false),
				WalkingState("Investigating", walking: true),
				WalkingState("Chasing", walking: true),
				WalkingState("Attacking", walking: false),
				WalkingState("Fleeing", walking: true)
			};
			((EnemyAI)ai).currentBehaviourStateIndex = 0;
			((EnemyAI)ai).previousBehaviourStateIndex = 0;
			((EnemyAI)ai).currentBehaviourState = ((EnemyAI)ai).enemyBehaviourStates[0];
		}

		private static EnemyBehaviourState WalkingState(string name, bool walking)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return new EnemyBehaviourState
			{
				name = name,
				IsAnimTrigger = false,
				parameterString = "isWalking",
				boolValue = walking
			};
		}

		private static void WireAudioClips(EyeMonsterAI ai)
		{
			ai.idleClips = LoadAudioClips("eyemonster_idle_01", "eyemonster_idle_02");
			ai.vocalClips = LoadAudioClips("eyemonster_vocal_01", "eyemonster_vocal_02");
			ai.playerHitClips = LoadAudioClips("eyemonster_player_hit_01");
			ai.runStepClips = LoadAudioClips("eyemonster_step_01", "eyemonster_step_02", "eyemonster_step_03");
		}

		private static AudioClip[] LoadAudioClips(params string[] names)
		{
			AudioClip[] array = (AudioClip[])(object)new AudioClip[names.Length];
			int num = 0;
			for (int i = 0; i < names.Length; i++)
			{
				AudioClip val = LoadAudioClip(names[i]);
				if ((Object)(object)val != (Object)null)
				{
					array[num++] = val;
				}
			}
			if (num == array.Length)
			{
				return array;
			}
			AudioClip[] array2 = (AudioClip[])(object)new AudioClip[num];
			Array.Copy(array, array2, num);
			return array2;
		}

		private static AudioClip LoadAudioClip(string shortName)
		{
			AudioClip val = ModAssets.LoadAsset<AudioClip>(shortName) ?? ModAssets.LoadAsset<AudioClip>(shortName + ".wav");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			string[] allAssetNames = ModAssets.GetAllAssetNames();
			foreach (string text in allAssetNames)
			{
				if (text.EndsWith("/" + shortName + ".wav", StringComparison.OrdinalIgnoreCase))
				{
					return ModAssets.LoadAsset<AudioClip>(text);
				}
			}
			Log.LogWarning((object)("[EyeMon] Audio clip missing from bundle: " + shortName));
			return null;
		}

		private static Material LoadMaterial(string shortName)
		{
			Material val = ModAssets.LoadAsset<Material>(shortName) ?? ModAssets.LoadAsset<Material>(shortName + ".mat");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			string[] allAssetNames = ModAssets.GetAllAssetNames();
			foreach (string text in allAssetNames)
			{
				if (text.EndsWith("/" + shortName + ".mat", StringComparison.OrdinalIgnoreCase))
				{
					return ModAssets.LoadAsset<Material>(text);
				}
			}
			return null;
		}

		private static Transform FindOrCreateChild(Transform parent, string name, Vector3 localPosition)
		{
			//IL_0026: 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)
			Transform val = parent.Find(name);
			if ((Object)(object)val == (Object)null)
			{
				val = new GameObject(name).transform;
				val.SetParent(parent, false);
			}
			val.localPosition = localPosition;
			return val;
		}

		private static void TrySetTag(GameObject target, string tagName)
		{
			try
			{
				target.tag = tagName;
			}
			catch (UnityException)
			{
				Log.LogWarning((object)("[EyeMon] Tag '" + tagName + "' is unavailable for '" + ((Object)target).name + "'."));
			}
		}

		internal static void TrySetLayer(GameObject target, string layerName)
		{
			if (!((Object)(object)target == (Object)null))
			{
				int num = LayerMask.NameToLayer(layerName);
				if (num < 0)
				{
					num = ResolveLayerFallback(layerName);
				}
				if (num < 0 || num > 31)
				{
					Log.LogWarning((object)("[EyeMon] Layer '" + layerName + "' is unavailable for '" + ((Object)target).name + "'."));
				}
				else
				{
					target.layer = num;
				}
			}
		}

		private static int ResolveLayerFallback(string layerName)
		{
			if (string.Equals(layerName, "ScanNode", StringComparison.OrdinalIgnoreCase))
			{
				return 22;
			}
			if (string.Equals(layerName, "Enemies", StringComparison.OrdinalIgnoreCase))
			{
				return 19;
			}
			return -1;
		}

		private static void EnsureHierarchyActive(Transform child, Transform stopAt)
		{
			Transform val = child;
			while ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(true);
				if (!((Object)(object)val == (Object)(object)stopAt))
				{
					val = val.parent;
					continue;
				}
				break;
			}
		}

		private static EnemyType CreateEnemyType(GameObject prefab)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			EnemyType obj = ScriptableObject.CreateInstance<EnemyType>();
			obj.enemyName = "Eye Monster";
			obj.enemyPrefab = prefab;
			obj.PowerLevel = ModConfig.PowerLevel.Value;
			obj.DiversityPowerLevel = 1;
			obj.MaxCount = ModConfig.MaxCount.Value;
			obj.canDie = true;
			obj.canBeStunned = true;
			obj.stunTimeMultiplier = 1f;
			obj.doorSpeedMultiplier = 1f;
			obj.stunGameDifficultyMultiplier = 1f;
			obj.destroyOnDeath = false;
			obj.isOutsideEnemy = false;
			obj.isDaytimeEnemy = false;
			obj.probabilityCurve = AnimationCurve.Constant(0f, 1f, 1f);
			obj.numberSpawnedFalloff = AnimationCurve.Linear(0f, 1f, 1f, 0.65f);
			obj.useNumberSpawnedFalloff = true;
			obj.SizeLimit = (NavSizeLimit)1;
			EyeMonsterAI component = prefab.GetComponent<EyeMonsterAI>();
			AudioClip[] array = (((Object)(object)component != (Object)null) ? component.vocalClips : null);
			CreatureSfx.Apply(obj, (EnemyAI)(object)component, (array != null && array.Length != 0) ? array[0] : null, (array != null && array.Length != 0) ? array[^1] : null);
			return obj;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "y4ngz.lethalcompany.eyemonster";

		public const string PLUGIN_NAME = "Y4NGZ Eye Monster";

		public const string PLUGIN_VERSION = "1.2.1";
	}
}
namespace EyeMonster.Utils
{
	public static class CreatureAudio
	{
		public static bool PlayExclusive(AudioSource source, AudioClip clip, bool interrupt)
		{
			if ((Object)(object)source == (Object)null || (Object)(object)clip == (Object)null)
			{
				return false;
			}
			if (source.isPlaying && !interrupt)
			{
				return false;
			}
			source.Stop();
			source.loop = false;
			source.clip = clip;
			source.Play();
			return true;
		}

		public static void Stop(AudioSource source)
		{
			if (!((Object)(object)source == (Object)null))
			{
				source.Stop();
				source.loop = false;
				source.clip = null;
			}
		}
	}
}
namespace EyeMonster.AI
{
	public class EyeMonsterAI : EnemyAI
	{
		private enum AudioCue
		{
			Idle,
			Vocal,
			PlayerHit,
			Step
		}

		public const int StateRoaming = 0;

		public const int StateInvestigating = 1;

		public const int StateChasing = 2;

		public const int StateAttacking = 3;

		public const int StateFleeing = 4;

		[Header("Exclusive audio")]
		public AudioClip[] idleClips;

		public AudioClip[] vocalClips;

		public AudioClip[] playerHitClips;

		public AudioClip[] runStepClips;

		public AudioSource exclusiveAudioSource;

		[Header("Cosmetics")]
		public EyeMonsterSlimeTrail slimeTrail;

		private const float LightCheckInterval = 0.2f;

		private const float PassiveEyelidClosure = 0.24f;

		private const float FlashlightEyelidClosure = 0.72f;

		private const float PassiveEyelidSmoothTime = 0.42f;

		private const float RevealEyelidSmoothTime = 0.24f;

		private const float FlashlightEyelidSmoothTime = 0.16f;

		private const float DeathEyelidSmoothTime = 0.13f;

		private const float IdleAudioMinSeconds = 7.5f;

		private const float IdleAudioMaxSeconds = 14f;

		private const float ChaseRangeMultiplier = 1.75f;

		private const string StunnedParameter = "stunned";

		private const float BiteForce = 12f;

		private const float FleeRouteRefreshSeconds = 1f;

		private const float FleeNodeMaxDistance = 40f;

		private const float FleePathThreatClearance = 2.5f;

		private const int FleeMaxPathChecks = 6;

		private static readonly RaycastHit[] LightPathHits = (RaycastHit[])(object)new RaycastHit[8];

		private const float NoiseMinLoudness = 0.5f;

		private const float NoiseHearingRange = 20f;

		private const float NoiseMemorySeconds = 3f;

		private const float NoiseReseedCooldown = 4f;

		private const int NoiseMaxRepeatsInOneSpot = 10;

		private static readonly Vector3 UpperLidOpenPosition = new Vector3(0f, 0.53408f, 0.668f);

		private static readonly Vector3 LowerLidOpenPosition = new Vector3(0f, 0.53408f, 0.668f);

		private static readonly Vector3 UpperLidClosedPosition = new Vector3(0f, 0.53408f, 0.668f);

		private static readonly Vector3 LowerLidClosedPosition = new Vector3(0.44242f, 0.53408f, 0.668f);

		private static readonly Quaternion UpperLidOpenRotation = Quaternion.identity;

		private static readonly Quaternion LowerLidOpenRotation = Quaternion.identity;

		private static readonly Quaternion UpperLidClosedRotation = Quaternion.Euler(35.10085f, 0.00239f, 0.00126f);

		private static readonly Quaternion LowerLidClosedRotation = Quaternion.Euler(-37.8065f, 0.00281f, -0.00115f);

		private readonly Dictionary<ulong, float> _noticeCooldownUntil = new Dictionary<ulong, float>();

		private readonly int[] _lastAudioIndices = new int[4] { -1, -1, -1, -1 };

		private readonly ServerOwnershipGuard _ownership = new ServerOwnershipGuard();

		private readonly NoiseMemory _noiseMemory = new NoiseMemory();

		private float _loseTargetTimer;

		private float _attackCooldownTimer;

		private float _lightCheckTimer;

		private float _fleeTimer;

		private float _investigationStartedAt;

		private float _nextIdleAudioTime;

		private float _eyelidClosure = 0.24f;

		private float _eyelidClosureVelocity;

		private float _remoteMovingUntil;

		private Vector3 _lastAnimationPosition;

		private bool _hasLastAnimationPosition;

		private bool _eyelidsInitialized;

		private float _nextFleeRouteTime;

		private Vector3 _lastLightThreatPosition;

		private Coroutine _attackCoroutine;

		private bool _gazeConfirmedForTarget;

		private bool _deathAnimationStarted;

		private float _nextNoiseReseedTime;

		private bool _wasStunned;

		private bool _audioRouted;

		private bool _attackSwingPending;

		private bool _deathPoseFrozen;

		private bool _corpseAnimatorStopped;

		private Transform _eyeBone;

		private Transform _upperLid;

		private Transform _lowerLid;

		private float RoamSpeed => Mathf.Max(0.1f, Plugin.ModConfig.RoamSpeed.Value);

		private float InvestigateSpeed => 2.6f;

		private float ChaseSpeed => Mathf.Max(0.1f, Plugin.ModConfig.ChaseSpeed.Value);

		private float FleeSpeed => Mathf.Max(0.1f, Plugin.ModConfig.FleeSpeed.Value);

		private int AttackDamage => Mathf.Max(0, Plugin.ModConfig.AttackDamage.Value);

		private float AttackCooldown => Mathf.Max(0.1f, Plugin.ModConfig.AttackCooldown.Value);

		private float AttackRange => 2.5f;

		private float NoticeRange => Mathf.Max(2f, Plugin.ModConfig.NoticeRange.Value);

		private float NoticeViewAngle => 52f;

		private float PlayerGazeAngle => Mathf.Clamp(Plugin.ModConfig.GazeAngle.Value, 5f, 90f);

		private float InvestigationStopDistance => 4.5f;

		private float InvestigationDecisionDelay => 0.8f;

		private float InvestigationTimeout => 8f;

		private float FlashlightDetectionRange => Mathf.Max(2f, Plugin.ModConfig.FlashlightRange.Value);

		private float FlashlightDetectionAngle => 25f;

		private float FleeDuration => Mathf.Max(0.5f, Plugin.ModConfig.FleeDuration.Value);

		private float LoseTargetSeconds => 3.5f;

		private float FailedNoticeCooldown => 4f;

		internal bool ShouldEmitSlimeTrail
		{
			get
			{
				if (!base.isEnemyDead && base.ventAnimationFinished)
				{
					return base.currentBehaviourStateIndex != 3;
				}
				return false;
			}
		}

		private bool AgentCanNavigate
		{
			get
			{
				if ((Object)(object)base.agent != (Object)null && ((Behaviour)base.agent).enabled)
				{
					return base.agent.isOnNavMesh;
				}
				return false;
			}
		}

		private void LogError(string message)
		{
			Plugin.Log.LogError((object)message);
		}

		private void LogDebug(string message)
		{
			EyeMonsterConfig modConfig = Plugin.ModConfig;
			if (modConfig != null && modConfig.DebugLogs.Value)
			{
				Plugin.Log.LogInfo((object)("[EyeMon] " + message));
			}
		}

		public override void Awake()
		{
			try
			{
				((EnemyAI)this).Awake();
				Plugin.EnsureScanNode(((Component)this).gameObject);
				CacheVisualRig();
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.Awake: {arg}");
			}
		}

		public override void Start()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((EnemyAI)this).Start();
				_audioRouted = CreatureAudioSetup.ConfigureSpatial(exclusiveAudioSource);
				base.enemyHP = Mathf.Max(1, Plugin.ModConfig.Health.Value);
				ConfigureSearchDefaults();
				if (((NetworkBehaviour)this).IsServer)
				{
					RepairAgentPlacementIfNeeded();
				}
				ConfigureAgent(RoamSpeed, 0f);
				slimeTrail?.Bind(this);
				if (((NetworkBehaviour)this).IsServer)
				{
					ResetIdleAudioTimer();
				}
				LogDebug($"Spawned at {((Component)this).transform.position}, HP={base.enemyHP}");
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.Start: {arg}");
			}
		}

		private void CacheVisualRig()
		{
			if ((Object)(object)base.eye == (Object)null)
			{
				base.eye = ((Component)this).transform.Find("Eye");
			}
			_eyeBone = FindDescendantByExactName(((Component)this).transform, "eye");
			_upperLid = FindDescendantByExactName(((Component)this).transform, "lid_up");
			_lowerLid = FindDescendantByExactName(((Component)this).transform, "lid_down");
		}

		private static Transform FindDescendantByExactName(Transform root, string childName)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (string.Equals(((Object)child).name, childName, StringComparison.OrdinalIgnoreCase))
				{
					return child;
				}
				Transform val = FindDescendantByExactName(child, childName);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private void LateUpdate()
		{
			try
			{
				if (!_corpseAnimatorStopped)
				{
					if (base.isEnemyDead)
					{
						UpdateDeathAnimation();
					}
					SyncEyeAnchorToBone();
					UpdateEyelidExpression();
					if (base.isEnemyDead)
					{
						TryStopCorpseAnimator();
					}
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.LateUpdate: {arg}");
			}
		}

		private void TryStopCorpseAnimator()
		{
			bool num = (Object)(object)base.creatureAnimator == (Object)null || _deathPoseFrozen;
			bool flag = (Object)(object)_upperLid == (Object)null || (Object)(object)_lowerLid == (Object)null || _eyelidClosure >= 1f;
			if (num && flag)
			{
				if ((Object)(object)base.creatureAnimator != (Object)null)
				{
					((Behaviour)base.creatureAnimator).enabled = false;
				}
				_corpseAnimatorStopped = true;
			}
		}

		private void SyncEyeAnchorToBone()
		{
			//IL_0029: 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)
			if (!((Object)(object)base.eye == (Object)null) && !((Object)(object)_eyeBone == (Object)null))
			{
				base.eye.position = _eyeBone.position;
				base.eye.rotation = ((Component)this).transform.rotation;
			}
		}

		private void UpdateEyelidExpression()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_upperLid == (Object)null) && !((Object)(object)_lowerLid == (Object)null))
			{
				if (!_eyelidsInitialized)
				{
					_eyelidClosure = (base.isEnemyDead ? 1f : GetDesiredEyelidClosure());
					_eyelidClosureVelocity = 0f;
					_eyelidsInitialized = true;
				}
				float num = (base.isEnemyDead ? 1f : GetDesiredEyelidClosure());
				float eyelidSmoothTime = GetEyelidSmoothTime(num);
				_eyelidClosure = Mathf.SmoothDamp(_eyelidClosure, num, ref _eyelidClosureVelocity, eyelidSmoothTime, 4f, Time.deltaTime);
				if (Mathf.Abs(_eyelidClosure - num) < 0.0005f)
				{
					_eyelidClosure = num;
				}
				float num2 = Mathf.Clamp01(_eyelidClosure);
				_upperLid.localPosition = Vector3.Lerp(UpperLidOpenPosition, UpperLidClosedPosition, num2);
				_lowerLid.localPosition = Vector3.Lerp(LowerLidOpenPosition, LowerLidClosedPosition, num2);
				_upperLid.localRotation = Quaternion.Slerp(UpperLidOpenRotation, UpperLidClosedRotation, num2);
				_lowerLid.localRotation = Quaternion.Slerp(LowerLidOpenRotation, LowerLidClosedRotation, num2);
			}
		}

		private float GetDesiredEyelidClosure()
		{
			switch (base.currentBehaviourStateIndex)
			{
			case 1:
			case 2:
			case 3:
				return 0f;
			case 4:
				return 0.72f;
			default:
				return 0.24f;
			}
		}

		private float GetEyelidSmoothTime(float desiredClosure)
		{
			if (base.isEnemyDead)
			{
				return 0.13f;
			}
			if (base.currentBehaviourStateIndex == 4)
			{
				return 0.16f;
			}
			if (desiredClosure <= 0.001f)
			{
				return 0.24f;
			}
			return 0.42f;
		}

		private void RepairAgentPlacementIfNeeded()
		{
			//IL_004b: 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_00b6: 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)
			if (!((Object)(object)base.agent == (Object)null) && ((Behaviour)base.agent).enabled && !base.agent.isOnNavMesh)
			{
				int num = ((base.agent.areaMask == 0) ? (-1) : base.agent.areaMask);
				NavMeshHit val = default(NavMeshHit);
				if (!NavMesh.SamplePosition(((Component)this).transform.position, ref val, 4f, num))
				{
					Plugin.Log.LogWarning((object)$"[EyeMon] Could not place NavMeshAgent near spawn position {((Component)this).transform.position}.");
					return;
				}
				((Behaviour)base.agent).enabled = false;
				((Component)this).transform.position = ((NavMeshHit)(ref val)).position;
				((Behaviour)base.agent).enabled = true;
				LogDebug($"Repaired NavMeshAgent placement to {((NavMeshHit)(ref val)).position}.");
			}
		}

		public override void Update()
		{
			try
			{
				_ownership.Ensure((EnemyAI)(object)this, Plugin.Log);
				((EnemyAI)this).Update();
				if (!_audioRouted)
				{
					_audioRouted = CreatureAudioSetup.ConfigureSpatial(exclusiveAudioSource);
				}
				if (base.isEnemyDead || (Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayersDead)
				{
					return;
				}
				UpdateStun();
				if (base.currentBehaviourStateIndex != 3)
				{
					_attackSwingPending = false;
				}
				UpdateWalkingAnimation();
				if (((NetworkBehaviour)this).IsServer && !_wasStunned)
				{
					if (_attackCooldownTimer > 0f)
					{
						_attackCooldownTimer -= Time.deltaTime;
					}
					TickIdleAudio();
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.Update: {arg}");
			}
		}

		private void UpdateStun()
		{
			StunEdge stunEdge = ((EnemyAI)(object)this).TrackStun(ref _wasStunned);
			if (stunEdge != StunEdge.None && (Object)(object)base.creatureAnimator != (Object)null)
			{
				base.creatureAnimator.SetBool("stunned", _wasStunned);
			}
			if (stunEdge == StunEdge.Started)
			{
				_attackSwingPending = false;
			}
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			if (_wasStunned)
			{
				if (stunEdge == StunEdge.Started && _attackCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_attackCoroutine);
					_attackCoroutine = null;
				}
				((EnemyAI)(object)this).HoldAgent();
			}
			else if (stunEdge == StunEdge.Ended)
			{
				((EnemyAI)(object)this).ReleaseAgent();
			}
		}

		private void UpdateWalkingAnimation()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0082: 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)
			Vector3 position = ((Component)this).transform.position;
			Vector3 val;
			if (_hasLastAnimationPosition)
			{
				val = position - _lastAnimationPosition;
				if (((Vector3)(ref val)).sqrMagnitude > 1E-06f)
				{
					_remoteMovingUntil = Time.time + 0.15f;
				}
			}
			_lastAnimationPosition = position;
			_hasLastAnimationPosition = true;
			if (!((Object)(object)base.creatureAnimator == (Object)null))
			{
				int num;
				if (!((NetworkBehaviour)this).IsOwner)
				{
					num = ((Time.time < _remoteMovingUntil) ? 1 : 0);
				}
				else if (AgentCanNavigate)
				{
					val = base.agent.velocity;
					num = ((((Vector3)(ref val)).sqrMagnitude > 0.01f) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				bool flag = (byte)num != 0;
				if (!base.ventAnimationFinished || base.currentBehaviourStateIndex == 3)
				{
					flag = false;
				}
				base.creatureAnimator.SetBool("isWalking", flag);
			}
		}

		public override void DoAIInterval()
		{
			try
			{
				((EnemyAI)this).DoAIInterval();
				if (!base.isEnemyDead && !((Object)(object)StartOfRound.Instance == (Object)null) && !StartOfRound.Instance.allPlayersDead && ((NetworkBehaviour)this).IsServer && !((EnemyAI)(object)this).IsStunned() && (base.currentBehaviourStateIndex == 4 || !TryBeginFlashlightFlee()))
				{
					switch (base.currentBehaviourStateIndex)
					{
					case 0:
						DoRoaming();
						break;
					case 1:
						DoInvestigating();
						break;
					case 2:
						DoChasing();
						break;
					case 4:
						DoFleeing();
						break;
					case 3:
						RecoverInterruptedAttack();
						break;
					}
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.DoAIInterval: {arg}");
			}
		}

		private void DoRoaming()
		{
			ConfigureAgent(RoamSpeed, 0f);
			if (!TryReseedSearchAtNoise())
			{
				StartFacilitySearchIfNeeded();
			}
			PlayerControllerB val = FindNoticeTarget();
			if (!((Object)(object)val == (Object)null))
			{
				StopFacilitySearch();
				base.targetPlayer = val;
				_gazeConfirmedForTarget = false;
				_loseTargetTimer = 0f;
				_investigationStartedAt = Time.time;
				((EnemyAI)this).SetMovingTowardsTargetPlayer(val);
				BroadcastAudioCue(AudioCue.Vocal, interrupt: true);
				((EnemyAI)this).SwitchToBehaviourState(1);
				LogDebug("Noticed " + val.playerUsername + "; beginning cautious approach.");
			}
		}

		private bool TryReseedSearchAtNoise()
		{
			//IL_0052: 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)
			if (Time.time < _nextNoiseReseedTime || !AgentCanNavigate)
			{
				return false;
			}
			if (!_noiseMemory.TryTake(3f, out var position))
			{
				return false;
			}
			_nextNoiseReseedTime = Time.time + 4f;
			ConfigureSearchDefaults();
			((EnemyAI)this).StopSearch(base.currentSearch, true);
			((EnemyAI)this).StartSearch(position, base.currentSearch);
			LogDebug($"Heard a noise at {position}; searching there.");
			return true;
		}

		private void DoInvestigating()
		{
			//IL_0036: 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)
			if (!IsTargetable(base.targetPlayer))
			{
				DropTarget(addNoticeCooldown: false);
				return;
			}
			float num = Time.time - _investigationStartedAt;
			bool flag = num >= InvestigationTimeout;
			float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position);
			if (!(num2 <= NoticeRange * 1.75f) || !HasClearSightToPlayer(base.targetPlayer))
			{
				_loseTargetTimer += base.AIIntervalTime;
				if (_loseTargetTimer >= LoseTargetSeconds || flag)
				{
					DropTarget(addNoticeCooldown: true);
				}
				return;
			}
			_loseTargetTimer = 0f;
			ConfigureAgent(InvestigateSpeed, InvestigationStopDistance);
			((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
			if ((num2 <= InvestigationStopDistance + 1f || AgentHasStopped() || flag) && !(num < InvestigationDecisionDelay))
			{
				StopAgentPath();
				FaceTarget(base.targetPlayer);
				if (IsMutualGaze(base.targetPlayer))
				{
					_gazeConfirmedForTarget = true;
					BroadcastAudioCue(AudioCue.Vocal, interrupt: true);
					ConfigureAgent(ChaseSpeed, Mathf.Max(0.25f, AttackRange * 0.65f));
					((EnemyAI)this).SwitchToBehaviourState(2);
					LogDebug(base.targetPlayer.playerUsername + " looked at the eye; aggro confirmed.");
				}
				else
				{
					LogDebug(base.targetPlayer.playerUsername + " refused eye contact; forgetting target.");
					DropTarget(addNoticeCooldown: true);
				}
			}
		}

		private void DoChasing()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!IsTargetable(base.targetPlayer) || !_gazeConfirmedForTarget)
			{
				DropTarget(addNoticeCooldown: false);
				return;
			}
			float num = Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position);
			if (!(num <= NoticeRange * 1.75f) || !HasClearSightToPlayer(base.targetPlayer))
			{
				_loseTargetTimer += base.AIIntervalTime;
				if (_loseTargetTimer >= LoseTargetSeconds)
				{
					LogDebug($"Lost {base.targetPlayer.playerUsername} after {_loseTargetTimer:F1}s.");
					DropTarget(addNoticeCooldown: false);
					return;
				}
			}
			else
			{
				_loseTargetTimer = 0f;
			}
			ConfigureAgent(ChaseSpeed, Mathf.Max(0.25f, AttackRange * 0.65f));
			((EnemyAI)this).SetMovingTowardsTargetPlayer(base.targetPlayer);
			if (num <= AttackRange && _attackCooldownTimer <= 0f)
			{
				EnterAttacking();
			}
		}

		private void EnterAttacking()
		{
			if (_gazeConfirmedForTarget && IsTargetable(base.targetPlayer))
			{
				StopAgentPath();
				((EnemyAI)this).SwitchToBehaviourState(3);
				PlayAttackAnimationClientRpc();
				if (_attackCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_attackCoroutine);
				}
				_attackCoroutine = ((MonoBehaviour)this).StartCoroutine(AttackRoutine());
			}
		}

		private IEnumerator AttackRoutine()
		{
			try
			{
				_attackCooldownTimer = AttackCooldown;
			}
			catch (Exception arg)
			{
				LogError($"AttackRoutine begin: {arg}");
				_attackCoroutine = null;
				yield break;
			}
			yield return (object)new WaitForSeconds(AttackCooldown);
			try
			{
				if (base.isEnemyDead || base.currentBehaviourStateIndex == 4)
				{
					_attackCoroutine = null;
					yield break;
				}
				if (!IsTargetable(base.targetPlayer) || !_gazeConfirmedForTarget)
				{
					DropTarget(addNoticeCooldown: false);
				}
				else if (Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) <= NoticeRange * 1.75f)
				{
					((EnemyAI)this).SwitchToBehaviourState(2);
				}
				else
				{
					DropTarget(addNoticeCooldown: false);
				}
			}
			catch (Exception arg2)
			{
				LogError($"AttackRoutine end: {arg2}");
			}
			_attackCoroutine = null;
		}

		private void RecoverInterruptedAttack()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (_attackCoroutine == null)
			{
				if (IsTargetable(base.targetPlayer) && _gazeConfirmedForTarget && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) <= NoticeRange * 1.75f)
				{
					((EnemyAI)this).SwitchToBehaviourState(2);
				}
				else
				{
					DropTarget(addNoticeCooldown: false);
				}
			}
		}

		[ClientRpc]
		public void PlayAttackAnimationClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1996458905u, val2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1996458905u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!base.isEnemyDead && !((Object)(object)base.creatureAnimator == (Object)null))
				{
					_attackSwingPending = true;
					base.creatureAnimator.SetTrigger("doAttack");
				}
			}
		}

		private PlayerControllerB FindNoticeTarget()
		{
			//IL_0097: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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)
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayerScripts == null)
			{
				return null;
			}
			PlayerControllerB result = null;
			float num = float.PositiveInfinity;
			float num2 = NoticeRange * NoticeRange;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsTargetable(val) && !IsNoticeCoolingDown(val))
				{
					Vector3 val2 = (((Object)(object)val.gameplayCamera != (Object)null) ? ((Component)val.gameplayCamera).transform.position : (((Component)val).transform.position + Vector3.up));
					Vector3 val3 = val2 - GetEyeFocusPosition();
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (!(sqrMagnitude > num2) && !(sqrMagnitude >= num) && ((EnemyAI)this).CheckLineOfSightForPosition(val2, NoticeViewAngle, Mathf.CeilToInt(NoticeRange), -1f, base.eye))
					{
						result = val;
						num = sqrMagnitude;
					}
				}
			}
			return result;
		}

		private bool IsMutualGaze(PlayerControllerB player)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!IsTargetable(player))
			{
				return false;
			}
			Vector3 val = (((Object)(object)player.gameplayCamera != (Object)null) ? ((Component)player.gameplayCamera).transform.position : (((Component)player).transform.position + Vector3.up)) - GetEyeFocusPosition();
			if (!(((Vector3)(ref val)).sqrMagnitude > 0.001f) || !(Vector3.Angle(((Component)this).transform.forward, val) <= NoticeViewAngle) || !HasClearSightToPlayer(player))
			{
				return false;
			}
			return player.HasLineOfSightToPosition(GetEyeFocusPosition(), PlayerGazeAngle, Mathf.CeilToInt(NoticeRange + 6f), -1f, -1);
		}

		private bool HasClearSightToPlayer(PlayerControllerB player)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//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_0029: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!IsTargetable(player))
			{
				return false;
			}
			Vector3 val = (((Object)(object)player.gameplayCamera != (Object)null) ? ((Component)player.gameplayCamera).transform.position : (((Component)player).transform.position + Vector3.up));
			return ((EnemyAI)this).CheckLineOfSightForPosition(val, 180f, Mathf.CeilToInt(NoticeRange * 1.75f), -1f, base.eye);
		}

		private Vector3 GetEyeFocusPosition()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			if (!((Object)(object)base.eye != (Object)null))
			{
				return ((Component)this).transform.position + Vector3.up * 1.45f;
			}
			return base.eye.position;
		}

		private bool IsTargetable(PlayerControllerB player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return ((EnemyAI)this).PlayerIsTargetable(player, false, false, true);
			}
			return false;
		}

		private static bool IsLivingPlayer(PlayerControllerB player)
		{
			if ((Object)(object)player != (Object)null && player.isPlayerControlled)
			{
				return !player.isPlayerDead;
			}
			return false;
		}

		private bool AgentHasStopped()
		{
			//IL_0039: 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)
			if (AgentCanNavigate && !base.agent.pathPending && base.agent.remainingDistance <= base.agent.stoppingDistance + 0.25f)
			{
				Vector3 velocity = base.agent.velocity;
				return ((Vector3)(ref velocity)).sqrMagnitude < 0.04f;
			}
			return false;
		}

		private bool IsNoticeCoolingDown(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (_noticeCooldownUntil.TryGetValue(player.actualClientId, out var value))
			{
				return Time.time < value;
			}
			return false;
		}

		private void DropTarget(bool addNoticeCooldown)
		{
			PlayerControllerB targetPlayer = base.targetPlayer;
			if (addNoticeCooldown && (Object)(object)targetPlayer != (Object)null)
			{
				_noticeCooldownUntil[targetPlayer.actualClientId] = Time.time + FailedNoticeCooldown;
			}
			base.targetPlayer = null;
			base.movingTowardsTargetPlayer = false;
			_gazeConfirmedForTarget = false;
			_loseTargetTimer = 0f;
			if (_attackCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_attackCoroutine);
				_attackCoroutine = null;
			}
			ConfigureAgent(RoamSpeed, 0f);
			if (base.currentBehaviourStateIndex != 0)
			{
				((EnemyAI)this).SwitchToBehaviourState(0);
			}
		}

		private void FaceTarget(PlayerControllerB player)
		{
			//IL_0010: 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)
			//IL_0025: 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)
			//IL_0048: 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_0052: 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)
			if (!((Object)(object)player == (Object)null))
			{
				Vector3 val = ((Component)player).transform.position - ((Component)this).transform.position;
				val.y = 0f;
				if (!(((Vector3)(ref val)).sqrMagnitude < 0.001f))
				{
					Quaternion rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
					((Component)this).transform.rotation = rotation;
				}
			}
		}

		private void ConfigureSearchDefaults()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (base.currentSearch == null)
			{
				base.currentSearch = new AISearchRoutine();
			}
			base.currentSearch.loopSearch = true;
			base.currentSearch.randomized = true;
			base.currentSearch.searchWidth = 200f;
			base.currentSearch.searchPrecision = 5f;
		}

		private void StartFacilitySearchIfNeeded()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer && AgentCanNavigate)
			{
				ConfigureSearchDefaults();
				if (!base.currentSearch.inProgress)
				{
					((EnemyAI)this).StartSearch(((Component)this).transform.position, base.currentSearch);
				}
			}
		}

		private void StopFacilitySearch()
		{
			if (base.currentSearch != null && base.currentSearch.inProgress)
			{
				((EnemyAI)this).StopSearch(base.currentSearch, false);
			}
		}

		private void ConfigureAgent(float speed, float stoppingDistance)
		{
			if (AgentCanNavigate)
			{
				base.agent.speed = speed;
				base.agent.stoppingDistance = stoppingDistance;
			}
		}

		private void StopAgentPath()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			base.movingTowardsTargetPlayer = false;
			if (AgentCanNavigate)
			{
				base.agent.ResetPath();
				base.agent.velocity = Vector3.zero;
				base.agent.speed = 0f;
			}
		}

		private bool TryBeginFlashlightFlee()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			_lightCheckTimer += base.AIIntervalTime;
			if (_lightCheckTimer < 0.2f)
			{
				return false;
			}
			_lightCheckTimer = 0f;
			if (!TryGetFlashlightThreat(out var threatPosition, out var threatPlayer))
			{
				return false;
			}
			if ((Object)(object)threatPlayer != (Object)null)
			{
				_lastLightThreatPosition = ((Component)threatPlayer).transform.position;
			}
			StartFleeFrom(threatPosition);
			return true;
		}

		private void DoFleeing()
		{
			ConfigureAgent(FleeSpeed, 0f);
			TryRefreshFlashlightFlee();
			_fleeTimer -= base.AIIntervalTime;
			if (_fleeTimer <= 0f)
			{
				LogDebug("Flashlight flee expired; returning to facility search.");
				DropTarget(addNoticeCooldown: false);
			}
		}

		private void TryRefreshFlashlightFlee()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			_lightCheckTimer += base.AIIntervalTime;
			if (_lightCheckTimer < 0.2f)
			{
				return;
			}
			_lightCheckTimer = 0f;
			if (TryGetFlashlightThreat(out var threatPosition, out var threatPlayer))
			{
				if ((Object)(object)threatPlayer != (Object)null)
				{
					_lastLightThreatPosition = ((Component)threatPlayer).transform.position;
				}
				StartFleeFrom(threatPosition);
			}
		}

		private void StartFleeFrom(Vector3 threatPosition)
		{
			//IL_008b: 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_009c: 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_00a1: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			bool num = base.currentBehaviourStateIndex != 4;
			_fleeTimer = FleeDuration;
			base.targetPlayer = null;
			base.movingTowardsTargetPlayer = false;
			_gazeConfirmedForTarget = false;
			_loseTargetTimer = 0f;
			if (_attackCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_attackCoroutine);
				_attackCoroutine = null;
			}
			StopFacilitySearch();
			ConfigureAgent(FleeSpeed, 0f);
			if (num || Time.time >= _nextFleeRouteTime)
			{
				_nextFleeRouteTime = Time.time + 1f;
				Vector3 threat = ((threatPosition == Vector3.zero) ? _lastLightThreatPosition : threatPosition);
				if (!TrySetFleeRoute(threat) && AgentCanNavigate)
				{
					((EnemyAI)this).SetDestinationToPosition(((Component)this).transform.position, false);
				}
			}
			if (num)
			{
				((EnemyAI)this).SwitchToBehaviourState(4);
			}
		}

		private bool TrySetFleeRoute(Vector3 threat)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00a3: 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_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] allAINodes = base.allAINodes;
			if (!AgentCanNavigate || allAINodes == null || allAINodes.Length == 0)
			{
				return false;
			}
			Vector3 position = ((Component)this).transform.position;
			Vector3 val = position - threat;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			Vector2 val2 = new Vector2(position.x - threat.x, position.z - threat.z);
			float magnitude = ((Vector2)(ref val2)).magnitude;
			float num = 1600f;
			float num2 = float.PositiveInfinity;
			int num3 = -1;
			for (int i = 0; i < 6; i++)
			{
				int num4 = -1;
				float num5 = sqrMagnitude;
				for (int j = 0; j < allAINodes.Length; j++)
				{
					GameObject val3 = allAINodes[j];
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					Vector3 position2 = val3.transform.position;
					val = position2 - threat;
					float sqrMagnitude2 = ((Vector3)(ref val)).sqrMagnitude;
					if (!(sqrMagnitude2 <= num5) && !(sqrMagnitude2 > num2) && (sqrMagnitude2 != num2 || j > num3))
					{
						val = position2 - position;
						if (!(((Vector3)(ref val)).sqrMagnitude > num))
						{
							num4 = j;
							num5 = sqrMagnitude2;
						}
					}
				}
				if (num4 < 0)
				{
					return false;
				}
				num2 = num5;
				num3 = num4;
				Vector3 position3 = allAINodes[num4].transform.position;
				if (!((EnemyAI)this).PathIsIntersectedByLineOfSight(position3, false, false, false) && !PathClosesOnThreat(threat, magnitude))
				{
					((EnemyAI)this).SetDestinationToPosition(position3, false);
					return true;
				}
			}
			return false;
		}

		private bool PathClosesOnThreat(Vector3 threat, float currentDistance)
		{
			//IL_0042: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00d0: 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_00d4: 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_00ea: 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_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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Min(2.5f, currentDistance - 0.1f);
			if (num <= 0f || base.path1 == null)
			{
				return false;
			}
			Vector3[] storedPathCorners = RoundManager.Instance.storedPathCorners;
			int cornersNonAlloc = base.path1.GetCornersNonAlloc(storedPathCorners);
			float num2 = num * num;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(threat.x, 0f, threat.z);
			Vector3 val2 = default(Vector3);
			for (int i = 1; i < cornersNonAlloc; i++)
			{
				((Vector3)(ref val2))..ctor(storedPathCorners[i - 1].x, 0f, storedPathCorners[i - 1].z);
				Vector3 val3 = new Vector3(storedPathCorners[i].x, 0f, storedPathCorners[i].z) - val2;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				float num3 = ((sqrMagnitude > 0.0001f) ? Mathf.Clamp01(Vector3.Dot(val - val2, val3) / sqrMagnitude) : 0f);
				Vector3 val4 = val2 + val3 * num3 - val;
				if (((Vector3)(ref val4)).sqrMagnitude < num2)
				{
					return true;
				}
			}
			return false;
		}

		private bool TryGetFlashlightThreat(out Vector3 threatPosition, out PlayerControllerB threatPlayer)
		{
			//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_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)
			threatPosition = Vector3.zero;
			threatPlayer = null;
			if ((Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayerScripts == null)
			{
				return false;
			}
			float angleCosine = Mathf.Cos(Mathf.Clamp(FlashlightDetectionAngle, 1f, 89f) * (MathF.PI / 180f));
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (IsLivingPlayer(val) && (CheckFlashlightSource(val, FlashlightDetectionRange, angleCosine, out threatPosition) || CheckHelmetLight(val, FlashlightDetectionRange, angleCosine, out threatPosition)))
				{
					threatPlayer = val;
					_lastLightThreatPosition = threatPosition;
					return true;
				}
			}
			return false;
		}

		private bool CheckFlashlightSource(PlayerControllerB player, float range, float angleCosine, out Vector3 sourcePosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_005b: 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_0071: 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_00a2: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			sourcePosition = Vector3.zero;
			GrabbableObject currentlyHeldObjectServer = player.currentlyHeldObjectServer;
			FlashlightItem val = (FlashlightItem)(object)((currentlyHeldObjectServer is FlashlightItem) ? currentlyHeldObjectServer : null);
			if ((Object)(object)val == (Object)null || !((GrabbableObject)val).isBeingUsed)
			{
				return false;
			}
			Transform val2 = (((Object)(object)val.flashlightBulb != (Object)null) ? ((Component)val.flashlightBulb).transform : ((Component)val).transform);
			if (CheckLightBeam(val2.position, val2.forward, GetEyeFocusPosition(), range, angleCosine))
			{
				sourcePosition = val2.position;
				return true;
			}
			if ((Object)(object)val.flashlightBulbGlow != (Object)null && CheckLightBeam(((Component)val.flashlightBulbGlow).transform.position, ((Component)val.flashlightBulbGlow).transform.forward, GetEyeFocusPosition(), range, angleCosine))
			{
				sourcePosition = ((Component)val.flashlightBulbGlow).transform.position;
				return true;
			}
			return false;
		}

		private bool CheckHelmetLight(PlayerControllerB player, float range, float angleCosine, out Vector3 sourcePosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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)
			sourcePosition = Vector3.zero;
			Light helmetLight = player.helmetLight;
			if ((Object)(object)helmetLight == (Object)null || !((Behaviour)helmetLight).enabled || helmetLight.intensity <= 0f)
			{
				return false;
			}
			Transform val = (((Object)(object)player.gameplayCamera != (Object)null) ? ((Component)player.gameplayCamera).transform : ((Component)helmetLight).transform);
			if (!CheckLightBeam(val.position, val.forward, GetEyeFocusPosition(), range, angleCosine))
			{
				return false;
			}
			sourcePosition = val.position;
			return true;
		}

		private bool CheckLightBeam(Vector3 sourcePosition, Vector3 sourceForward, Vector3 detectionPoint, float range, float angleCosine)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = detectionPoint - sourcePosition;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude <= 0.01f || magnitude > range)
			{
				return false;
			}
			Vector3 val2 = val / magnitude;
			if (Vector3.Dot(((Vector3)(ref sourceForward)).normalized, val2) > angleCosine)
			{
				return HasClearLightPath(sourcePosition, detectionPoint);
			}
			return false;
		}

		private bool HasClearLightPath(Vector3 sourcePosition, Vector3 detectionPoint)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return true;
			}
			Vector3 val = detectionPoint - sourcePosition;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude <= 0.01f)
			{
				return true;
			}
			int num = Physics.RaycastNonAlloc(sourcePosition, val / magnitude, LightPathHits, magnitude, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				Collider collider = ((RaycastHit)(ref LightPathHits[i])).collider;
				if (!((Object)(object)collider == (Object)null) && !((Component)collider).transform.IsChildOf(((Component)this).transform))
				{
					return false;
				}
			}
			return true;
		}

		private void TickIdleAudio()
		{
			if (!(Time.time < _nextIdleAudioTime))
			{
				ResetIdleAudioTimer();
				if (base.currentBehaviourStateIndex == 0 || base.currentBehaviourStateIndex == 1)
				{
					BroadcastAudioCue(AudioCue.Idle, interrupt: false);
				}
			}
		}

		private void ResetIdleAudioTimer()
		{
			_nextIdleAudioTime = Time.time + Random.Range(7.5f, 14f);
		}

		private void BroadcastAudioCue(AudioCue cue, bool interrupt)
		{
			if (!base.isEnemyDead)
			{
				AudioClip[] audioPool = GetAudioPool(cue);
				if (audioPool != null && audioPool.Length != 0)
				{
					int num = ChooseAudioIndex(audioPool, _lastAudioIndices[(int)cue]);
					_lastAudioIndices[(int)cue] = num;
					PlayAudioCueClientRpc((int)cue, num, interrupt);
				}
			}
		}

		[ClientRpc]
		public void PlayAudioCueClientRpc(int cueValue, int clipIndex, bool interrupt)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3333831235u, val2, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, cueValue);
				BytePacker.WriteValueBitPacked(val, clipIndex);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref interrupt, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3333831235u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (base.isEnemyDead || !Enum.IsDefined(typeof(AudioCue), cueValue))
			{
				return;
			}
			AudioClip[] audioPool = GetAudioPool((AudioCue)cueValue);
			if (audioPool != null && clipIndex >= 0 && clipIndex < audioPool.Length)
			{
				AudioClip val3 = audioPool[clipIndex];
				if (CreatureAudio.PlayExclusive(exclusiveAudioSource, val3, interrupt))
				{
					WalkieTalkie.TransmitOneShotAudio(exclusiveAudioSource, val3, 1f);
				}
			}
		}

		private AudioClip[] GetAudioPool(AudioCue cue)
		{
			return cue switch
			{
				AudioCue.Idle => idleClips, 
				AudioCue.Vocal => vocalClips, 
				AudioCue.PlayerHit => playerHitClips, 
				AudioCue.Step => runStepClips, 
				_ => null, 
			};
		}

		private static int ChooseAudioIndex(AudioClip[] pool, int previous)
		{
			if (pool == null || pool.Length <= 1)
			{
				return 0;
			}
			int num = Random.Range(0, pool.Length);
			if (num == previous)
			{
				num = (num + Random.Range(1, pool.Length)) % pool.Length;
			}
			return num;
		}

		public void Anim_RunStep()
		{
			try
			{
				if (!base.isEnemyDead && base.currentBehaviourStateIndex != 3 && runStepClips != null && runStepClips.Length != 0)
				{
					int num = ChooseAudioIndex(runStepClips, _lastAudioIndices[3]);
					AudioClip val = runStepClips[num];
					if (CreatureAudio.PlayExclusive(exclusiveAudioSource, val, interrupt: false))
					{
						_lastAudioIndices[3] = num;
						WalkieTalkie.TransmitOneShotAudio(exclusiveAudioSource, val, 1f);
					}
				}
			}
			catch (Exception arg)
			{
				LogError($"Anim_RunStep: {arg}");
			}
		}

		public void Anim_AttackDamage()
		{
			//IL_0066: 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_0055: 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_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)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			try
			{
				_attackSwingPending = false;
				if (!((NetworkBehaviour)this).IsServer || base.isEnemyDead || ((EnemyAI)(object)this).IsStunned() || !_gazeConfirmedForTarget || !IsTargetable(base.targetPlayer) || base.currentBehaviourStateIndex == 4)
				{
					return;
				}
				if (TryGetFlashlightThreat(out var threatPosition, out var _))
				{
					StartFleeFrom(threatPosition);
				}
				else if (!(Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) > AttackRange * 1.5f) && HasClearSightToPlayer(base.targetPlayer))
				{
					Vector3 force = ((Component)base.targetPlayer).transform.position - ((Component)this).transform.position;
					force.y = 0f;
					if (((Vector3)(ref force)).sqrMagnitude < 0.01f)
					{
						force = ((Component)this).transform.forward;
					}
					force = ((Vector3)(ref force)).normalized * 12f;
					ApplyAttackDamageClientRpc(base.targetPlayer.actualClientId, AttackDamage, force, VictimRpc.TargetOnly(base.targetPlayer));
					BroadcastAudioCue(AudioCue.PlayerHit, interrupt: true);
				}
			}
			catch (Exception arg)
			{
				LogError($"Anim_AttackDamage: {arg}");
			}
		}

		[ClientRpc]
		public void ApplyAttackDamageClientRpc(ulong targetClientId, int damage, Vector3 force, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3973268519u, clientRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, targetClientId);
				BytePacker.WriteValueBitPacked(val, damage);
				((FastBufferWriter)(ref val)).WriteValueSafe(ref force);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3973268519u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val2 = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
				if (!((Object)(object)val2 == (Object)null) && !val2.isPlayerDead && VictimRpc.IsLocalVictim(targetClientId))
				{
					val2.DamagePlayer(damage, true, true, (CauseOfDeath)6, 0, false, force);
				}
			}
		}

		public override void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot = 0, int noiseID = 0)
		{
			//IL_0001: 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)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((EnemyAI)this).DetectNoise(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID);
				if (((NetworkBehaviour)this).IsServer && !base.isEnemyDead && !((EnemyAI)(object)this).IsStunned() && timesPlayedInOneSpot <= 10 && base.currentBehaviourStateIndex == 0)
				{
					_noiseMemory.Record(noisePosition, noiseLoudness, 0.5f, GetEyeFocusPosition(), 20f);
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.DetectNoise: {arg}");
			}
		}

		public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			try
			{
				((EnemyAI)this).HitEnemy(force, playerWhoHit, playHitSFX, hitID);
				if (base.isEnemyDead)
				{
					return;
				}
				base.enemyHP -= force;
				if (base.enemyHP <= 0)
				{
					if (((NetworkBehaviour)this).IsOwner)
					{
						((EnemyAI)this).KillEnemyOnOwnerClient(false);
					}
					return;
				}
				if ((Object)(object)base.creatureAnimator != (Object)null && (!_attackSwingPending || base.currentBehaviourStateIndex != 3))
				{
					base.creatureAnimator.SetTrigger("doHit");
				}
				if (((NetworkBehaviour)this).IsServer)
				{
					RetaliateAgainst(playerWhoHit);
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.HitEnemy: {arg}");
			}
		}

		private void RetaliateAgainst(PlayerControllerB attacker)
		{
			if (IsTargetable(attacker) && base.currentBehaviourStateIndex != 4 && base.currentBehaviourStateIndex != 3)
			{
				StopFacilitySearch();
				((EnemyAI)this).SetMovingTowardsTargetPlayer(attacker);
				_gazeConfirmedForTarget = true;
				_loseTargetTimer = 0f;
				ConfigureAgent(ChaseSpeed, Mathf.Max(0.25f, AttackRange * 0.65f));
				if (base.currentBehaviourStateIndex != 2)
				{
					((EnemyAI)this).SwitchToBehaviourState(2);
				}
				LogDebug("Hit by " + attacker.playerUsername + "; retaliating.");
			}
		}

		public override void KillEnemy(bool destroy = false)
		{
			try
			{
				bool flag = destroy && base.enemyType.canBeDestroyed;
				if (base.isEnemyDead && !flag)
				{
					return;
				}
				if (!flag && base.enemyType.canDie)
				{
					CreatureAudio.Stop(exclusiveAudioSource);
				}
				((EnemyAI)this).KillEnemy(destroy);
				if (!(!base.isEnemyDead || flag))
				{
					_attackSwingPending = false;
					UpdateDeathAnimation();
					StopFacilitySearch();
					StopAgentPath();
					base.targetPlayer = null;
					_gazeConfirmedForTarget = false;
					if (_attackCoroutine != null)
					{
						((MonoBehaviour)this).StopCoroutine(_attackCoroutine);
						_attackCoroutine = null;
					}
				}
			}
			catch (Exception arg)
			{
				LogError($"EyeMonsterAI.KillEnemy: {arg}");
			}
		}

		private void UpdateDeathAnimation()
		{
			//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)
			if ((Object)(object)base.creatureAnimator == (Object)null || _deathPoseFrozen)
			{
				return;
			}
			if (!_deathAnimationStarted)
			{
				PlayDeathAnimation(base.creatureAnimator);
				_deathAnimationStarted = true;
			}
			else if (!base.creatureAnimator.IsInTransition(0))
			{
				AnimatorStateInfo currentAnimatorStateInfo = base.creatureAnimator.GetCurrentAnimatorStateInfo(0);
				if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("Base Layer.DeadIdle"))
				{
					base.creatureAnimator.speed = 0f;
					_deathPoseFrozen = true;
				}
			}
		}

		private static void PlayDeathAnimation(Animator animator)
		{
			((Behaviour)animator).enabled = true;
			animator.cullingMode = (AnimatorCullingMode)0;
			animator.speed = 1f;
			animator.SetBool("isWalking", false);
			animator.SetBool("Dead", true);
			animator.ResetTrigger("doAttack");
			animator.ResetTrigger("doHit");
			animator.ResetTrigger("doDeath");
			animator.ResetTrigger("KillEnemy");
			animator.Play("Base Layer.Dead", 0, 0f);
		}

		public override void OnDestroy()
		{
			CreatureAudio.Stop(exclusiveAudioSource);
			((EnemyAI)this).OnDestroy();
		}

		protected override void __initializeVariables()
		{
			((EnemyAI)this).__initializeVariables();
		}

		protected override void __initiali