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 GameNetcodeStuff;
using HarmonyLib;
using LethalGargoyles.src.Config;
using LethalGargoyles.src.Enemy;
using LethalGargoyles.src.Patch;
using LethalGargoyles.src.SoftDepends;
using LethalGargoyles.src.Utility;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using NVorbis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Networking;

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

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

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

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

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

		public const string PLUGIN_NAME = "LethalGargoyles";

		public const string PLUGIN_VERSION = "0.5.0";
	}
}
namespace LethalGargoyles.src
{
	[BepInPlugin("DropDaDeuce.LethalGargoyles", "LethalGargoyles", "0.5.0")]
	[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 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 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);
			InitializeNetworkBehaviours();
			Instance = this;
			string path = "gargoyleassets";
			ModAssets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), path));
			if ((Object)(object)ModAssets == (Object)null)
			{
				Logger.LogError((object)"Failed to load custom assets.");
				return;
			}
			CustomAudioFolderPath = Path.Combine(Path.GetDirectoryName(Paths.ExecutablePath), "Lethal Gargoyles", "Custom Voice Lines");
			if (!Directory.Exists(CustomAudioFolderPath))
			{
				try
				{
					Directory.CreateDirectory(CustomAudioFolderPath);
				}
				catch (Exception arg)
				{
					Logger.LogError((object)$"Failed to create custom audio directory: {arg}");
					return;
				}
			}
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Combat Dialog", "Attack"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Combat Dialog", "Hit"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Activity"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Aggro"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Enemy"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Gargoyle Death"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - General"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Player Death"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - Prior Death", "Coroner"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - EmployeeClass"));
			Directory.CreateDirectory(Path.Combine(CustomAudioFolderPath, "Taunt - SteamIDs"));
			EnemyType val = ModAssets.LoadAsset<EnemyType>("LethalGargoyle");
			TerminalNode val2 = ModAssets.LoadAsset<TerminalNode>("LethalGargoyleTN");
			TerminalKeyword val3 = ModAssets.LoadAsset<TerminalKeyword>("LethalGargoyleTK");
			NetworkPrefabs.RegisterNetworkPrefab(val.enemyPrefab);
			Enemies.RegisterEnemy(val, BoundConfig.SpawnWeight.Value, (LevelTypes)(-1), val2, val3);
			harmony.PatchAll();
			IsCoronerLoaded = DepIsLoaded("com.elitemastereric.coroner");
			IsEmployeeClassesLoaded = DepIsLoaded("Jade.EmployeeClasses");
			Logger.LogInfo((object)("Coroner Is Loaded? " + IsCoronerLoaded));
			Logger.LogInfo((object)("EmployeeClasses Is Loaded? " + IsEmployeeClassesLoaded));
			if (IsCoronerLoaded)
			{
				CoronerClass.Init();
			}
			defaultAudioClipFilePaths = GetDefaultAudioClipFilePaths();
			BoundConfig.InitializeAudioClipConfigs(defaultAudioClipFilePaths);
			Logger.LogInfo((object)"Plugin DropDaDeuce.LethalGargoyles is loaded!");
		}

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

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

		private Dictionary<string, List<string>> GetDefaultAudioClipFilePaths()
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>
			{
				{
					"General",
					new List<string>()
				},
				{
					"Aggro",
					new List<string>()
				},
				{
					"Enemy",
					new List<string>()
				},
				{
					"PlayerDeath",
					new List<string>()
				},
				{
					"GargoyleDeath",
					new List<string>()
				},
				{
					"PriorDeath",
					new List<string>()
				},
				{
					"Attack",
					new List<string>()
				},
				{
					"Hit",
					new List<string>()
				},
				{
					"Activity",
					new List<string>()
				},
				{
					"SteamIDs",
					new List<string>()
				}
			};
			if (Instance.IsEmployeeClassesLoaded)
			{
				dictionary.Add("Class", new List<string>());
			}
			foreach (KeyValuePair<string, List<string>> item in dictionary)
			{
				string key = item.Key;
				List<string> value = item.Value;
				FileInfo[] mP3Files = AudioManager.GetMP3Files(key, "Voice Lines");
				FileInfo[] array = mP3Files;
				foreach (FileInfo fileInfo in array)
				{
					value.Add(fileInfo.FullName);
				}
				if (key == "PriorDeath" && Instance.IsCoronerLoaded)
				{
					FileInfo[] mP3Files2 = AudioManager.GetMP3Files("Coroner", "Voice Lines");
					FileInfo[] array2 = mP3Files2;
					foreach (FileInfo fileInfo2 in array2)
					{
						value.Add(fileInfo2.FullName);
					}
				}
				if (Instance.IsEmployeeClassesLoaded && key == "Class")
				{
					FileInfo[] mP3Files3 = AudioManager.GetMP3Files("EmployeeClass", "Voice Lines");
					FileInfo[] array3 = mP3Files3;
					foreach (FileInfo fileInfo3 in array3)
					{
						value.Add(fileInfo3.FullName);
					}
				}
			}
			return dictionary;
		}
	}
}
namespace LethalGargoyles.src.Utility
{
	public class AudioManager : NetworkBehaviour
	{
		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[] audioData2;
					if (PluginConfig.AudioClipEnableConfig.TryGetValue(clipName, out ConfigEntry<bool> value2))
					{
						if (!value2.Value)
						{
							continue;
						}
						audioData2 = AudioFileToByteArray(item);
						byte[] array = audioData2;
						if (array != null && array.Length > 512000)
						{
							Plugin.Logger.LogError((object)("Sending Clip(" + clipName + ") failed. Max clip size is 512000 bytes or 500KB"));
							break;
						}
						if (audioData2 != null)
						{
							await WaitForClientReady(clientId);
							if (!clientReady.ContainsKey(clientId))
							{
								break;
							}
							await SendAudioClipToClient(clientId, audioData2, clipName, category);
							clientReady[clientId] = false;
							SetClientReadyClientRpc(isReady: false, clientId);
							Plugin.Logger.LogInfo((object)$"Sent Clip({clipName}) to ClientID({clientId})");
						}
						continue;
					}
					audioData2 = AudioFileToByteArray(item);
					byte[] array2 = audioData2;
					if (array2 != null && array2.Length > 512000)
					{
						Plugin.Logger.LogError((object)("Sending Clip(" + clipName + ") failed. Max clip size is 512000 bytes or 500KB"));
						break;
					}
					if (audioData2 != null)
					{
						await WaitForClientReady(clientId);
						if (!clientReady.ContainsKey(clientId))
						{
							break;
						}
						await SendAudioClipToClient(clientId, audioData2, clipName, category);
						clientReady[clientId] = false;
						SetClientReadyClientRpc(isReady: false, clientId);
						Plugin.Logger.LogInfo((object)$"Sent Clip({clipName}) to ClientID({clientId})");
					}
				}
			}
		}

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

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

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

		public void OnReceivedMessage(ulong clientId, FastBufferReader messagePayload)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				SetClientReadyServerRpc(isReady: true, NetworkManager.Singleton.LocalClientId);
				string category = default(string);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe(ref category, false);
				string clipName = default(string);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe(ref clipName, false);
				int num = default(int);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				byte[] audioData = new byte[num];
				((FastBufferReader)(ref messagePayload)).ReadBytesSafe(ref audioData, num, 0);
				((MonoBehaviour)this).StartCoroutine(ProcessAudioClip(audioData, clipName, category));
			}
		}

		private IEnumerator ProcessAudioClip(byte[] audioData, string clipName, string category)
		{
			VorbisReader val = new VorbisReader((Stream)new MemoryStream(audioData, writable: false), true);
			try
			{
				float[] array = new float[val.TotalSamples];
				AudioClip val2 = AudioClip.Create(clipName, (int)(val.TotalSamples / val.Channels), val.Channels, val.SampleRate, false);
				val.ReadSamples(array, 0, (int)val.TotalSamples);
				val2.SetData(array, 0);
				List<AudioClip> clipListByCategory = GetClipListByCategory(category);
				clipListByCategory.Add(val2);
				Plugin.Logger.LogInfo((object)("Clip Loaded: " + ((Object)val2).name));
			}
			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);
					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 = defaultAudioClipFilePaths;
			foreach (KeyValuePair<string, List<string>> audioClipFilePath in AudioClipFilePaths)
			{
				string key = audioClipFilePath.Key;
				List<string> value = audioClipFilePath.Value;
				FileInfo[] mP3Files = GetMP3Files(key, "Custom Voice Lines");
				FileInfo[] array = mP3Files;
				foreach (FileInfo fileInfo in array)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
					bool flag = false;
					for (int j = 0; j < value.Count; j++)
					{
						string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(value[j]);
						if (fileNameWithoutExtension == fileNameWithoutExtension2)
						{
							value[j] = fileInfo.FullName;
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						value.Add(fileInfo.FullName);
					}
				}
				if (key == "PriorDeath" && Plugin.Instance.IsCoronerLoaded)
				{
					FileInfo[] mP3Files2 = GetMP3Files("Coroner", "Voice Lines");
					FileInfo[] mP3Files3 = GetMP3Files("Coroner", "Custom Voice Lines");
					FileInfo[] array2 = mP3Files2;
					foreach (FileInfo fileInfo2 in array2)
					{
						value.Add(fileInfo2.FullName);
					}
					FileInfo[] array3 = mP3Files3;
					foreach (FileInfo fileInfo3 in array3)
					{
						string fileNameWithoutExtension3 = Path.GetFileNameWithoutExtension(fileInfo3.FullName);
						bool flag2 = false;
						for (int m = 0; m < value.Count; m++)
						{
							string fileNameWithoutExtension4 = Path.GetFileNameWithoutExtension(value[m]);
							if (fileNameWithoutExtension3 == fileNameWithoutExtension4)
							{
								value[m] = fileInfo3.FullName;
								flag2 = true;
								break;
							}
						}
						if (!flag2)
						{
							value.Add(fileInfo3.FullName);
						}
					}
				}
				if (!Plugin.Instance.IsEmployeeClassesLoaded || !(key == "Class"))
				{
					continue;
				}
				FileInfo[] mP3Files4 = GetMP3Files("EmployeeClass", "Voice Lines");
				FileInfo[] mP3Files5 = GetMP3Files("EmployeeClass", "Custom Voice Lines");
				FileInfo[] array4 = mP3Files4;
				foreach (FileInfo fileInfo4 in array4)
				{
					value.Add(fileInfo4.FullName);
				}
				FileInfo[] array5 = mP3Files5;
				foreach (FileInfo fileInfo5 in array5)
				{
					string fileNameWithoutExtension5 = Path.GetFileNameWithoutExtension(fileInfo5.FullName);
					bool flag3 = false;
					for (int num2 = 0; num2 < value.Count; num2++)
					{
						string fileNameWithoutExtension6 = Path.GetFileNameWithoutExtension(value[num2]);
						if (fileNameWithoutExtension5 == fileNameWithoutExtension6)
						{
							value[num2] = fileInfo5.FullName;
							flag3 = true;
							break;
						}
					}
					if (!flag3)
					{
						value.Add(fileInfo5.FullName);
					}
				}
			}
		}

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

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

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_AudioManager()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2917554051u, new RpcReceiveHandler(__rpc_handler_2917554051));
			NetworkManager.__rpc_func_table.Add(1384767487u, new RpcReceiveHandler(__rpc_handler_1384767487));
		}

		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)2;
				((AudioManager)(object)target).SetClientReadyClientRpc(isReady, clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

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

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

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GargoyleDeath = API.Register("DeathEnemyLGargoyle");
				GargoylePushDeath = API.Register("DeathEnemyGargoylePush");
				Plugin.Logger.LogInfo((object)"Gargoyle causes of death registered with Coroner.");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Skipping Coroner initialization. Exception: {arg}");
			}
		}

		internal static void CoronerSetCauseOfDeath(PlayerControllerB player, string deathType)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (!(deathType == "Attack"))
			{
				if (deathType == "Push" && GargoylePushDeath != null)
				{
					SetCauseOfDeath((int)player.playerClientId, (AdvancedCauseOfDeath)GargoylePushDeath);
				}
			}
			else if (GargoyleDeath != null)
			{
				SetCauseOfDeath((int)player.playerClientId, (AdvancedCauseOfDeath)GargoyleDeath);
			}
		}

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

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

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static string? GetPlayerClass(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			try
			{
				if (Chainloader.PluginInfos.TryGetValue("Jade.EmployeeClasses", out var value))
				{
					Type type = ((object)value.Instance).GetType().Assembly.GetType("EmployeeClasses.Roles.RoleManager");
					if (type != null)
					{
						Component component = ((Component)player).GetComponent(type);
						if ((Object)(object)component != (Object)null)
						{
							FieldInfo field = type.GetField("selectedRole", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (field != null)
							{
								string text = (string)field.GetValue(component);
								if (text == null)
								{
									return null;
								}
								return text;
							}
						}
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error getting player class from EmployeeClasses: {arg}");
				return null;
			}
			return null;
		}
	}
}
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)(CauseOfDeath)(ref val.causeOfDeath)).ToString() ?? "Unknown";
						Plugin.Logger.LogInfo((object)("Vanilla caught " + val.playerUsername + "'s cause of death this round was " + text));
						previousRoundDeaths.Add((val.playerUsername, text, "Vanilla"));
						text = CoronerClass.CoronerGetCauseOfDeath(val) ?? "Unknown";
						Plugin.Logger.LogInfo((object)("Coroner caught " + val.playerUsername + "'s cause of death this round was " + text));
						previousRoundDeaths.Add((val.playerUsername, text, "Coroner"));
					}
					else
					{
						string text = ((object)(CauseOfDeath)(ref val.causeOfDeath)).ToString() ?? "Unknown";
						previousRoundDeaths.Add((val.playerUsername, text, "Vanilla"));
						Plugin.Logger.LogInfo((object)("Vanilla caught " + val.playerUsername + "'s cause of death this round was " + text));
					}
				}
			}
		}
	}
}
namespace LethalGargoyles.src.Enemy
{
	public class LethalGargoylesAI : EnemyAI
	{
		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 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 enum State
		{
			SearchingForPlayer,
			StealthyPursuit,
			GetOutOfSight,
			AggressivePursuit,
			Idle,
			PushTarget
		}

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

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

		public Transform turnCompass;

		public Transform attackArea;

		public DoorLock? currentDoor;

		public float lastDoorCloseTime;

		private PlayerControllerB closestPlayer;

		private PlayerControllerB aggroPlayer;

		private float randGenTauntTime;

		private float randAgrTauntTime;

		private float randEnemyTauntTime;

		private float lastGenTauntTime;

		private float lastAgrTauntTime;

		private float lastEnemyTauntTime;

		private float lastSteamIDTauntTime;

		private static int lastGenTaunt = -1;

		private static int lastAgrTaunt = -1;

		private int genTauntCount;

		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<Transform> cachedKillTriggers = new List<Transform>();

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

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

		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 readonly Dictionary<RelativeZone, Vector3> RelativeZones = new Dictionary<RelativeZone, Vector3>();

		public AISearchRoutine? searchForPlayers;

		public int myID;

		private static float lastNodeCheckTime = 0f;

		private readonly float nodeCheckInterval = 5f;

		private float lastAttackTime;

		private float distanceToPlayerSqr;

		private float distanceToClosestPlayerSqr;

		private string? lastEnemy;

		private bool isSeen;

		private bool canSeePlayer;

		private bool targetSeesGargoyle;

		private float pushTimer;

		private int pushStage;

		private float targetTimer;

		private RelativeZone currentZone;

		private RelativeZone nextZoneRight;

		private RelativeZone nextZoneLeft;

		private float leftPathDist;

		private float rightPathDist;

		private static int lastGargoyleToSwitch = 0;

		private float playerCheckTimer;

		private float pathDelayTimer;

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

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

		private int previousStateIndex;

		private Transform? killTrigger;

		private float distToKillTriggerSqr;

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

		private float lastSeenCheckTime;

		private float baseSpeed;

		private float attackRangeSqr;

		private int attackDamage;

		private float aggroRangeSqr;

		private int minTaunt;

		private int maxTaunt;

		private float distWarnSqr;

		private float bufferDistSqr;

		private float awareDistSqr;

		private float idleDistanceSqr;

		private bool enablePush;

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

		private string StateToString(int state)
		{
			return state switch
			{
				0 => "SearchingForPlayer", 
				1 => "StealthyPusuit", 
				2 => "GetOutOfSight", 
				3 => "AggressivePursuit", 
				4 => "Idle", 
				5 => "PushTarget", 
				_ => "Unknown", 
			};
		}

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

		public override void Start()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).Start();
			LGInstance = this;
			DoAnimationClientRpc("startWalk");
			((EnemyAI)this).SwitchToBehaviourClientRpc(0);
			((EnemyAI)this).StartSearch(((Component)this).transform.position, (AISearchRoutine)null);
			baseSpeed = Plugin.BoundConfig.baseSpeed.Value;
			attackDamage = Plugin.BoundConfig.attackDamage.Value;
			minTaunt = Plugin.BoundConfig.minTaunt.Value;
			maxTaunt = Plugin.BoundConfig.maxTaunt.Value;
			attackRangeSqr = Plugin.BoundConfig.attackRange.Value;
			attackRangeSqr *= attackRangeSqr;
			aggroRangeSqr = Plugin.BoundConfig.aggroRange.Value;
			aggroRangeSqr *= aggroRangeSqr;
			distWarnSqr = Plugin.BoundConfig.distWarn.Value;
			distWarnSqr *= distWarnSqr;
			idleDistanceSqr = Plugin.BoundConfig.idleDistance.Value;
			idleDistanceSqr *= idleDistanceSqr;
			bufferDistSqr = Plugin.BoundConfig.bufferDist.Value;
			bufferDistSqr *= bufferDistSqr;
			awareDistSqr = Plugin.BoundConfig.awareDist.Value;
			awareDistSqr *= awareDistSqr;
			enablePush = Plugin.BoundConfig.enablePush.Value;
			lastAttackTime = Time.time;
			pushTimer = Time.time;
			myID = ((Object)base.agent).GetInstanceID();
			gargoyleTargets[myID] = base.targetPlayer;
			AudioSource creatureVoice = base.creatureVoice;
			creatureVoice.maxDistance *= 3f;
			pathDelayTimer = Time.time;
			lastSteamIDTauntTime = Time.time - 91f;
			if (cachedOutsideAINodes.Count > 0)
			{
				cachedOutsideAINodes.Clear();
			}
			GameObject[] outsideAINodes = RoundManager.Instance.outsideAINodes;
			foreach (GameObject val in outsideAINodes)
			{
				if ((Object)(object)val != (Object)null)
				{
					cachedOutsideAINodes.Add(val);
				}
			}
			if (cachedInsideAINodes.Count > 0)
			{
				cachedInsideAINodes.Clear();
			}
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			foreach (GameObject val2 in insideAINodes)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					cachedInsideAINodes.Add(val2);
				}
			}
			if (cachedAllAINodes.Count > 0)
			{
				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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).Update();
			if (base.isEnemyDead || StartOfRound.Instance.allPlayersDead)
			{
				return;
			}
			gargoyleTargets[myID] = base.targetPlayer;
			if (Time.time - lastNodeCheckTime > nodeCheckInterval)
			{
				CheckAndRefreshAINodes();
				lastNodeCheckTime = Time.time;
			}
			HandleTargetPlayer();
			if (Time.time - lastSeenCheckTime > 0.2f)
			{
				closestPlayer = ((EnemyAI)this).GetClosestPlayer(false, false, false);
				float num;
				if (!((Object)(object)closestPlayer != (Object)null))
				{
					num = 0f;
				}
				else
				{
					Vector3 val = ((Component)this).transform.position - ((Component)closestPlayer).transform.position;
					num = ((Vector3)(ref val)).sqrMagnitude;
				}
				distanceToClosestPlayerSqr = num;
				isSeen = GargoyleIsSeen(((Component)this).transform);
				lastSeenCheckTime = Time.time;
			}
			HandlePushStage();
			HandleBehaviorState();
		}

		private void HandleTargetPlayer()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.targetPlayer == (Object)null)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(0);
				return;
			}
			Vector3 val = ((Component)this).transform.position - ((Component)base.targetPlayer).transform.position;
			distanceToPlayerSqr = ((Vector3)(ref val)).sqrMagnitude;
			if (base.currentBehaviourStateIndex != 5)
			{
				ResetPushStage();
			}
			if (!base.isOutside != base.targetPlayer.isInsideFactory || !base.targetPlayer.isPlayerControlled || base.targetPlayer.isPlayerDead || distanceToPlayerSqr > awareDistSqr)
			{
				base.targetPlayer = null;
				((EnemyAI)this).SwitchToBehaviourClientRpc(0);
			}
		}

		private void HandleBehaviorState()
		{
			switch (base.currentBehaviourStateIndex)
			{
			case 4:
				HandleIdleState();
				break;
			case 0:
				HandleSearchingForPlayerState();
				break;
			case 1:
				HandleStealthyPursuitState();
				break;
			case 3:
				HandleAggressivePursuitState();
				break;
			case 2:
				HandleGetOutOfSightState();
				break;
			case 5:
				HandlePushTargetState();
				break;
			}
		}

		private void ResetPushStage()
		{
			pushStage = 0;
			ConcurrentDictionary<int, bool> orAdd = playerPushStates.GetOrAdd(base.targetPlayer, new ConcurrentDictionary<int, bool>());
			orAdd[myID] = false;
			foreach (KeyValuePair<PlayerControllerB, ConcurrentDictionary<int, bool>> playerPushState in playerPushStates)
			{
				if (!playerPushState.Key.playerUsername.Equals(base.targetPlayer.playerUsername))
				{
					playerPushState.Value.TryRemove(myID, out var _);
				}
			}
		}

		private void HandlePushStage()
		{
			if (pushStage < 1 && distanceToClosestPlayerSqr <= awareDistSqr)
			{
				HandleAggroAndPush();
			}
		}

		private void HandleOutOfAggroRange()
		{
			if (isSeen)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(2);
			}
			else if (distanceToPlayerSqr <= idleDistanceSqr && (Object)(object)base.targetPlayer != (Object)null)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(4);
			}
			else if ((Object)(object)base.targetPlayer != (Object)null)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(1);
			}
			else if (base.currentBehaviourStateIndex != 0)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(0);
			}
		}

		private void HandleAggroAndPush()
		{
			if (distanceToClosestPlayerSqr > aggroRangeSqr)
			{
				randAgrTauntTime = Time.time - lastAgrTauntTime;
			}
			if (distanceToClosestPlayerSqr <= aggroRangeSqr && isSeen)
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(3);
			}
			else if (distanceToClosestPlayerSqr <= attackRangeSqr && !isSeen && (Object)(object)closestPlayer != (Object)null && base.currentBehaviourStateIndex != 3 && enablePush)
			{
				PushPlayer(closestPlayer);
			}
			else if (distanceToClosestPlayerSqr > aggroRangeSqr)
			{
				HandleOutOfAggroRange();
			}
			if (!targetSeesGargoyle && (Object)(object)base.targetPlayer != (Object)null && base.currentBehaviourStateIndex != 3 && Time.time > pushTimer && enablePush && distToKillTriggerSqr <= 4f)
			{
				HandlePushTarget();
			}
		}

		private void HandlePushTarget()
		{
			lock (playerPushStates)
			{
				if (playerPushStates.TryGetValue(base.targetPlayer, out ConcurrentDictionary<int, bool> value) && !value.Any((KeyValuePair<int, bool> kvp) => kvp.Key != myID && kvp.Value))
				{
					playerPushStates.GetOrAdd(base.targetPlayer, new ConcurrentDictionary<int, bool>())[myID] = true;
					((EnemyAI)this).SwitchToBehaviourClientRpc(5);
				}
				else
				{
					pushTimer = Time.time + 10f;
				}
			}
		}

		private void HandleIdleState()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			base.agent.speed = 0f;
			base.agent.angularSpeed = 140f;
			base.creatureSFX.volume = 0f;
			base.agent.stoppingDistance = 0.1f;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				LookAtTarget(((Component)base.targetPlayer).transform.position);
				if (Time.time - lastGenTauntTime >= randGenTauntTime)
				{
					Taunt();
				}
				else if (Time.time - lastEnemyTauntTime >= randEnemyTauntTime)
				{
					EnemyTaunt();
				}
			}
		}

		private void HandleSearchingForPlayerState()
		{
			base.agent.speed = baseSpeed * 1.5f;
			base.agent.angularSpeed = 250f;
			base.creatureSFX.volume = 1f;
			base.agent.stoppingDistance = 0.2f;
			SearchForPlayers();
		}

		private void HandleStealthyPursuitState()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			base.agent.speed = baseSpeed;
			base.agent.angularSpeed = 140f;
			base.creatureSFX.volume = 0.5f;
			base.agent.stoppingDistance = 0.1f;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				if (!SetDestinationToHiddenPosition())
				{
					((EnemyAI)this).SetDestinationToPosition(((Component)base.targetPlayer).transform.position, false);
				}
				if (Time.time - lastGenTauntTime >= randGenTauntTime)
				{
					Taunt();
				}
				else if (Time.time - lastEnemyTauntTime >= randEnemyTauntTime)
				{
					EnemyTaunt();
				}
			}
			else
			{
				((EnemyAI)this).SwitchToBehaviourClientRpc(0);
			}
		}

		private void HandleAggressivePursuitState()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			base.agent.speed = baseSpeed * 1.8f;
			base.creatureSFX.volume = 1.7f;
			base.agent.angularSpeed = 180f;
			base.agent.stoppingDistance = 0.1f;
			if ((Object)(object)closestPlayer != (Object)null)
			{
				aggroPlayer = closestPlayer;
				canSeePlayer = CanSeePlayer(aggroPlayer);
				bool flag = GargoyleIsTalking();
				if (Time.time - lastAgrTauntTime >= randAgrTauntTime && !flag)
				{
					OtherTaunt("aggro", ref lastAgrTaunt, ref lastAgrTauntTime, ref randAgrTauntTime);
				}
				LookAtTarget(((Component)aggroPlayer).transform.position);
				((EnemyAI)this).SetDestinationToPosition(((Component)aggroPlayer).transform.position, false);
				if (Time.time - lastAttackTime >= 1f && canSeePlayer && attackRangeSqr >= distanceToClosestPlayerSqr)
				{
					AttackPlayer(aggroPlayer);
				}
			}
		}

		private void HandleGetOutOfSightState()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			base.agent.speed = baseSpeed * 1.5f;
			base.agent.angularSpeed = 250f;
			base.creatureSFX.volume = 1f;
			base.agent.stoppingDistance = 0.2f;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				bool flag = SetDestinationToHiddenPosition();
				if (Time.time - lastGenTauntTime >= randGenTauntTime)
				{
					Taunt();
				}
				if (!flag)
				{
					((EnemyAI)this).SetDestinationToPosition(((Component)base.targetPlayer).transform.position, false);
				}
			}
		}

		private void HandlePushTargetState()
		{
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			base.agent.speed = baseSpeed * 2.5f;
			base.creatureSFX.volume = 1.7f;
			base.agent.angularSpeed = 500f;
			base.agent.stoppingDistance = 0.3f;
			if (!((Object)(object)base.targetPlayer != (Object)null))
			{
				return;
			}
			canSeePlayer = CanSeePlayer(base.targetPlayer);
			if (distanceToPlayerSqr <= attackRangeSqr && (!targetSeesGargoyle || pushStage == 1))
			{
				PushPlayer(base.targetPlayer);
				pushStage = 0;
				pushTimer = Time.time + 45f;
				if (playerPushStates.TryGetValue(base.targetPlayer, out ConcurrentDictionary<int, bool> value))
				{
					value[myID] = false;
				}
				((EnemyAI)this).SwitchToBehaviourClientRpc(1);
			}
			if (pushStage < 1)
			{
				if ((double)distanceToPlayerSqr <= (double)aggroRangeSqr * 1.5 && !targetSeesGargoyle && canSeePlayer)
				{
					pushStage = 1;
					((EnemyAI)this).SetDestinationToPosition(((Component)base.targetPlayer).transform.position, false);
				}
			}
			else
			{
				((EnemyAI)this).SetDestinationToPosition(((Component)base.targetPlayer).transform.position, false);
			}
		}

		public override void DoAIInterval()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			((EnemyAI)this).DoAIInterval();
			if (base.isEnemyDead || StartOfRound.Instance.allPlayersDead)
			{
				return;
			}
			_ = base.currentBehaviourStateIndex;
			_ = previousStateIndex;
			previousStateIndex = base.currentBehaviourStateIndex;
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				killTrigger = FindNearestKillTrigger(((Component)base.targetPlayer).transform.position);
				if (Time.time - playerCheckTimer > 3f)
				{
					ChangeTarget();
					playerCheckTimer = Time.time;
				}
			}
			if ((Object)(object)LGInstance != (Object)null && (Object)(object)currentDoor != (Object)null && Time.time - lastDoorCloseTime >= 0.75f && !currentDoor.isLocked && ((Component)currentDoor).GetComponent<AnimatedObjectTrigger>().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;
				}
			}
			switch (base.currentBehaviourStateIndex)
			{
			case 0:
				if (FoundClosestPlayerInRange())
				{
					((EnemyAI)this).StopSearch(base.currentSearch, true);
					((EnemyAI)this).SwitchToBehaviourClientRpc(1);
				}
				if (base.agent.hasPath)
				{
					DoAnimationClientRpc("startWalk");
				}
				else
				{
					DoAnimationClientRpc("startIdle");
				}
				break;
			case 1:
			case 2:
				if (base.agent.hasPath)
				{
					DoAnimationClientRpc("startWalk");
				}
				else
				{
					DoAnimationClientRpc("startIdle");
				}
				break;
			case 4:
				DoAnimationClientRpc("startIdle");
				break;
			case 3:
				if (base.agent.hasPath)
				{
					DoAnimationClientRpc("startChase");
				}
				else
				{
					DoAnimationClientRpc("startIdle");
				}
				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);
						((EnemyAI)this).SetDestinationToPosition(targetPosition, true);
					}
					else
					{
						((EnemyAI)this).SetDestinationToPosition(((Component)base.targetPlayer).transform.position, false);
					}
					targetTimer = Time.time;
				}
				if (base.agent.hasPath)
				{
					DoAnimationClientRpc("startChase");
				}
				else
				{
					DoAnimationClientRpc("startIdle");
				}
				break;
			}
		}

		private void CacheKillTriggers()
		{
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			cachedKillTriggers.Clear();
			GameObject[] array2 = array;
			BoxCollider val2 = default(BoxCollider);
			foreach (GameObject val in array2)
			{
				if (((Object)val).name.StartsWith("KillTrigger") && val.TryGetComponent<BoxCollider>(ref val2))
				{
					cachedKillTriggers.Add(val.transform);
				}
			}
		}

		private void CheckAndRefreshAINodes()
		{
			RefreshNodesIfNull(cachedOutsideAINodes, RoundManager.Instance.outsideAINodes, "outside");
			RefreshNodesIfNull(cachedInsideAINodes, RoundManager.Instance.insideAINodes, "inside");
			RefreshNodesIfNull(cachedAllAINodes, base.allAINodes, "all");
		}

		private void RefreshNodesIfNull(List<GameObject> cachedNodes, IEnumerable<GameObject> sourceNodes, string nodeType)
		{
			if (!cachedNodes.Any((GameObject node) => (Object)(object)node == (Object)null) || !sourceNodes.Any())
			{
				return;
			}
			cachedNodes.Clear();
			foreach (GameObject sourceNode in sourceNodes)
			{
				if ((Object)(object)sourceNode != (Object)null)
				{
					cachedNodes.Add(sourceNode);
				}
			}
		}

		private Transform? FindNearestKillTrigger(Vector3 playerPosition)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(playerPosition.x, playerPosition.z);
			Vector2 val5 = default(Vector2);
			Bounds bounds;
			foreach (Transform cachedKillTrigger in cachedKillTriggers)
			{
				if (!((Object)(object)cachedKillTrigger != (Object)null))
				{
					continue;
				}
				Vector3 val3 = playerPosition - cachedKillTrigger.position;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				if (!(sqrMagnitude <= num2))
				{
					continue;
				}
				BoxCollider component = ((Component)cachedKillTrigger).GetComponent<BoxCollider>();
				Vector3 val4 = ((Collider)component).ClosestPointOnBounds(playerPosition);
				((Vector2)(ref val5))..ctor(val4.x, val4.z);
				if (!(cachedKillTrigger.position.y < playerPosition.y))
				{
					continue;
				}
				float num3 = Mathf.Abs(val5.x - val2.x);
				bounds = ((Collider)component).bounds;
				if (!(num3 < ((Bounds)(ref bounds)).extents.x + 1f))
				{
					continue;
				}
				float num4 = Mathf.Abs(val5.y - val2.y);
				bounds = ((Collider)component).bounds;
				if (num4 < ((Bounds)(ref bounds)).extents.z + 1f)
				{
					Vector2 val6 = val5 - val2;
					float sqrMagnitude2 = ((Vector2)(ref val6)).sqrMagnitude;
					if (sqrMagnitude2 < num)
					{
						num = sqrMagnitude2;
						val = cachedKillTrigger;
					}
				}
			}
			distToKillTriggerSqr = num;
			if ((Object)(object)val != (Object)null)
			{
				BoxCollider component2 = ((Component)val).GetComponent<BoxCollider>();
				float x = playerPosition.x;
				bounds = ((Collider)component2).bounds;
				Vector3 val7 = default(Vector3);
				((Vector3)(ref val7))..ctor(x, ((Bounds)(ref bounds)).center.y, playerPosition.z);
				bounds = ((Collider)component2).bounds;
				if (((Bounds)(ref bounds)).Contains(val7))
				{
					distToKillTriggerSqr = 0f;
				}
			}
			return val;
		}

		private Transform? FindNearestRailing(Vector3 position)
		{
			//IL_0008: 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_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)
			Transform result = null;
			float num = float.MaxValue;
			Collider[] array = Physics.OverlapSphere(position, 2f, 1 << LayerMask.NameToLayer("Railing"));
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				Vector3 val2 = position - ((Component)val).transform.position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = ((Component)val).transform;
				}
			}
			return result;
		}

		private IEnumerator DelayDoorClose(DoorLock door)
		{
			yield return (object)new WaitForSeconds(0.1f);
			if ((Object)(object)LGInstance != (Object)null)
			{
				AnimatedObjectTrigger component = ((Component)door).gameObject.GetComponent<AnimatedObjectTrigger>();
				component.TriggerAnimationNonPlayer(true, true, false);
			}
			door.CloseDoorNonPlayerServerRpc();
		}

		private EnemyAI? EnemyNearGargoyle()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.targetPlayer != (Object)null)
			{
				foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
				{
					Vector3 val = ((Component)spawnedEnemy).transform.position - ((Component)this).transform.position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude <= distWarnSqr)
					{
						return spawnedEnemy;
					}
				}
			}
			return null;
		}

		private Dictionary<PlayerControllerB, int> GetGargoyleTargetCounts()
		{
			UpdateValidPlayersAndGargoyles();
			Dictionary<PlayerControllerB, int> dictionary = new Dictionary<PlayerControllerB, int>();
			foreach (PlayerControllerB validPlayer in validPlayers)
			{
				dictionary[validPlayer] = 0;
			}
			foreach (LethalGargoylesAI gargoyle in gargoyles)
			{
				if (gargoyleTargets.TryGetValue(gargoyle.myID, out PlayerControllerB value) && (Object)(object)value != (Object)null && validPlayers.Contains(value))
				{
					dictionary[value]++;
				}
			}
			return dictionary;
		}

		private bool FoundClosestPlayerInRange()
		{
			Dictionary<PlayerControllerB, int> gargoyleTargetCounts = GetGargoyleTargetCounts();
			int fairShare = Mathf.CeilToInt((float)gargoyles.Count / (float)validPlayers.Count);
			if ((Object)(object)base.targetPlayer != (Object)null && gargoyleTargetCounts.ContainsKey(base.targetPlayer) && gargoyleTargetCounts[base.targetPlayer] > 1 && validPlayers.Count > 1)
			{
				PlayerControllerB val = FindBestTarget(gargoyleTargetCounts, fairShare);
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)base.targetPlayer)
				{
					gargoyleTargets[myID] = val;
					base.targetPlayer = val;
				}
			}
			else
			{
				base.targetPlayer = null;
			}
			if ((Object)(object)base.targetPlayer == (Object)null)
			{
				base.targetPlayer = FindBestTarget(gargoyleTargetCounts, fairShare);
				if ((Object)(object)base.targetPlayer != (Object)null)
				{
					return true;
				}
				return false;
			}
			return true;
		}

		private void ChangeTarget()
		{
			Dictionary<PlayerControllerB, int> gargoyleTargetCounts = GetGargoyleTargetCounts();
			int num = Mathf.CeilToInt((float)gargoyles.Count / (float)validPlayers.Count);
			bool flag = false;
			foreach (KeyValuePair<PlayerControllerB, int> item in gargoyleTargetCounts)
			{
				if (item.Value > num)
				{
					flag = true;
					break;
				}
			}
			if (!((Object)(object)base.targetPlayer != (Object)null && gargoyleTargets.ContainsKey(myID) && (Object)(object)gargoyleTargets[myID] == (Object)(object)base.targetPlayer && gargoyleTargetCounts.ContainsKey(base.targetPlayer) && gargoyleTargetCounts[base.targetPlayer] > num && validPlayers.Count > 1 && flag))
			{
				return;
			}
			List<int> list = new List<int>(from g in gargoyles
				select g.myID into id
				orderby id
				select id);
			int num2 = list.IndexOf(myID);
			if (num2 == (lastGargoyleToSwitch = (lastGargoyleToSwitch + 1) % list.Count))
			{
				PlayerControllerB val = FindBestTarget(gargoyleTargetCounts, num);
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)base.targetPlayer)
				{
					gargoyleTargets[myID] = val;
					base.targetPlayer = val;
				}
			}
		}

		private PlayerControllerB? FindBestTarget(Dictionary<PlayerControllerB, int> targetCounts, int fairShare)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB result = null;
			int num = int.MaxValue;
			float num2 = awareDistSqr;
			foreach (KeyValuePair<PlayerControllerB, int> targetCount in targetCounts)
			{
				if (targetCount.Value >= fairShare)
				{
					continue;
				}
				Vector3 val = ((Component)this).transform.position - ((Component)targetCount.Key).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude <= awareDistSqr)
				{
					val = ((Component)this).transform.position - ((Component)targetCount.Key).transform.position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (targetCount.Value < num || (targetCount.Value == num && sqrMagnitude < num2))
					{
						num = targetCount.Value;
						num2 = sqrMagnitude;
						result = targetCount.Key;
					}
				}
			}
			return result;
		}

		private void UpdateValidPlayersAndGargoyles()
		{
			validPlayers.Clear();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!val.isPlayerDead && val.isInsideFactory == !base.isOutside)
				{
					validPlayers.Add(val);
				}
			}
			gargoyles.Clear();
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (spawnedEnemy is LethalGargoylesAI lethalGargoylesAI && ((EnemyAI)lethalGargoylesAI).isOutside == base.isOutside)
				{
					gargoyles.Add(lethalGargoylesAI);
				}
			}
		}

		public void SearchForPlayers()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (searchForPlayers != null && !searchForPlayers.inProgress)
			{
				((EnemyAI)this).StartSearch(((Component)this).transform.position, searchForPlayers);
			}
		}

		private bool SetDestinationToHiddenPosition()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time - pathDelayTimer < 2f && base.agent.hasPath)
			{
				return true;
			}
			if (distanceToPlayerSqr > idleDistanceSqr)
			{
				((EnemyAI)this).SetDestinationToPosition(ChooseClosestNodeToPos(((Component)base.targetPlayer).transform.position, avoidLineOfSight: true), true);
				return true;
			}
			List<Vector3> list = FindCoverPointsAroundTarget();
			PlayerControllerB targetPlayer = base.targetPlayer;
			Transform val = ((targetPlayer != null) ? ((Component)targetPlayer).transform : null);
			if (list.Count == 0 || (Object)(object)val == (Object)null)
			{
				return false;
			}
			Vector3 val2 = default(Vector3);
			float num = awareDistSqr;
			Vector3 val3;
			foreach (Vector3 item in list)
			{
				val3 = val.position - item;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				if (sqrMagnitude >= bufferDistSqr && sqrMagnitude < num)
				{
					val2 = item;
					num = sqrMagnitude;
				}
			}
			Vector3 val4 = val2;
			val3 = default(Vector3);
			if (val4 == val3)
			{
				num = float.MaxValue;
				foreach (Vector3 item2 in list)
				{
					val3 = val.position - item2;
					float sqrMagnitude2 = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude2 >= aggroRangeSqr + 2f && sqrMagnitude2 < num)
					{
						val2 = item2;
						num = sqrMagnitude2;
					}
				}
			}
			Vector3 val5 = val2;
			val3 = default(Vector3);
			if (val5 != val3)
			{
				((EnemyAI)this).SetDestinationToPosition(val2, true);
				pathDelayTimer = Time.time;
				return true;
			}
			return false;
		}

		public List<Vector3> FindCoverPointsAroundTarget()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: 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_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			Vector3 position = ((Component)base.targetPlayer).transform.position;
			Bounds val = default(Bounds);
			((Bounds)(ref val))..ctor(position, new Vector3(40f, 2f, 40f));
			Bounds val2 = default(Bounds);
			((Bounds)(ref val2))..ctor(((Component)this).transform.position, new Vector3(40f, 2f, 40f));
			List<GameObject> list2 = new List<GameObject>();
			if (base.isOutside)
			{
				foreach (GameObject cachedOutsideAINode in cachedOutsideAINodes)
				{
					if ((Object)(object)cachedOutsideAINode != (Object)null && (((Bounds)(ref val2)).Contains(cachedOutsideAINode.transform.position) || ((Bounds)(ref val)).Contains(cachedOutsideAINode.transform.position)))
					{
						list2.Add(cachedOutsideAINode);
					}
				}
				if (list2.Count == 0)
				{
					foreach (GameObject cachedAllAINode in cachedAllAINodes)
					{
						if ((Object)(object)cachedAllAINode != (Object)null && (((Bounds)(ref val2)).Contains(cachedAllAINode.transform.position) || ((Bounds)(ref val)).Contains(cachedAllAINode.transform.position)))
						{
							list2.Add(cachedAllAINode);
						}
					}
				}
			}
			else
			{
				foreach (GameObject cachedInsideAINode in cachedInsideAINodes)
				{
					if ((Object)(object)cachedInsideAINode != (Object)null && (((Bounds)(ref val2)).Contains(cachedInsideAINode.transform.position) || ((Bounds)(ref val)).Contains(cachedInsideAINode.transform.position)))
					{
						list2.Add(cachedInsideAINode);
					}
				}
				if (list2.Count == 0)
				{
					foreach (GameObject cachedAllAINode2 in cachedAllAINodes)
					{
						if ((Object)(object)cachedAllAINode2 != (Object)null && (((Bounds)(ref val2)).Contains(cachedAllAINode2.transform.position) || ((Bounds)(ref val)).Contains(cachedAllAINode2.transform.position)))
						{
							list2.Add(cachedAllAINode2);
						}
					}
				}
			}
			foreach (GameObject item in list2)
			{
				for (int i = 0; i < 3; i++)
				{
					Vector3 position2 = item.transform.position;
					Vector2 val3 = Random.insideUnitCircle * 3f;
					position2 += new Vector3(val3.x, 0f, val3.y);
					position2 = ValidateZonePosition(position2);
					if (!(position2 != default(Vector3)))
					{
						continue;
					}
					bool flag = true;
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val4 in allPlayerScripts)
					{
						if (!val4.isPlayerDead && val4.isPlayerControlled && base.isOutside != val4.isInsideFactory && (((Bounds)(ref val)).Contains(((Component)val4).transform.position) || ((Bounds)(ref val2)).Contains(((Component)val4).transform.position)) && (val4.HasLineOfSightToPosition(position2, 60f, 60, 25f) || PathIsIntersectedByLOS(position2)) && CheckForPath(((Component)this).transform.position, position2))
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						list.Add(position2);
					}
				}
			}
			return list;
		}

		public Vector3 ChooseClosestNodeToPos(Vector3 pos, bool avoidLineOfSight = false, int offset = 0)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] array = null;
			Vector3 zero = Vector3.zero;
			List<GameObject> list = new List<GameObject>();
			if (base.isOutside)
			{
				foreach (GameObject cachedOutsideAINode in cachedOutsideAINodes)
				{
					if ((Object)(object)cachedOutsideAINode != (Object)null)
					{
						list.Add(cachedOutsideAINode);
					}
				}
				if (list.Count == 0)
				{
					foreach (GameObject cachedAllAINode in cachedAllAINodes)
					{
						if ((Object)(object)cachedAllAINode != (Object)null)
						{
							list.Add(cachedAllAINode);
						}
					}
				}
			}
			else
			{
				foreach (GameObject cachedInsideAINode in cachedInsideAINodes)
				{
					if ((Object)(object)cachedInsideAINode != (Object)null)
					{
						list.Add(cachedInsideAINode);
					}
				}
				if (list.Count == 0)
				{
					foreach (GameObject cachedAllAINode2 in cachedAllAINodes)
					{
						if ((Object)(object)cachedAllAINode2 != (Object)null)
						{
							list.Add(cachedAllAINode2);
						}
					}
				}
			}
			if (array == null || zero != pos)
			{
				array = (GameObject[])(object)new GameObject[list.Count];
				list.CopyTo(array);
				for (int i = 0; i < array.Length - 1; i++)
				{
					for (int j = i + 1; j < array.Length; j++)
					{
						Vector3 val = pos - array[i].transform.position;
						float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
						val = pos - array[j].transform.position;
						if (sqrMagnitude > ((Vector3)(ref val)).sqrMagnitude)
						{
							ref GameObject reference = ref array[i];
							ref GameObject reference2 = ref array[j];
							GameObject val2 = array[j];
							GameObject val3 = array[i];
							reference = val2;
							reference2 = val3;
						}
					}
				}
			}
			Transform transform = array[0].transform;
			for (int k = 0; k < array.Length; k++)
			{
				if (!PathIsIntersectedByLOS(array[k].transform.position, calculatePathDistance: false, avoidLineOfSight))
				{
					base.mostOptimalDistance = Vector3.Distance(pos, array[k].transform.position);
					transform = array[k].transform;
					if (offset == 0 || k >= array.Length - 1)
					{
						break;
					}
					offset--;
				}
			}
			return transform.position;
		}

		public bool PathIsIntersectedByLOS(Vector3 targetPos, bool calculatePathDistance = false, bool avoidLineOfSight = true, bool checkLOSToTargetPlayer = false)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: 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_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: 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)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			base.pathDistance = 0f;
			if (base.agent.isOnNavMesh && !base.agent.CalculatePath(targetPos, base.path1))
			{
				return true;
			}
			if (base.path1 == null || base.path1.corners.Length == 0)
			{
				return true;
			}
			Vector3 val = base.path1.corners[^1] - RoundManager.Instance.GetNavMeshPosition(targetPos, RoundManager.Instance.navHit, 2.7f, -1);
			if (((Vector3)(ref val)).sqrMagnitude > 2.25f)
			{
				return true;
			}
			bool flag = false;
			if (calculatePathDistance)
			{
				for (int i = 1; i < base.path1.corners.Length; i++)
				{
					base.pathDistance += Vector3.Distance(base.path1.corners[i - 1], base.path1.corners[i]);
					if (i > 15 || !(avoidLineOfSight || checkLOSToTargetPlayer))
					{
						continue;
					}
					if (!flag && i > 8)
					{
						val = base.path1.corners[i - 1] - base.path1.corners[i];
						if (((Vector3)(ref val)).sqrMagnitude < 4f)
						{
							flag = true;
							i++;
							continue;
						}
					}
					flag = false;
					if (checkLOSToTargetPlayer && (Object)(object)base.targetPlayer != (Object)null && !Physics.Linecast(base.path1.corners[i - 1], ((Component)base.targetPlayer).transform.position + Vector3.up * 0.3f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
					{
						return true;
					}
					if (avoidLineOfSight && Physics.Linecast(base.path1.corners[i - 1], base.path1.corners[i], 262144))
					{
						return true;
					}
				}
			}
			else if (avoidLineOfSight)
			{
				for (int j = 1; j < base.path1.corners.Length; j++)
				{
					if (!flag && j > 8