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

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

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

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

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

		public const string PLUGIN_NAME = "LethalGargoyles";

		public const string PLUGIN_VERSION = "0.8.0";
	}
}
namespace LethalGargoyles.src
{
	[BepInPlugin("DropDaDeuce.LethalGargoyles", "LethalGargoyles", "0.8.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);
			BoundConfig.InitializeDiagnostics();
			IsCoronerLoaded = DepIsLoaded("com.elitemastereric.coroner");
			IsEmployeeClassesLoaded = DepIsLoaded("Jade.EmployeeClasses");
			IsEnhancedMonstersLoaded = DepIsLoaded("com.velddev.enhancedmonsters");
			Instance = this;
			InitializeNetworkBehaviours();
			string text = "gargoyleassets";
			ModAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), text));
			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");
			try
			{
				Directory.CreateDirectory(CustomAudioFolderPath);
				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"));
			}
			catch (Exception ex)
			{
				Logger.LogError((object)("Could not create the Custom Voice Lines folders at '" + CustomAudioFolderPath + "': " + ex.GetType().Name + ": " + ex.Message + ". Custom voice lines will be unavailable; the rest of the mod will load normally."));
			}
			EnemyType val = ModAssets.LoadAsset<EnemyType>("LethalGargoyle");
			TerminalNode val2 = ModAssets.LoadAsset<TerminalNode>("LethalGargoyleTN");
			TerminalKeyword val3 = ModAssets.LoadAsset<TerminalKeyword>("LethalGargoyleTK");
			if ((Object)(object)val == (Object)null || (Object)(object)val.enemyPrefab == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				Logger.LogError((object)$"Failed to load the gargoyle from '{text}' (EnemyType={(Object)(object)val != (Object)null}, prefab={(Object)(object)val?.enemyPrefab != (Object)null}, TN={(Object)(object)val2 != (Object)null}, TK={(Object)(object)val3 != (Object)null}). The enemy will not be registered. This usually means the asset bundle is stale relative to the DLL.");
				return;
			}
			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");
				if ((Object)(object)val4 == (Object)null || (Object)(object)val4.spawnPrefab == (Object)null)
				{
					Logger.LogError((object)"Failed to load the Gargoyle Statue scrap from the asset bundle. Scrap registration skipped; the rest of the mod is unaffected.");
				}
				else
				{
					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");
			if ((Object)(object)stepSound == (Object)null)
			{
				Logger.LogError((object)"Failed to load sfx_Step.ogg from the asset bundle - the gargoyle will walk silently.");
			}
			LogSessionBanner();
			Logger.LogInfo((object)"Plugin DropDaDeuce.LethalGargoyles is loaded!");
		}

		private void LogSessionBanner()
		{
			Logger.LogInfo((object)("=== LethalGargoyles 0.8.0 | bundle '" + (((Object)(object)ModAssets != (Object)null) ? "loaded" : "MISSING") + "' | Unity " + Application.unityVersion + " ==="));
			Logger.LogInfo((object)$"Soft deps: Coroner={IsCoronerLoaded} EmployeeClasses={IsEmployeeClassesLoaded} EnhancedMonsters={IsEnhancedMonstersLoaded}");
			Logger.LogInfo((object)$"Config: sightRange={Math.Sqrt(120.0):0.00}m aggroRange={BoundConfig.aggroRange.Value} awareDist={BoundConfig.awareDist.Value} push={BoundConfig.enablePush.Value} scrap={BoundConfig.enableScrap.Value}");
			Logger.LogInfo((object)("Custom voice lines: " + (CustomAudioFolderPath ?? "(unavailable)")));
			Logger.LogInfo((object)$"Diagnostics: enabled={BoundConfig.diagEnabled.Value} default={BoundConfig.diagDefaultLevel.Value} repeatLimit={BoundConfig.diagRepeatLimit.Value}");
		}

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

		private static void InitializeNetworkBehaviours()
		{
			Type[] array;
			try
			{
				array = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				Logger.LogError((object)("Could not enumerate assembly types for netcode initialization: " + ex.Message + ". Continuing with whatever loaded."));
				array = Array.FindAll(ex.Types, (Type t) => t != null);
			}
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				if (type.FullName == "LethalGargoyles.src.SoftDepends.CoronerClass" && !Instance.IsCoronerLoaded)
				{
					continue;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array3 = methods;
				foreach (MethodInfo methodInfo in array3)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						try
						{
							methodInfo.Invoke(null, null);
						}
						catch (Exception ex2)
						{
							Logger.LogError((object)("Netcode initializer " + type.FullName + "." + methodInfo.Name + " threw: " + (ex2.InnerException?.Message ?? ex2.Message) + ". RPCs on that type will not work."));
						}
					}
				}
			}
		}

		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
	{
		public const int MaxClipBytes = 512000;

		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;
			}
		}

		private IEnumerator LogClipCounts()
		{
			yield return null;
		}

		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[] audioData;
					if (PluginConfig.AudioClipEnableConfig.TryGetValue(clipName, out ConfigEntry<bool> value2))
					{
						if (!value2.Value)
						{
							continue;
						}
						audioData = AudioFileToByteArray(item);
						byte[] array = audioData;
						if (array != null && array.Length > 512000)
						{
							Plugin.Logger.LogError((object)$"Skipping Clip({clipName}): {audioData?.Length} bytes exceeds the {512000} byte (500KB) limit. Remaining clips in '{category}' will still be sent.");
						}
						else if (audioData != null)
						{
							await WaitForClientReady(clientId);
							if (!clientReady.ContainsKey(clientId))
							{
								break;
							}
							await SendAudioClipToClient(clientId, audioData, clipName, category);
							clientReady[clientId] = false;
							SetClientReadyClientRpc(isReady: false, clientId);
							Plugin.Logger.LogInfo((object)$"Sent Clip({clipName}) to ClientID({clientId})");
						}
						continue;
					}
					audioData = AudioFileToByteArray(item);
					byte[] array2 = audioData;
					if (array2 != null && array2.Length > 512000)
					{
						Plugin.Logger.LogError((object)$"Skipping Clip({clipName}): {audioData?.Length} bytes exceeds the {512000} byte (500KB) limit. Remaining clips in '{category}' will still be sent.");
					}
					else if (audioData != null)
					{
						await WaitForClientReady(clientId);
						if (!clientReady.ContainsKey(clientId))
						{
							break;
						}
						await SendAudioClipToClient(clientId, audioData, 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 unsafe 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*)(&writer))/*cast due to .constrained prefix*/).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));
			}
		}

		private IEnumerator ProcessAudioClip(byte[] audioData, string clipName, string category)
		{
			VorbisReader val = new VorbisReader((Stream)new MemoryStream(audioData, writable: false), true);
			try
			{
				int channels = val.Channels;
				int num = (int)val.TotalSamples;
				float[] array = new float[num * channels];
				AudioClip val2 = AudioClip.Create(clipName, num, channels, val.SampleRate, false);
				int num2 = val.ReadSamples(array, 0, array.Length);
				if (num2 < array.Length)
				{
					LGLog.Warn(LogCat.Audio, $"Clip '{clipName}' decoded short: got {num2} of {array.Length} samples ({channels}ch). It will play truncated.");
				}
				val2.SetData(array, 0);
				List<AudioClip> clipListByCategory = GetClipListByCategory(category);
				clipListByCategory.Add(val2);
				LGLog.Info(LogCat.Audio, $"Clip loaded: {((Object)val2).name} ({channels}ch, {val.SampleRate}Hz, {val2.length:0.00}s)");
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			yield break;
		}

		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);
					try
					{
						FileInfo fileInfo = new FileInfo(item);
						if (fileInfo.Exists && fileInfo.Length > 512000)
						{
							LGLog.Warn(LogCat.Audio, $"Skipping '{fileNameWithoutExtension}' locally too: {fileInfo.Length} bytes exceeds the {512000} byte limit, so no client can receive it. Re-export it smaller.");
							continue;
						}
					}
					catch (Exception ex)
					{
						LGLog.Warn(LogCat.Audio, "Could not stat '" + item + "': " + ex.GetType().Name + ". Loading anyway.");
					}
					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));
					}
				}
			}
		}

		private IEnumerator LoadAudioClip(string filePath, string category)
		{
			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));
				yield break;
			}
			UnityWebRequest webRequest = UnityWebRequestMultimedia.GetAudioClip(filePath, val2);
			yield return webRequest.SendWebRequest();
			if ((int)webRequest.result == 3)
			{
				Plugin.Logger.LogError((object)webRequest.error);
				yield break;
			}
			AudioClip content = DownloadHandlerAudioClip.GetContent(webRequest);
			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));
		}

		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 = new Dictionary<string, List<string>>();
			foreach (KeyValuePair<string, List<string>> defaultAudioClipFilePath in defaultAudioClipFilePaths)
			{
				AudioClipFilePaths[defaultAudioClipFilePath.Key] = new List<string>(defaultAudioClipFilePath.Value);
			}
			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", "Custom Voice Lines");
					FileInfo[] array2 = mP3Files2;
					foreach (FileInfo fileInfo2 in array2)
					{
						string fileNameWithoutExtension3 = Path.GetFileNameWithoutExtension(fileInfo2.FullName);
						bool flag2 = false;
						for (int l = 0; l < value.Count; l++)
						{
							string fileNameWithoutExtension4 = Path.GetFileNameWithoutExtension(value[l]);
							if (fileNameWithoutExtension3 == fileNameWithoutExtension4)
							{
								value[l] = fileInfo2.FullName;
								flag2 = true;
								break;
							}
						}
						if (!flag2)
						{
							value.Add(fileInfo2.FullName);
						}
					}
				}
				if (!Plugin.Instance.IsEmployeeClassesLoaded || !(key == "Class"))
				{
					continue;
				}
				FileInfo[] mP3Files3 = GetMP3Files("EmployeeClass", "Voice Lines");
				FileInfo[] mP3Files4 = GetMP3Files("EmployeeClass", "Custom Voice Lines");
				FileInfo[] array3 = mP3Files3;
				foreach (FileInfo fileInfo3 in array3)
				{
					value.Add(fileInfo3.FullName);
				}
				FileInfo[] array4 = mP3Files4;
				foreach (FileInfo fileInfo4 in array4)
				{
					string fileNameWithoutExtension5 = Path.GetFileNameWithoutExtension(fileInfo4.FullName);
					bool flag3 = false;
					for (int num = 0; num < value.Count; num++)
					{
						string fileNameWithoutExtension6 = Path.GetFileNameWithoutExtension(value[num]);
						if (fileNameWithoutExtension5 == fileNameWithoutExtension6)
						{
							value[num] = fileInfo4.FullName;
							flag3 = true;
							break;
						}
					}
					if (!flag3)
					{
						value.Add(fileInfo4.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":
				text = Path.Combine("Taunt - General");
				break;
			case "Aggro":
				text = Path.Combine("Taunt - Aggro");
				break;
			case "Enemy":
				text = Path.Combine("Taunt - Enemy");
				break;
			case "PlayerDeath":
				text = Path.Combine("Taunt - Player Death");
				break;
			case "GargoyleDeath":
				text = Path.Combine("Taunt - Gargoyle Death");
				break;
			case "PriorDeath":
				text = Path.Combine("Taunt - Prior Death");
				break;
			case "Coroner":
				text = Path.Combine("Taunt - Prior Death", "Coroner");
				break;
			case "Class":
			case "EmployeeClass":
				text = Path.Combine("Taunt - EmployeeClass");
				break;
			case "Activity":
				text = Path.Combine("Taunt - Activity");
				break;
			case "Attack":
				text = Path.Combine("Combat Dialog", "Attack");
				break;
			case "Hit":
				text = Path.Combine("Combat Dialog", "Hit");
				break;
			case "SteamIDs":
				text = Path.Combine("Taunt - SteamIDs");
				break;
			default:
				text = null;
				break;
			}
			string text2 = text;
			if (text2 == null)
			{
				LGLog.Warn(LogCat.Audio, "Unknown voice line category '" + type + "' requested - no clips will load for it. This is a code bug, not a user error.");
				return Array.Empty<FileInfo>();
			}
			string text3 = Path.Combine(path, text2);
			try
			{
				DirectoryInfo directoryInfo = new DirectoryInfo(text3);
				if (!directoryInfo.Exists)
				{
					LGLog.Debug(LogCat.Audio, "Voice line folder missing, skipping: " + text3);
					return Array.Empty<FileInfo>();
				}
				return directoryInfo.GetFiles("*.ogg");
			}
			catch (Exception ex)
			{
				LGLog.Warn(LogCat.Audio, "Could not read voice line folder '" + text3 + "': " + ex.GetType().Name + ": " + ex.Message + ". That category will be empty rather than silencing the whole mod.");
				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 val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2917554051u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isReady, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, clientId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2917554051u, val2, (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 val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1384767487u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isReady, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1384767487u, val2, (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";
		}
	}
	public enum LGLevel
	{
		Off,
		Error,
		Warn,
		Info,
		Debug,
		Trace
	}
	[Flags]
	public enum LogCat
	{
		None = 0,
		Lifecycle = 1,
		StateMachine = 2,
		Targeting = 4,
		Movement = 8,
		Perception = 0x10,
		Combat = 0x20,
		Taunt = 0x40,
		Audio = 0x80,
		Netcode = 0x100,
		Config = 0x200,
		Scrap = 0x400
	}
	internal static class LGLog
	{
		private static readonly Dictionary<LogCat, LGLevel> Levels = new Dictionary<LogCat, LGLevel>();

		private static LGLevel _defaultLevel = LGLevel.Warn;

		private static bool _enabled = true;

		private static bool _includeContext = true;

		private static int _repeatLimit = 20;

		private static readonly Dictionary<string, int> RepeatCounts = new Dictionary<string, int>();

		private static readonly HashSet<string> FiredOnce = new HashSet<string>();

		internal static void Configure(bool enabled, LGLevel defaultLevel, Dictionary<LogCat, LGLevel> perCategory, bool includeContext, int repeatLimit)
		{
			_enabled = enabled;
			_defaultLevel = defaultLevel;
			_includeContext = includeContext;
			_repeatLimit = repeatLimit;
			Levels.Clear();
			foreach (KeyValuePair<LogCat, LGLevel> item in perCategory)
			{
				Levels[item.Key] = item.Value;
			}
		}

		internal static bool On(LogCat cat, LGLevel level)
		{
			if (!_enabled)
			{
				return false;
			}
			LGLevel value;
			LGLevel lGLevel = (Levels.TryGetValue(cat, out value) ? value : _defaultLevel);
			if (_defaultLevel > lGLevel)
			{
				lGLevel = _defaultLevel;
			}
			if (lGLevel != LGLevel.Off)
			{
				return level <= lGLevel;
			}
			return false;
		}

		internal static void Error(LogCat cat, string msg)
		{
			Write(cat, LGLevel.Error, msg);
		}

		internal static void Warn(LogCat cat, string msg)
		{
			Write(cat, LGLevel.Warn, msg);
		}

		internal static void Info(LogCat cat, string msg)
		{
			Write(cat, LGLevel.Info, msg);
		}

		internal static void Debug(LogCat cat, string msg)
		{
			Write(cat, LGLevel.Debug, msg);
		}

		internal static void Trace(LogCat cat, string msg)
		{
			Write(cat, LGLevel.Trace, msg);
		}

		internal static void Once(LogCat cat, LGLevel level, string key, string msg)
		{
			if (On(cat, level) && FiredOnce.Add(key))
			{
				Write(cat, level, msg);
			}
		}

		internal static void Invariant(bool condition, LogCat cat, string key, string msg)
		{
			if (!condition && _enabled && FiredOnce.Add("INV:" + key))
			{
				Emit(LGLevel.Error, Prefix(cat) + " INVARIANT VIOLATED: " + msg);
			}
		}

		private static void Write(LogCat cat, LGLevel level, string msg)
		{
			if (!On(cat, level))
			{
				return;
			}
			if (_repeatLimit > 0)
			{
				string key = cat.ToString() + "|" + level.ToString() + "|" + msg;
				RepeatCounts.TryGetValue(key, out var value);
				if (value > _repeatLimit)
				{
					return;
				}
				RepeatCounts[key] = value + 1;
				if (value == _repeatLimit)
				{
					Emit(level, $"{Prefix(cat)} {msg}  (repeated {_repeatLimit}x - suppressing further occurrences)");
					return;
				}
			}
			Emit(level, Prefix(cat) + " " + msg);
		}

		private static string Prefix(LogCat cat)
		{
			if (!_includeContext)
			{
				return $"[{cat}]";
			}
			char c = 'C';
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				c = '?';
			}
			else if (singleton.IsHost || singleton.IsServer)
			{
				c = 'H';
			}
			return $"[{c}][{cat}]";
		}

		private static void Emit(LGLevel level, string line)
		{
			switch (level)
			{
			case LGLevel.Error:
				Plugin.Logger.LogError((object)line);
				break;
			case LGLevel.Warn:
				Plugin.Logger.LogWarning((object)line);
				break;
			default:
				Plugin.Logger.LogInfo((object)line);
				break;
			}
		}

		internal static void ResetRound()
		{
			RepeatCounts.Clear();
			FiredOnce.Clear();
		}
	}
}
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
	{
		private AudioSource? scrapAudio;

		private int lastTaunt;

		private float dogHearDistSqr;

		private float dogCooldown;

		private bool dogHear;

		private float lastDogCheck;

		private float lastDogTaunt;

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

		private float _nextTalkTime;

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

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

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if ((Object)(object)scrapAudio != (Object)null && ((NetworkBehaviour)this).IsServer && !base.isPocketed && 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 && (Object)(object)((NetworkBehaviour)this).NetworkObject != (Object)null && ((NetworkBehaviour)this).NetworkObject.IsSpawned)
				{
					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 > dogHearDistSqr) && 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 (LGLog.On(LogCat.Scrap, LGLevel.Debug))
			{
				LGLog.Debug(LogCat.Scrap, $"Statue#{((NetworkBehaviour)this).NetworkObjectId} ItemActivate(used={used}, down={buttonDown}) " + $"pocketed={base.isPocketed} held={base.isHeld} " + "heldBy=" + (((Object)(object)base.playerHeldBy != (Object)null) ? base.playerHeldBy.playerUsername : "null") + " " + $"server={((NetworkBehaviour)this).IsServer} owner={((NetworkBehaviour)this).IsOwner}");
			}
			if (((NetworkBehaviour)this).IsServer && !base.isPocketed && (Object)(object)scrapAudio != (Object)null)
			{
				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)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val2 = default(ServerRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3724832850u, val2, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref used, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref buttonDown, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3724832850u, val2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				LGLog.Debug(LogCat.Scrap, $"Statue#{((NetworkBehaviour)this).NetworkObjectId} ItemActivateServerRpc RECEIVED pocketed={base.isPocketed}");
				if (!base.isPocketed)
				{
					GeneralTaunt();
				}
			}
		}

		private bool TryReserveTalkSlot(float clipLength)
		{
			float time = Time.time;
			if (time < _nextTalkTime)
			{
				return false;
			}
			if ((Object)(object)base.playerHeldBy != (Object)null)
			{
				ulong actualClientId = base.playerHeldBy.actualClientId;
				if (s_playerTalkingUntil.TryGetValue(actualClientId, out var value) && time < value)
				{
					LGLog.Debug(LogCat.Scrap, $"Statue#{((NetworkBehaviour)this).NetworkObjectId} suppressed - {base.playerHeldBy.playerUsername} already has a statue talking for another {value - time:0.0}s");
					return false;
				}
				s_playerTalkingUntil[actualClientId] = time + clipLength;
			}
			_nextTalkTime = time + clipLength;
			return true;
		}

		public void GeneralTaunt()
		{
			List<AudioClip> list = new List<AudioClip>(AudioManager.tauntClips);
			AudioClip val = null;
			if ((Object)(object)base.playerHeldBy != (Object)null)
			{
				val = LethalGargoylesAI.FindClip($"{base.playerHeldBy.playerSteamId}", AudioManager.playerClips);
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			if (list.Count > 0)
			{
				int num = Random.Range(0, list.Count);
				if (num == lastTaunt)
				{
					num = (num + 1) % list.Count;
				}
				AudioClip val2 = list[num];
				if (TryReserveTalkSlot(val2.length))
				{
					lastTaunt = num;
					string clipType = (((Object)(object)val != (Object)null && (Object)(object)val2 == (Object)(object)val) ? "steamids" : "general");
					TauntClientRpc(((Object)val2).name, clipType);
				}
			}
			else
			{
				LGLog.Warn(LogCat.Scrap, "Gargoyle Statue was activated but the general taunt list is empty - nothing to play.");
			}
		}

		[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 val2 = default(ClientRpcParams);
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3274531793u, val2, (RpcDelivery)0);
				bool flag = clipName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(clipName, false);
				}
				bool flag2 = clipType != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(clipType, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3274531793u, val2, (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)
			{
				LGLog.Debug(LogCat.Scrap, $"Statue#{((NetworkBehaviour)this).NetworkObjectId} PLAYING {clipType}: {((Object)val3).name} (audio={((Object)scrapAudio).GetInstanceID()})");
				scrapAudio.PlayOneShot(val3);
				if (dogHear)
				{
					((MonoBehaviour)this).StartCoroutine(PlayNoiseWhileTalking());
				}
			}
			else if ((Object)(object)scrapAudio == (Object)null)
			{
				LGLog.Warn(LogCat.Scrap, "Gargoyle Statue has no AudioSource - it cannot play anything. The prefab is likely missing its AudioSource component.");
			}
			else
			{
				LGLog.Warn(LogCat.Audio, $"Statue taunt '{clipName}' (type '{clipType}') did not resolve locally - this machine has {list.Count} clip(s) for that type. " + "The audio transfer for that category was incomplete.");
			}
		}

		private IEnumerator PlayNoiseWhileTalking()
		{
			while ((Object)(object)scrapAudio != (Object)null && scrapAudio.isPlaying)
			{
				RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, scrapAudio.maxDistance / 1.2f, scrapAudio.volume, 0, false, 0);
				yield return (object)new WaitForSeconds(3f);
			}
		}

		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
	{
		public static IEnumerator KillEnemy(EnemyAI enemyAI, PlayerControllerB playerWhoHit)
		{
			yield return (object)new WaitForSeconds(1f);
			if (enemyAI.isEnemyDead)
			{
				LethalGargoylesAI.PlayerActivityTracker.UpdatePlayerActivity(playerWhoHit, LethalGargoylesAI.PlayerActivityTracker.PlayerActivityType.KilledEnemy, enemyAI.enemyType.enemyName);
			}
		}
	}
	[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)Unsafe.As<CauseOfDeath, CauseOfDeath>(ref val.causeOfDeath)/*cast due to .constrained prefix*/).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)Unsafe.As<CauseOfDeath, CauseOfDeath>(ref val.causeOfDeath)/*cast due to .constrained prefix*/).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;
		}

		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 int PUSH_DAMAGE = 2;

		private const float SlowMs = 2f;

		private const float AGGRO_EVAL_INTERVAL = 0.2f;

		private const float HIDE_EVAL_INTERVAL = 0.35f;

		public const int DEFAULT_SIGHT_RANGE_SQR = 120;

		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 SmartPathfindingLinkFlags _allowedLinks = (SmartPathfindingLinkFlags)1;

		private NavMeshPath? _zoneScratchPath;

		private float _corneredSince;

		private Vector3 _corneredAnchorPos;

		private float _corneredAggroUntil;

		private float corneredAggroDelay;

		private const float CORNERED_AGGRO_COMMIT = 8f;

		private const float CORNERED_PROGRESS_DIST = 8f;

		private bool _hideFoundCover = true;

		private bool _nodeChoiceFellBack;

		private float _nextHideTraceTime;

		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 steamIDTauntCooldown = 90f;

		private float distWarnSqr;

		private float bufferDistSqr;

		private float awareDistSqr;

		private float idleDistanceSqr;

		private bool enablePush;

		private const float IDLE_HYSTERESIS = 1.2f;

		private const float AWARE_HYSTERESIS = 1.15f;

		private float idleKeepDistSqr;

		private float awareKeepDistSqr;

		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 _lastSfxVolume = -1f;

		private float _nextTeleportTime;

		private readonly List<GameObject> _nodeScratch = new List<GameObject>();

		private readonly List<(float distSqr, Transform t)> _candidateScratch = new List<(float, Transform)>();

		private readonly List<(float distSqr, Transform t)> _bestScratch = new List<(float, Transform)>();

		private NavMeshPath? _scratchPath;

		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_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: 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);
			baseSpeed = Plugin.BoundConfig.baseSpeed.Value;
			attackDamage = Plugin.BoundConfig.attackDamage.Value;
			minTaunt = Plugin.BoundConfig.minTaunt.Value;
			maxTaunt = Plugin.BoundConfig.maxTaunt.Value;
			steamIDTauntCooldown = Plugin.BoundConfig.steamIDTauntCooldown.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;
			awareKeepDistSqr = awareDistSqr * 1.3225f;
			idleKeepDistSqr = idleDistanceSqr * 1.44f;
			enablePush = Plugin.BoundConfig.enablePush.Value;
			corneredAggroDelay = Plugin.BoundConfig.corneredAggroDelay.Value;
			float value = Plugin.BoundConfig.agentRadius.Value;
			if (value > 0f && !Mathf.Approximately(base.agent.radius, value))
			{
				LGLog.Info(LogCat.Movement, $"{GargoyleTag} agent radius {base.agent.radius:0.00} -> {value:0.00} (config)");
				base.agent.radius = value;
			}
			_allowedLinks = (SmartPathfindingLinkFlags)1;
			if (Plugin.BoundConfig.allowExitFacility.Value)
			{
				_allowedLinks = (SmartPathfindingLinkFlags)(_allowedLinks | 0xC);
			}
			if (Plugin.BoundConfig.allowElevators.Value)
			{
				_allowedLinks = (SmartPathfindingLinkFlags)(_allowedLinks | 2);
			}
			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 - (steamIDTauntCooldown + 1f);
			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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			((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)
			{
				return;
			}
			ApplyStateAudio();
			if (!((Behaviour)base.agent).enabled || !base.agent.isOnNavMesh || !((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			if ((Object)(object)_lastTarget != (Object)(object)base.targetPlayer)
			{
				gargoyleTargets[myID] = base.targetPlayer;
				_lastTarget = base.targetPlayer;
			}
			if (Time.time - lastNodeCheckTime > nodeCheckInterval)
			{
				CheckAndRefreshAINodes();
				lastNodeCheckTime = Time.time;
			}
			HandleTargetPlayer();
			if (Time.time - lastSeenCheckTime > 0.33f)
			{
				closestPlayer = ((EnemyAI)this).GetClosestPlayer(false, false, false);
				float num;
				if (!((Object)(object)closestPlayer != (Object)null))
				{
					num = float.MaxValue;
				}
				else
				{
					Vector3 val = ((Component)this).transform.position - ((Component)closestPlayer).transform.position;
					num = ((Vector3)(ref val)).sqrMagnitude;
				}
				distanceToClosestPlayerSqr = num;
				bool flag = GargoyleIsSeen(((Component)this).transform);
				if (flag && !isSeen)
				{
					pathDelayTimer = Time.time - 2f;
					_nextHideEvalTime = 0f;
					_nextPathRequestTime = 0f;
					LGLog.Debug(LogCat.Movement, GargoyleTag + " spotted - clearing hide commitment for an immediate re-evaluation");
					_corneredSince = Time.time;
					_corneredAnchorPos = ((Component)this).transform.position;
				}
				else if (!flag && isSeen)
				{
					_corneredSince = 0f;
					_corneredAggroUntil = 0f;
				}
				isSeen = flag;
				UpdateCorneredTimer();
				lastSeenCheckTime = Time.time;
			}
			HandlePushStage();
			HandleBehaviorState();
			if (base.currentBehaviourStateIndex == 0)
			{
				TryActivateSmartLink();
			}
			else if (base.currentBehaviourStateIndex != 4)
			{
				FollowSmartPath();
			}
		}

		[Conditional("DEBUG")]
		private void LogAiIntervalState()
		{
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: 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_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: 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)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time < _nextDoAiLogTime)
			{
				return;
			}
			_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}(keep {Mathf.Sqrt(awareKeepDistSqr):0.0}) aggro={Mathf.Sqrt(aggroRangeSqr):0.0} idle={Mathf.Sqrt(idleDistanceSqr):0.0}(keep {Mathf.Sqrt(idleKeepDistSqr):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");
		}

		public override void DoAIInterval()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).DoAIInterval();
			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)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())
				{
					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 OnNetworkDespawn()
		{
			RemoveSelfFromSharedState();
			((NetworkBehaviour)this).OnNetworkDespawn();
		}

		public override void OnDestroy()
		{
			RemoveSelfFromSharedState();
			CleanupSmartPathing();
			((EnemyAI)this).OnDestroy();
		}

		private void RemoveSelfFromSharedState()
		{
			gargoyleTargets.TryRemove(myID, out PlayerControllerB _);
			foreach (KeyValuePair<PlayerControllerB, ConcurrentDictionary<int, bool>> playerPushState in playerPushStates)
			{
				playerPushState.Value.TryRemove(myID, out var _);
			}
			activeGargoyles.Remove(this);
		}

		private void CleanupSmartPathing()
		{
			SmartPathTask? obj = pathingTask;
			if (obj != null)
			{
				obj.Dispose();
			}
			pathingTask = null;
			if (_smartRegistered)
			{
				if ((Object)(object)base.agent != (Object)null)
				{
					SmartPathfinding.UnregisterSmartAgent(base.agent);
				}
				_smartRegistered = false;
			}
		}

		private static void ClearAllVariables()
		{
			activeGargoyles.Clear();
			gargoyl