using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Coroner;
using DropDaDeuce.LethalGargoyles.NetcodePatcher;
using EnhancedMonsters.Utils;
using GameNetcodeStuff;
using HarmonyLib;
using LethalGargoyles.src.Config;
using LethalGargoyles.src.Enemy;
using LethalGargoyles.src.Patch;
using LethalGargoyles.src.Scrap;
using LethalGargoyles.src.SoftDepends;
using LethalGargoyles.src.Utility;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using NVorbis;
using PathfindingLib.API.SmartPathfinding;
using PathfindingLib.Utilities;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;

[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("DropDaDeuce.LethalGargoyles")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.7.0.0")]
[assembly: AssemblyInformationalVersion("0.7.0+decb0d8ae524aa7571f98698b2ac30bfa5b0f4d3")]
[assembly: AssemblyProduct("LethalGargoyles")]
[assembly: AssemblyTitle("DropDaDeuce.LethalGargoyles")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.7.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalGargoyles
{
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "DropDaDeuce.LethalGargoyles";

		public const string PLUGIN_NAME = "LethalGargoyles";

		public const string PLUGIN_VERSION = "0.7.0";
	}
}
namespace LethalGargoyles.src
{
	[BepInPlugin("DropDaDeuce.LethalGargoyles", "LethalGargoyles", "0.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger = null;

		internal static readonly Harmony harmony = new Harmony("LethalLib");

		public static AssetBundle? ModAssets;

		public AudioClip? stepSound;

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

		public static Plugin Instance { get; private set; } = null;


		internal static PluginConfig BoundConfig { get; private set; } = null;


		public bool IsCoronerLoaded { get; private set; }

		public bool IsEmployeeClassesLoaded { get; private set; }

		public bool IsEnhancedMonstersLoaded { get; private set; }

		public static string? CustomAudioFolderPath { get; private set; }

		[Conditional("DEBUG")]
		public void LogIfDebugBuild(string text)
		{
			Logger.LogInfo((object)text);
		}

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			BoundConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			IsCoronerLoaded = DepIsLoaded("com.elitemastereric.coroner");
			IsEmployeeClassesLoaded = DepIsLoaded("Jade.EmployeeClasses");
			IsEnhancedMonstersLoaded = DepIsLoaded("com.velddev.enhancedmonsters");
			Instance = this;
			InitializeNetworkBehaviours();
			string path = "gargoyleassets";
			ModAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), path));
			if ((Object)(object)ModAssets == (Object)null)
			{
				Logger.LogError((object)"Failed to load custom assets.");
				return;
			}
			CustomAudioFolderPath = Path.Combine(Path.GetDirectoryName(Paths.ExecutablePath), "Lethal Gargoyles", "Custom Voice Lines");
			if (!Directory.Exists(CustomAudioFolderPath))
			{
				try
				{
					Directory.CreateDirectory(CustomAudioFolderPath);
				}
				catch (Exception arg)
				{
					Logger.LogError((object)$"Failed to create custom audio directory: {arg}");
					return;
				}
			}
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Combat Dialog", "Attack"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Combat Dialog", "Hit"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Activity"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Aggro"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Enemy"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Gargoyle Death"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - General"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Player Death"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Prior Death", "Coroner"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - EmployeeClass"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - SteamIDs"));
			EnemyType val = ModAssets.LoadAsset<EnemyType>("LethalGargoyle");
			TerminalNode val2 = ModAssets.LoadAsset<TerminalNode>("LethalGargoyleTN");
			TerminalKeyword val3 = ModAssets.LoadAsset<TerminalKeyword>("LethalGargoyleTK");
			NetworkPrefabs.RegisterNetworkPrefab(val.enemyPrefab);
			Enemies.RegisterEnemy(val, BoundConfig.SpawnWeight.Value, (LevelTypes)(-1), val2, val3);
			harmony.PatchAll();
			Logger.LogInfo((object)("Checking Soft Dependencies:\nCoroner Is Loaded? " + IsCoronerLoaded + "\nEmployeeClasses Is Loaded? " + IsEmployeeClassesLoaded + "\nEnhancedMonsters Is Loaded? " + IsEnhancedMonstersLoaded));
			if (IsCoronerLoaded)
			{
				CoronerClass.Init();
			}
			defaultAudioClipFilePaths = GetDefaultAudioClipFilePaths();
			BoundConfig.InitializeAudioClipConfigs(defaultAudioClipFilePaths);
			if (BoundConfig.enableScrap.Value)
			{
				int value = BoundConfig.scrapWeight.Value;
				Item val4 = ModAssets.LoadAsset<Item>("Assets/ModAssets/LethalGargoyle/Scrap/GargoyleScrap.asset");
				GargoyleStatue gargoyleStatue = val4.spawnPrefab.AddComponent<GargoyleStatue>();
				((GrabbableObject)gargoyleStatue).grabbable = true;
				((GrabbableObject)gargoyleStatue).grabbableToEnemies = true;
				((GrabbableObject)gargoyleStatue).itemProperties = val4;
				Utilities.FixMixerGroups(val4.spawnPrefab);
				NetworkPrefabs.RegisterNetworkPrefab(val4.spawnPrefab);
				Items.RegisterScrap(val4, value, (LevelTypes)(-1));
				Logger.LogInfo((object)"Gargoyle Statue scrap is registered.");
			}
			stepSound = ModAssets.LoadAsset<AudioClip>("Assets/ModAssets/LethalGargoyle/Audio/sfx_Step.ogg");
			Logger.LogInfo((object)"Plugin DropDaDeuce.LethalGargoyles is loaded!");
		}

		private void OnEnable()
		{
			if (IsEnhancedMonstersLoaded)
			{
				EnhancedMonstersCompatibilityLayer.RegisterCustomMonsterEnemyData();
				Logger.LogInfo((object)"Gargoyle has been registered with EnhancedMonsters.");
			}
		}

		private static void InitializeNetworkBehaviours()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				if (type.FullName == "LethalGargoyles.src.SoftDepends.CoronerClass" && !Instance.IsCoronerLoaded)
				{
					continue;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		private bool DepIsLoaded(string pGUID)
		{
			try
			{
				return Chainloader.PluginInfos.ContainsKey(pGUID);
			}
			catch
			{
				return false;
			}
		}

		private Dictionary<string, List<string>> GetDefaultAudioClipFilePaths()
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>
			{
				{
					"General",
					new List<string>()
				},
				{
					"Aggro",
					new List<string>()
				},
				{
					"Enemy",
					new List<string>()
				},
				{
					"PlayerDeath",
					new List<string>()
				},
				{
					"GargoyleDeath",
					new List<string>()
				},
				{
					"PriorDeath",
					new List<string>()
				},
				{
					"Attack",
					new List<string>()
				},
				{
					"Hit",
					new List<string>()
				},
				{
					"Activity",
					new List<string>()
				},
				{
					"SteamIDs",
					new List<string>()
				}
			};
			if (Instance.IsEmployeeClassesLoaded)
			{
				dictionary.Add("Class", new List<string>());
			}
			foreach (KeyValuePair<string, List<string>> item in dictionary)
			{
				string key = item.Key;
				List<string> value = item.Value;
				FileInfo[] mP3Files = AudioManager.GetMP3Files(key, "Voice Lines");
				FileInfo[] array = mP3Files;
				foreach (FileInfo fileInfo in array)
				{
					value.Add(fileInfo.FullName);
				}
				if (key == "PriorDeath" && Instance.IsCoronerLoaded)
				{
					FileInfo[] mP3Files2 = AudioManager.GetMP3Files("Coroner", "Voice Lines");
					FileInfo[] array2 = mP3Files2;
					foreach (FileInfo fileInfo2 in array2)
					{
						value.Add(fileInfo2.FullName);
					}
				}
				if (Instance.IsEmployeeClassesLoaded && key == "Class")
				{
					FileInfo[] mP3Files3 = AudioManager.GetMP3Files("EmployeeClass", "Voice Lines");
					FileInfo[] array3 = mP3Files3;
					foreach (FileInfo fileInfo3 in array3)
					{
						value.Add(fileInfo3.FullName);
					}
				}
			}
			return dictionary;
		}
	}
}
namespace LethalGargoyles.src.Utility
{
	public class AudioManager : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <LoadAudioClip>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string filePath;

			public string category;

			private UnityWebRequest <webRequest>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Invalid comparison between Unknown and I4
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string text = Path.GetExtension(filePath).ToLower();
					AudioType val = ((!(text == ".ogg")) ? ((AudioType)0) : ((AudioType)14));
					AudioType val2 = val;
					if ((int)val2 == 0)
					{
						Plugin.Logger.LogError((object)("Unsupported audio file format: " + filePath));
						return false;
					}
					<webRequest>5__2 = UnityWebRequestMultimedia.GetAudioClip(filePath, val2);
					<>2__current = <webRequest>5__2.SendWebRequest();
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					if ((int)<webRequest>5__2.result == 3)
					{
						Plugin.Logger.LogError((object)<webRequest>5__2.error);
					}
					else
					{
						AudioClip content = DownloadHandlerAudioClip.GetContent(<webRequest>5__2);
						List<AudioClip> clipListByCategory = GetClipListByCategory(category);
						((Object)content).name = Path.GetFileNameWithoutExtension(filePath);
						clipListByCategory.Add(content);
						Plugin.Logger.LogInfo((object)("Loaded clip: " + ((Object)content).name + " | Catagory: " + category));
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public byte[] audioData;

			public string clipName;

			public string category;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Expected O, but got Unknown
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				VorbisReader val = new VorbisReader((Stream)new MemoryStream(audioData, writable: false), true);
				try
				{
					float[] array = new float[val.TotalSamples];
					AudioClip val2 = AudioClip.Create(clipName, (int)(val.TotalSamples / val.Channels), val.Channels, val.SampleRate, false);
					int num = val.ReadSamples(array, 0, (int)val.TotalSamples);
					val2.SetData(array, 0);
					List<AudioClip> clipListByCategory = GetClipListByCategory(category);
					clipListByCategory.Add(val2);
					Plugin.Logger.LogInfo((object)("Clip Loaded: " + ((Object)val2).name));
					return false;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}

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

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

		public static List<AudioClip> tauntClips = new List<AudioClip>();

		public static List<AudioClip> aggroClips = new List<AudioClip>();

		public static List<AudioClip> enemyClips = new List<AudioClip>();

		public static List<AudioClip> playerDeathClips = new List<AudioClip>();

		public static List<AudioClip> deathClips = new List<AudioClip>();

		public static List<AudioClip> priorDeathClips = new List<AudioClip>();

		public static List<AudioClip> activityClips = new List<AudioClip>();

		public static List<AudioClip> attackClips = new List<AudioClip>();

		public static List<AudioClip> hitClips = new List<AudioClip>();

		public static List<AudioClip> classClips = new List<AudioClip>();

		public static List<AudioClip> playerClips = new List<AudioClip>();

		public static AudioManager? Instance;

		private readonly Dictionary<ulong, bool> clientReady = new Dictionary<ulong, bool>();

		public static Dictionary<string, List<string>> AudioClipFilePaths { get; private set; } = new Dictionary<string, List<string>>();


		[Conditional("DEBUG")]
		private static void LogIfDebugBuild(string text)
		{
			Plugin.Logger.LogInfo((object)text);
		}

		public override void OnNetworkSpawn()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instance = this;
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("SendLGAudioClip", new HandleNamedMessageDelegate(OnReceivedMessage));
			Plugin.Logger.LogInfo((object)"Registered message handler for 'SendLGAudioClip'");
			if (((NetworkBehaviour)this).IsServer)
			{
				NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnectedCallback;
				NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnectedCallback;
			}
			else
			{
				Plugin.Logger.LogInfo((object)$"Connected to host with ID: {NetworkManager.Singleton.LocalClientId}");
			}
			if (((NetworkBehaviour)this).IsHost)
			{
				Plugin.Logger.LogInfo((object)"Creating Audio Clip List");
				LoadClipList(Plugin.defaultAudioClipFilePaths);
				LoadAudioClipsFromConfig();
			}
		}

		public override void OnNetworkDespawn()
		{
			Plugin.Logger.LogInfo((object)"Clearing clip lists");
			tauntClips.Clear();
			aggroClips.Clear();
			enemyClips.Clear();
			playerDeathClips.Clear();
			deathClips.Clear();
			priorDeathClips.Clear();
			activityClips.Clear();
			attackClips.Clear();
			hitClips.Clear();
			classClips.Clear();
			playerClips.Clear();
			if (((NetworkBehaviour)this).IsServer)
			{
				NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnectedCallback;
				NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnectedCallback;
			}
		}

		[IteratorStateMachine(typeof(<LogClipCounts>d__20))]
		private IEnumerator LogClipCounts()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LogClipCounts>d__20(0);
		}

		private void OnClientConnectedCallback(ulong clientId)
		{
			Plugin.Logger.LogInfo((object)$"Client connected: {clientId}");
			if (!clientReady.ContainsKey(clientId))
			{
				clientReady.Add(clientId, value: true);
			}
			SendAudioClipsDelayed(clientId);
		}

		private void OnClientDisconnectedCallback(ulong clientId)
		{
			if (clientReady.ContainsKey(clientId))
			{
				clientReady.Remove(clientId);
			}
		}

		public async void SendAudioClipsDelayed(ulong clientId)
		{
			bool isPlayerFullyLoaded = false;
			List<ulong> fullyLoadedPlayers = StartOfRound.Instance.fullyLoadedPlayers;
			CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
			cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(10.0));
			await Task.Run(delegate
			{
				while (!isPlayerFullyLoaded || !clientReady.ContainsKey(clientId))
				{
					for (int i = 0; i < fullyLoadedPlayers.Count; i++)
					{
						if (fullyLoadedPlayers[i] == clientId)
						{
							isPlayerFullyLoaded = true;
							break;
						}
					}
					Task.Yield();
				}
			}, cancellationTokenSource.Token);
			foreach (KeyValuePair<string, List<string>> audioClipFilePath in AudioClipFilePaths)
			{
				string category = audioClipFilePath.Key;
				List<string> value = audioClipFilePath.Value;
				GetClipListByCategory(category);
				foreach (string item in value)
				{
					string clipName = Path.GetFileNameWithoutExtension(item);
					byte[] audioData2;
					if (PluginConfig.AudioClipEnableConfig.TryGetValue(clipName, out ConfigEntry<bool> value2))
					{
						if (!value2.Value)
						{
							continue;
						}
						audioData2 = AudioFileToByteArray(item);
						byte[] array = audioData2;
						if (array != null && array.Length > 512000)
						{
							Plugin.Logger.LogError((object)("Sending Clip(" + clipName + ") failed. Max clip size is 512000 bytes or 500KB"));
							break;
						}
						if (audioData2 != null)
						{
							await WaitForClientReady(clientId);
							if (!clientReady.ContainsKey(clientId))
							{
								break;
							}
							await SendAudioClipToClient(clientId, audioData2, clipName, category);
							clientReady[clientId] = false;
							SetClientReadyClientRpc(isReady: false, clientId);
							Plugin.Logger.LogInfo((object)$"Sent Clip({clipName}) to ClientID({clientId})");
						}
						continue;
					}
					audioData2 = AudioFileToByteArray(item);
					byte[] array2 = audioData2;
					if (array2 != null && array2.Length > 512000)
					{
						Plugin.Logger.LogError((object)("Sending Clip(" + clipName + ") failed. Max clip size is 512000 bytes or 500KB"));
						break;
					}
					if (audioData2 != null)
					{
						await WaitForClientReady(clientId);
						if (!clientReady.ContainsKey(clientId))
						{
							break;
						}
						await SendAudioClipToClient(clientId, audioData2, clipName, category);
						clientReady[clientId] = false;
						SetClientReadyClientRpc(isReady: false, clientId);
						Plugin.Logger.LogInfo((object)$"Sent Clip({clipName}) to ClientID({clientId})");
					}
				}
			}
		}

		private async Task WaitForClientReady(ulong clientId)
		{
			CancellationTokenSource cts = new CancellationTokenSource();
			cts.CancelAfter(TimeSpan.FromSeconds(5.0));
			try
			{
				await Task.Run(async delegate
				{
					while (!clientReady[clientId])
					{
						await Task.Delay(100, cts.Token);
					}
				}, cts.Token);
			}
			catch (OperationCanceledException)
			{
				if (!clientReady.ContainsKey(clientId))
				{
					Plugin.Logger.LogWarning((object)$"Client {clientId} is disconnected.");
					return;
				}
				Plugin.Logger.LogWarning((object)$"Client {clientId} did not respond within the timeout, trying to send clip anyways.");
				clientReady[clientId] = true;
			}
		}

		private byte[]? AudioFileToByteArray(string filePath)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			AudioType val = (AudioType)(Path.GetExtension(filePath).ToLower() switch
			{
				".mp3" => 13, 
				".wav" => 20, 
				".ogg" => 14, 
				_ => 0, 
			});
			if ((int)val == 0)
			{
				Plugin.Logger.LogError((object)("Unsupported audio file format: " + filePath));
				return null;
			}
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(filePath, val);
			audioClip.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			UnityWebRequestAsyncOperation val2 = audioClip.SendWebRequest();
			while (!((AsyncOperation)val2).isDone)
			{
				Task.Yield();
			}
			if ((int)audioClip.result == 3)
			{
				Plugin.Logger.LogError((object)audioClip.error);
				return null;
			}
			return audioClip.downloadHandler.data;
		}

		private async Task SendAudioClipToClient(ulong clientId, byte[] audioData, string clipName, string category)
		{
			int num = audioData.Length + 200;
			FastBufferWriter writer = new FastBufferWriter(num, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(category, false);
				((FastBufferWriter)(ref writer)).WriteValueSafe(clipName, false);
				if (((FastBufferWriter)(ref writer)).Capacity < audioData.Length)
				{
					Plugin.Logger.LogError((object)"Writer Capacity is less than clip size!");
					return;
				}
				int num2 = audioData.Length;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteBytesSafe(audioData, audioData.Length, 0);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("SendLGAudioClip", clientId, writer, (NetworkDelivery)4);
				await Task.Yield();
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref writer)).Dispose();
			}
		}

		public void OnReceivedMessage(ulong clientId, FastBufferReader messagePayload)
		{
			//IL_003c: 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 (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				SetClientReadyServerRpc(isReady: true, NetworkManager.Singleton.LocalClientId);
				string category = default(string);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe(ref category, false);
				string clipName = default(string);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe(ref clipName, false);
				int num = default(int);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				byte[] audioData = new byte[num];
				((FastBufferReader)(ref messagePayload)).ReadBytesSafe(ref audioData, num, 0);
				((MonoBehaviour)this).StartCoroutine(ProcessAudioClip(audioData, clipName, category));
			}
		}

		[IteratorStateMachine(typeof(<ProcessAudioClip>d__28))]
		private IEnumerator ProcessAudioClip(byte[] audioData, string clipName, string category)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessAudioClip>d__28(0)
			{
				audioData = audioData,
				clipName = clipName,
				category = category
			};
		}

		private void LoadAudioClipsFromConfig()
		{
			foreach (KeyValuePair<string, List<string>> audioClipFilePath in AudioClipFilePaths)
			{
				string key = audioClipFilePath.Key;
				List<string> value = audioClipFilePath.Value;
				List<AudioClip> clipListByCategory = GetClipListByCategory(key);
				foreach (string item in value)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
					if (PluginConfig.AudioClipEnableConfig.TryGetValue(fileNameWithoutExtension, out ConfigEntry<bool> value2))
					{
						if (value2.Value)
						{
							((MonoBehaviour)this).StartCoroutine(LoadAudioClip(item, key));
						}
					}
					else
					{
						((MonoBehaviour)this).StartCoroutine(LoadAudioClip(item, key));
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<LoadAudioClip>d__30))]
		private IEnumerator LoadAudioClip(string filePath, string category)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudioClip>d__30(0)
			{
				filePath = filePath,
				category = category
			};
		}

		public static List<AudioClip> GetClipListByCategory(string category)
		{
			return category switch
			{
				"General" => tauntClips, 
				"Aggro" => aggroClips, 
				"Enemy" => enemyClips, 
				"PlayerDeath" => playerDeathClips, 
				"GargoyleDeath" => deathClips, 
				"PriorDeath" => priorDeathClips, 
				"Activity" => activityClips, 
				"Class" => classClips, 
				"Attack" => attackClips, 
				"Hit" => hitClips, 
				"SteamIDs" => playerClips, 
				_ => throw new ArgumentException("Invalid audio clip category: " + category), 
			};
		}

		public void LoadClipList(Dictionary<string, List<string>> defaultAudioClipFilePaths)
		{
			AudioClipFilePaths = defaultAudioClipFilePaths;
			foreach (KeyValuePair<string, List<string>> audioClipFilePath in AudioClipFilePaths)
			{
				string key = audioClipFilePath.Key;
				List<string> value = audioClipFilePath.Value;
				FileInfo[] mP3Files = GetMP3Files(key, "Custom Voice Lines");
				FileInfo[] array = mP3Files;
				foreach (FileInfo fileInfo in array)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
					bool flag = false;
					for (int j = 0; j < value.Count; j++)
					{
						string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(value[j]);
						if (fileNameWithoutExtension == fileNameWithoutExtension2)
						{
							value[j] = fileInfo.FullName;
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						value.Add(fileInfo.FullName);
					}
				}
				if (key == "PriorDeath" && Plugin.Instance.IsCoronerLoaded)
				{
					FileInfo[] mP3Files2 = GetMP3Files("Coroner", "Voice Lines");
					FileInfo[] mP3Files3 = GetMP3Files("Coroner", "Custom Voice Lines");
					FileInfo[] array2 = mP3Files2;
					foreach (FileInfo fileInfo2 in array2)
					{
						value.Add(fileInfo2.FullName);
					}
					FileInfo[] array3 = mP3Files3;
					foreach (FileInfo fileInfo3 in array3)
					{
						string fileNameWithoutExtension3 = Path.GetFileNameWithoutExtension(fileInfo3.FullName);
						bool flag2 = false;
						for (int m = 0; m < value.Count; m++)
						{
							string fileNameWithoutExtension4 = Path.GetFileNameWithoutExtension(value[m]);
							if (fileNameWithoutExtension3 == fileNameWithoutExtension4)
							{
								value[m] = fileInfo3.FullName;
								flag2 = true;
								break;
							}
						}
						if (!flag2)
						{
							value.Add(fileInfo3.FullName);
						}
					}
				}
				if (!Plugin.Instance.IsEmployeeClassesLoaded || !(key == "Class"))
				{
					continue;
				}
				FileInfo[] mP3Files4 = GetMP3Files("EmployeeClass", "Voice Lines");
				FileInfo[] mP3Files5 = GetMP3Files("EmployeeClass", "Custom Voice Lines");
				FileInfo[] array4 = mP3Files4;
				foreach (FileInfo fileInfo4 in array4)
				{
					value.Add(fileInfo4.FullName);
				}
				FileInfo[] array5 = mP3Files5;
				foreach (FileInfo fileInfo5 in array5)
				{
					string fileNameWithoutExtension5 = Path.GetFileNameWithoutExtension(fileInfo5.FullName);
					bool flag3 = false;
					for (int num2 = 0; num2 < value.Count; num2++)
					{
						string fileNameWithoutExtension6 = Path.GetFileNameWithoutExtension(value[num2]);
						if (fileNameWithoutExtension5 == fileNameWithoutExtension6)
						{
							value[num2] = fileInfo5.FullName;
							flag3 = true;
							break;
						}
					}
					if (!flag3)
					{
						value.Add(fileInfo5.FullName);
					}
				}
			}
		}

		public static FileInfo[] GetMP3Files(string type, string folderName)
		{
			string text = ((folderName == "Voice Lines") ? Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), folderName) : ((!(folderName == "Custom Voice Lines")) ? Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), folderName) : Plugin.CustomAudioFolderPath));
			string path = text;
			switch (type)
			{
			case "General":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - General"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Aggro":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Aggro"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Enemy":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Enemy"));
				return directoryInfo.GetFiles("*.*");
			}
			case "PlayerDeath":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Player Death"));
				return directoryInfo.GetFiles("*.*");
			}
			case "GargoyleDeath":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Gargoyle Death"));
				return directoryInfo.GetFiles("*.*");
			}
			case "PriorDeath":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Prior Death"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Coroner":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Prior Death", "Coroner"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Class":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - EmployeeClass"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Activity":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - Activity"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Attack":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Combat Dialog", "Attack"));
				return directoryInfo.GetFiles("*.*");
			}
			case "Hit":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Combat Dialog", "Hit"));
				return directoryInfo.GetFiles("*.*");
			}
			case "SteamIDs":
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(path, "Taunt - SteamIDs"));
				return directoryInfo.GetFiles("*.*");
			}
			default:
				return Array.Empty<FileInfo>();
			}
		}

		[ClientRpc]
		private void SetClientReadyClientRpc(bool isReady, ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_007d: 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)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2917554051u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isReady, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2917554051u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (clientReady.ContainsKey(NetworkManager.Singleton.LocalClientId) && NetworkManager.Singleton.LocalClientId == clientId)
				{
					clientReady[NetworkManager.Singleton.LocalClientId] = isReady;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetClientReadyServerRpc(bool isReady, ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_007d: 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)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1384767487u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isReady, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1384767487u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (clientReady.ContainsKey(clientId))
				{
					clientReady[clientId] = isReady;
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2917554051u, new RpcReceiveHandler(__rpc_handler_2917554051), "SetClientReadyClientRpc");
			((NetworkBehaviour)this).__registerRpc(1384767487u, new RpcReceiveHandler(__rpc_handler_1384767487), "SetClientReadyServerRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2917554051(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isReady = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isReady, default(ForPrimitives));
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((AudioManager)(object)target).SetClientReadyClientRpc(isReady, clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1384767487(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isReady = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isReady, default(ForPrimitives));
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((AudioManager)(object)target).SetClientReadyServerRpc(isReady, clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "AudioManager";
		}
	}
}
namespace LethalGargoyles.src.SoftDepends
{
	internal class CoronerClass
	{
		public static object? GargoyleDeath { get; private set; }

		public static object? GargoylePushDeath { get; private set; }

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			//IL_0005: 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)
			try
			{
				GargoyleDeath = API.Register("DeathEnemyLGargoyle");
				GargoylePushDeath = API.Register("DeathEnemyGargoylePush");
				Plugin.Logger.LogInfo((object)"Gargoyle causes of death registered with Coroner.");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Skipping Coroner initialization. Exception: {arg}");
			}
		}

		internal static void CoronerSetCauseOfDeath(PlayerControllerB player, string deathType)
		{
			//IL_002e: 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 (!(deathType == "Attack"))
			{
				if (deathType == "Push" && GargoylePushDeath != null)
				{
					SetCauseOfDeath((int)player.playerClientId, (AdvancedCauseOfDeath)GargoylePushDeath);
				}
			}
			else if (GargoyleDeath != null)
			{
				SetCauseOfDeath((int)player.playerClientId, (AdvancedCauseOfDeath)GargoyleDeath);
			}
		}

		internal static void SetCauseOfDeath(int playerId, AdvancedCauseOfDeath cause)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Type type = typeof(Plugin).Assembly.GetType("Coroner.AdvancedDeathTracker");
			if (type != null)
			{
				MethodInfo method = type.GetMethod("SetCauseOfDeath", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(int),
					typeof(AdvancedCauseOfDeath),
					typeof(bool)
				}, null);
				method?.Invoke(null, new object[3] { playerId, cause, true });
				_ = method != null;
			}
		}

		internal static string? CoronerGetCauseOfDeath(PlayerControllerB player)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			AdvancedCauseOfDeath? causeOfDeath = API.GetCauseOfDeath(player);
			if (causeOfDeath.HasValue)
			{
				AdvancedCauseOfDeath value = causeOfDeath.Value;
				return Regex.Replace(((AdvancedCauseOfDeath)(ref value)).GetLanguageTag(), "Death", "");
			}
			return null;
		}
	}
	internal class EmployeeClassesClass
	{
		[Conditional("DEBUG")]
		private static void LogIfDebugBuild(string text)
		{
			Plugin.Logger.LogInfo((object)text);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static string? GetPlayerClass(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			try
			{
				if (Chainloader.PluginInfos.TryGetValue("Jade.EmployeeClasses", out var value))
				{
					Type type = ((object)value.Instance).GetType().Assembly.GetType("EmployeeClasses.Roles.RoleManager");
					if (type != null)
					{
						Component component = ((Component)player).GetComponent(type);
						if ((Object)(object)component != (Object)null)
						{
							FieldInfo field = type.GetField("selectedRole", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (field != null)
							{
								string text = (string)field.GetValue(component);
								if (text == null)
								{
									return null;
								}
								return text;
							}
						}
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error getting player class from EmployeeClasses: {arg}");
				return null;
			}
			return null;
		}
	}
	public static class EnhancedMonstersCompatibilityLayer
	{
		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void RegisterCustomMonsterEnemyData()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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)
			EnemyMetadata val = default(EnemyMetadata);
			((EnemyMetadata)(ref val))..ctor();
			val.MeshOffset = Vec3.op_Implicit(new Vector3(0f, 0f, 0f));
			val.FloorRotation = Vec3.op_Implicit(new Vector3(0f, 90f, 0f));
			val.HandRotation = Vec3.op_Implicit(new Vector3(0f, 90f, 0f));
			val.AnimateOnDeath = false;
			EnemyMetadata val2 = val;
			EnemiesDataManager.RegisterEnemy("LethalGargoyle", true, 70, 90, 30f, "B", val2, false);
		}
	}
}
namespace LethalGargoyles.src.Scrap
{
	internal class GargoyleStatue : GrabbableObject
	{
		[CompilerGenerated]
		private sealed class <PlayNoiseWhileTalking>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GargoyleStatue <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				int num = <>1__state;
				GargoyleStatue gargoyleStatue = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)gargoyleStatue.scrapAudio != (Object)null && gargoyleStatue.scrapAudio.isPlaying)
				{
					RoundManager.Instance.PlayAudibleNoise(((Component)gargoyleStatue).transform.position, gargoyleStatue.scrapAudio.maxDistance / 1.2f, gargoyleStatue.scrapAudio.volume, 0, false, 0);
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		private AudioSource? scrapAudio;

		private static int lastTaunt;

		private float distWarnSqr;

		private float dogCooldown;

		private bool dogHear;

		private float lastDogCheck;

		private static float lastDogTaunt;

		[Conditional("DEBUG")]
		private void LogIfDebugBuild(string text)
		{
			Plugin.Logger.LogInfo((object)text);
		}

		public override void Start()
		{
			((GrabbableObject)this).Start();
			scrapAudio = ((Component)this).GetComponentInParent<AudioSource>();
			distWarnSqr = Plugin.BoundConfig.distWarn.Value;
			dogCooldown = Plugin.BoundConfig.dogCooldown.Value;
			dogHear = Plugin.BoundConfig.dogHear.Value;
			distWarnSqr *= distWarnSqr;
			lastDogTaunt = Time.time - dogCooldown;
		}

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if ((Object)(object)scrapAudio != (Object)null && dogHear && Time.time - lastDogTaunt > dogCooldown && Time.time - lastDogCheck > 1f && !scrapAudio.isPlaying)
			{
				lastDogCheck = Time.time;
				if (DogNearStatue() && LethalGargoylesAI.ChooseRandomClip("taunt_enemy_Mouthdog", "Enemy", out string audioClip) && audioClip != null)
				{
					lastDogTaunt = Time.time;
					TauntClientRpc(audioClip, "enemy");
				}
			}
		}

		private bool DogNearStatue()
		{
			//IL_0020: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				Vector3 val = ((Component)spawnedEnemy).transform.position - ((Component)this).transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (!(sqrMagnitude > distWarnSqr) && string.Equals(spawnedEnemy.enemyType.enemyName, "MouthDog", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (((NetworkBehaviour)this).IsServer && (Object)(object)scrapAudio != (Object)null && !scrapAudio.isPlaying)
			{
				ItemActivateServerRpc(used, buttonDown);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ItemActivateServerRpc(bool used, bool buttonDown)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_007d: 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)
			//IL_0098: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3724832850u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref used, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref buttonDown, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3724832850u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					GeneralTaunt();
				}
			}
		}

		public void GeneralTaunt()
		{
			List<AudioClip> tauntClips = AudioManager.tauntClips;
			if ((Object)(object)base.playerHeldBy != (Object)null)
			{
				AudioClip val = LethalGargoylesAI.FindClip($"{base.playerHeldBy.playerSteamId}", AudioManager.playerClips);
				if ((Object)(object)val != (Object)null)
				{
					tauntClips.Add(val);
				}
			}
			if (tauntClips.Count > 0)
			{
				int num = Random.Range(0, tauntClips.Count);
				if (num == lastTaunt)
				{
					num++;
				}
				lastTaunt = num;
				TauntClientRpc(((Object)tauntClips[num]).name, "general");
			}
		}

		[ClientRpc]
		private void TauntClientRpc(string clipName, string clipType)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3274531793u, val, (RpcDelivery)0);
				bool flag = clipName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(clipName, false);
				}
				bool flag2 = clipType != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(clipType, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3274531793u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			List<AudioClip> list = new List<AudioClip>();
			switch (clipType)
			{
			case "general":
				list = AudioManager.tauntClips;
				break;
			case "enemy":
				list = AudioManager.enemyClips;
				break;
			case "aggro":
				list = AudioManager.aggroClips;
				break;
			case "death":
				list = AudioManager.deathClips;
				break;
			case "attack":
				list = AudioManager.attackClips;
				break;
			case "hit":
				list = AudioManager.hitClips;
				break;
			case "priordeath":
				list = AudioManager.priorDeathClips;
				break;
			case "playerdeath":
				list = AudioManager.playerDeathClips;
				break;
			case "class":
				list = AudioManager.classClips;
				break;
			case "activity":
				list = AudioManager.activityClips;
				break;
			case "steamids":
				list = AudioManager.playerClips;
				break;
			}
			AudioClip val3 = LethalGargoylesAI.FindClip(clipName, list);
			if (list.Count > 0 && (Object)(object)val3 != (Object)null && (Object)(object)scrapAudio != (Object)null)
			{
				scrapAudio.PlayOneShot(val3);
				if (dogHear)
				{
					((MonoBehaviour)this).StartCoroutine(PlayNoiseWhileTalking());
				}
			}
		}

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

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3724832850u, new RpcReceiveHandler(__rpc_handler_3724832850), "ItemActivateServerRpc");
			((NetworkBehaviour)this).__registerRpc(3274531793u, new RpcReceiveHandler(__rpc_handler_3274531793), "TauntClientRpc");
			((GrabbableObject)this).__initializeRpcs();
		}

		private static void __rpc_handler_3724832850(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool used = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref used, default(ForPrimitives));
				bool buttonDown = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref buttonDown, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GargoyleStatue)(object)target).ItemActivateServerRpc(used, buttonDown);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3274531793(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0067: 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_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string clipName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref clipName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string clipType = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref clipType, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GargoyleStatue)(object)target).TauntClientRpc(clipName, clipType);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "GargoyleStatue";
		}
	}
}
namespace LethalGargoyles.src.Patch
{
	[HarmonyPatch(typeof(DoorLock), "OnTriggerStay")]
	public class HarmonyDoorPatch
	{
		private static readonly FieldInfo enemyDoorMeterField = typeof(DoorLock).GetField("enemyDoorMeter", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPostfix]
		private static void PostFixOnTriggerStay(DoorLock __instance, Collider other)
		{
			if ((Object)(object)other == (Object)null || (Object)(object)((Component)other).GetComponent<EnemyAICollisionDetect>() == (Object)null || (Object)(object)((Component)other).GetComponent<EnemyAICollisionDetect>().mainScript == (Object)null || !(((Component)other).GetComponent<EnemyAICollisionDetect>().mainScript is LethalGargoylesAI lethalGargoylesAI))
			{
				return;
			}
			if (enemyDoorMeterField != null)
			{
				float num = (float)enemyDoorMeterField.GetValue(__instance);
				if (num <= 0f && (Object)(object)lethalGargoylesAI.currentDoor == (Object)null)
				{
					lethalGargoylesAI.currentDoor = __instance;
					lethalGargoylesAI.lastDoorCloseTime = Time.time;
				}
			}
			else
			{
				Plugin.Logger.LogWarning((object)"enemyDoorMeter field not found in DoorLock.");
			}
		}
	}
	[HarmonyPatch(typeof(EnemyAI), "HitEnemy")]
	public class KillEnemyPatch
	{
		[HarmonyPostfix]
		private static void Postfix(EnemyAI __instance, PlayerControllerB? playerWhoHit)
		{
			if ((Object)(object)playerWhoHit != (Object)null)
			{
				((MonoBehaviour)__instance).StartCoroutine(KillEnemyHelper.KillEnemy(__instance, playerWhoHit));
			}
		}
	}
	public class KillEnemyHelper
	{
		[CompilerGenerated]
		private sealed class <KillEnemy>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemyAI enemyAI;

			public PlayerControllerB playerWhoHit;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (enemyAI.isEnemyDead)
					{
						LethalGargoylesAI.PlayerActivityTracker.UpdatePlayerActivity(playerWhoHit, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.KilledEnemy, enemyAI.enemyType.enemyName);
					}
					return false;
				}
			}

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

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

		[IteratorStateMachine(typeof(<KillEnemy>d__0))]
		public static IEnumerator KillEnemy(EnemyAI enemyAI, PlayerControllerB playerWhoHit)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <KillEnemy>d__0(0)
			{
				enemyAI = enemyAI,
				playerWhoHit = playerWhoHit
			};
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectServerRpc")]
	public class GrabObjectServerRpcPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject)
		{
			NetworkObject val = default(NetworkObject);
			if (!((NetworkBehaviour)__instance).IsServer || !((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null))
			{
				return;
			}
			GrabbableObject componentInChildren = ((Component)val).GetComponentInChildren<GrabbableObject>();
			if (componentInChildren != null)
			{
				string itemName = componentInChildren.itemProperties.itemName;
				if (LethalGargoylesAI.trackedItems.Contains(itemName))
				{
					LethalGargoylesAI.PlayerActivityTracker.UpdatePlayerActivity(__instance, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.PickedUpItem, componentInChildren.itemProperties.itemName);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SetObjectAsNoLongerHeld")]
	public class SetObjectAsNoLongerHeldPatch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayerControllerB __instance, GrabbableObject dropObject)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				string itemName = dropObject.itemProperties.itemName;
				if (LethalGargoylesAI.trackedItems.Contains(itemName))
				{
					LethalGargoylesAI.PlayerActivityTracker.RemoveActivity(__instance, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.PickedUpItem, itemName);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	public class PlayerInFacilityPatch
	{
		private static readonly Dictionary<PlayerControllerB, float> playerEnterTimes = new Dictionary<PlayerControllerB, float>();

		private static readonly Dictionary<PlayerControllerB, float> lastRanTimes = new Dictionary<PlayerControllerB, float>();

		private const float MinimumTimeInFacility = 5f;

		private const float delay = 1f;

		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			float value;
			float num = (lastRanTimes.TryGetValue(__instance, out value) ? value : 0f);
			if (!(Time.time - num > 1f))
			{
				return;
			}
			if (__instance.isPlayerControlled && __instance.isInsideFactory && !__instance.isPlayerDead)
			{
				if (!playerEnterTimes.ContainsKey(__instance))
				{
					playerEnterTimes[__instance] = Time.time;
				}
				else
				{
					float num2 = playerEnterTimes[__instance];
					float num3 = Time.time - num2;
					if (num3 >= 300f)
					{
						LethalGargoylesAI.PlayerActivityTracker.UpdatePlayerActivity(__instance, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.InFacility, "InFacilityTime", num3);
					}
				}
			}
			else
			{
				if (playerEnterTimes.ContainsKey(__instance))
				{
					playerEnterTimes.Remove(__instance);
				}
				LethalGargoylesAI.PlayerActivityTracker.RemoveActivity(__instance, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.InFacility);
			}
			lastRanTimes[__instance] = Time.time;
		}
	}
	[HarmonyPatch]
	public class NetworkObjectManager
	{
		public static GameObject? networkPrefab;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		public static void Init()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			if (!((Object)(object)networkPrefab != (Object)null) && (Object)(object)Plugin.ModAssets != (Object)null)
			{
				networkPrefab = (GameObject)Plugin.ModAssets.LoadAsset("LGNetworkHandler");
				networkPrefab.AddComponent<AudioManager>();
				NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		public static void LoadClipsHostPostFix()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost && (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer))
			{
				GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
				if (val != null)
				{
					val.GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public static class GetDeathCauses
	{
		public static List<(string playerName, string causeOfDeath, string source)> previousRoundDeaths = new List<(string, string, string)>();

		[HarmonyPostfix]
		[HarmonyPatch("WritePlayerNotes")]
		private static void PostFixWritePlayerNotes()
		{
			Plugin.Logger.LogInfo((object)"Getting Causes of Death.");
			previousRoundDeaths.Clear();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerDead)
				{
					if (Plugin.Instance.IsCoronerLoaded)
					{
						string text = ((object)(CauseOfDeath)(ref val.causeOfDeath)).ToString() ?? "Unknown";
						Plugin.Logger.LogInfo((object)("Vanilla caught " + val.playerUsername + "'s cause of death this round was " + text));
						previousRoundDeaths.Add((val.playerUsername, text, "Vanilla"));
						text = CoronerClass.CoronerGetCauseOfDeath(val) ?? "Unknown";
						Plugin.Logger.LogInfo((object)("Coroner caught " + val.playerUsername + "'s cause of death this round was " + text));
						previousRoundDeaths.Add((val.playerUsername, text, "Coroner"));
					}
					else
					{
						string text = ((object)(CauseOfDeath)(ref val.causeOfDeath)).ToString() ?? "Unknown";
						previousRoundDeaths.Add((val.playerUsername, text, "Vanilla"));
						Plugin.Logger.LogInfo((object)("Vanilla caught " + val.playerUsername + "'s cause of death this round was " + text));
					}
				}
			}
		}
	}
}
namespace LethalGargoyles.src.Enemy
{
	public class LethalGargoylesSFX : MonoBehaviour
	{
		public AudioSource? audioSource;

		public AudioClip? audioClip;

		public void PlayStep()
		{
			if (!((Object)(object)audioSource == (Object)null) && !((Object)(object)audioClip == (Object)null))
			{
				audioSource.PlayOneShot(audioClip);
			}
		}
	}
	public class LethalGargoylesAI : EnemyAI, ISmartAI
	{
		private enum State
		{
			SearchingForPlayer,
			StealthyPursuit,
			GetOutOfSight,
			AggressivePursuit,
			Idle,
			PushTarget
		}

		public enum AnimState : byte
		{
			Idle,
			Walk,
			Chase,
			SwingAttack
		}

		public enum RelativeZone
		{
			Front,
			FrontRight,
			Right,
			BackRight,
			Back,
			BackLeft,
			Left,
			FrontLeft
		}

		public static class PlayerActivityTracker
		{
			public enum PlayerActivityType
			{
				KilledEnemy,
				PickedUpItem,
				InFacility
			}

			public class ActivityData
			{
				public string? Data { get; set; }

				public float TimeValue { get; set; }

				public float LastActivityTime { get; set; }
			}

			private static readonly Dictionary<PlayerControllerB, Dictionary<PlayerActivityType, ActivityData>> playerActivities = new Dictionary<PlayerControllerB, Dictionary<PlayerActivityType, ActivityData>>();

			private static readonly Dictionary<PlayerControllerB, Dictionary<string, float>> playerTauntTimers = new Dictionary<PlayerControllerB, Dictionary<string, float>>();

			public static void UpdatePlayerActivity(PlayerControllerB player, PlayerActivityType activityType, string? data = null, float timeValue = 0f)
			{
				if (!playerActivities.ContainsKey(player))
				{
					playerActivities[player] = new Dictionary<PlayerActivityType, ActivityData>();
				}
				playerActivities[player][activityType] = new ActivityData
				{
					Data = data,
					TimeValue = timeValue,
					LastActivityTime = Time.time
				};
			}

			public static ActivityData GetPlayerActivity(PlayerControllerB player, PlayerActivityType activityType)
			{
				if (playerActivities.TryGetValue(player, out Dictionary<PlayerActivityType, ActivityData> value) && value.TryGetValue(activityType, out var value2))
				{
					return value2;
				}
				return new ActivityData
				{
					Data = null,
					TimeValue = 0f,
					LastActivityTime = 0f
				};
			}

			public static void RemoveActivity(PlayerControllerB player, PlayerActivityType activityType, string? dataValue = null)
			{
				if (!playerActivities.TryGetValue(player, out Dictionary<PlayerActivityType, ActivityData> value) || !value.ContainsKey(activityType))
				{
					return;
				}
				if (dataValue != null)
				{
					if (value[activityType].Data == dataValue)
					{
						value.Remove(activityType);
					}
				}
				else
				{
					value.Remove(activityType);
				}
				if (value.Count == 0)
				{
					playerActivities.Remove(player);
				}
			}

			public static void ClearAllPlayerData()
			{
				playerActivities.Clear();
				playerTauntTimers.Clear();
			}

			public static float GetPlayerTauntTimer(PlayerControllerB player, string timerName)
			{
				if (!playerTauntTimers.TryGetValue(player, out Dictionary<string, float> value))
				{
					value = new Dictionary<string, float>
					{
						{
							"lastLostTauntTime",
							Time.time - 61f
						},
						{
							"lastGrabTauntTime",
							Time.time - 61f
						},
						{
							"lastKillTauntTime",
							Time.time - 61f
						}
					};
					playerTauntTimers[player] = value;
				}
				if (!value.TryGetValue(timerName, out var value2))
				{
					value2 = (value[timerName] = Time.time - 61f);
				}
				return value2;
			}

			public static void UpdatePlayerTauntTimer(PlayerControllerB player, string timerName)
			{
				if (playerTauntTimers.ContainsKey(player))
				{
					playerTauntTimers[player][timerName] = Time.time;
				}
			}
		}

		private struct KillTriggerInfo
		{
			public Transform T;

			public BoxCollider C;
		}

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

			private object <>2__current;

			public DoorLock door;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					AnimatedObjectTrigger val = default(AnimatedObjectTrigger);
					if ((Object)(object)LGInstance != (Object)null && (Object)(object)door != (Object)null && ((Component)door).gameObject.TryGetComponent<AnimatedObjectTrigger>(ref val))
					{
						val.TriggerAnimationNonPlayer(true, true, false);
					}
					DoorLock obj = door;
					if (obj != null)
					{
						obj.CloseDoorNonPlayerServerRpc();
					}
					return false;
				}
				}
			}

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

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

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

			private object <>2__current;

			public LethalGargoylesAI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				int num = <>1__state;
				LethalGargoylesAI lethalGargoylesAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (((EnemyAI)lethalGargoylesAI).creatureVoice.isPlaying)
				{
					RoundManager.Instance.PlayAudibleNoise(((Component)lethalGargoylesAI).transform.position, ((EnemyAI)lethalGargoylesAI).creatureVoice.maxDistance / 3f, ((EnemyAI)lethalGargoylesAI).creatureVoice.volume, 0, false, 0);
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public PlayerControllerB player;

			public string deathType;

			public LethalGargoylesAI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				LethalGargoylesAI lethalGargoylesAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (player.isPlayerDead)
					{
						if (Plugin.Instance.IsCoronerLoaded)
						{
							CoronerClass.CoronerSetCauseOfDeath(player, deathType);
						}
						((EnemyAI)lethalGargoylesAI).targetPlayer = null;
						lethalGargoylesAI.PlayVoice(AudioManager.playerDeathClips, "playerdeath");
						lethalGargoylesAI.SwitchState(State.SearchingForPlayer);
					}
					return false;
				}
			}

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

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

		private static readonly int TrigIdle = Animator.StringToHash("startIdle");

		private static readonly int TrigWalk = Animator.StringToHash("startWalk");

		private static readonly int TrigChase = Animator.StringToHash("startChase");

		private static readonly int TrigSwingAttack = Animator.StringToHash("swingAttack");

		private const float DEST_EPSILON_SQR = 0.01f;

		private const float REPATH_INTERVAL = 0.75f;

		private const float DEST_CHANGE_SQR = 1f;

		private const float TELEPORT_COOLDOWN = 10f;

		private const float TELEPORT_MIN_DIST_SQR = 2025f;

		private const float TELEPORT_RANGE_MIN = 10f;

		private const float TELEPORT_RANGE_MAX = 18f;

		private const int TELEPORT_ATTEMPTS = 10;

		private const float SlowMs = 2f;

		private const float AGGRO_EVAL_INTERVAL = 0.2f;

		private const float HIDE_EVAL_INTERVAL = 0.35f;

		public static readonly HashSet<string> trackedItems = new HashSet<string> { "Key", "Apparatus", "Comedy", "Tragedy", "Maneater" };

		protected static ConcurrentDictionary<int, PlayerControllerB?> gargoyleTargets = new ConcurrentDictionary<int, PlayerControllerB>();

		protected static ConcurrentDictionary<PlayerControllerB, ConcurrentDictionary<int, bool>> playerPushStates = new ConcurrentDictionary<PlayerControllerB, ConcurrentDictionary<int, bool>>();

		private static readonly List<GameObject> cachedOutsideAINodes = new List<GameObject>();

		private static readonly List<GameObject> cachedInsideAINodes = new List<GameObject>();

		private static readonly List<GameObject> cachedAllAINodes = new List<GameObject>();

		private static readonly List<LethalGargoylesAI> activeGargoyles = new List<LethalGargoylesAI>();

		private static readonly List<Transform> cachedRailings = new List<Transform>();

		private static int s_cachedRailingsSceneHandle = -1;

		private static readonly List<KillTriggerInfo> cachedKillTriggerInfos = new List<KillTriggerInfo>();

		private static readonly int RailingMask = 1 << LayerMask.NameToLayer("Railing");

		private static readonly Collider[] _tmpRailingColliders = (Collider[])(object)new Collider[16];

		private static readonly Dictionary<RelativeZone, float> bufferDistances = new Dictionary<RelativeZone, float>
		{
			{
				RelativeZone.Front,
				15f
			},
			{
				RelativeZone.FrontRight,
				12f
			},
			{
				RelativeZone.Right,
				10f
			},
			{
				RelativeZone.BackRight,
				6f
			},
			{
				RelativeZone.Back,
				3f
			},
			{
				RelativeZone.BackLeft,
				6f
			},
			{
				RelativeZone.Left,
				10f
			},
			{
				RelativeZone.FrontLeft,
				12f
			}
		};

		private static int s_nextGargoyleSerial;

		private static readonly object PlayerPushStatesLock = new object();

		private static int lastGenTaunt = -1;

		private static int lastAgrTaunt = -1;

		private static int lastGargoyleToSwitch = 0;

		private static float lastNodeCheckTime = 0f;

		public Transform turnCompass;

		public Transform attackArea;

		private int _gargoyleSerial;

		public int myID;

		private bool _smartRegistered;

		private SmartPathTask? pathingTask;

		private SmartPathDestination? activeDestination;

		private Vector3 _lastActiveDestination = new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity);

		private Vector3 _lastRequestedDest;

		private float _nextPathRequestTime;

		private float pathDelayTimer;

		private AnimatedObjectTrigger? currentDoorTrigger;

		private PlayerControllerB closestPlayer;

		private PlayerControllerB aggroPlayer;

		private PlayerControllerB? _lastTarget;

		private Vector3 cachedTargetPosition;

		private float distanceToPlayerSqr;

		private float distanceToClosestPlayerSqr;

		private bool isSeen;

		private bool canSeePlayer;

		private bool targetSeesGargoyle;

		private Transform? killTrigger;

		private float distToKillTriggerSqr;

		private float pushTimer;

		private int pushStage;

		private float targetTimer;

		private float _nextAggroEvalTime;

		private float playerCheckTimer;

		private int previousStateIndex;

		private float lastSeenCheckTime;

		private readonly Dictionary<RelativeZone, Vector3> RelativeZones = new Dictionary<RelativeZone, Vector3>();

		private RelativeZone currentZone;

		private RelativeZone nextZoneRight;

		private RelativeZone nextZoneLeft;

		private float leftPathDist;

		private float rightPathDist;

		private float _nextZoneFailLogTime;

		private Vector3 lastCoverSearchPosition;

		private float coverSearchCooldown = 3f;

		private float lastCoverSearchTime = -10f;

		private List<Vector3> cachedCoverPoints = new List<Vector3>();

		private float _nextHideEvalTime;

		public DoorLock? currentDoor;

		public float lastDoorCloseTime;

		private float baseSpeed;

		private float attackRangeSqr;

		private int attackDamage;

		private float aggroRangeSqr;

		private int minTaunt;

		private int maxTaunt;

		private float distWarnSqr;

		private float bufferDistSqr;

		private float awareDistSqr;

		private float idleDistanceSqr;

		private bool enablePush;

		private float randGenTauntTime;

		private float randAgrTauntTime;

		private float randEnemyTauntTime;

		private float lastGenTauntTime;

		private float lastAgrTauntTime;

		private float lastEnemyTauntTime;

		private float lastSteamIDTauntTime;

		private int genTauntCount;

		private string? lastEnemy;

		private string? _lastEnemyLogName;

		private float _nextEnemyLogTime;

		private float _nextActivityLogTime;

		private float _nextDoAiLogTime;

		private readonly float nodeCheckInterval = 5f;

		private float lastAttackTime;

		private readonly List<PlayerControllerB> validPlayers = new List<PlayerControllerB>();

		private readonly List<LethalGargoylesAI> gargoyles = new List<LethalGargoylesAI>();

		private readonly Dictionary<PlayerControllerB, string> playerClasses = new Dictionary<PlayerControllerB, string>();

		private AnimState _lastAnim;

		private float _nextTeleportTime;

		public static LethalGargoylesAI? LGInstance { get; private set; }

		private string GargoyleTag => $"LG#{_gargoyleSerial}(agentId={myID}, netId={(((Object)(object)((NetworkBehaviour)this).NetworkObject != (Object)null) ? ((NetworkBehaviour)this).NetworkObject.NetworkObjectId : 0)})";

		private static bool IsInvalidPos(Vector3 p)
		{
			return ((Vector3)(ref p)).sqrMagnitude < 0.0001f;
		}

		public override void Start()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).Start();
			_gargoyleSerial = Interlocked.Increment(ref s_nextGargoyleSerial);
			myID = ((Object)base.agent).GetInstanceID();
			SmartPathfinding.RegisterSmartAgent(base.agent);
			_smartRegistered = true;
			LGInstance = this;
			SetAnim(AnimState.Walk);
			SwitchState(State.SearchingForPlayer);
			((EnemyAI)this).StartSearch(((Component)this).transform.position, (AISearchRoutine)null);
			baseSpeed = Plugin.BoundConfig.baseSpeed.Value;
			attackDamage = Plugin.BoundConfig.attackDamage.Value;
			minTaunt = Plugin.BoundConfig.minTaunt.Value;
			maxTaunt = Plugin.BoundConfig.maxTaunt.Value;
			attackRangeSqr = Plugin.BoundConfig.attackRange.Value;
			attackRangeSqr *= attackRangeSqr;
			aggroRangeSqr = Plugin.BoundConfig.aggroRange.Value;
			aggroRangeSqr *= aggroRangeSqr;
			distWarnSqr = Plugin.BoundConfig.distWarn.Value;
			distWarnSqr *= distWarnSqr;
			idleDistanceSqr = Plugin.BoundConfig.idleDistance.Value;
			idleDistanceSqr *= idleDistanceSqr;
			bufferDistSqr = Plugin.BoundConfig.bufferDist.Value;
			bufferDistSqr *= bufferDistSqr;
			awareDistSqr = Plugin.BoundConfig.awareDist.Value;
			awareDistSqr *= awareDistSqr;
			enablePush = Plugin.BoundConfig.enablePush.Value;
			lastAttackTime = Time.time;
			pushTimer = Time.time;
			gargoyleTargets[myID] = base.targetPlayer;
			_lastTarget = base.targetPlayer;
			_nextAggroEvalTime = Time.time;
			AudioSource creatureVoice = base.creatureVoice;
			creatureVoice.maxDistance *= 3f;
			pathDelayTimer = Time.time;
			lastSteamIDTauntTime = Time.time - 91f;
			cachedOutsideAINodes.Clear();
			GameObject[] outsideAINodes = RoundManager.Instance.outsideAINodes;
			foreach (GameObject val in outsideAINodes)
			{
				if ((Object)(object)val != (Object)null)
				{
					cachedOutsideAINodes.Add(val);
				}
			}
			cachedInsideAINodes.Clear();
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			foreach (GameObject val2 in insideAINodes)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					cachedInsideAINodes.Add(val2);
				}
			}
			cachedAllAINodes.Clear();
			GameObject[] allAINodes = base.allAINodes;
			foreach (GameObject val3 in allAINodes)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					cachedAllAINodes.Add(val3);
				}
			}
			CacheKillTriggers();
			playerClasses.Clear();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val4 in allPlayerScripts)
			{
				playerClasses[val4] = EmployeeClassesClass.GetPlayerClass(val4) ?? "Employee";
			}
			activeGargoyles.Add(this);
		}

		public override void Update()
		{
			//IL_002d: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).Update();
			cachedTargetPosition = (((Object)(object)base.targetPlayer != (Object)null) ? ((Component)base.targetPlayer).transform.position : ((Component)this).transform.position);
			if (base.isEnemyDead || StartOfRound.Instance.allPlayersDead || !((Behaviour)base.agent).enabled || !base.agent.isOnNavMesh || !((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			Stopwatch stopwatch = Stopwatch.StartNew();
			if ((Object)(object)_lastTarget != (Object)(object)base.targetPlayer)
			{
				gargoyleTargets[myID] = base.targetPlayer;
				_lastTarget = base.targetPlayer;
			}
			if (Time.time - lastNodeCheckTime > nodeCheckInterval)
			{
				float num = (float)stopwatch.Elapsed.TotalMilliseconds;
				CheckAndRefreshAINodes();
				lastNodeCheckTime = Time.time;
			}
			float num2 = (float)stopwatch.Elapsed.TotalMilliseconds;
			HandleTargetPlayer();
			if (Time.time - lastSeenCheckTime > 0.33f)
			{
				float num3 = (float)stopwatch.Elapsed.TotalMilliseconds;
				closestPlayer = ((EnemyAI)this).GetClosestPlayer(false, false, false);
				float num4;
				if (!((Object)(object)closestPlayer != (Object)null))
				{
					num4 = 0f;
				}
				else
				{
					Vector3 val = ((Component)this).transform.position - ((Component)closestPlayer).transform.position;
					num4 = ((Vector3)(ref val)).sqrMagnitude;
				}
				distanceToClosestPlayerSqr = num4;
				isSeen = GargoyleIsSeen(((Component)this).transform);
				lastSeenCheckTime = Time.time;
			}
			float num5 = (float)stopwatch.Elapsed.TotalMilliseconds;
			HandlePushStage();
			float num6 = (float)stopwatch.Elapsed.TotalMilliseconds;
			HandleBehaviorState();
			if (base.currentBehaviourStateIndex != 4)
			{
				float num7 = (float)stopwatch.Elapsed.TotalMilliseconds;
				FollowSmartPath();
			}
			stopwatch.Stop();
		}

		public override void DoAIInterval()
		{
			//IL_0759: Unknown result type (might be due to invalid IL or missing references)
			//IL_0987: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Unknown result type (might be due to invalid IL or missing references)
			//IL_097c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0828: Unknown result type (might be due to invalid IL or missing references)
			//IL_0833: Unknown result type (might be due to invalid IL or missing references)
			//IL_0838: Unknown result type (might be due to invalid IL or missing references)
			//IL_083d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).DoAIInterval();
			if (Time.time >= _nextDoAiLogTime)
			{
				_nextDoAiLogTime = Time.time + 3f;
				string text = StateToString(base.currentBehaviourStateIndex);
				string text2 = $"Owner={((NetworkBehaviour)this).IsOwner} Server={((NetworkBehaviour)this).IsServer} Spawned={(Object)(object)((NetworkBehaviour)this).NetworkObject != (Object)null && ((NetworkBehaviour)this).NetworkObject.IsSpawned}";
				string text3 = (((Object)(object)base.targetPlayer == (Object)null) ? "Target=null" : $"Target={base.targetPlayer.playerUsername} id={base.targetPlayer.playerClientId} dead={base.targetPlayer.isPlayerDead} controlled={base.targetPlayer.isPlayerControlled} insideFactory={base.targetPlayer.isInsideFactory}");
				string text4 = (((Object)(object)closestPlayer == (Object)null) ? "Closest=null" : $"Closest={closestPlayer.playerUsername} id={closestPlayer.playerClientId} dead={closestPlayer.isPlayerDead} insideFactory={closestPlayer.isInsideFactory}");
				float num = (((Object)(object)base.targetPlayer != (Object)null) ? Mathf.Sqrt(distanceToPlayerSqr) : (-1f));
				float num2 = (((Object)(object)closestPlayer != (Object)null) ? Mathf.Sqrt(distanceToClosestPlayerSqr) : (-1f));
				string text5 = $"dist(target)={num:0.0}m dist(closest)={num2:0.0}m " + $"ranges: aware={Mathf.Sqrt(awareDistSqr):0.0} aggro={Mathf.Sqrt(aggroRangeSqr):0.0} idle={Mathf.Sqrt(idleDistanceSqr):0.0} atk={Mathf.Sqrt(attackRangeSqr):0.0} buffer={Mathf.Sqrt(bufferDistSqr):0.0}";
				string text6 = $"seen={isSeen} targetSees={targetSeesGargoyle} canSee={canSeePlayer} " + $"push: enable={enablePush} stage={pushStage} timerIn={pushTimer - Time.time:0.0}s";
				string text7 = string.Format("killTrigger={0} dist={1:0.0}m", ((Object)(object)killTrigger != (Object)null) ? ((Object)killTrigger).name : "null", (distToKillTriggerSqr == float.MaxValue) ? (-1f) : Mathf.Sqrt(distToKillTriggerSqr));
				bool flag = false;
				if ((Object)(object)base.targetPlayer != (Object)null && playerPushStates.TryGetValue(base.targetPlayer, out ConcurrentDictionary<int, bool> value) && value.TryGetValue(myID, out var value2))
				{
					flag = value2;
				}
				ConcurrentDictionary<int, bool> value3;
				string text8 = (((Object)(object)base.targetPlayer != (Object)null) ? $"pushMap: iAmPushing={flag} entries={(playerPushStates.TryGetValue(base.targetPlayer, out value3) ? value3.Count : 0)}" : "pushMap: n/a");
				Vector3 position = ((Component)this).transform.position;
				Vector3 destination = base.agent.destination;
				Vector3 velocity = base.agent.velocity;
				string text9 = $"agent: enabled={((Behaviour)base.agent).enabled} onNavMesh={base.agent.isOnNavMesh} " + $"speed={base.agent.speed:0.00} angSpeed={base.agent.angularSpeed:0.0} stopDist={base.agent.stoppingDistance:0.00} " + $"hasPath={base.agent.hasPath} pending={base.agent.pathPending} status={base.agent.pathStatus} " + $"remDist={base.agent.remainingDistance:0.00} " + $"pos=({position.x:0.0},{position.y:0.0},{position.z:0.0}) dest=({destination.x:0.0},{destination.y:0.0},{destination.z:0.0}) vel=({velocity.x:0.0},{velocity.y:0.0},{velocity.z:0.0})";
				if (pathingTask == null)
				{
					string text10 = "smartPath: task=null";
				}
				else
				{
					bool isStarted = pathingTask.IsStarted;
					bool flag2 = isStarted && pathingTask.IsResultReady(0);
					string text11 = $"requested=({_lastRequestedDest.x:0.0},{_lastRequestedDest.y:0.0},{_lastRequestedDest.z:0.0})";
					string text12 = $"lastActive=({_lastActiveDestination.x:0.0},{_lastActiveDestination.y:0.0},{_lastActiveDestination.z:0.0})";
					string text13;
					if (!flag2)
					{
						text13 = "result=not-ready";
					}
					else
					{
						SmartPathDestination? result = pathingTask.GetResult(0);
						if (!result.HasValue)
						{
							text13 = "result=null";
						}
						else
						{
							SmartPathDestination value4 = result.Value;
							Vector3 position2 = ((SmartPathDestination)(ref value4)).Position;
							text13 = $"result: type={((SmartPathDestination)(ref value4)).Type} pos=({position2.x:0.0},{position2.y:0.0},{position2.z:0.0})";
						}
					}
					string text10 = $"smartPath: started={isStarted} ready={flag2} {text11} {text12} {text13}";
				}
				string text14 = (((Object)(object)currentDoor == (Object)null) ? "door=null" : $"door={((Object)currentDoor).name} locked={currentDoor.isLocked} trigCached={(Object)(object)currentDoorTrigger != (Object)null} trigBool={(Object)(object)currentDoorTrigger != (Object)null && currentDoorTrigger.boolValue} lastCloseAgo={Time.time - lastDoorCloseTime:0.00}s");
			}
			if (base.isEnemyDead || StartOfRound.Instance.allPlayersDead)
			{
				if (StartOfRound.Instance.allPlayersDead)
				{
					ClearAllVariables();
				}
				return;
			}
			_ = base.currentBehaviourStateIndex;
			_ = previousStateIndex;
			previousStateIndex = base.currentBehaviourStateIndex;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				killTrigger = FindNearestKillTrigger(cachedTargetPosition);
				if (Time.time - playerCheckTimer > 3f)
				{
					ChangeTarget();
					playerCheckTimer = Time.time;
				}
			}
			if ((Object)(object)LGInstance != (Object)null)
			{
				if ((Object)(object)currentDoorTrigger == (Object)null && (Object)(object)currentDoor != (Object)null)
				{
					currentDoorTrigger = ((Component)currentDoor).gameObject.GetComponent<AnimatedObjectTrigger>();
				}
				if (Time.time - lastDoorCloseTime >= 0.75f && (Object)(object)currentDoor != (Object)null && !currentDoor.isLocked && (Object)(object)currentDoorTrigger != (Object)null && currentDoorTrigger.boolValue)
				{
					Vector3 val = ((Component)currentDoor).transform.position - ((Component)this).transform.position;
					if (((Vector3)(ref val)).sqrMagnitude > ((base.currentBehaviourStateIndex == 4) ? 8f : 16f))
					{
						((MonoBehaviour)this).StartCoroutine(DelayDoorClose(currentDoor));
						currentDoor = null;
						currentDoorTrigger = null;
					}
				}
			}
			switch (base.currentBehaviourStateIndex)
			{
			case 0:
				if (FoundClosestPlayerInRange())
				{
					((EnemyAI)this).StopSearch(base.currentSearch, true);
					SwitchState(State.StealthyPursuit);
				}
				if (base.agent.hasPath)
				{
					SetAnim(base.agent.hasPath ? AnimState.Walk : AnimState.Idle);
				}
				else
				{
					SetAnim(AnimState.Idle);
				}
				break;
			case 1:
			case 2:
				if (base.agent.hasPath)
				{
					SetAnim(AnimState.Walk);
				}
				else
				{
					SetAnim(AnimState.Idle);
				}
				break;
			case 4:
				SetAnim(AnimState.Idle);
				break;
			case 3:
				if (base.agent.hasPath)
				{
					SetAnim(AnimState.Chase);
				}
				else
				{
					SetAnim(AnimState.Idle);
				}
				break;
			case 5:
				if ((Time.time - targetTimer > 0.5f || !base.agent.hasPath) && (Object)(object)base.targetPlayer != (Object)null)
				{
					if (distanceToPlayerSqr <= idleDistanceSqr)
					{
						Vector3 targetPosition = GetTargetPosition(base.targetPlayer);
						SetSmartDestination(targetPosition);
					}
					else
					{
						SetSmartDestination(cachedTargetPosition);
					}
					targetTimer = Time.time;
				}
				if (base.agent.hasPath)
				{
					SetAnim(AnimState.Chase);
				}
				else
				{
					SetAnim(AnimState.Idle);
				}
				break;
			}
		}

		private void OnDisable()
		{
			CleanupSmartPathing();
		}

		public override void OnDestroy()