using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EverythingCanDieAlternative.ModCompatibility;
using EverythingCanDieAlternative.ModCompatibility.Handlers;
using EverythingCanDieAlternative.UI;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EverythingCanDieAlternative")]
[assembly: AssemblyFileVersion("1.1.81")]
[assembly: AssemblyDescription("A mod that makes everything in Lethal Company damageable")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("1.1.81.0")]
namespace EverythingCanDieAlternative
{
	public class DespawnConfiguration
	{
		private static DespawnConfiguration _instance;

		private ConfigFile _configFile;

		private readonly Dictionary<string, ConfigEntry<bool>> _enemyDespawnEnabled = new Dictionary<string, ConfigEntry<bool>>();

		private static readonly HashSet<string> _enemiesWithProperDeathAnimations = new HashSet<string>(StringComparer.Ordinal)
		{
			"DOGDAY", "DOGDAYCRITTER", "PICKYCRITTER", "CATNAPCRITTER", "BOBBYCRITTER", "CRAFTYCRITTER", "HOPPYCRITTER", "BUBBACRITTER", "KICKINCRITTER", "BABOONHAWK",
			"MANEATER", "CENTIPEDE", "CRAWLER", "TULIPSNAKE", "FLOWERMAN", "FORESTGIANT", "HOARDINGBUG", "MASKED", "MOUTHDOG", "NUTCRACKER",
			"BUNKERSPIDER", "BUSHWOLF"
		};

		public static DespawnConfiguration Instance => _instance ?? (_instance = new DespawnConfiguration());

		public ConfigEntry<bool> EnableDespawnFeature { get; private set; }

		private DespawnConfiguration()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			string text = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative_Despawn_Rules.cfg");
			_configFile = new ConfigFile(text, true);
			EnableDespawnFeature = _configFile.Bind<bool>("General", "EnableDespawnFeature", true, new ConfigDescription("If true, dead enemies can despawn based on other settings", (AcceptableValueBase)null, Array.Empty<object>()));
			PreCreateEnemyConfigEntries();
		}

		public void ReloadConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			try
			{
				_configFile.Reload();
				_enemyDespawnEnabled.Clear();
				EnableDespawnFeature = _configFile.Bind<bool>("General", "EnableDespawnFeature", true, new ConfigDescription("If true, dead enemies can despawn based on other settings", (AcceptableValueBase)null, Array.Empty<object>()));
				Plugin.LogInfo("Despawn configuration reloaded from disk");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error reloading despawn config: " + ex.Message));
			}
		}

		private void PreCreateEnemyConfigEntries()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (Plugin.enemies == null || Plugin.enemies.Count <= 0)
			{
				return;
			}
			foreach (EnemyType enemy in Plugin.enemies)
			{
				string text = Plugin.RemoveInvalidCharacters(enemy.enemyName).ToUpper();
				bool flag = !_enemiesWithProperDeathAnimations.Contains(text);
				_configFile.Bind<bool>("Enemies", text + ".Despawn", flag, new ConfigDescription("If true, " + enemy.enemyName + " will despawn after death", (AcceptableValueBase)null, Array.Empty<object>()));
			}
		}

		public bool ShouldDespawnEnemy(string enemyName)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			if (!EnableDespawnFeature.Value)
			{
				return false;
			}
			string text = Plugin.RemoveInvalidCharacters(enemyName).ToUpper();
			if (_enemyDespawnEnabled.TryGetValue(text, out var value))
			{
				return value.Value;
			}
			bool flag = !_enemiesWithProperDeathAnimations.Contains(text);
			ConfigEntry<bool> val = _configFile.Bind<bool>("Enemies", text + ".Despawn", flag, new ConfigDescription("If true, " + enemyName + " will despawn after death", (AcceptableValueBase)null, Array.Empty<object>()));
			_enemyDespawnEnabled[text] = val;
			return val.Value;
		}

		public void ClearCache()
		{
			_enemyDespawnEnabled.Clear();
			Plugin.Log.LogInfo((object)"Despawn cache cleared");
		}
	}
	public class EnemyControlConfiguration
	{
		private static EnemyControlConfiguration _instance;

		private ConfigFile _configFile;

		private readonly Dictionary<string, ConfigEntry<bool>> _enemyModEnabled = new Dictionary<string, ConfigEntry<bool>>();

		public static EnemyControlConfiguration Instance => _instance ?? (_instance = new EnemyControlConfiguration());

		private EnemyControlConfiguration()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			string text = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative_Enemy_Control.cfg");
			_configFile = new ConfigFile(text, true);
			_configFile.Bind<string>("Enemies", "_INFO", "Control which enemies are affected by this mod", new ConfigDescription("This is an Experimental Feature: If you set an enemy's value to 'false', it will not be affected by the EverythingCanDieAlternative mod. The health and hit synconization, and the despawn feature will not take effect for the configured enemy. This can be useful if specific enemies have built-in hit/health/death mechanisms that you want to preserve, but that ECDA overwrites. Now you can preserve them by setting the enemy to false.", (AcceptableValueBase)null, Array.Empty<object>()));
		}

		public void ReloadConfig()
		{
			try
			{
				_configFile.Reload();
				_enemyModEnabled.Clear();
				Plugin.LogInfo("Enemy control configuration reloaded from disk");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error reloading enemy control config: " + ex.Message));
			}
		}

		public void PreCreateEnemyConfigEntries()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			if (Plugin.enemies == null || Plugin.enemies.Count <= 0)
			{
				return;
			}
			Plugin.LogInfo($"Creating control entries for {Plugin.enemies.Count} enemy types");
			foreach (EnemyType enemy in Plugin.enemies)
			{
				if (!((Object)(object)enemy == (Object)null) && !string.IsNullOrEmpty(enemy.enemyName))
				{
					string text = Plugin.RemoveInvalidCharacters(enemy.enemyName).ToUpper();
					_configFile.Bind<bool>("Enemies", text + ".Enabled", true, new ConfigDescription("If set to false, " + enemy.enemyName + " will not be affected by this mod", (AcceptableValueBase)null, Array.Empty<object>()));
				}
			}
		}

		public bool IsModEnabledForEnemy(string enemyName)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			string text = Plugin.RemoveInvalidCharacters(enemyName).ToUpper();
			if (_enemyModEnabled.TryGetValue(text, out var value))
			{
				return value.Value;
			}
			try
			{
				ConfigEntry<bool> val = _configFile.Bind<bool>("Enemies", text + ".Enabled", true, new ConfigDescription("If set to false, " + enemyName + " will not be affected by this mod", (AcceptableValueBase)null, Array.Empty<object>()));
				_enemyModEnabled[text] = val;
				return val.Value;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error checking if mod is enabled for " + enemyName + ": " + ex.Message + " - defaulting to true"));
				return true;
			}
		}

		public void ClearCache()
		{
			_enemyModEnabled.Clear();
			Plugin.LogInfo("Enemy control cache cleared");
		}
	}
	public static class HealthManager
	{
		[Serializable]
		public struct HitData
		{
			public int EnemyInstanceId;

			public ulong EnemyNetworkId;

			public int EnemyIndex;

			public string EnemyName;

			public float Damage;

			public ulong PlayerClientId;

			public override string ToString()
			{
				return $"HitData(EnemyId={EnemyInstanceId}, NetworkId={EnemyNetworkId}, Index={EnemyIndex}, Name={EnemyName}, Damage={Damage}, PlayerClientId={PlayerClientId})";
			}
		}

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

			private object <>2__current;

			public EnemyAI enemy;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Plugin.LogInfo("DelayedSilence started for " + enemy?.enemyType?.enemyName);
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)enemy == (Object)null || (Object)(object)((Component)enemy).gameObject == (Object)null)
					{
						return false;
					}
					try
					{
						AudioSource[] componentsInChildren = ((Component)enemy).GetComponentsInChildren<AudioSource>(true);
						if (componentsInChildren.Length == 0)
						{
							return false;
						}
						((MonoBehaviour)StartOfRound.Instance).StartCoroutine(FadeOutEnemyAudio(componentsInChildren, 1f));
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error silencing dead enemy " + enemy?.enemyType?.enemyName + ": " + ex.Message));
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public AudioSource[] sources;

			public float duration;

			private float[] <startVolumes>5__2;

			private float <elapsed>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<startVolumes>5__2 = new float[sources.Length];
					for (int i = 0; i < sources.Length; i++)
					{
						<startVolumes>5__2[i] = (((Object)(object)sources[i] != (Object)null) ? sources[i].volume : 0f);
					}
					<elapsed>5__3 = 0f;
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__3 < duration)
				{
					<elapsed>5__3 += Time.deltaTime;
					float num = Mathf.Clamp01(<elapsed>5__3 / duration);
					for (int j = 0; j < sources.Length; j++)
					{
						if ((Object)(object)sources[j] != (Object)null)
						{
							sources[j].volume = Mathf.Lerp(<startVolumes>5__2[j], 0f, num);
						}
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				for (int k = 0; k < sources.Length; k++)
				{
					if ((Object)(object)sources[k] != (Object)null)
					{
						sources[k].volume = 0f;
						sources[k].Stop();
					}
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public EnemyAI enemy;

			private int <instanceId>5__2;

			private int <enemyIndex>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if ((Object)(object)enemy == (Object)null)
					{
						return false;
					}
					<instanceId>5__2 = ((Object)enemy).GetInstanceID();
					<enemyIndex>5__3 = enemy.thisEnemyIndex;
					float num = 0.5f;
					SellBodiesCompatibility sellBodies = ModCompatibilityManager.Instance.SellBodies;
					if (sellBodies != null && sellBodies.IsInstalled)
					{
						num = sellBodies.GetDespawnDelay();
						Plugin.LogInfo($"Using SellBodies compatibility despawn delay: {num}s for {enemy.enemyType.enemyName}");
					}
					<>2__current = (object)new WaitForSeconds(num);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					if ((Object)(object)enemy != (Object)null && enemy.isEnemyDead)
					{
						if (despawnMessage != null)
						{
							despawnMessage.SendClients(<enemyIndex>5__3);
						}
						Object.Destroy((Object)(object)((Component)enemy).gameObject);
					}
					enemiesInDespawnProcess.Remove(<instanceId>5__2);
					return false;
				}
			}

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

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

		private static int networkVarCounter = 0;

		private static readonly Dictionary<int, LNetworkVariable<float>> enemyHealthVars = new Dictionary<int, LNetworkVariable<float>>();

		private static readonly Dictionary<int, float> enemyMaxHealth = new Dictionary<int, float>();

		private static readonly Dictionary<int, bool> processedEnemies = new Dictionary<int, bool>();

		private static readonly Dictionary<int, ulong> enemyNetworkIds = new Dictionary<int, ulong>();

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

		private static readonly Dictionary<int, bool> enemiesInDespawnProcess = new Dictionary<int, bool>();

		private static readonly Dictionary<int, bool> immortalEnemies = new Dictionary<int, bool>();

		private static readonly Dictionary<int, EnemyAI> enemyInstanceCache = new Dictionary<int, EnemyAI>();

		private static readonly Dictionary<ulong, EnemyAI> enemyByNetworkId = new Dictionary<ulong, EnemyAI>();

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

		private static readonly Dictionary<int, float> pendingDamage = new Dictionary<int, float>();

		private static float lastBatchTime = 0f;

		private const float BATCH_INTERVAL = 0.1f;

		private static LNetworkMessage<int> despawnMessage;

		private static LNetworkMessage<HitData> hitMessage;

		private static bool networkMessagesCreated = false;

		public static void Initialize()
		{
			enemyHealthVars.Clear();
			enemyMaxHealth.Clear();
			processedEnemies.Clear();
			enemyNetworkIds.Clear();
			enemyNetworkVarNames.Clear();
			enemiesInDespawnProcess.Clear();
			immortalEnemies.Clear();
			enemyInstanceCache.Clear();
			enemyByNetworkId.Clear();
			sanitizedEnemyNames.Clear();
			pendingDamage.Clear();
			lastBatchTime = 0f;
			CreateNetworkMessages();
			Plugin.LogInfo("Networked Health Manager initialized");
		}

		private static void CreateNetworkMessages()
		{
			if (networkMessagesCreated)
			{
				Plugin.LogInfo("Network messages already created, skipping recreation");
				return;
			}
			try
			{
				hitMessage = LNetworkMessage<HitData>.Create("ECDA_HitMessage", (Action<HitData, ulong>)delegate(HitData hitData, ulong clientId)
				{
					Plugin.LogInfo($"[HOST] Received hit message from client {clientId}: {hitData}");
					if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
					{
						EnemyAI val2 = FindEnemyMultiMethod(hitData);
						PlayerControllerB playerWhoHit = null;
						if (hitData.PlayerClientId != 0L)
						{
							PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
							foreach (PlayerControllerB val3 in allPlayerScripts)
							{
								if (val3.actualClientId == hitData.PlayerClientId)
								{
									playerWhoHit = val3;
									break;
								}
							}
						}
						if ((Object)(object)val2 != (Object)null && !val2.isEnemyDead)
						{
							ProcessDamageDirectly(val2, hitData.Damage, playerWhoHit);
						}
						else
						{
							Plugin.Log.LogWarning((object)$"Could not find enemy: {hitData.EnemyName} (NetworkID: {hitData.EnemyNetworkId}, Index: {hitData.EnemyIndex})");
						}
					}
				}, (Action<HitData>)null, (Action<HitData, ulong>)null);
				despawnMessage = LNetworkMessage<int>.Create("ECDA_DespawnMessage", (Action<int, ulong>)delegate(int enemyIndex, ulong clientId)
				{
					if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
					{
						EnemyAI val = FindEnemyByIndex(enemyIndex);
						if ((Object)(object)val != (Object)null)
						{
							Plugin.LogInfo($"[CLIENT] Received despawn message for enemy index {enemyIndex}");
							Object.Destroy((Object)(object)((Component)val).gameObject);
						}
					}
				}, (Action<int>)null, (Action<int, ulong>)null);
				networkMessagesCreated = true;
				Plugin.LogInfo("Network messages created successfully");
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Error creating network messages: {arg}");
			}
		}

		public static string GetSanitizedName(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null || (Object)(object)enemy.enemyType == (Object)null)
			{
				return string.Empty;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (sanitizedEnemyNames.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			string text = Plugin.RemoveInvalidCharacters(enemy.enemyType.enemyName).ToUpper();
			sanitizedEnemyNames[instanceID] = text;
			return text;
		}

		private static EnemyAI FindEnemyByIndex(int index)
		{
			RoundManager instance = RoundManager.Instance;
			if (instance?.SpawnedEnemies != null)
			{
				foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
				{
					if ((Object)(object)spawnedEnemy != (Object)null && spawnedEnemy.thisEnemyIndex == index)
					{
						return spawnedEnemy;
					}
				}
			}
			return null;
		}

		private static EnemyAI FindEnemyMultiMethod(HitData hitData)
		{
			if (hitData.EnemyNetworkId != 0L && enemyByNetworkId.TryGetValue(hitData.EnemyNetworkId, out var value) && (Object)(object)value != (Object)null)
			{
				Plugin.LogInfo($"Found enemy by NetworkObjectId (cache): {hitData.EnemyNetworkId}");
				return value;
			}
			if (hitData.EnemyIndex >= 0)
			{
				EnemyAI val = FindEnemyByIndex(hitData.EnemyIndex);
				if ((Object)(object)val != (Object)null)
				{
					Plugin.LogInfo($"Found enemy by index: {hitData.EnemyIndex}");
					return val;
				}
			}
			if (!string.IsNullOrEmpty(hitData.EnemyName))
			{
				RoundManager instance = RoundManager.Instance;
				if (instance?.SpawnedEnemies != null)
				{
					foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
					{
						if ((Object)(object)spawnedEnemy != (Object)null && (Object)(object)spawnedEnemy.enemyType != (Object)null && spawnedEnemy.enemyType.enemyName == hitData.EnemyName)
						{
							Plugin.LogInfo("Found enemy by name: " + hitData.EnemyName);
							return spawnedEnemy;
						}
					}
				}
			}
			Plugin.Log.LogWarning((object)"Could not find enemy. SpawnedEnemies in round:");
			RoundManager instance2 = RoundManager.Instance;
			if (instance2?.SpawnedEnemies != null)
			{
				foreach (EnemyAI spawnedEnemy2 in instance2.SpawnedEnemies)
				{
					if ((Object)(object)spawnedEnemy2 != (Object)null)
					{
						Plugin.Log.LogWarning((object)$"  - {spawnedEnemy2.enemyType?.enemyName}, Index: {spawnedEnemy2.thisEnemyIndex}, NetworkId: {((NetworkBehaviour)spawnedEnemy2).NetworkObjectId}");
					}
				}
			}
			return null;
		}

		public static void SetupEnemy(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null || (Object)(object)enemy.enemyType == (Object)null)
			{
				return;
			}
			try
			{
				int instanceId = ((Object)enemy).GetInstanceID();
				enemyInstanceCache[instanceId] = enemy;
				if ((Object)(object)((NetworkBehaviour)enemy).NetworkObject != (Object)null)
				{
					enemyNetworkIds[instanceId] = ((NetworkBehaviour)enemy).NetworkObjectId;
					enemyByNetworkId[((NetworkBehaviour)enemy).NetworkObjectId] = enemy;
				}
				if (processedEnemies.TryGetValue(instanceId, out var value) && value)
				{
					Plugin.LogInfo($"Enemy {enemy.enemyType.enemyName} (ID: {instanceId}) already processed, skipping setup");
					return;
				}
				string enemyName = enemy.enemyType.enemyName;
				string sanitizedName = GetSanitizedName(enemy);
				if (!Plugin.IsModEnabledForEnemy(sanitizedName))
				{
					Plugin.LogInfo("Mod disabled for enemy " + enemyName + " via config, using vanilla behavior");
					processedEnemies[instanceId] = true;
				}
				else if (Plugin.CanMob(".Unimmortal", sanitizedName))
				{
					float num = Plugin.GetMobHealth(sanitizedName, enemy.enemyHP);
					BrutalCompanyMinusCompatibility brutalCompanyMinus = ModCompatibilityManager.Instance.BrutalCompanyMinus;
					if (brutalCompanyMinus != null && brutalCompanyMinus.IsInstalled)
					{
						num = brutalCompanyMinus.ApplyBonusHp(num);
					}
					string text = $"ECDA_Health_{enemy.thisEnemyIndex}_{networkVarCounter++}";
					enemyNetworkVarNames[instanceId] = text;
					Plugin.LogInfo($"Creating network variable {text} for enemy {enemyName} (ID: {instanceId})");
					if (!enemyHealthVars.TryGetValue(instanceId, out var value2))
					{
						try
						{
							value2 = LNetworkVariable<float>.Create(text, num, (LNetworkVariableWritePerms)0, (Action<float, float>)null);
							value2.OnValueChanged += delegate(float oldHealth, float newHealth)
							{
								HandleHealthChange(instanceId, newHealth);
							};
							enemyHealthVars[instanceId] = value2;
						}
						catch (Exception ex)
						{
							Plugin.Log.LogError((object)("Failed to create network variable " + text + ": " + ex.Message));
							text = $"ECDA_Health_{enemy.thisEnemyIndex}_{networkVarCounter++}_Retry";
							Plugin.LogInfo("Retrying with new variable name: " + text);
							enemyNetworkVarNames[instanceId] = text;
							value2 = LNetworkVariable<float>.Create(text, num, (LNetworkVariableWritePerms)0, (Action<float, float>)null);
							value2.OnValueChanged += delegate(float oldHealth, float newHealth)
							{
								HandleHealthChange(instanceId, newHealth);
							};
							enemyHealthVars[instanceId] = value2;
						}
					}
					else
					{
						Plugin.LogInfo($"Using existing health variable for enemy {enemyName} (ID: {instanceId})");
					}
					enemyMaxHealth[instanceId] = num;
					enemy.enemyType.canDie = true;
					enemy.enemyType.canBeDestroyed = true;
					enemy.enemyHP = 999;
					processedEnemies[instanceId] = true;
					immortalEnemies[instanceId] = false;
					try
					{
						EnemyHealthBarUI.Attach(enemy);
					}
					catch (Exception ex2)
					{
						Plugin.Log.LogWarning((object)("Failed to attach health bar UI to " + enemyName + ": " + ex2.Message));
					}
					Plugin.LogInfo($"Setup enemy {enemyName} (ID: {instanceId}, NetID: {((NetworkBehaviour)enemy).NetworkObjectId}, Index: {enemy.thisEnemyIndex}) with {num} networked health");
				}
				else
				{
					Plugin.LogInfo("Enemy " + enemyName + " is configured as immortal (Unimmortal=false, Enabled=true)");
					enemy.enemyHP = 999;
					if (Plugin.ProtectImmortalEnemiesFromInstaKill.Value)
					{
						enemy.enemyType.canDie = false;
						Plugin.LogInfo("Protected immortal enemy " + enemyName + " from insta-kill effects (canDie = false)");
					}
					else
					{
						enemy.enemyType.canDie = true;
						Plugin.LogInfo("Immortal enemy " + enemyName + " can still be killed by insta-kill effects (canDie = true)");
					}
					immortalEnemies[instanceId] = true;
					processedEnemies[instanceId] = true;
					Plugin.LogInfo($"Set enemy {enemyName} (ID: {instanceId}) to be immortal with 999 HP");
				}
			}
			catch (Exception ex3)
			{
				Plugin.Log.LogError((object)("Error setting up enemy: " + ex3.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex3.StackTrace));
			}
		}

		private static void HandleHealthChange(int instanceId, float newHealth)
		{
			EnemyAI val = FindEnemyById(instanceId);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Plugin.LogInfo($"Health changed for enemy {val.enemyType.enemyName} (ID: {instanceId}): new health = {newHealth}");
			if (newHealth <= 0f && !val.isEnemyDead && ((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
				if (hitmarker != null && hitmarker.IsInstalled)
				{
					PlayerControllerB lastDamageSource = hitmarker.GetLastDamageSource(instanceId);
					hitmarker.NotifyEnemyKilled(val, lastDamageSource);
				}
				KillEnemy(val);
			}
		}

		private static EnemyAI FindEnemyById(int instanceId)
		{
			if (enemyInstanceCache.TryGetValue(instanceId, out var value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				enemyInstanceCache.Remove(instanceId);
			}
			EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
			foreach (EnemyAI val in array)
			{
				if (((Object)val).GetInstanceID() == instanceId)
				{
					enemyInstanceCache[instanceId] = val;
					return val;
				}
			}
			return null;
		}

		public static void ProcessHit(EnemyAI enemy, float damage, PlayerControllerB playerWhoHit)
		{
			if ((Object)(object)enemy == (Object)null || enemy.isEnemyDead)
			{
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!Plugin.IsModEnabledForEnemy(GetSanitizedName(enemy)))
			{
				Plugin.LogInfo("Mod disabled for enemy " + enemy.enemyType.enemyName + ", not processing hit");
				return;
			}
			if (immortalEnemies.TryGetValue(instanceID, out var value) && value)
			{
				enemy.enemyHP = 999;
				Plugin.LogInfo("Refreshed immortal enemy " + enemy.enemyType.enemyName + " HP to 999");
				return;
			}
			LethalHandsCompatibility lethalHands = ModCompatibilityManager.Instance.LethalHands;
			if (lethalHands != null && lethalHands.IsInstalled && damage == -22f)
			{
				damage = lethalHands.ConvertPunchForceToDamage(damage);
				Plugin.LogInfo($"Converted LethalHands punch to damage: {damage}");
			}
			else if (damage < 0f)
			{
				Plugin.Log.LogWarning((object)$"Received negative damage value: {damage}, setting to 0");
				damage = 0f;
			}
			if (damage <= 0f)
			{
				return;
			}
			if (((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Plugin.LogInfo($"Processing hit locally as host: Enemy {enemy.enemyType.enemyName}, Damage {damage}");
				ProcessDamageDirectly(enemy, damage, playerWhoHit);
				return;
			}
			pendingDamage.TryGetValue(instanceID, out var value2);
			pendingDamage[instanceID] = value2 + damage;
			HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
			if (hitmarker != null && hitmarker.IsInstalled && (Object)(object)playerWhoHit != (Object)null)
			{
				hitmarker.TrackDamageSource(instanceID, playerWhoHit);
			}
			if (Time.time - lastBatchTime >= 0.1f)
			{
				SendDamageBatch();
			}
		}

		private static void SendDamageBatch()
		{
			if (pendingDamage.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<int, float> item in pendingDamage)
			{
				EnemyAI val = FindEnemyById(item.Key);
				if (!((Object)(object)val != (Object)null) || val.isEnemyDead)
				{
					continue;
				}
				HitData hitData = default(HitData);
				hitData.EnemyInstanceId = item.Key;
				hitData.EnemyNetworkId = ((NetworkBehaviour)val).NetworkObjectId;
				hitData.EnemyIndex = val.thisEnemyIndex;
				hitData.EnemyName = val.enemyType.enemyName;
				hitData.Damage = item.Value;
				hitData.PlayerClientId = StartOfRound.Instance.localPlayerController?.actualClientId ?? 0;
				HitData hitData2 = hitData;
				try
				{
					if (hitMessage == null)
					{
						Plugin.LogWarning("Hit message is null, recreating it");
						CreateNetworkMessages();
					}
					hitMessage.SendServer(hitData2);
					Plugin.LogInfo($"Sent batched damage: {item.Value} to {val.enemyType.enemyName}");
				}
				catch (Exception arg)
				{
					Plugin.LogError($"Error sending batched hit message: {arg}");
				}
			}
			pendingDamage.Clear();
			lastBatchTime = Time.time;
		}

		private static void ProcessDamageDirectly(EnemyAI enemy, float damage, PlayerControllerB playerWhoHit = null)
		{
			if ((Object)(object)enemy == (Object)null || enemy.isEnemyDead)
			{
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!Plugin.IsModEnabledForEnemy(GetSanitizedName(enemy)))
			{
				Plugin.LogInfo("Mod disabled for enemy " + enemy.enemyType.enemyName + ", not processing damage");
				return;
			}
			if ((Object)(object)playerWhoHit != (Object)null)
			{
				HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
				if (hitmarker != null && hitmarker.IsInstalled)
				{
					hitmarker.TrackDamageSource(instanceID, playerWhoHit);
				}
			}
			if (immortalEnemies.TryGetValue(instanceID, out var value) && value)
			{
				enemy.enemyHP = 999;
				Plugin.LogInfo("Refreshed immortal enemy " + enemy.enemyType.enemyName + " HP to 999");
				return;
			}
			if (!processedEnemies.TryGetValue(instanceID, out var value2) || !value2)
			{
				SetupEnemy(enemy);
			}
			if (enemyHealthVars.TryGetValue(instanceID, out var value3))
			{
				float value4 = value3.Value;
				float num = Mathf.Max(0f, value4 - damage);
				Plugin.LogInfo($"Enemy {enemy.enemyType.enemyName} damaged for {damage}: {value4} -> {num}");
				value3.Value = num;
			}
			else
			{
				Plugin.Log.LogWarning((object)$"No health variable found for enemy {enemy.enemyType.enemyName} (ID: {instanceID})");
			}
		}

		public static void NotifyClientsOfDestroy(int enemyIndex)
		{
			if (despawnMessage != null)
			{
				despawnMessage.SendClients(enemyIndex);
			}
		}

		private static void KillEnemy(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null || enemy.isEnemyDead)
			{
				return;
			}
			Plugin.LogInfo("Killing enemy " + enemy.enemyType.enemyName);
			SellBodiesCompatibility sellBodies = ModCompatibilityManager.Instance.SellBodies;
			if (sellBodies != null && sellBodies.IsInstalled && sellBodies.IsProblemEnemy(enemy.enemyType.enemyName))
			{
				sellBodies.HandleProblemEnemyDeath(enemy);
			}
			if (!((NetworkBehaviour)enemy).IsOwner)
			{
				Plugin.LogInfo("Attempting to take ownership of " + enemy.enemyType.enemyName + " to kill it");
				ulong actualClientId = StartOfRound.Instance.allPlayerScripts[0].actualClientId;
				enemy.ChangeOwnershipOfEnemy(actualClientId);
			}
			LastResortKillerCompatibility lastResortKiller = ModCompatibilityManager.Instance.LastResortKiller;
			if (lastResortKiller != null)
			{
				bool allowDespawn = DespawnConfiguration.Instance.ShouldDespawnEnemy(enemy.enemyType.enemyName);
				lastResortKiller.AttemptToKillEnemy(enemy, allowDespawn);
			}
			else
			{
				enemy.KillEnemyOnOwnerClient(false);
				if (enemy.enemyType.enemyName.Contains("Spring"))
				{
					Plugin.LogInfo("Using fallback kill method for " + enemy.enemyType.enemyName);
					enemy.KillEnemyOnOwnerClient(true);
				}
			}
			if (DespawnConfiguration.Instance.ShouldDespawnEnemy(enemy.enemyType.enemyName))
			{
				StartDespawnProcess(enemy);
			}
			else if (Plugin.MuteDeadEnemies.Value)
			{
				Plugin.LogInfo("Starting audio fade for " + enemy.enemyType.enemyName);
				SilenceDeadEnemy(enemy);
			}
			else
			{
				Plugin.LogInfo($"Silence skipped: MuteDeadEnemies={Plugin.MuteDeadEnemies.Value}, Despawn={DespawnConfiguration.Instance.ShouldDespawnEnemy(enemy.enemyType.enemyName)}");
			}
		}

		public static void SilenceDeadEnemy(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)StartOfRound.Instance == (Object)null)
				{
					Plugin.Log.LogError((object)"SilenceDeadEnemy: StartOfRound.Instance is null");
				}
				else
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(DelayedSilence(enemy));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to start DelayedSilence coroutine: " + ex.Message));
			}
		}

		[IteratorStateMachine(typeof(<DelayedSilence>d__32))]
		private static IEnumerator DelayedSilence(EnemyAI enemy)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedSilence>d__32(0)
			{
				enemy = enemy
			};
		}

		[IteratorStateMachine(typeof(<FadeOutEnemyAudio>d__33))]
		private static IEnumerator FadeOutEnemyAudio(AudioSource[] sources, float duration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOutEnemyAudio>d__33(0)
			{
				sources = sources,
				duration = duration
			};
		}

		private static void StartDespawnProcess(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!(enemiesInDespawnProcess.TryGetValue(instanceID, out var value) && value))
			{
				enemiesInDespawnProcess[instanceID] = true;
				Plugin.LogInfo($"Starting despawn process for {enemy.enemyType.enemyName} (Index: {enemy.thisEnemyIndex})");
				if ((Object)(object)StartOfRound.Instance != (Object)null)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(WaitForDeathAnimationAndDespawn(enemy));
				}
			}
		}

		[IteratorStateMachine(typeof(<WaitForDeathAnimationAndDespawn>d__35))]
		private static IEnumerator WaitForDeathAnimationAndDespawn(EnemyAI enemy)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForDeathAnimationAndDespawn>d__35(0)
			{
				enemy = enemy
			};
		}

		public static float GetEnemyHealth(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return 0f;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (enemyHealthVars.TryGetValue(instanceID, out var value))
			{
				return value.Value;
			}
			return 0f;
		}

		public static float GetEnemyMaxHealth(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return 0f;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (enemyMaxHealth.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			return 0f;
		}

		public static bool IsEnemyTracked(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!enemyHealthVars.ContainsKey(instanceID))
			{
				return immortalEnemies.ContainsKey(instanceID);
			}
			return true;
		}

		public static void DirectHealthChange(EnemyAI enemy, int damage, PlayerControllerB playerWhoHit = null)
		{
			if ((Object)(object)enemy == (Object)null || enemy.isEnemyDead || damage <= 0)
			{
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!enemyHealthVars.ContainsKey(instanceID))
			{
				Plugin.LogInfo("No network health variable found for " + enemy.enemyType.enemyName + ", probably set to enabled = false");
				return;
			}
			HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
			if (hitmarker != null && hitmarker.IsInstalled && (Object)(object)playerWhoHit != (Object)null)
			{
				hitmarker.TrackDamageSource(instanceID, playerWhoHit);
			}
			LNetworkVariable<float> val = enemyHealthVars[instanceID];
			float value = val.Value;
			float num = Mathf.Max(0f, value - (float)damage);
			Plugin.LogInfo($"DirectHealthChange: {enemy.enemyType.enemyName} damaged for {damage}: {value} -> {num}");
			val.Value = num;
		}

		public static void CleanupExternallyKilledEnemy(EnemyAI enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				int instanceID = ((Object)enemy).GetInstanceID();
				enemyHealthVars.Remove(instanceID);
				enemyMaxHealth.Remove(instanceID);
				processedEnemies.Remove(instanceID);
				if (enemyNetworkIds.TryGetValue(instanceID, out var value))
				{
					enemyNetworkIds.Remove(instanceID);
					enemyByNetworkId.Remove(value);
				}
				enemyNetworkVarNames.Remove(instanceID);
				immortalEnemies.Remove(instanceID);
				enemyInstanceCache.Remove(instanceID);
				sanitizedEnemyNames.Remove(instanceID);
				Plugin.LogInfo("Cleaned up tracking data for externally killed enemy " + enemy.enemyType.enemyName);
			}
		}
	}
	public static class Patches
	{
		[CompilerGenerated]
		private sealed class <HandleSpikeKillCleanup>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemyAI enemy;

			private string <enemyName>5__2;

			private float <timeout>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)enemy == (Object)null)
					{
						return false;
					}
					<enemyName>5__2 = enemy.enemyType.enemyName;
					<timeout>5__3 = 2f;
					goto IL_007e;
				case 1:
					<>1__state = -1;
					goto IL_007e;
				case 2:
					{
						<>1__state = -1;
						if ((Object)(object)enemy != (Object)null && enemy.isEnemyDead)
						{
							Plugin.LogInfo("Despawning spike-killed enemy: " + <enemyName>5__2);
							if (enemy.thisEnemyIndex >= 0)
							{
								HealthManager.NotifyClientsOfDestroy(enemy.thisEnemyIndex);
							}
							Object.Destroy((Object)(object)((Component)enemy).gameObject);
						}
						break;
					}
					IL_007e:
					if (!enemy.isEnemyDead && <timeout>5__3 > 0f)
					{
						<timeout>5__3 -= Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if (enemy.isEnemyDead)
					{
						Plugin.LogInfo("Cleaning up spike-killed enemy: " + <enemyName>5__2);
						HealthManager.CleanupExternallyKilledEnemy(enemy);
						int instanceID = ((Object)enemy).GetInstanceID();
						HandleKillCompatibility(enemy, instanceID, <enemyName>5__2);
						if (DespawnConfiguration.Instance.ShouldDespawnEnemy(<enemyName>5__2))
						{
							<>2__current = (object)new WaitForSeconds(GetDespawnDelay());
							<>1__state = 2;
							return true;
						}
					}
					break;
				}
				return false;
			}

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

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

		private static bool isProcessingLandmineExplosion;

		public static void Initialize(Harmony harmony)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected O, but got Unknown
			//IL_0261: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(StartOfRound), "Start", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.Log.LogError((object)"Could not find StartOfRound.Start method - patches failed!");
					return;
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(Patches), "StartOfRoundPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo3 = AccessTools.Method(typeof(EnemyAI), "Start", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(Patches), "EnemyAIStartPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo5 = AccessTools.Method(typeof(EnemyAI), "HitEnemyOnLocalClient", (Type[])null, (Type[])null);
				MethodInfo methodInfo6 = AccessTools.Method(typeof(Patches), "HitEnemyOnLocalClientPrefix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo5, new HarmonyMethod(methodInfo6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo7 = AccessTools.Method(typeof(EnemyAI), "HitEnemy", (Type[])null, (Type[])null);
				MethodInfo methodInfo8 = AccessTools.Method(typeof(Patches), "HitEnemyPrefix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo7, new HarmonyMethod(methodInfo8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo9 = AccessTools.Method(typeof(RoundManager), "FinishGeneratingLevel", (Type[])null, (Type[])null);
				MethodInfo methodInfo10 = AccessTools.Method(typeof(Patches), "FinishGeneratingLevelPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo9, (HarmonyMethod)null, new HarmonyMethod(methodInfo10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo11 = AccessTools.Method(typeof(StartOfRound), "ShipLeave", (Type[])null, (Type[])null);
				MethodInfo methodInfo12 = AccessTools.Method(typeof(Patches), "ShipLeavePostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo11, (HarmonyMethod)null, new HarmonyMethod(methodInfo12), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo13 = AccessTools.Method(typeof(SpikeRoofTrap), "OnTriggerStay", (Type[])null, (Type[])null);
				MethodInfo methodInfo14 = AccessTools.Method(typeof(Patches), "SpikeRoofTrapPrefix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo13, new HarmonyMethod(methodInfo14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Log.LogInfo((object)"SpikeRoofTrap.OnTriggerStay patched successfully");
				MethodInfo methodInfo15 = AccessTools.Method(typeof(Landmine), "SpawnExplosion", (Type[])null, (Type[])null);
				MethodInfo methodInfo16 = AccessTools.Method(typeof(Patches), "SpawnExplosionPrefix", (Type[])null, (Type[])null);
				MethodInfo methodInfo17 = AccessTools.Method(typeof(Patches), "SpawnExplosionPostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo15, new HarmonyMethod(methodInfo16), new HarmonyMethod(methodInfo17), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Log.LogInfo((object)"Landmine.SpawnExplosion patched successfully");
				Plugin.Log.LogInfo((object)"All Harmony patches applied successfully");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error applying Harmony patches: " + ex.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		public static void StartOfRoundPostfix(StartOfRound __instance)
		{
			try
			{
				Plugin.Log.LogInfo((object)"Game starting, initializing networked enemy health system...");
				((BaseUnityPlugin)Plugin.Instance).Config.Reload();
				Plugin.InvalidateConfigKeyIndex();
				EnemyControlConfiguration.Instance.ReloadConfig();
				DespawnConfiguration.Instance.ReloadConfig();
				Plugin.LogInfo("All configurations reloaded from files");
				HealthManager.Initialize();
				Plugin.enemies = new List<EnemyType>(Resources.FindObjectsOfTypeAll<EnemyType>());
				Plugin.LogInfo($"Found {Plugin.enemies.Count} enemy types");
				foreach (EnemyType enemy in Plugin.enemies)
				{
					if ((Object)(object)enemy == (Object)null || string.IsNullOrEmpty(enemy.enemyName))
					{
						Plugin.Log.LogWarning((object)"Found null or invalid enemy type, skipping");
						continue;
					}
					string mobName = Plugin.RemoveInvalidCharacters(enemy.enemyName).ToUpper();
					Plugin.LogInfo("Processing enemy type: " + enemy.enemyName);
					Plugin.CanMob(".Unimmortal", mobName);
					float num = 3f;
					if ((Object)(object)enemy.enemyPrefab != (Object)null)
					{
						EnemyAI componentInChildren = enemy.enemyPrefab.GetComponentInChildren<EnemyAI>();
						if ((Object)(object)componentInChildren != (Object)null)
						{
							if (componentInChildren.enemyHP <= 0)
							{
								num = 1f;
								Plugin.LogInfo("Detected 0 or negative HP for " + enemy.enemyName + ", setting default to 1");
							}
							else
							{
								num = Math.Min(componentInChildren.enemyHP, 30f);
								if (componentInChildren.enemyHP > 30)
								{
									Plugin.LogInfo($"Capped HP for {enemy.enemyName} from {componentInChildren.enemyHP} to {num}");
								}
							}
						}
					}
					Plugin.GetMobHealth(mobName, num);
					Plugin.ShouldDespawn(mobName);
				}
				EnemyControlConfiguration.Instance.PreCreateEnemyConfigEntries();
				ProcessExistingEnemies();
				EnemyAliases.ScanAndPersistDisplayNames();
				Plugin.Log.LogInfo((object)"StartOfRoundPostfix completed successfully");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in StartOfRoundPostfix: " + ex.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		private static void ProcessExistingEnemies()
		{
			try
			{
				EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
				Plugin.LogInfo($"Found {array.Length} active enemies");
				EnemyAI[] array2 = array;
				foreach (EnemyAI val in array2)
				{
					if (!((Object)(object)val?.enemyType == (Object)null))
					{
						Plugin.LogInfo("Setting up enemy: " + val.enemyType.enemyName);
						HealthManager.SetupEnemy(val);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error processing existing enemies: " + ex.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		public static void EnemyAIStartPostfix(EnemyAI __instance)
		{
			try
			{
				if (!((Object)(object)__instance?.enemyType == (Object)null))
				{
					HealthManager.SetupEnemy(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in EnemyAIStartPostfix: " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(Landmine), "SpawnExplosion")]
		[HarmonyPrefix]
		public static void SpawnExplosionPrefix()
		{
			isProcessingLandmineExplosion = true;
		}

		[HarmonyPatch(typeof(Landmine), "SpawnExplosion")]
		[HarmonyPostfix]
		public static void SpawnExplosionPostfix()
		{
			isProcessingLandmineExplosion = false;
		}

		public static bool HitEnemyOnLocalClientPrefix(EnemyAI __instance, int force, Vector3 hitDirection, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
		{
			try
			{
				if ((Object)(object)__instance == (Object)null || __instance.isEnemyDead)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || __instance.isEnemyDead)
				{
					return true;
				}
				if (Plugin.ProtectOldBirdsFromOwnRockets.Value && __instance.enemyType.enemyName.Contains("RadMech") && (Object)(object)playerWhoHit == (Object)null && isProcessingLandmineExplosion)
				{
					Plugin.LogInfo($"Blocking Old Bird damage during landmine explosion processing (force: {force})");
					return false;
				}
				Plugin.LogInfo(string.Format("Local hit detected on {0} from {1} with force {2}", __instance.enemyType.enemyName, playerWhoHit?.playerUsername ?? "unknown", force));
				LethalHandsCompatibility lethalHands = ModCompatibilityManager.Instance.LethalHands;
				if (lethalHands != null && lethalHands.IsInstalled && force == -22)
				{
					Plugin.LogInfo($"Detected LethalHands punch with force {force}");
				}
				HealthManager.ProcessHit(__instance, force, playerWhoHit);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in HitEnemyOnLocalClientPrefix: " + ex.Message));
				return true;
			}
		}

		public static bool HitEnemyPrefix(EnemyAI __instance, int force, PlayerControllerB playerWhoHit)
		{
			try
			{
				string enemyName = __instance.enemyType.enemyName;
				string sanitizedName = HealthManager.GetSanitizedName(__instance);
				if (Plugin.IsModEnabledForEnemy(sanitizedName) && !Plugin.CanMob(".Unimmortal", sanitizedName))
				{
					__instance.enemyHP = 999;
					Plugin.LogInfo("HitEnemyPrefix: Refreshed immortal enemy " + enemyName + " HP to 999");
					return true;
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in HitEnemyPrefix: " + ex.Message));
				return true;
			}
		}

		public static bool SpikeRoofTrapPrefix(SpikeRoofTrap __instance, Collider other)
		{
			try
			{
				if (!((Component)other).CompareTag("Enemy"))
				{
					return true;
				}
				EnemyAICollisionDetect component = ((Component)other).gameObject.GetComponent<EnemyAICollisionDetect>();
				if ((Object)(object)component?.mainScript == (Object)null)
				{
					return true;
				}
				EnemyAI mainScript = component.mainScript;
				if ((Object)(object)mainScript == (Object)null || mainScript.isEnemyDead)
				{
					return true;
				}
				string enemyName = mainScript.enemyType.enemyName;
				if (!Plugin.IsModEnabledForEnemy(HealthManager.GetSanitizedName(mainScript)))
				{
					return true;
				}
				if (!Plugin.AllowSpikeTrapsToKillEnemies.Value)
				{
					Plugin.LogInfo("Spike trap blocked from killing " + enemyName + " due to global setting");
					return false;
				}
				Plugin.LogInfo("Spike trap allowed to kill " + enemyName);
				if (DespawnConfiguration.Instance.ShouldDespawnEnemy(enemyName) && ((NetworkBehaviour)StartOfRound.Instance).IsHost)
				{
					((MonoBehaviour)__instance).StartCoroutine(HandleSpikeKillCleanup(mainScript));
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in SpikeRoofTrapPrefix: " + ex.Message));
				return true;
			}
		}

		[IteratorStateMachine(typeof(<HandleSpikeKillCleanup>d__10))]
		private static IEnumerator HandleSpikeKillCleanup(EnemyAI enemy)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HandleSpikeKillCleanup>d__10(0)
			{
				enemy = enemy
			};
		}

		private static float GetDespawnDelay()
		{
			SellBodiesCompatibility sellBodies = ModCompatibilityManager.Instance.SellBodies;
			if (sellBodies != null && sellBodies.IsInstalled)
			{
				return sellBodies.GetDespawnDelay();
			}
			return 0.5f;
		}

		private static void HandleKillCompatibility(EnemyAI enemy, int instanceId, string enemyName)
		{
			SellBodiesCompatibility sellBodies = ModCompatibilityManager.Instance.SellBodies;
			if (sellBodies != null && sellBodies.IsInstalled && sellBodies.IsProblemEnemy(enemyName))
			{
				sellBodies.HandleProblemEnemyDeath(enemy);
			}
			HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
			if (hitmarker != null && hitmarker.IsInstalled)
			{
				PlayerControllerB lastDamageSource = hitmarker.GetLastDamageSource(instanceId);
				if ((Object)(object)lastDamageSource != (Object)null)
				{
					hitmarker.NotifyEnemyKilled(enemy, lastDamageSource);
				}
			}
		}

		[HarmonyPostfix]
		public static void ShipLeavePostfix()
		{
			try
			{
				HitmarkerCompatibility hitmarker = ModCompatibilityManager.Instance.Hitmarker;
				if (hitmarker != null && hitmarker.IsInstalled)
				{
					Plugin.LogInfo("Clearing Hitmarker compatibility data on level unload");
					hitmarker.ClearTracking();
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in ShipLeavePostfix: " + ex.Message));
			}
		}

		public static void FinishGeneratingLevelPostfix()
		{
			try
			{
				BrutalCompanyMinusCompatibility brutalCompanyMinus = ModCompatibilityManager.Instance.BrutalCompanyMinus;
				if (brutalCompanyMinus != null && brutalCompanyMinus.IsInstalled)
				{
					Plugin.LogInfo("Refreshing BrutalCompanyMinus compatibility data after level generation");
					brutalCompanyMinus.RefreshBonusHp();
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in FinishGeneratingLevelPostfix: " + ex.Message));
			}
		}
	}
	[BepInPlugin("nwnt.EverythingCanDieAlternative", "EverythingCanDieAlternative", "1.1.81")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static List<EnemyType> enemies = new List<EnemyType>();

		private static bool _infoLogsEnabled = true;

		private static readonly Dictionary<string, ConfigEntry<bool>> boolConfigCache = new Dictionary<string, ConfigEntry<bool>>();

		private static readonly Dictionary<string, ConfigEntry<float>> floatConfigCache = new Dictionary<string, ConfigEntry<float>>();

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

		private static Dictionary<string, ConfigDefinition> _configKeyIndex = null;

		public static Plugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public static Harmony Harmony { get; private set; }

		public static ConfigEntry<bool> PatchCruiserDamage { get; private set; }

		public static ConfigEntry<float> CruiserDamageAtHighSpeeds { get; private set; }

		public static ConfigEntry<bool> AllowSpikeTrapsToKillEnemies { get; private set; }

		public static ConfigEntry<bool> ProtectImmortalEnemiesFromInstaKill { get; private set; }

		public static ConfigEntry<bool> ProtectOldBirdsFromOwnRockets { get; private set; }

		public static ConfigEntry<bool> MuteDeadEnemies { get; private set; }

		public bool IsSellBodiesModDetected => IsModInstalled("Entity378.sellbodies");

		public static void InvalidateConfigKeyIndex()
		{
			_configKeyIndex = null;
		}

		private static Dictionary<string, ConfigDefinition> GetConfigKeyIndex()
		{
			if (_configKeyIndex != null)
			{
				return _configKeyIndex;
			}
			Dictionary<string, ConfigDefinition> dictionary = new Dictionary<string, ConfigDefinition>();
			foreach (ConfigDefinition key2 in ((BaseUnityPlugin)Instance).Config.Keys)
			{
				string key = RemoveInvalidCharacters(key2.Key.ToUpper());
				dictionary[key] = key2;
			}
			_configKeyIndex = dictionary;
			return _configKeyIndex;
		}

		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony = new Harmony("nwnt.EverythingCanDieAlternative");
			try
			{
				_ = UIConfiguration.Instance;
				if (UIConfiguration.Instance != null && UIConfiguration.Instance.IsInitialized)
				{
					_infoLogsEnabled = UIConfiguration.Instance.ShouldLogInfo();
				}
				AllowSpikeTrapsToKillEnemies = ((BaseUnityPlugin)this).Config.Bind<bool>("Traps", "AllowSpikeTrapsToKillEnemies", true, "If true, spike roof traps can kill enemies. If false, spike traps will not affect enemies managed by this mod.");
				ProtectImmortalEnemiesFromInstaKill = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ProtectImmortalEnemiesFromInstaKill", true, "If true, enemies set as immortal will be protected from insta-kill effects by setting their canDie property to false.");
				ProtectOldBirdsFromOwnRockets = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ProtectOldBirdsFromOwnRockets", true, "If true, Old Birds will be protected from damage caused by their own rocket explosions.");
				MuteDeadEnemies = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "MuteDeadEnemies", true, "If true, all audio sources on dead enemies are faded out and silenced when despawn is disabled.");
				_ = DespawnConfiguration.Instance;
				_ = EnemyControlConfiguration.Instance;
				ModCompatibilityManager.Instance.Initialize();
				Patches.Initialize(Harmony);
				if (UIConfiguration.Instance.IsConfigMenuEnabled())
				{
					ConfigMenuPatch.Initialize(Harmony);
					Log.LogInfo((object)"EverythingCanDieAlternative v1.1.81 is loaded with network support and configuration menu!");
				}
				else
				{
					Log.LogInfo((object)"EverythingCanDieAlternative v1.1.81 is loaded with network support (configuration menu disabled)");
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error initializing EverythingCanDieAlternative: " + ex.Message));
				Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		public bool IsModInstalled(string modId)
		{
			return ModCompatibilityManager.Instance.IsModInstalled(modId);
		}

		public static bool IsModEnabledForEnemy(string mobName)
		{
			return EnemyControlConfiguration.Instance.IsModEnabledForEnemy(mobName);
		}

		public static string RemoveInvalidCharacters(string source)
		{
			if (string.IsNullOrEmpty(source))
			{
				return string.Empty;
			}
			if (sanitizedNameCache.TryGetValue(source, out var value))
			{
				return value;
			}
			StringBuilder stringBuilder = new StringBuilder(source.Length);
			foreach (char c in source)
			{
				if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
				{
					stringBuilder.Append(c);
				}
			}
			string text = stringBuilder.ToString();
			sanitizedNameCache[source] = text;
			return text;
		}

		public static void LogInfo(string message)
		{
			if (_infoLogsEnabled)
			{
				Log.LogInfo((object)message);
			}
		}

		public static void LogError(string message)
		{
			Log.LogError((object)message);
		}

		public static void LogWarning(string message)
		{
			Log.LogWarning((object)message);
		}

		public static void RefreshLoggingState()
		{
			if (UIConfiguration.Instance != null && UIConfiguration.Instance.IsInitialized)
			{
				_infoLogsEnabled = UIConfiguration.Instance.ShouldLogInfo();
				LogInfo("Logging state refreshed: info logs " + (_infoLogsEnabled ? "enabled" : "disabled"));
			}
		}

		public static bool CanMob(string identifier, string mobName)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			try
			{
				string text = RemoveInvalidCharacters(mobName).ToUpper();
				string text2 = text + identifier.ToUpper();
				if (boolConfigCache.TryGetValue(text2, out var value))
				{
					return value.Value;
				}
				ConfigEntry<bool> val = null;
				string key = RemoveInvalidCharacters(text2);
				if (GetConfigKeyIndex().TryGetValue(key, out var value2))
				{
					val = (ConfigEntry<bool>)(object)((BaseUnityPlugin)Instance).Config[value2];
					boolConfigCache[text2] = val;
					return val.Value;
				}
				val = ((BaseUnityPlugin)Instance).Config.Bind<bool>("Mobs", text + identifier, true, "If true, " + mobName + " will be damageable");
				boolConfigCache[text2] = val;
				if (_configKeyIndex != null)
				{
					_configKeyIndex[key] = new ConfigDefinition("Mobs", text + identifier);
				}
				return val.Value;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error in config check for mob " + mobName + ": " + ex.Message));
				return false;
			}
		}

		public static float GetMobHealth(string mobName, float defaultHealth)
		{
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			try
			{
				if (defaultHealth <= 0f)
				{
					defaultHealth = 1f;
					LogInfo("Enforcing minimum health of 1 for " + mobName);
				}
				string text = RemoveInvalidCharacters(mobName).ToUpper();
				string key = text + ".HEALTH";
				if (floatConfigCache.TryGetValue(key, out var value))
				{
					float num = value.Value;
					if (num <= 0f)
					{
						num = 1f;
						value.Value = 1f;
					}
					return num;
				}
				ConfigEntry<float> val = null;
				string key2 = text + "HEALTH";
				if (GetConfigKeyIndex().TryGetValue(key2, out var value2))
				{
					val = (ConfigEntry<float>)(object)((BaseUnityPlugin)Instance).Config[value2];
					floatConfigCache[key] = val;
					float num2 = val.Value;
					if (num2 <= 0f)
					{
						num2 = 1f;
						val.Value = 1f;
					}
					return num2;
				}
				val = ((BaseUnityPlugin)Instance).Config.Bind<float>("Mobs", text + ".Health", defaultHealth, "Health for " + mobName);
				floatConfigCache[key] = val;
				if (_configKeyIndex != null)
				{
					_configKeyIndex[key2] = new ConfigDefinition("Mobs", text + ".Health");
				}
				return val.Value;
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error getting health for " + mobName + ": " + ex.Message));
				return Math.Max(1f, defaultHealth);
			}
		}

		public static bool ShouldDespawn(string mobName)
		{
			return DespawnConfiguration.Instance.ShouldDespawnEnemy(mobName);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "nwnt.EverythingCanDieAlternative";

		public const string PLUGIN_NAME = "EverythingCanDieAlternative";

		public const string PLUGIN_VERSION = "1.1.81";
	}
}
namespace EverythingCanDieAlternative.UI
{
	public class UIConfiguration
	{
		public enum HealthBarDisplayMode
		{
			Off,
			NumberOnly,
			BarOnly,
			Both
		}

		public enum HealthBarSize
		{
			Small,
			Medium,
			Large
		}

		public enum HealthBarVisibilityDistance
		{
			Close,
			Medium,
			Far
		}

		public static ConfigEntry<bool> EnableConfigMenu;

		public static ConfigEntry<bool> EnableInfoLogs;

		public static ConfigEntry<bool> ShowEnemyImages;

		public static ConfigEntry<HealthBarDisplayMode> HealthBarMode;

		public static ConfigEntry<HealthBarSize> HealthBarSizeOption;

		public static ConfigEntry<bool> HideHealthBarForFullHpEnemies;

		public static ConfigEntry<HealthBarVisibilityDistance> HealthBarRange;

		private static UIConfiguration _instance;

		public static UIConfiguration Instance => _instance ?? (_instance = new UIConfiguration());

		public bool IsInitialized { get; private set; }

		private UIConfiguration()
		{
			try
			{
				EnableConfigMenu = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("General", "EnableConfigMenu", true, "If set to true, the config menu button will be shown in the main menu");
				EnableInfoLogs = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("General", "EnableInfoLogs", true, "If set to false, info logs will be suppressed to reduce console spam");
				ShowEnemyImages = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("General", "ShowEnemyImages", false, "If set to true, preview images for enemies will be shown in the config menu if available");
				HealthBarMode = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<HealthBarDisplayMode>("General", "EnemyHealthBar", HealthBarDisplayMode.Off, "Show enemy health above damageable enemies. Off / NumberOnly / BarOnly / Both");
				HealthBarSizeOption = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<HealthBarSize>("General", "EnemyHealthBarSize", HealthBarSize.Medium, "Size of the floating enemy health bar and number. Small / Medium / Large");
				HideHealthBarForFullHpEnemies = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("General", "HideHealthBarForFullHpEnemies", true, "If true, the floating health bar is only shown after the enemy has taken damage. Prevents giving away hiding enemies.");
				HealthBarRange = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<HealthBarVisibilityDistance>("General", "EnemyHealthBarRange", HealthBarVisibilityDistance.Close, "Maximum distance at which the floating health bar is visible. Close / Medium / Far");
				IsInitialized = true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error initializing UI configuration: " + ex.Message));
				IsInitialized = false;
			}
		}

		public bool IsConfigMenuEnabled()
		{
			if (!IsInitialized || EnableConfigMenu == null)
			{
				return true;
			}
			return EnableConfigMenu.Value;
		}

		public bool ShouldLogInfo()
		{
			if (!IsInitialized || EnableInfoLogs == null)
			{
				return true;
			}
			return EnableInfoLogs.Value;
		}

		public bool ShouldShowEnemyImages()
		{
			if (!IsInitialized || ShowEnemyImages == null)
			{
				return false;
			}
			return ShowEnemyImages.Value;
		}

		public void SetInfoLogsEnabled(bool enabled)
		{
			if (IsInitialized && EnableInfoLogs != null)
			{
				EnableInfoLogs.Value = enabled;
				Plugin.Log.LogInfo((object)("Info logs " + (enabled ? "enabled" : "disabled")));
				Plugin.RefreshLoggingState();
			}
		}

		public void SetConfigMenuEnabled(bool enabled)
		{
			if (IsInitialized && EnableConfigMenu != null)
			{
				EnableConfigMenu.Value = enabled;
				Plugin.Log.LogInfo((object)("Config menu " + (enabled ? "enabled" : "disabled")));
			}
		}

		public void SetShowEnemyImages(bool enabled)
		{
			if (IsInitialized && ShowEnemyImages != null)
			{
				ShowEnemyImages.Value = enabled;
				Plugin.Log.LogInfo((object)("Enemy images " + (enabled ? "enabled" : "disabled")));
			}
		}

		public HealthBarDisplayMode GetHealthBarMode()
		{
			if (!IsInitialized || HealthBarMode == null)
			{
				return HealthBarDisplayMode.Off;
			}
			return HealthBarMode.Value;
		}

		public void SetHealthBarMode(HealthBarDisplayMode mode)
		{
			if (IsInitialized && HealthBarMode != null)
			{
				HealthBarMode.Value = mode;
				Plugin.Log.LogInfo((object)$"Enemy health bar mode set to {mode}");
			}
		}

		public HealthBarSize GetHealthBarSize()
		{
			if (!IsInitialized || HealthBarSizeOption == null)
			{
				return HealthBarSize.Medium;
			}
			return HealthBarSizeOption.Value;
		}

		public void SetHealthBarSize(HealthBarSize size)
		{
			if (IsInitialized && HealthBarSizeOption != null)
			{
				HealthBarSizeOption.Value = size;
				Plugin.Log.LogInfo((object)$"Enemy health bar size set to {size}");
			}
		}

		public bool ShouldHideHealthBarForFullHp()
		{
			if (!IsInitialized || HideHealthBarForFullHpEnemies == null)
			{
				return true;
			}
			return HideHealthBarForFullHpEnemies.Value;
		}

		public void SetHideHealthBarForFullHp(bool hide)
		{
			if (IsInitialized && HideHealthBarForFullHpEnemies != null)
			{
				HideHealthBarForFullHpEnemies.Value = hide;
				Plugin.Log.LogInfo((object)("Hide health bar for full HP enemies " + (hide ? "enabled" : "disabled")));
			}
		}

		public HealthBarVisibilityDistance GetHealthBarRange()
		{
			if (!IsInitialized || HealthBarRange == null)
			{
				return HealthBarVisibilityDistance.Close;
			}
			return HealthBarRange.Value;
		}

		public void SetHealthBarRange(HealthBarVisibilityDistance range)
		{
			if (IsInitialized && HealthBarRange != null)
			{
				HealthBarRange.Value = range;
				Plugin.Log.LogInfo((object)$"Enemy health bar range set to {range}");
			}
		}

		public void Save()
		{
			try
			{
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				((BaseUnityPlugin)Plugin.Instance).Config.Reload();
				EnemyControlConfiguration.Instance.ReloadConfig();
				DespawnConfiguration.Instance.ReloadConfig();
				Plugin.LogInfo("All UI settings saved and reloaded");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error saving UI settings: " + ex.Message));
			}
		}

		public void ReloadAllConfigs()
		{
			try
			{
				((BaseUnityPlugin)Plugin.Instance).Config.Reload();
				EnemyControlConfiguration.Instance.ReloadConfig();
				DespawnConfiguration.Instance.ReloadConfig();
				Plugin.LogInfo("All configs reloaded from files");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error reloading configs: " + ex.Message));
			}
		}
	}
	public static class ConfigBridge
	{
		private static readonly Regex sectionRegex = new Regex("^\\[(.*)\\]$", RegexOptions.Compiled);

		private static string pluginConfigPath = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative.cfg");

		private static string enemyControlConfigPath = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative_Enemy_Control.cfg");

		private static string despawnConfigPath = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative_Despawn_Rules.cfg");

		private static Dictionary<string, Dictionary<string, object>> cachedConfigEntries = new Dictionary<string, Dictionary<string, object>>();

		private static bool isLoading = false;

		public static List<EnemyConfigData> LoadAllEnemyConfigs()
		{
			if (isLoading)
			{
				return new List<EnemyConfigData>();
			}
			isLoading = true;
			List<EnemyConfigData> list = new List<EnemyConfigData>();
			try
			{
				cachedConfigEntries.Clear();
				LogFileDetails(pluginConfigPath, "Main plugin config");
				LogFileDetails(enemyControlConfigPath, "Enemy control config");
				LogFileDetails(despawnConfigPath, "Despawn config");
				ReadConfigFileDirectly(pluginConfigPath, "Mobs");
				ReadConfigFileDirectly(enemyControlConfigPath, "Enemies");
				ReadConfigFileDirectly(despawnConfigPath, "Enemies");
				List<string> allConfiguredEnemyNames = GetAllConfiguredEnemyNames();
				if (allConfiguredEnemyNames.Count == 0)
				{
					Plugin.Log.LogWarning((object)"No configured enemies found in any config files. Start a round to generate configurations.");
					isLoading = false;
					return list;
				}
				Plugin.LogInfo($"Found {allConfiguredEnemyNames.Count} configured enemies in config files");
				foreach (string item in allConfiguredEnemyNames)
				{
					bool isEnabled = false;
					bool canDie = true;
					bool shouldDespawn = true;
					float health = 3f;
					if (cachedConfigEntries.TryGetValue(item, out var value))
					{
						if (value.TryGetValue(".ENABLED", out var value2) && value2 is bool flag)
						{
							isEnabled = flag;
						}
						if (value.TryGetValue(".UNIMMORTAL", out var value3) && value3 is bool flag2)
						{
							canDie = flag2;
						}
						if (value.TryGetValue(".DESPAWN", out var value4) && value4 is bool flag3)
						{
							shouldDespawn = flag3;
						}
						if (value.TryGetValue(".HEALTH", out var value5))
						{
							float result;
							if (value5 is float num)
							{
								health = num;
							}
							else if (value5 is int num2)
							{
								health = num2;
							}
							else if (value5 is string s && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
							{
								health = result;
							}
						}
					}
					list.Add(new EnemyConfigData(item, isEnabled, canDie, shouldDespawn, health));
				}
				Plugin.LogInfo($"Loaded {list.Count} enemy configurations successfully");
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Error loading enemy configurations: {arg}");
			}
			finally
			{
				isLoading = false;
			}
			return list;
		}

		private static void LogFileDetails(string path, string description)
		{
			if (File.Exists(path))
			{
				new FileInfo(path);
			}
		}

		private static void ReadConfigFileDirectly(string path, string targetSection)
		{
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				string[] array = File.ReadAllLines(path);
				Plugin.LogInfo($"Reading config file {Path.GetFileName(path)} ({array.Length} lines)");
				string text = "";
				int num = 0;
				string[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					string text2 = array2[i].Trim();
					if (string.IsNullOrWhiteSpace(text2) || text2.StartsWith("#") || text2.StartsWith("//"))
					{
						continue;
					}
					Match match = sectionRegex.Match(text2);
					if (match.Success)
					{
						text = match.Groups[1].Value;
					}
					else if (!(text != targetSection))
					{
						int num2 = text2.IndexOf('=');
						if (num2 > 0)
						{
							string key = text2.Substring(0, num2).Trim();
							string value = text2.Substring(num2 + 1).Trim();
							ProcessConfigEntry(text, key, value);
							num++;
						}
					}
				}
				Plugin.LogInfo($"Found {num} entries in section [{targetSection}]");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error reading config file " + path + ": " + ex.Message));
			}
		}

		private static void ProcessConfigEntry(string section, string key, string value)
		{
			string text = null;
			string text2 = null;
			if (section == "Mobs")
			{
				int num = key.LastIndexOf('.');
				if (num > 0)
				{
					text = key.Substring(0, num).ToUpper();
					text2 = key.Substring(num).ToUpper();
				}
			}
			else if (section == "Enemies")
			{
				int num2 = key.LastIndexOf('.');
				if (num2 > 0)
				{
					text = key.Substring(0, num2).ToUpper();
					text2 = key.Substring(num2).ToUpper();
				}
			}
			if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(text2))
			{
				return;
			}
			if (!cachedConfigEntries.ContainsKey(text))
			{
				cachedConfigEntries[text] = new Dictionary<string, object>();
			}
			switch (text2)
			{
			case ".ENABLED":
			case ".UNIMMORTAL":
			case ".DESPAWN":
			{
				if (bool.TryParse(value, out var result2))
				{
					cachedConfigEntries[text][text2] = result2;
				}
				break;
			}
			case ".HEALTH":
			{
				if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					cachedConfigEntries[text][text2] = result;
					break;
				}
				cachedConfigEntries[text][text2] = value;
				Plugin.Log.LogWarning((object)("Could not parse health value " + value + " for " + text));
				break;
			}
			}
		}

		private static List<string> GetAllConfiguredEnemyNames()
		{
			return cachedConfigEntries.Keys.ToList();
		}

		public static void SaveEnemyConfig(EnemyConfigData config)
		{
			if (config == null)
			{
				return;
			}
			string sanitizedName = config.SanitizedName;
			string name = config.Name;
			if (!cachedConfigEntries.ContainsKey(sanitizedName))
			{
				Plugin.Log.LogWarning((object)("Cannot save config for " + name + " as no existing entries were found"));
				return;
			}
			try
			{
				if (cachedConfigEntries[sanitizedName].ContainsKey(".UNIMMORTAL") || cachedConfigEntries[sanitizedName].ContainsKey(".HEALTH"))
				{
					Dictionary<string, string> dictionary = new Dictionary<string, string>();
					if (cachedConfigEntries[sanitizedName].ContainsKey(".UNIMMORTAL"))
					{
						dictionary[sanitizedName + ".Unimmortal"] = config.CanDie.ToString().ToLower();
					}
					if (cachedConfigEntries[sanitizedName].ContainsKey(".HEALTH"))
					{
						dictionary[sanitizedName + ".Health"] = config.Health.ToString(CultureInfo.InvariantCulture);
					}
					UpdateConfigFileDirectly(pluginConfigPath, "Mobs", dictionary);
				}
				if (cachedConfigEntries[sanitizedName].ContainsKey(".ENABLED"))
				{
					UpdateConfigFileDirectly(enemyControlConfigPath, "Enemies", new Dictionary<string, string> { 
					{
						sanitizedName + ".Enabled",
						config.IsEnabled.ToString().ToLower()
					} });
				}
				if (cachedConfigEntries[sanitizedName].ContainsKey(".DESPAWN"))
				{
					UpdateConfigFileDirectly(despawnConfigPath, "Enemies", new Dictionary<string, string> { 
					{
						sanitizedName + ".Despawn",
						config.ShouldDespawn.ToString().ToLower()
					} });
				}
				cachedConfigEntries[sanitizedName][".ENABLED"] = config.IsEnabled;
				cachedConfigEntries[sanitizedName][".UNIMMORTAL"] = config.CanDie;
				cachedConfigEntries[sanitizedName][".HEALTH"] = config.Health;
				cachedConfigEntries[sanitizedName][".DESPAWN"] = config.ShouldDespawn;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error saving configuration: " + ex.Message));
			}
		}

		private static bool UpdateConfigFileDirectly(string path, string section, Dictionary<string, string> updates)
		{
			if (!File.Exists(path))
			{
				return false;
			}
			try
			{
				string[] array = File.ReadAllLines(path);
				List<string> list = new List<string>();
				string text = "";
				bool flag = false;
				Dictionary<string, bool> dictionary = new Dictionary<string, bool>();
				foreach (string key in updates.Keys)
				{
					dictionary[key.ToUpper()] = false;
				}
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					string text3 = text2.Trim();
					Match match = sectionRegex.Match(text3);
					if (match.Success)
					{
						text = match.Groups[1].Value;
						list.Add(text2);
					}
					else if (text == section)
					{
						bool flag2 = false;
						int num = text3.IndexOf('=');
						if (num > 0)
						{
							string text4 = text3.Substring(0, num).Trim();
							foreach (string key2 in updates.Keys)
							{
								if (text4.Equals(key2, StringComparison.OrdinalIgnoreCase) || Plugin.RemoveInvalidCharacters(text4.ToUpper()) == Plugin.RemoveInvalidCharacters(key2.ToUpper()))
								{
									list.Add(text4 + " = " + updates[key2]);
									dictionary[key2.ToUpper()] = true;
									flag = true;
									flag2 = true;
									break;
								}
							}
						}
						if (!flag2)
						{
							list.Add(text2);
						}
					}
					else
					{
						list.Add(text2);
					}
				}
				bool flag3 = false;
				foreach (KeyValuePair<string, bool> item in dictionary)
				{
					if (!item.Value)
					{
						flag3 = true;
						break;
					}
				}
				if (flag3)
				{
					bool flag4 = false;
					for (int j = 0; j < list.Count; j++)
					{
						if (list[j].Trim() == "[" + section + "]")
						{
							flag4 = true;
							break;
						}
					}
					if (!flag4)
					{
						if (list.Count > 0 && !string.IsNullOrWhiteSpace(list[list.Count - 1]))
						{
							list.Add("");
						}
						list.Add("[" + section + "]");
					}
					foreach (KeyValuePair<string, bool> entry in dictionary)
					{
						if (!entry.Value)
						{
							string text5 = updates.Keys.First((string k) => k.ToUpper() == entry.Key);
							string text6 = updates[text5];
							list.Add(text5 + " = " + text6);
							flag = true;
						}
					}
				}
				if (flag)
				{
					File.WriteAllLines(path, list);
				}
				return flag;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error updating config file " + path + ": " + ex.Message));
				return false;
			}
		}
	}
	public class ConfigMenuManager : MonoBehaviour
	{
		private enum GlobalSettingsTab
		{
			Rules,
			HealthBar,
			BulkConfig
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Comparison<EnemyConfigData> <>9__24_0;

			public static UnityAction <>9__34_0;

			public static UnityAction<bool> <>9__34_1;

			public static UnityAction<bool> <>9__34_2;

			public static UnityAction<bool> <>9__34_3;

			public static UnityAction<bool> <>9__42_0;

			public static UnityAction<bool> <>9__42_1;

			public static UnityAction<bool> <>9__42_2;

			public static UnityAction<bool> <>9__42_3;

			public static UnityAction<int> <>9__43_0;

			public static UnityAction<int> <>9__43_1;

			public static UnityAction<bool> <>9__43_2;

			public static UnityAction<int> <>9__43_3;

			internal int <RefreshEnemyData>b__24_0(EnemyConfigData a, EnemyConfigData b)
			{
				return string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase);
			}

			internal void <CreateMenuPrefab>b__34_0()
			{
				CloseConfigMenu();
			}

			internal void <CreateMenuPrefab>b__34_1(bool isHideMenu)
			{
				PlayConfirmSFX();
				UIConfiguration.Instance.SetConfigMenuEnabled(!isHideMenu);
				UIConfiguration.Instance.Save();
			}

			internal void <CreateMenuPrefab>b__34_2(bool isLessLogs)
			{
				PlayConfirmSFX();
				UIConfiguration.Instance.SetInfoLogsEnabled(!isLessLogs);
				UIConfiguration.Instance.Save();
			}

			internal void <CreateMenuPrefab>b__34_3(bool showImages)
			{
				PlayConfirmSFX();
				UIConfiguration.Instance.SetShowEnemyImages(showImages);
				UIConfiguration.Instance.Save();
				ConfigMenuManager component = menuPrefab.GetComponent<ConfigMenuManager>();
				if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.selectedEnemyName))
				{
					component.UpdateConfigPanel();
				}
			}

			internal void <PopulateRulesTab>b__42_0(bool allowSpikeTraps)
			{
				Plugin.AllowSpikeTrapsToKillEnemies.Value = allowSpikeTraps;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Spike trap kills " + (allowSpikeTraps ? "enabled" : "disabled"));
			}

			internal void <PopulateRulesTab>b__42_1(bool protectImmortals)
			{
				Plugin.ProtectImmortalEnemiesFromInstaKill.Value = protectImmortals;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Immortal enemy insta-kill protection " + (protectImmortals ? "enabled" : "disabled"));
			}

			internal void <PopulateRulesTab>b__42_2(bool protectOldBirds)
			{
				Plugin.ProtectOldBirdsFromOwnRockets.Value = protectOldBirds;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Old Birds rocket self-damage protection " + (protectOldBirds ? "enabled" : "disabled"));
			}

			internal void <PopulateRulesTab>b__42_3(bool mute)
			{
				Plugin.MuteDeadEnemies.Value = mute;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Mute dead enemies " + (mute ? "enabled" : "disabled"));
			}

			internal void <PopulateHealthBarTab>b__43_0(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarMode((UIConfiguration.HealthBarDisplayMode)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			}

			internal void <PopulateHealthBarTab>b__43_1(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarSize((UIConfiguration.HealthBarSize)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			}

			internal void <PopulateHealthBarTab>b__43_2(bool hide)
			{
				UIConfiguration.Instance.SetHideHealthBarForFullHp(hide);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			}

			internal void <PopulateHealthBarTab>b__43_3(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarRange((UIConfiguration.HealthBarVisibilityDistance)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			}
		}

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

			private object <>2__current;

			public ConfigMenuManager <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				ConfigMenuManager configMenuManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (configMenuManager.isShowingGlobalSettings)
					{
						configMenuManager.ShowGlobalSettings();
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public ConfigMenuManager <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				int num = <>1__state;
				ConfigMenuManager configMenuManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Plugin.LogInfo("Starting delayed refresh");
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					configMenuManager.RefreshEnemyData();
					refreshScheduled = false;
					Plugin.LogInfo("Delayed refresh completed");
					return false;
				}
			}

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

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

		private static GameObject menuPrefab;

		private GameObject menuPanel;

		private RectTransform enemyListContent;

		private GameObject enemyConfigPanel;

		private GameObject globalSettingsButton;

		private bool isShowingGlobalSettings;

		private GlobalSettingsTab selectedGlobalTab;

		private GameObject globalRulesTabButton;

		private GameObject globalHealthBarTabButton;

		private GameObject globalBulkTabButton;

		private GameObject globalSettingsContentRoot;

		private List<EnemyConfigData> enemyConfigs = new List<EnemyConfigData>();

		private Dictionary<string, GameObject> enemyEntries = new Dictionary<string, GameObject>();

		private Dictionary<string, EnemyConfigData> enemyConfigsByName = new Dictionary<string, EnemyConfigData>();

		private readonly Stack<GameObject> enemyEntryPool = new Stack<GameObject>();

		private const int INITIAL_POOL_SIZE = 20;

		private string selectedEnemyName;

		private const float ENTRY_HEIGHT = 35f;

		private static bool refreshScheduled;

		private TMP_InputField searchInputField;

		private string lastSearchText = "";

		private static MenuManager _cachedMenuManager;

		private void ClearSearch()
		{
			if ((Object)(object)searchInputField != (Object)null)
			{
				searchInputField.text = "";
				lastSearchText = "";
				FilterEnemyList(lastSearchText);
			}
		}

		private void ScheduleRefresh()
		{
			if (!refreshScheduled)
			{
				refreshScheduled = true;
				ClearSearch();
				((MonoBehaviour)this).StartCoroutine(DelayedRefresh());
			}
		}

		public void RefreshEnemyData()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			Plugin.LogInfo("RefreshEnemyData called");
			foreach (Transform item in (Transform)enemyListContent)
			{
				Transform val = item;
				((Component)val).gameObject.SetActive(false);
				enemyEntryPool.Push(((Component)val).gameObject);
			}
			enemyEntries.Clear();
			enemyConfigs = ConfigBridge.LoadAllEnemyConfigs();
			enemyConfigs.Sort((EnemyConfigData a, EnemyConfigData b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
			Plugin.LogInfo($"Sorted {enemyConfigs.Count} enemies alphabetically");
			enemyConfigsByName.Clear();
			foreach (EnemyConfigData enemyConfig in enemyConfigs)
			{
				enemyConfigsByName[enemyConfig.Name] = enemyConfig;
			}
			foreach (EnemyConfigData enemyConfig2 in enemyConfigs)
			{
				CreateEnemyListEntry(enemyConfig2);
			}
			FilterEnemyList(lastSearchText);
			selectedEnemyName = null;
			UpdateConfigPanel();
			Plugin.LogInfo($"Loaded {enemyConfigs.Count} enemy configurations");
		}

		private static MenuManager GetMenuManager()
		{
			if ((Object)(object)_cachedMenuManager == (Object)null)
			{
				_cachedMenuManager = Object.FindObjectOfType<MenuManager>();
			}
			return _cachedMenuManager;
		}

		private static void PlayConfirmSFX()
		{
			MenuManager menuManager = GetMenuManager();
			if ((Object)(object)menuManager != (Object)null && (Object)(object)menuManager.MenuAudio != (Object)null)
			{
				menuManager.PlayConfirmSFX();
			}
		}

		private static void PlayCancelSFX()
		{
			MenuManager menuManager = GetMenuManager();
			if ((Object)(object)menuManager != (Object)null && (Object)(object)menuManager.MenuAudio != (Object)null)
			{
				menuManager.PlayCancelSFX();
			}
		}

		public static void CloseConfigMenu(bool playSfx = true)
		{
			if (!((Object)(object)menuPrefab == (Object)null) && menuPrefab.activeSelf)
			{
				if (playSfx)
				{
					PlayCancelSFX();
				}
				ConfigMenuManager component = menuPrefab.GetComponent<ConfigMenuManager>();
				if ((Object)(object)component != (Object)null)
				{
					component.ResetViewState();
				}
				menuPrefab.SetActive(false);
			}
		}

		private void ResetViewState()
		{
			try
			{
				if (isShowingGlobalSettings)
				{
					isShowingGlobalSettings = false;
					UpdateGlobalSettingsButtonStyle(isActive: false);
				}
				selectedGlobalTab = GlobalSettingsTab.Rules;
				if (selectedEnemyName != null)
				{
					selectedEnemyName = null;
				}
				if ((Object)(object)enemyConfigPanel != (Object)null)
				{
					UpdateConfigPanel();
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error resetting menu view state: " + ex.Message);
			}
		}

		private void Update()
		{
			Keyboard current = Keyboard.current;
			if (current != null && ((ButtonControl)current.escapeKey).wasPressedThisFrame)
			{
				CloseConfigMenu();
			}
		}

		public static void ToggleConfigMenu()
		{
			if (!UIConfiguration.Instance.IsConfigMenuEnabled())
			{
				Plugin.LogWarning("Attempted to open config menu, but it's disabled in settings");
				return;
			}
			Plugin.LogInfo("ToggleConfigMenu called");
			if ((Object)(object)menuPrefab == (Object)null)
			{
				CreateMenuPrefab();
			}
			if (menuPrefab.activeSelf)
			{
				CloseConfigMenu(playSfx: false);
				return;
			}
			menuPrefab.SetActive(true);
			Plugin.LogInfo("Menu opened, scheduling refresh");
			menuPrefab.GetComponent<ConfigMenuManager>().ScheduleRefresh();
		}

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

		private static void CreateMenuPrefab()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_007a: 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_0113: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: 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_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0750: Unknown result type (might be due to invalid IL or missing references)
			//IL_075a: Expected O, but got Unknown
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0788: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0901: Unknown result type (might be due to invalid IL or missing references)
			//IL_0917: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0943: Unknown result type (might be due to invalid IL or missing references)
			//IL_0959: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Unknown result type (might be due to invalid IL or missing references)
			//IL_0857: Unknown result type (might be due to invalid IL or missing references)
			//IL_0863: Unknown result type (might be due to invalid IL or missing references)
			//IL_089f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a16: Expected O, but got Unknown
			//IL_0a3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0adb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b9b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c35: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c50: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d91: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ddd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e9f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e56: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e6b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0edf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ef4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Plugin.LogInfo("Creating menu prefab");
				menuPrefab = new GameObject("ECDAConfigMenu");
				ConfigMenuManager menuManager = menuPrefab.AddComponent<ConfigMenuManager>();
				menuPrefab.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)menuPrefab);
				Canvas obj = menuPrefab.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 1000;
				CanvasScaler obj2 = menuPrefab.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				menuPrefab.AddComponent<GraphicRaycaster>();
				GameObject val = UIHelper.CreatePanel(menuPrefab.transform, "Overlay", new Vector2(2000f, 2000f));
				if ((Object)(object)val == (Object)null)
				{
					Plugin.LogError("Failed to create overlay panel");
					return;
				}
				Image component = val.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = new Color(0f, 0f, 0f, 0.7f);
				}
				GameObject val2 = UIHelper.CreatePanel(menuPrefab.transform, "MainPanel", new Vector2(800f, 600f));
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.LogError("Failed to create main panel");
					return;
				}
				menuManager.menuPanel = val2;
				Image component2 = val2.GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = new Color(0.1f, 0.1f, 0.1f, 0.95f);
				}
				Transform transform = val2.transform;
				object obj3 = <>c.<>9__34_0;
				if (obj3 == null)
				{
					UnityAction val3 = delegate
					{
						CloseConfigMenu();
					};
					<>c.<>9__34_0 = val3;
					obj3 = (object)val3;
				}
				GameObject val4 = UIHelper.CreateButton(transform, "CloseButton", "X", (UnityAction)obj3);
				if ((Object)(object)val4 != (Object)null)
				{
					RectTransform component3 = val4.GetComponent<RectTransform>();
					component3.anchorMin = new Vector2(1f, 1f);
					component3.anchorMax = new Vector2(1f, 1f);
					component3.pivot = new Vector2(1f, 1f);
					component3.sizeDelta = new Vector2(80f, 40f);
					component3.anchoredPosition = new Vector2(-10f, -10f);
				}
				GameObject val5 = UIHelper.CreateYesNoSelector(val2.transform, "HideMenuSelector", "Hide Menu:", !UIConfiguration.Instance.IsConfigMenuEnabled(), delegate(bool isHideMenu)
				{
					PlayConfirmSFX();
					UIConfiguration.Instance.SetConfigMenuEnabled(!isHideMenu);
					UIConfiguration.Instance.Save();
				});
				if ((Object)(object)val5 != (Object)null)
				{
					RectTransform component4 = val5.GetComponent<RectTransform>();
					component4.anchorMin = new Vector2(0f, 1f);
					component4.anchorMax = new Vector2(0f, 1f);
					component4.pivot = new Vector2(0f, 1f);
					component4.sizeDelta = new Vector2(160f, 30f);
					component4.anchoredPosition = new Vector2(40f, -15f);
					Transform obj4 = val5.transform.Find("Label");
					RectTransform val6 = ((obj4 != null) ? ((Component)obj4).GetComponent<RectTransform>() : null);
					if ((Object)(object)val6 != (Object)null)
					{
						val6.sizeDelta = new Vector2(80f, 30f);
					}
				}
				GameObject val7 = UIHelper.CreateYesNoSelector(val2.transform, "LessLogsSelector", "Less Logs:", !UIConfiguration.Instance.ShouldLogInfo(), delegate(bool isLessLogs)
				{
					PlayConfirmSFX();
					UIConfiguration.Instance.SetInfoLogsEnabled(!isLessLogs);
					UIConfiguration.Instance.Save();
				});
				if ((Object)(object)val7 != (Object)null)
				{
					RectTransform component5 = val7.GetComponent<RectTransform>();
					component5.anchorMin = new Vector2(0f, 1f);
					component5.anchorMax = new Vector2(0f, 1f);
					component5.pivot = new Vector2(0f, 1f);
					component5.sizeDelta = new Vector2(150f, 30f);
					component5.anchoredPosition = new Vector2(260f, -15f);
					Transform obj5 = val7.transform.Find("Label");
					RectTransform val8 = ((obj5 != null) ? ((Component)obj5).GetComponent<RectTransform>() : null);
					if ((Object)(object)val8 != (Object)null)
					{
						val8.sizeDelta = new Vector2(70f, 30f);
					}
				}
				GameObject val9 = UIHelper.CreateYesNoSelector(val2.transform, "ShowImagesSelector", "Show Images:", UIConfiguration.Instance.ShouldShowEnemyImages(), delegate(bool showImages)
				{
					PlayConfirmSFX();
					UIConfiguration.Instance.SetShowEnemyImages(showImages);
					UIConfiguration.Instance.Save();
					ConfigMenuManager component19 = menuPrefab.GetComponent<ConfigMenuManager>();
					if ((Object)(object)component19 != (Object)null && !string.IsNullOrEmpty(component19.selectedEnemyName))
					{
						component19.UpdateConfigPanel();
					}
				});
				if ((Object)(object)val9 != (Object)null)
				{
					RectTransform component6 = val9.GetComponent<RectTransform>();
					component6.anchorMin = new Vector2(0f, 1f);
					component6.anchorMax = new Vector2(0f, 1f);
					component6.pivot = new Vector2(0f, 1f);
					component6.sizeDelta = new Vector2(170f, 30f);
					component6.anchoredPosition = new Vector2(470f, -15f);
					Transform obj6 = val9.transform.Find("Label");
					RectTransform val10 = ((obj6 != null) ? ((Component)obj6).GetComponent<RectTransform>() : null);
					if ((Object)(object)val10 != (Object)null)
					{
						val10.sizeDelta = new Vector2(100f, 30f);
					}
				}
				GameObject val11 = UIHelper.CreatePanel(val2.transform, "ContentPanel", new Vector2(780f, 520f));
				if ((Object)(object)val11 == (Object)null)
				{
					Plugin.LogError("Failed to create content panel");
					return;
				}
				RectTransform component7 = val11.GetComponent<RectTransform>();
				component7.anchorMin = new Vector2(0f, 0f);
				component7.anchorMax = new Vector2(1f, 1f);
				component7.pivot = new Vector2(0.5f, 0.5f);
				component7.offsetMin = new Vector2(10f, 60f);
				component7.offsetMax = new Vector2(-10f, -50f);
				GameObject val12 = UIHelper.CreatePanel(val11.transform, "EnemyListPanel", new Vector2(250f, 520f));
				if ((Object)(object)val12 == (Object)null)
				{
					Plugin.LogError("Failed to create enemy list panel");
					return;
				}
				RectTransform component8 = val12.GetComponent<RectTransform>();
				component8.anchorMin = new Vector2(0f, 0f);
				component8.anchorMax = new Vector2(0f, 1f);
				component8.pivot = new Vector2(0f, 0.5f);
				component8.sizeDelta = new Vector2(250f, 0f);
				GameObject val13 = UIHelper.CreateText(val12.transform, "ListLabel", "ENEMIES", (TextAlignmentOptions)514);
				if ((Object)(object)val13 != (Object)null)
				{
					RectTransform component9 = val13.GetComponent<RectTransform>();
					component9.anchorMin = new Vector2(0f, 1f);
					component9.anchorMax = new Vector2(1f, 1f);
					component9.pivot = new Vector2(0.5f, 1f);
					component9.sizeDelta = new Vector2(0f, 30f);
					component9.anchoredPosition = new Vector2(0f, -5f);
					TextMeshProUGUI component10 = val13.GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component10 != (Object)null)
					{
						((TMP_Text)component10).fontSize = 16f;
						((TMP_Text)component10).fontStyle = (FontStyles)1;
						((Graphic)component10).color = new Color(1f, 0.9f, 0.5f, 1f);
					}
				}
				GameObject val14 = UIHelper.CreateButton(val12.transform, "GlobalSettingsButton", "Global Settings", (UnityAction)delegate
				{
					PlayConfirmSFX();
					menuManager.ToggleGlobalSettings();
				});
				if ((Object)(object)val14 != (Object)null)
				{
					menuManager.globalSettingsButton = val14;
					RectTransform component11 = val14.GetComponent<RectTransform>();
					component11.anchorMin = new Vector2(0f, 1f);
					component11.anchorMax = new Vector2(1f, 1f);
					component11.pivot = new Vector2(0.5f, 1f);
					component11.sizeDelta = new Vector2(-20f, 35f);
					component11.anchoredPosition = new Vector2(0f, -40f);
					Button component12 = val14.GetComponent<Button>();
					if ((Object)(object)component12 != (Object)null)
					{
						ColorBlock colors = ((Selectable)component12).colors;
						((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
						((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.4f, 0.4f, 1f);
						((ColorBlock)(ref colors)).pressedColor = new Color(0.2f, 0.2f, 0.2f, 1f);
						((Selectable)component12).colors = colors;
					}
					TextMeshProUGUI componentInChildren = val14.GetComponentInChildren<TextMeshProUGUI>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						((TMP_Text)componentInChildren).fontSize = 14f;
						((Graphic)componentInChildren).color = new Color(1f, 0.9f, 0.5f, 1f);
						((TMP_Text)componentInChildren).fontStyle = (FontStyles)1;
					}
				}
				GameObject val15 = UIHelper.CreateScrollView(val12.transform, "EnemyScrollView", new Vector2(240f, 450f));
				if ((Object)(object)val15 == (Object)null)
				{
					Plugin.LogError("Failed to create enemy scroll view");
					return;
				}
				RectTransform component13 = val15.GetComponent<RectTransform>();
				component13.anchorMin = new Vector2(0.5f, 0.5f);
				component13.anchorMax = new Vector2(0.5f, 0.5f);
				component13.pivot = new Vector2(0.5f, 0.5f);
				component13.anchoredPosition = new Vector2(0f, -90f);
				component13.sizeDelta = new Vector2(240f, 385f);
				if ((Object)(object)val15.GetComponent<ScrollRect>() != (Object)null)
				{
					NormalizedScrollRect.ApplyTo(val15, 0.08f, 0.08f);
				}
				Transform val16 = val15.transform.Find("Viewport");
				if ((Object)(object)val16 == (Object)null)
				{
					Plugin.LogError("Viewport not found in scroll view");
					return;
				}
				Transform val17 = val16.Find("Content");
				if ((Object)(object)val17 == (Object)null)
				{
					Plugin.LogError("Content not found in viewport");
					return;
				}
				menuManager.enemyListContent = ((Component)val17).GetComponent<RectTransform>();
				if ((Object)(object)menuManager.enemyListContent == (Object)null)
				{
					Plugin.LogError("Failed to get RectTransform for enemyListContent");
					return;
				}
				GameObject val18 = new GameObject("SearchContainer");
				val18.transform.SetParent(val12.transform, false);
				RectTransform obj7 = val18.AddComponent<RectTransform>();
				obj7.anchorMin = new Vector2(0f, 1f);
				obj7.anchorMax = new Vector2(1f, 1f);
				obj7.pivot = new Vector2(0.5f, 1f);
				obj7.sizeDelta = new Vector2(-20f, 30f);
				obj7.anchoredPosition = new Vector2(0f, -80f);
				((Graphic)val18.AddComponent<Image>()).color = new Color(0.12f, 0.12f, 0.12f, 1f);
				GameObject val19 = new GameObject("SearchIcon");
				val19.transform.SetParent(val18.transform, false);
				RectTransform obj8 = val19.AddComponent<RectTransform>();
				obj8.anchorMin = new Vector2(0f, 0.5f);
				obj8.anchorMax = new Vector2(0f, 0.5f);
				obj8.pivot = new Vector2(0.5f, 0.5f);
				obj8.sizeDelta = new Vector2(20f, 20f);
				obj8.anchoredPosition = new Vector2(15f, 0f);
				TextMeshProUGUI obj9 = val19.AddComponent<TextMeshProUGUI>();
				((TMP_Text)obj9).text = ">";
				((TMP_Text)obj9).fontSize = 16f;
				((Graphic)obj9).color = new Color(0.7f, 0.7f, 0.7f, 1f);
				((TMP_Text)obj9).alignment = (TextAlignmentOptions)514;
				TMP_InputField val20 = val18.AddComponent<TMP_InputField>();
				GameObject val21 = new GameObject("Text");
				val21.transform.SetParent(val18.transform, false);
				RectTransform obj10 = val21.AddComponent<RectTransform>();
				obj10.anchorMin = new Vector2(0f, 0f);
				obj10.anchorMax = new Vector2(1f, 1f);
				obj10.offsetMin = new Vector2(35f, 2f);
				obj10.offsetMax = new Vector2(-5f, -2f);
				TextMeshProUGUI val22 = val21.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val22).fontSize = 14f;
				((Graphic)val22).color = new Color(0.9f, 0.9f, 0.9f, 1f);
				((TMP_Text)val22).alignment = (TextAlignmentOptions)513;
				GameObject val23 = new GameObject("Placeholder");
				val23.transform.SetParent(val18.transform, false);
				RectTransform obj11 = val23.AddComponent<RectTransform>();
				obj11.anchorMin = new Vector2(0f, 0f);
				obj11.anchorMax = new Vector2(1f, 1f);
				obj11.offsetMin = new Vector2(35f, 2f);
				obj11.offsetMax = new Vector2(-5f, -2f);
				TextMeshProUGUI val24 = val23.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val24).text = "Search enemies...";
				((TMP_Text)val24).fontSize = 14f;
				((Graphic)val24).color = new Color(0.5f, 0.5f, 0.5f, 1f);
				((TMP_Text)val24).alignment = (TextAlignmentOptions)513;
				val20.textComponent = (TMP_Text)(object)val22;
				val20.placeholder = (Graphic)(object)val24;
				val20.text = "";
				menuManager.searchInputField = val20;
				((UnityEvent<string>)(object)val20.onValueChanged).AddListener((UnityAction<string>)delegate(string searchText)
				{
					menuManager.FilterEnemyList(searchText);
				});
				component13.anchoredPosition = new Vector2(0f, -70f);
				component13.sizeDelta = new Vector2(240f, 405f);
				GameObject val25 = UIHelper.CreatePanel(val11.transform, "ConfigPanel", new Vector2(500f, 520f));
				if ((Object)(object)val25 == (Object)null)
				{
					Plugin.LogError("Failed to create config panel");
					return;
				}
				RectTransform component14 = val25.GetComponent<RectTransform>();
				component14.anchorMin = new Vector2(1f, 0f);
				component14.anchorMax = new Vector2(1f, 1f);
				component14.pivot = new Vector2(1f, 0.5f);
				component14.sizeDelta = new Vector2(500f, 0f);
				menuManager.enemyConfigPanel = val25;
				GameObject val26 = UIHelper.CreateText(val25.transform, "NoSelection", "Select an enemy from the list", (TextAlignmentOptions)514);
				if ((Object)(object)val26 != (Object)null)
				{
					RectTransform component15 = val26.GetComponent<RectTransform>();
					component15.anchorMin = new Vector2(0f, 0f);
					component15.anchorMax = new Vector2(1f, 1f);
					component15.offsetMin = Vector2.zero;
					component15.offsetMax = Vector2.zero;
				}
				GameObject val27 = UIHelper.CreatePanel(val2.transform, "MissingEnemiesMessage", new Vector2(780f, 40f));
				if ((Object)(object)val27 != (Object)null)
				{
					RectTransform component16 = val27.GetComponent<RectTransform>();
					component16.anchorMin = new Vector2(0.5f, 0f);
					component16.anchorMax = new Vector2(0.5f, 0f);
					component16.pivot = new Vector2(0.5f, 0f);
					component16.anchoredPosition = new Vector2(0f, 10f);
					Image component17 = val27.GetComponent<Image>();
					if ((Object)(object)component17 != (Object)null)
					{
						((Graphic)component17).color = new Color(0.2f, 0.2f, 0.2f, 0.8f);
					}
					GameObject val28 = UIHelper.CreateText(val27.transform, "Text", "If enemies are missing, start a round to generate their entries.", (TextAlignmentOptions)514);
					if ((Object)(object)val28 != (Object)null)
					{
						TextMeshProUGUI component18 = val28.GetComponent<TextMeshProUGUI>();
						if ((Object)(object)component18 != (Object)null)
						{
							((TMP_Text)component18).fontSize = 14f;
							((Graphic)component18).color = new Color(1f, 0.9f, 0.5f, 1f);
						}
					}
				}
				EnemyImageLoader.Initialize();
				Plugin.LogInfo("Config menu created successfully");
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error creating menu prefab: " + ex.Message + "\nStack trace: " + ex.StackTrace);
			}
		}

		private void ToggleGlobalSettings()
		{
			isShowingGlobalSettings = !isShowingGlobalSettings;
			if (isShowingGlobalSettings)
			{
				ShowGlobalSettings();
				UpdateGlobalSettingsButtonStyle(isActive: true);
			}
			else
			{
				selectedEnemyName = null;
				UpdateConfigPanel();
				UpdateGlobalSettingsButtonStyle(isActive: false);
			}
		}

		private void UpdateGlobalSettingsButtonStyle(bool isActive)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_00ee: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)globalSettingsButton == (Object)null)
			{
				return;
			}
			Button component = globalSettingsButton.GetComponent<Button>();
			TextMeshProUGUI componentInChildren = globalSettingsButton.GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)component != (Object)null)
			{
				ColorBlock colors = ((Selectable)component).colors;
				if (isActive)
				{
					((ColorBlock)(ref colors)).normalColor = new Color(0.5f, 0.5f, 0.5f, 1f);
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.6f, 0.6f, 0.6f, 1f);
				}
				else
				{
					((ColorBlock)(ref colors)).normalColor = new Color(0.3f, 0.3f, 0.3f, 1f);
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.4f, 0.4f, 0.4f, 1f);
				}
				((Selectable)component).colors = colors;
			}
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Graphic)componentInChildren).color = (Color)(isActive ? Color.white : new Color(1f, 0.9f, 0.5f, 1f));
			}
		}

		private void ShowGlobalSettings()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: 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_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Expected O, but got Unknown
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Expected O, but got Unknown
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Expected O, but got Unknown
			try
			{
				if ((Object)(object)enemyConfigPanel == (Object)null)
				{
					return;
				}
				foreach (Transform item in enemyConfigPanel.transform)
				{
					Transform val = item;
					if ((Object)(object)val != (Object)null && ((Object)val).name != "NoSelection")
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				Transform val2 = enemyConfigPanel.transform.Find("NoSelection");
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
				GameObject val3 = UIHelper.CreateText(enemyConfigPanel.transform, "Title", "Global Settings", (TextAlignmentOptions)514);
				if ((Object)(object)val3 != (Object)null)
				{
					RectTransform component = val3.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(0f, 1f);
					component.anchorMax = new Vector2(1f, 1f);
					component.pivot = new Vector2(0.5f, 1f);
					component.sizeDelta = new Vector2(0f, 40f);
					TextMeshProUGUI component2 = val3.GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component2 != (Object)null)
					{
						((TMP_Text)component2).fontSize = 22f;
						((Graphic)component2).color = new Color(1f, 0.9f, 0.5f, 1f);
						((TMP_Text)component2).fontStyle = (FontStyles)1;
					}
				}
				GameObject val4 = new GameObject("GlobalTabRow", new Type[1] { typeof(RectTransform) });
				val4.transform.SetParent(enemyConfigPanel.transform, false);
				RectTransform val5 = (RectTransform)val4.transform;
				val5.anchorMin = new Vector2(0f, 1f);
				val5.anchorMax = new Vector2(1f, 1f);
				val5.pivot = new Vector2(0.5f, 1f);
				val5.sizeDelta = new Vector2(-20f, 32f);
				val5.anchoredPosition = new Vector2(0f, -45f);
				HorizontalLayoutGroup obj = val4.AddComponent<HorizontalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
				((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = true;
				((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
				((LayoutGroup)obj).childAlignment = (TextAnchor)4;
				((LayoutGroup)obj).padding = new RectOffset(0, 0, 0, 0);
				globalRulesTabButton = UIHelper.CreateButton(val4.transform, "TabRules", "Rules", (UnityAction)delegate
				{
					SetGlobalSettingsTab(GlobalSettingsTab.Rules);
				});
				globalHealthBarTabButton = UIHelper.CreateButton(val4.transform, "TabHealthBar", "Health Bar", (UnityAction)delegate
				{
					SetGlobalSettingsTab(GlobalSettingsTab.HealthBar);
				});
				globalBulkTabButton = UIHelper.CreateButton(val4.transform, "TabBulk", "Bulk Config", (UnityAction)delegate
				{
					SetGlobalSettingsTab(GlobalSettingsTab.BulkConfig);
				});
				GameObject val6 = UIHelper.CreateScrollView(enemyConfigPanel.transform, "GlobalSettingsScrollView", new Vector2(480f, 380f));
				if ((Object)(object)val6 == (Object)null)
				{
					return;
				}
				RectTransform component3 = val6.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0.5f, 0.5f);
				component3.anchorMax = new Vector2(0.5f, 0.5f);
				component3.pivot = new Vector2(0.5f, 0.5f);
				component3.anchoredPosition = new Vector2(8f, -30f);
				component3.sizeDelta = new Vector2(464f, 380f);
				NormalizedScrollRect.ApplyTo(val6, 0.08f, 0.08f);
				ScrollRect component4 = val6.GetComponent<ScrollRect>();
				GameObject val7 = UIHelper.CreateVerticalScrollbar(enemyConfigPanel.transform, "GlobalSettingsScrollbar", component4);
				if ((Object)(object)val7 != (Object)null)
				{
					RectTransform component5 = val7.GetComponent<RectTransform>();
					component5.anchorMin = new Vector2(0.5f, 0.5f);
					component5.anchorMax = new Vector2(0.5f, 0.5f);
					component5.pivot = new Vector2(1f, 0.5f);
					component5.sizeDelta = new Vector2(10f, 380f);
					component5.anchoredPosition = new Vector2(component3.anchoredPosition.x - component3.sizeDelta.x * 0.5f - 4f, component3.anchoredPosition.y);
				}
				Transform obj2 = val6.transform.Find("Viewport/Content");
				GameObject val8 = ((obj2 != null) ? ((Component)obj2).gameObject : null);
				if ((Object)(object)val8 == (Object)null)
				{
					Plugin.LogError("GlobalSettings: Could not find Viewport/Content");
					return;
				}
				globalSettingsContentRoot = val8;
				VerticalLayoutGroup component6 = val8.GetComponent<VerticalLayoutGroup>();
				if ((Object)(object)component6 != (Object)null)
				{
					((LayoutGroup)component6).padding = new RectOffset(20, 20, 20, 20);
					((HorizontalOrVerticalLayoutGroup)component6).spacing = 20f;
				}
				SetGlobalSettingsTab(selectedGlobalTab);
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error creating global settings panel: " + ex.Message);
			}
		}

		private void SetGlobalSettingsTab(GlobalSettingsTab tab)
		{
			selectedGlobalTab = tab;
			UpdateGlobalTabButtonStyles();
			if (!((Object)(object)globalSettingsContentRoot == (Object)null))
			{
				for (int num = globalSettingsContentRoot.transform.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)globalSettingsContentRoot.transform.GetChild(num)).gameObject);
				}
				switch (tab)
				{
				case GlobalSettingsTab.Rules:
					PopulateRulesTab(globalSettingsContentRoot);
					break;
				case GlobalSettingsTab.HealthBar:
					PopulateHealthBarTab(globalSettingsContentRoot);
					break;
				case GlobalSettingsTab.BulkConfig:
					PopulateBulkConfigTab(globalSettingsContentRoot);
					break;
				}
				PlayConfirmSFX();
				ScrollRect componentInParent = globalSettingsContentRoot.GetComponentInParent<ScrollRect>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					componentInParent.verticalNormalizedPosition = 1f;
				}
			}
		}

		private void UpdateGlobalTabButtonStyles()
		{
			ApplyTabStyle(globalRulesTabButton, selectedGlobalTab == GlobalSettingsTab.Rules);
			ApplyTabStyle(globalHealthBarTabButton, selectedGlobalTab == GlobalSettingsTab.HealthBar);
			ApplyTabStyle(globalBulkTabButton, selectedGlobalTab == GlobalSettingsTab.BulkConfig);
		}

		private static void ApplyTabStyle(GameObject buttonObj, bool active)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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)
			if (!((Object)(object)buttonObj == (Object)null))
			{
				Button component = buttonObj.GetComponent<Button>();
				TextMeshProUGUI componentInChildren = buttonObj.GetComponentInChildren<TextMeshProUGUI>();
				if ((Object)(object)component != (Object)null)
				{
					ColorBlock colors = ((Selectable)component).colors;
					((ColorBlock)(ref colors)).normalColor = (active ? new Color(0.5f, 0.5f, 0.5f, 1f) : new Color(0.2f, 0.2f, 0.2f, 1f));
					((ColorBlock)(ref colors)).highlightedColor = (active ? new Color(0.6f, 0.6f, 0.6f, 1f) : new Color(0.3f, 0.3f, 0.3f, 1f));
					((Selectable)component).colors = colors;
				}
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Graphic)componentInChildren).color = (Color)(active ? Color.white : new Color(1f, 0.9f, 0.5f, 1f));
					((TMP_Text)componentInChildren).fontStyle = (FontStyles)(active ? 1 : 0);
				}
			}
		}

		private static void AddDescription(GameObject parent, string name, string text)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent.transform, false);
			val.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 40f);
			GameObject obj = UIHelper.CreateText(val.transform, name + "Text", text, (TextAlignmentOptions)513);
			TextMeshProUGUI val2 = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)val2).fontSize = 12f;
				((Graphic)val2).color = new Color(0.7f, 0.7f, 0.7f, 1f);
				((TMP_Text)val2).fontStyle = (FontStyles)2;
			}
		}

		private void PopulateRulesTab(GameObject content)
		{
			//IL_0058: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIHelper.CreateYesNoSelector(content.transform, "SpikeTrapsSelector", "Allow spike traps to kill enemies:", Plugin.AllowSpikeTrapsToKillEnemies.Value, delegate(bool allowSpikeTraps)
			{
				Plugin.AllowSpikeTrapsToKillEnemies.Value = allowSpikeTraps;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Spike trap kills " + (allowSpikeTraps ? "enabled" : "disabled"));
			});
			if ((Object)(object)val != (Object)null)
			{
				val.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "SpikeDescPanel", "When disabled, spike roof traps will not be able to kill enemies managed by this mod.");
			GameObject val2 = UIHelper.CreateYesNoSelector(content.transform, "ImmortalProtectionSelector", "Protect immortal enemies from insta-kill effects:", Plugin.ProtectImmortalEnemiesFromInstaKill.Value, delegate(bool protectImmortals)
			{
				Plugin.ProtectImmortalEnemiesFromInstaKill.Value = protectImmortals;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Immortal enemy insta-kill protection " + (protectImmortals ? "enabled" : "disabled"));
			});
			if ((Object)(object)val2 != (Object)null)
			{
				val2.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "ImmortalDescPanel", "When disabled, immortal enemies can still be killed by insta-kill effects like spike traps.");
			GameObject val3 = UIHelper.CreateYesNoSelector(content.transform, "OldBirdsProtectionSelector", "Protect Old Birds from their own rockets:", Plugin.ProtectOldBirdsFromOwnRockets.Value, delegate(bool protectOldBirds)
			{
				Plugin.ProtectOldBirdsFromOwnRockets.Value = protectOldBirds;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Old Birds rocket self-damage protection " + (protectOldBirds ? "enabled" : "disabled"));
			});
			if ((Object)(object)val3 != (Object)null)
			{
				val3.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "OldBirdDescPanel", "When enabled, Old Birds will not take damage from their own rocket explosions. Works with FairAI.");
			GameObject val4 = UIHelper.CreateYesNoSelector(content.transform, "MuteDeadEnemiesSelector", "Mute dead enemies:", Plugin.MuteDeadEnemies.Value, delegate(bool mute)
			{
				Plugin.MuteDeadEnemies.Value = mute;
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
				Plugin.LogInfo("Mute dead enemies " + (mute ? "enabled" : "disabled"));
			});
			if ((Object)(object)val4 != (Object)null)
			{
				val4.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "MuteDescPanel", "When enabled, all audio sources on enemy corpses will be silenced. Only applies when despawn is disabled.");
		}

		private void PopulateHealthBarTab(GameObject content)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			string[] options = new string[4] { "Off", "Number", "Bar", "Both" };
			int healthBarMode = (int)UIConfiguration.Instance.GetHealthBarMode();
			GameObject val = UIHelper.CreateCycleSelector(content.transform, "HealthBarSelector", "Enemy health bar:", options, healthBarMode, delegate(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarMode((UIConfiguration.HealthBarDisplayMode)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			});
			if ((Object)(object)val != (Object)null)
			{
				val.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "HealthBarDescPanel", "Show a floating health indicator above damageable enemies. Click to cycle: Off / Number / Bar / Both.");
			string[] options2 = new string[3] { "Small", "Medium", "Large" };
			int healthBarSize = (int)UIConfiguration.Instance.GetHealthBarSize();
			GameObject val2 = UIHelper.CreateCycleSelector(content.transform, "HealthBarSizeSelector", "Health bar size:", options2, healthBarSize, delegate(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarSize((UIConfiguration.HealthBarSize)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			});
			if ((Object)(object)val2 != (Object)null)
			{
				val2.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "HealthBarSizeDescPanel", "Scales both the bar and the number together. Click to cycle: Small / Medium / Large.");
			GameObject val3 = UIHelper.CreateYesNoSelector(content.transform, "HideFullHpSelector", "Hide Health Bar for full HP Enemies:", UIConfiguration.Instance.ShouldHideHealthBarForFullHp(), delegate(bool hide)
			{
				UIConfiguration.Instance.SetHideHealthBarForFullHp(hide);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			});
			if ((Object)(object)val3 != (Object)null)
			{
				val3.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "HideFullHpDescPanel", "When enabled, the health bar only appears once an enemy has taken damage. Avoids revealing enemies that are hiding.");
			string[] options3 = new string[3] { "Close", "Medium", "Far" };
			int healthBarRange = (int)UIConfiguration.Instance.GetHealthBarRange();
			GameObject val4 = UIHelper.CreateCycleSelector(content.transform, "HealthBarRangeSelector", "Health bar range:", options3, healthBarRange, delegate(int newIndex)
			{
				UIConfiguration.Instance.SetHealthBarRange((UIConfiguration.HealthBarVisibilityDistance)newIndex);
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				PlayConfirmSFX();
			});
			if ((Object)(object)val4 != (Object)null)
			{
				val4.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			AddDescription(content, "HealthBarRangeDescPanel", "Maximum distance at which the health bar is visible. Click to cycle: Close / Medium / Far.");
		}

		private void PopulateBulkConfigTab(GameObject content)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIHelper.CreateBulkActionSelector(content.transform, "BulkEnabledSelector", "Set ALL Enemies to:", "Affected", "Unaffected", delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies to: Affected", (UnityAction)delegate
				{
					SetAllEnemiesEnabled(enabled: true);
				});
			}, delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies to: Unaffected", (UnityAction)delegate
				{
					SetAllEnemiesEnabled(enabled: false);
				});
			});
			if ((Object)(object)val != (Object)null)
			{
				val.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			GameObject val2 = UIHelper.CreateBulkActionSelector(content.transform, "BulkKillableSelector", "Set ALL Enemies to:", "Killable", "Unkillable", delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies to: Killable", (UnityAction)delegate
				{
					SetAllEnemiesKillable(killable: true);
				});
			}, delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies to: Unkillable", (UnityAction)delegate
				{
					SetAllEnemiesKillable(killable: false);
				});
			});
			if ((Object)(object)val2 != (Object)null)
			{
				val2.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
			GameObject val3 = UIHelper.CreateBulkActionSelector(content.transform, "BulkDespawnSelector", "Set ALL Enemies corpses to:", "Despawn", "Keep", delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies corpses to: Despawn", (UnityAction)delegate
				{
					SetAllEnemiesDespawn(despawn: true);
				});
			}, delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				ShowBulkActionConfirmation("Set ALL Enemies corpses to: Keep", (UnityAction)delegate
				{
					SetAllEnemiesDespawn(despawn: false);
				});
			});
			if ((Object)(object)val3 != (Object)null)
			{
				val3.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
			}
		}

		private void CreateEnemyListEntry(EnemyConfigData config)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val;
			if (enemyEntryPool.Count > 0)
			{
				val = enemyEntryPool.Pop();
				val.SetActive(true);
				((Object)val).name = "Enemy_" + config.SanitizedName;
				val.transform.SetAsLastSibling();
				UpdateEnemyListEntry(val, config);
			}
			else
			{
				val = UIHelper.CreatePanel((Transform)(object)enemyListContent, "Enemy_" + config.SanitizedName, new Vector2(230f, 35f));
				SetupNewEnemyListEntry(val, config);
			}
			enemyEntries[config.Name] = val;
		}

		private void SetupNewEnemyListEntry(GameObject entryObj, EnemyConfigData config)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0069: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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)
			LayoutElement obj = entryObj.AddComponent<LayoutElement>();
			obj.minHeight = 35f;
			obj.preferredHeight = 35f;
			obj.flexibleHeight = 0f;
			GameObject val = UIHelper.CreateButton(entryObj.transform, "Button", config.Name, (UnityAction)delegate
			{
				SelectEnemy(config.Name);
			});
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(5f, 3f);
			component.offsetMax = new Vector2(-5f, -3f);
			GameObject val2 = new GameObject("Status");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj2 = val2.AddComponent<RectTransform>();
			obj2.anchorMin = new Vector2(0f, 0.5f);
			obj2.anchorMax = new Vector2(0f, 0.5f);
			obj2.pivot = new Vector2(0f, 0.5f);
			obj2.sizeDelta = new Vector2(10f, 10f);
			obj2.anchoredPosition = new Vector2(10f, 0f);
			((Graphic)val2.AddComponent<Image>()).color = config.GetStatusColor();
			Transform val3 = val.transform.Find("Text");
			if ((Object)(object)val3 != (Object)null)
			{
				((Component)val3).GetComponent<RectTransform>().offsetMin = new Vector2(25f, 0f);
				TextMeshProUGUI component2 = ((Component)val3).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component2).fontSize = UITheme.NormalFontSize;
				((TMP_Text)component2).alignment = (TextAlignmentOptions)513;
			}
		}

		private void UpdateEnemyListEntry(GameObject entryObj, EnemyConfigData config)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			Transform val = entryObj.transform.Find("Button");
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			Button component = ((Component)val).GetComponent<Button>();
			((UnityEventBase)component.onClick).RemoveAllListeners();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				SelectEnemy(config.Name);
			});
			Transform val2 = ((Component)val).transform.Find("Text");
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)((Component)val2).GetComponent<TextMeshProUGUI>()).text = config.Name;
			}
			Transform val3 = ((Component)val).transform.Find("Status");
			if ((Object)(object)val3 != (Object)null)
			{
				Image component2 = ((Component)val3).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = config.GetStatusColor();
				}
			}
		}

		private void FilterEnemyList(string searchText = "")
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			searchText = searchText?.ToLower() ?? "";
			lastSearchText = searchText;
			bool flag = false;
			foreach (KeyValuePair<string, GameObject> enemyEntry in enemyEntries)
			{
				if (enemyConfigsByName.TryGetValue(enemyEntry.Key, out var value))
				{
					bool flag2 = value.Name.ToLower().Contains(searchText);
					bool flag3 = EnemyAliases.MatchesAlias(value.Name, searchText);
					bool flag4 = string.IsNullOrEmpty(searchText) || flag2 || flag3;
					enemyEntry.Value.SetActive(flag4);
					if (flag4)
					{
						flag = true;
					}
				}
			}
			Transform obj = ((Component)enemyListContent).transform.Find("NoResults");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if (!flag && !string.IsNullOrEmpty(searchText))
			{
				if ((Object)(object)val == (Object)null)
				{
					val = UIHelper.CreateText(((Component)enemyListContent).transform, "NoResults", "No enemies found matching \"" + searchText + "\"", (TextAlignmentOptions)514);
					TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component != (Object)null)
					{
						((TMP_Text)component).fontSize = 14f;
						((Graphic)component).color = new Color(0.7f, 0.7f, 0.7f, 1f);
						((TMP_Text)component).alignment = (TextAlignmentOptions)514;
					}
				}
				else
				{
					TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component2 != (Object)null)
					{
						((TMP_Text)component2).text = "No enemies found matching \"" + searchText + "\"";
					}
				}
			}
			else if (flag && (Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)val);
			}
			else if ((Object)(object)val != (Object)null && string.IsNullOrEmpty(searchText))
			{
				Object.Destroy((Object)(object)val);
			}
		}

		private void SelectEnemy(string enemyName)
		{
			PlayConfirmSFX();
			selectedEnemyName = enemyName;
			if (isShowingGlobalSettings)
			{
				isShowingGlobalSettings = false;
				UpdateGlobalSettingsButtonStyle(isActive: false);
			}
			UpdateConfigPanel();
		}

		private void UpdateConfigPanel()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: 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_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)enemyConfigPanel == (Object)null)
				{
					Plugin.LogError("enemyConfigPanel is null in UpdateConfigPanel");
					return;
				}
				foreach (Transform item in enemyConfigPanel.transform)
				{
					Transform val = item;
					if ((Object)(object)val != (Object)null && ((Object)val).name != "NoSelection")
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				Transform val2 = enemyConfigPanel.transform.Find("NoSelection");
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(string.IsNullOrEmpty(selectedEnemyName));
				}
				if (string.IsNullOrEmpty(selectedEnemyName))
				{
					return;
				}
				EnemyConfigData config = enemyConfigs.Find((EnemyConfigData c) => c.Name == selectedEnemyName);
				if (config == null)
				{
					return;
				}
				string displayName = EnemyAliases.GetDisplayName(config.Name);
				string text = ((displayName != null) ? (config.Name + " (" + displayName + ")") : config.Name);
				GameObject val3 = UIHelper.CreateText(enemyConfigPanel.transform, "Title", text, (TextAlignmentOptions)514);
				if ((Object)(object)val3 != (Object)null)
				{
					RectTransform component = val3.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(0f, 1f);
					component.anchorMax = new Vector2(1f, 1f);
					component.pivot = new Vector2(0.5f, 1f);
					component.sizeDelta = new Vector2(0f, 40f);
					TextMeshProUGUI component2 = val3.GetComponent<TextMeshProUGUI>();
					if ((Object)(object)component2 != (Object)null)
					{
						((TMP_Text)component2).fontSize = 22f;
						((Graphic)component2).color = new Color(1f, 0.9f, 0.5f, 1f);
						((TMP_Text)component2).fontStyle = (FontStyles)1;
					}
				}
				GameObject controlsPanel = UIHelper.CreatePanel(enemyConfigPanel.transform, "ControlsPanel", new Vector2(480f, 400f));
				if ((Object)(object)controlsPanel == (Object)null)
				{
					Plugin.LogError("Failed to create controls panel");
					return;
				}
				RectTransform component3 = controlsPanel.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0.5f, 0.5f);
				component3.anchorMax = new Vector2(0.5f, 0.5f);
				component3.pivot = new Vector2(0.5f, 0.5f);
				component3.anchoredPosition = new Vector2(0f, 30f);
				component3.sizeDelta = new Vector2(480f, 380f);
				Image component4 = controlsPanel.GetComponent<Image>();
				if ((Object)(object)component4 != (Object)null)
				{
					((Graphic)component4).color = new Color(0f, 0f, 0f, 0f);
				}
				VerticalLayoutGroup obj = controlsPanel.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)obj).padding = new RectOffset(20, 20, 20, 20);
				((HorizontalOrVerticalLayoutGroup)obj).spacing = 15f;
				((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = false;
				((LayoutGroup)obj).childAlignment = (TextAnchor)0;
				GameObject val4 = new GameObject("StatusPanel");
				val4.transform.SetParent(controlsPanel.transform, false);
				val4.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
				GameObject val5 = UIHelper.CreateText(val4.transform, "StatusText", "Current Status: " + config.GetStatusText(), (TextAlignmentOptions)513);
				TextMeshProUGUI statusTextComp = ((val5 != null) ? val5.GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)statusTextComp != (Object)null)
				{
					((Graphic)statusTextComp).color = config.GetStatusColor();
				}
				GameObject val6 = new GameObject("AutoSavePanel");
				val6.transform.SetParent(controlsPanel.transform, false);
				val6.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 25f);
				GameObject obj2 = UIHelper.CreateText(val6.transform, "AutoSaveText", "All changes are saved immediately - you dont need to restart the game", (TextAlignmentOptions)513);
				TextMeshProUGUI val7 = ((obj2 != null) ? obj2.GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val7 != (Object)null)
				{
					((TMP_Text)val7).fontSize = 14f;
					((Graphic)val7).color = new Color(0.7f, 0.7f, 0.7f, 1f);
					((TMP_Text)val7).fontStyle = (FontStyles)2;
				}
				GameObject val8 = UIHelper.CreateYesNoSelector(controlsPanel.transform, "EnabledSelector", "Affected by ECDA mod:", config.IsEnabled, delegate(bool isYes)
				{
					//IL_0058: Unknown result type (might be due to invalid IL or missing references)
					config.IsEnabled = isYes;
					UpdateSelectorEnablements(controlsPanel, isYes);
					if ((Object)(object)statusTextComp != (Object)null)
					{
						((TMP_Text)statusTextComp).text = "Current Status: " + config.GetStatusText();
						((Graphic)statusTextComp).color = config.GetStatusColor();
					}
					SaveCurrentEnemyConfig();
					PlayConfirmSFX();
				});
				if ((Object)(object)val8 != (Object)null)
				{
					val8.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
				}
				GameObject val9 = UIHelper.CreateYesNoSelector(controlsPanel.transform, "CanDieSelector", "Can be damaged and killed:", config.CanDie, delegate(bool isYes)
				{
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					config.CanDie = isYes;
					if ((Object)(object)statusTextComp != (Object)null)
					{
						((TMP_Text)statusTextComp).text = "Current Status: " + config.GetStatusText();
						((Graphic)statusTextComp).color = config.GetStatusColor();
					}
					SaveCurrentEnemyConfig();
					PlayConfirmSFX();
				});
				if ((Object)(object)val9 != (Object)null)
				{
					val9.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
				}
				GameObject val10 = UIHelper.CreateYesNoSelector(controlsPanel.transform, "DespawnSelector", "Remove corpse after death:", config.ShouldDespawn, delegate(bool isYes)
				{
					config.ShouldDespawn = isYes;
					SaveCurrentEnemyConfig();
					PlayConfirmSFX();
				});
				if ((Object)(object)val10 != (Object)null)
				{
					val10.GetComponent<RectTransform>().sizeDelta = new Vector2(0f, 30f);
				}
				GameObject val11 = UIHelper.CreateNumericInputWithArrows(controlsPanel.transform, "HealthInput", "Health:", config.Health, 0.5f, 999f, delegate(float newValue)
				{
					config.Health = newValue;
					SaveCurrentEnemyConfig();
					PlayConfirmSFX();
				});
				if ((Object)(object)val11 != (Object)null)
				{
					((Object)val11).name = "HealthPanel";
				}
				UpdateSelectorEnablements(controlsPanel, config.IsEnabled);
				UpdateEnemyImageVisibility(controlsPanel, config.Name);
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error in UpdateConfigPanel: " + ex.Message + "\nStack trace: " + ex.StackTrace);
			}
		}

		private void UpdateSelectorEnablements(GameObject controlsPanel, bool isEnabled)
		{
			Transform obj = controlsPanel.transform.Find("CanDieSelector");
			UIHelper.StateHolder stateHolder = ((obj != null) ? ((Component)obj).GetComponent<UIHelper.StateHolder>() : null);
			Transform obj2 = controlsPanel.transform.Find("DespawnSelector");
			UIHelper.StateHolder stateHolder2 = ((obj2 != null) ? ((Component)obj2).GetComponent<UIHelper.StateHolder>() : null);
			Transform obj3 = controlsPanel.transform.Find("HealthPanel");
			UIHelper.NumericInputState numericInputState = ((obj3 != null) ? ((Component)obj3).GetComponent<UIHelper.NumericInputState>() : null);
			if ((Object)(object)stateHolder != (Object)null)
			{
				EnemyConfigData enemyConfigData = enemyConfigs.Find((EnemyConfigData c) => c.Name == selectedEnemyName);
				if (enemyConfigData != null)
				{
					stateHolder.SetInteractable(isEnabled);
					stateHolder.UpdateVisualState(enemyConfigData.CanDie);
				}
			}
			if ((Object)(object)stateHolder2 != (Object)null)
			{
				EnemyConfigData enemyConfigData2 = enemyConfigs.Find((EnemyConfigData c) => c.Name == selectedEnemyName);
				if (enemyConfigData2 != null)
				{
					stateHolder2.SetInteractable(isEnabled);
					stateHolder2.UpdateVisualState(enemyConfigData2.ShouldDespawn);
				}
			}
			if ((Object)(object)numericInputState != (Object)null)
			{
				EnemyConfigData enemyConfigData3 = enemyConfigs.Find((EnemyConfigData c) => c.Name == selectedEnemyName);
				if (enemyConfigData3 != null)
				{
					numericInputState.SetInteractable(isEnabled);
					numericInputState.SetValue(enemyConfigData3.Health);
				}
			}
		}

		private void UpdateEnemyImageVisibility(GameObject controlsPanel, string enemyName)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform obj = controlsPanel.transform.Find("ImageContainer");
				GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
				if ((Object)(object)val == (Object)null && UIConfiguration.Instance.ShouldShowEnemyImages())
				{
					val = new GameObject("ImageContainer");
					val.transform.SetParent(controlsPanel.transform, false);
					val.transform.SetAsLastSibling();
					val.AddComponent<RectTransform>().sizeDelta = new Vector2(0f, 180f);
					LayoutElement obj2 = val.AddComponent<LayoutElement>();
					obj2.minHeight = 180f;
					obj2.preferredHeight = 180f;
					obj2.flexibleHeight = 0f;
					GameObject val2 = new GameObject("EnemyImage");
					val2.transform.SetParent(val.transform, false);
					RectTransform obj3 = val2.AddComponent<RectTransform>();
					obj3.anchorMin = new Vector2(0.5f, 0.5f);
					obj3.anchorMax = new Vector2(0.5f, 0.5f);
					obj3.pivot = new Vector2(0.5f, 0.5f);
					obj3.sizeDelta = new Vector2(170f, 170f);
					val2.AddComponent<Image>().preserveAspect = true;
				}
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				if (UIConfiguration.Instance.ShouldShowEnemyImages() && !string.IsNullOrEmpty(enemyName))
				{
					Texture2D enemyTexture = EnemyImageLoader.GetEnemyTexture(enemyName);
					if ((Object)(object)enemyTexture != (Object)null)
					{
						val.SetActive(true);
						Transform val3 = val.transform.Find("EnemyImage");
						if ((Object)(object)val3 != (Object)null)
						{
							Image component = ((Component)val3).GetComponent<Image>();
							if ((Object)(object)component != (Object)null)
							{
								Sprite sprite = Sprite.Create(enemyTexture, new Rect(0f, 0f, (float)((Texture)enemyTexture).width, (float)((Texture)enemyTexture).height), new Vector2(0.5f, 0.5f));
								component.sprite = sprite;
								component.preserveAspect = true;
							}
						}
					}
					else
					{
						val.SetActive(false);
					}
				}
				else
				{
					val.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error updating enemy image visibility: " + ex.Message));
			}
		}

		private void SaveCurrentEnemyConfig()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(selectedEnemyName))
			{
				return;
			}
			EnemyConfigData enemyConfigData = enemyConfigs.Find((EnemyConfigData c) => c.Name == selectedEnemyName);
			if (enemyConfigData == null)
			{
				return;
			}
			ConfigBridge.SaveEnemyConfig(enemyConfigData);
			if (!enemyEntries.TryGetValue(enemyConfigData.Name, out var value))
			{
				return;
			}
			Transform val = value.transform.Find("Button/Status");
			if ((Object)(object)val != (Object)null)
			{
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = enemyConfigData.GetStatusColor();
				}
			}
		}

		private void OnDisable()
		{
			EnemyImageLoader.ClearCache();
		}

		private void ShowBulkActionConfirmation(string actionText, UnityAction onConfirm)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0058: Expected O, but got Unknown
			string message = "Do you really want to \"" + actionText + "\"?\n\nThis will modify all enemy configurations.";
			UIHelper.CreateConfirmationDialog(menuPanel.transform.parent, message, (UnityAction)delegate
			{
				PlayConfirmSFX();
				Plugin.LogInfo("User confirmed bulk action: " + actionText);
				UnityAction obj = onConfirm;
				if (obj != null)
				{
					obj.Invoke();
				}
			}, (UnityAction)delegate
			{
				PlayCancelSFX();
				Plugin.LogInfo("User cancelled bulk action: " + actionText);
			});
		}

		private void SetAllEnemiesEnabled(bool enabled)
		{
			try
			{
				Plugin.LogInfo("Setting all enemies to " + (enabled ? "enabled" : "disabled"));
				int num = 0;
				foreach (EnemyConfigData enemyConfig in enemyConfigs)
				{
					if (enemyConfig.IsEnabled != enabled)
					{
						enemyConfig.IsEnabled = enabled;
						ConfigBridge.SaveEnemyConfig(enemyConfig);
						num++;
					}
				}
				Plugin.LogInfo($"Updated {num} enemy configurations");
				RefreshAfterBulkAction();
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error in SetAllEnemiesEnabled: " + ex.Message);
			}
		}

		private void SetAllEnemiesKillable(bool killable)
		{
			try
			{
				Plugin.LogInfo("Setting all enemies to " + (killable ? "killable" : "unkillable"));
				int num = 0;
				foreach (EnemyConfigData enemyConfig in enemyConfigs)
				{
					if (enemyConfig.CanDie != killable)
					{
						enemyConfig.CanDie = killable;
						ConfigBridge.SaveEnemyConfig(enemyConfig);
						num++;
					}
				}
				Plugin.LogInfo($"Updated {num} enemy configurations");
				RefreshAfterBulkAction();
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error in SetAllEnemiesKillable: " + ex.Message);
			}
		}

		private void SetAllEnemiesDespawn(bool despawn)
		{
			try
			{
				Plugin.LogInfo("Setting all enemies corpses to " + (despawn ? "despawn" : "keep"));
				int num = 0;
				foreach (EnemyConfigData enemyConfig in enemyConfigs)
				{
					if (enemyConfig.ShouldDespawn != despawn)
					{
						enemyConfig.ShouldDespawn = despawn;
						ConfigBridge.SaveEnemyConfig(enemyConfig);
						num++;
					}
				}
				Plugin.LogInfo($"Updated {num} enemy despawn configurations");
				RefreshAfterBulkAction();
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error in SetAllEnemiesDespawn: " + ex.Message);
			}
		}

		private void RefreshAfterBulkAction()
		{
			try
			{
				Plugin.LogInfo("Refreshing menu after bulk action");
				ScheduleRefresh();
				if (isShowingGlobalSettings)
				{
					((MonoBehaviour)this).StartCoroutine(DelayedGlobalSettingsRefresh());
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error in RefreshAfterBulkAction: " + ex.Message);
			}
		}

		[IteratorStateMachine(typeof(<DelayedGlobalSettingsRefresh>d__60))]
		private IEnumerator DelayedGlobalSettingsRefresh()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedGlobalSettingsRefresh>d__60(0)
			{
				<>4__this = this
			};
		}
	}
	public class ConfigMenuPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Canvas, bool> <>9__12_0;

			public static Func<Button, bool> <>9__13_0;

			public static UnityAction <>9__14_0;

			public static Func<GameObject, string> <>9__15_6;

			public static Func<Button, GameObject> <>9__15_1;

			public static Func<GameObject, RectTransform> <>9__15_3;

			public static Func<RectTransform, float> <>9__15_4;

			public static Func<float, float, float> <>9__15_5;

			internal bool <TryMinimalFallback>b__12_0(Canvas c)
			{
				if (!((Object)c).name.Contains("Menu"))
				{
					return ((Object)c).name.Contains("UI");
				}
				return true;
			}

			internal bool <TryInjectIntoCanvas>b__13_0(Button b)
			{
				if (!((Object)b).name.ToLower().Contains("quit"))
				{
					return ((Object)b).name.ToLower().Contains("exit");
				}
				return true;
			}

			internal void <CreateConfigButton>b__14_0()
			{
				try
				{
					MenuManager val = Object.FindObjectOfType<MenuManager>();
					if ((Object)(object)val != (Object)null && (Object)(object)val.MenuAudio != (Object)null)
					{
						val.PlayConfirmSFX();
					}
				}
				catch
				{
				}
				ConfigMenuManager.ToggleConfigMenu();
			}

			internal string <InjectToMainMenu>b__15_6(GameObject go)
			{
				return ((Object)go).name;
			}

			internal GameObject <InjectToMainMenu>b__15_1(Button b)
			{
				return ((Component)b).gameObject;
			}

			internal RectTransform <InjectToMainMenu>b__15_3(GameObject b)
			{
				Transform transform = b.transform;
				return (RectTransform)(object)((transform is RectTransform) ? transform : null);
			}

			internal float <InjectToMainMenu>b__15_4(RectTransform t)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return t.anchoredPosition.y;
			}

			internal float <InjectToMainMenu>b__15_5(float y1, float y2)
			{
				return Mathf.Abs(y2 - y1);
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.8f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!menuInjectionSuccessful)
					{
						TryInjectToMainMenu("Awake");
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					TryInjectToMainMenu("Start");
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!menuInjectionSuccessful)
					{
						Plugin.LogInfo("Normal menu injection methods failed, attempting scene-based fallback...");
						TryInjectToMainMenu("SceneLoad");
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!menuInjectionSuccessful)
					{
						TryInjectToMainMenu("OnEnable");
					}
					return false;
				}
			}

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

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

		private static bool menuInjectionSuccessful;

		private static MenuManager lastMenuManagerInstance;

		public static bool IsMenuInjectionSuccessful => menuInjectionSuccessful;

		static ConfigMenuPatch()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name.Contains("Menu") || ((Scene)(ref scene)).name.Contains("MainMenu"))
			{
				MenuManager val = Object.FindObjectOfType<MenuManager>();
				if ((Object)(object)val != (Object)null)
				{
					((MonoBehaviour)val).StartCoroutine(DelayedSceneBasedCheck());
				}
			}
		}

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

		[HarmonyPatch(typeof(MenuManager), "Start")]
		[HarmonyPostfix]
		public static void Start(ref MenuManager __instance)
		{
			if (!__instance.isInitScene)
			{
				if ((Object)(object)lastMenuManagerInstance != (Object)(object)__instance)
				{
					menuInjectionSuccessful = false;
					lastMenuManagerInstance = __instance;
				}
				((MonoBehaviour)__instance).StartCoroutine(DelayedMainMenuInjection(__instance));
			}
		}

		[HarmonyPatch(typeof(MenuManager), "Awake")]
		[HarmonyPostfix]
		public static void Awake(ref MenuManager __instance)
		{
			if (!__instance.isInitScene)
			{
				((MonoBehaviour)__instance).StartCoroutine(AwakeDelayedInjection(__instance));
			}
		}

		[HarmonyPatch(typeof(MenuManager), "OnEnable")]
		[HarmonyPostfix]
		public static void OnEnable(ref MenuManager __instance)
		{
			if (!__instance.isInitScene && !menuInjectionSuccessful)
			{
				((MonoBehaviour)__instance).StartCoroutine(OnEnableDelayedInjection(__instance));
			}
		}

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

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

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

		private static void TryInjectToMainMenu(string source)
		{
			if (menuInjectionSuccessful)
			{
				return;
			}
			try
			{
				Plugin.LogInfo("Attempting menu injection from " + source);
				InjectToMainMenu();
				menuInjectionSuccessful = true;
				Plugin.LogInfo("Menu injection successful from " + source);
			}
			catch (Exception ex)
			{
				Plugin.LogError("Menu injection failed from " + source + ": " + ex.Message);
				Plugin.LogError("Trying minimal fallback...");
				TryMinimalFallback();
			}
		}

		private static void TryMinimalFallback()
		{
			try
			{
				Plugin.LogInfo("Attempting minimal fallback menu injection...");
				Canvas[] array = (from c in Object.FindObjectsOfType<Canvas>()
					where ((Object)c).name.Contains("Menu") || ((Object)c).name.Contains("UI")
					select c).ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					if (TryInjectIntoCanvas(array[i]))
					{
						menuInjectionSuccessful = true;
						Plugin.LogInfo("Minimal fallback injection successful");
						return;
					}
				}
				Plugin.LogError("All fallback methods failed. Menu button will not be available.");
			}
			catch (Exception ex)
			{
				Plugin.LogError("Minimal fallback also failed: " + ex.Message);
			}
		}

		private static bool TryInjectIntoCanvas(Canvas canvas)
		{
			try
			{
				Button[] componentsInChildren = ((Component)canvas).GetComponentsInChildren<Button>();
				if (componentsInChildren.Length == 0)
				{
					return false;
				}
				Transform val = null;
				Button[] array = componentsInChildren;
				for (int i = 0; i < array.Length; i++)
				{
					Transform parent = ((Component)array[i]).transform.parent;
					if ((Object)(object)parent != (Object)null && (((Object)parent).name.ToLower().Contains("main") || ((Object)parent).name.ToLower().Contains("button")))
					{
						val = parent;
						break;
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)componentsInChildren[0]).transform.parent;
				}
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Button val2 = ((IEnumerable<Button>)componentsInChildren).FirstOrDefault((Func<Button, bool>)((Button b) => ((Object)b).name.ToLower().Contains("quit") || ((Object)b).name.ToLower().Contains("exit")));
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = componentsInChildren[0];
				}
				CreateConfigButton(val, ((Component)val2).gameObject);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void CreateConfigButton(Transform parent, GameObject referenceButton)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0093: 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)
			GameObject obj = Object.Instantiate<GameObject>(referenceButton, parent);
			((Object)obj).name = "ECDAConfigButton";
			TextMeshProUGUI componentInChildren = obj.GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = "> EverythingCanDieAlt";
			}
			Button component = obj.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = component.onClick;
				object obj2 = <>c.<>9__14_0;
				if (obj2 == null)
				{
					UnityAction val = delegate
					{
						try
						{
							MenuManager val2 = Object.FindObjectOfType<MenuManager>();
							if ((Object)(object)val2 != (Object)null && (Object)(object)val2.MenuAudio != (Object)null)
							{
								val2.PlayConfirmSFX();
							}
						}
						catch
						{
						}
						ConfigMenuManager.ToggleConfigMenu();
					};
					<>c.<>9__14_0 = val;
					obj2 = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj2);
			}
			RectTransform component2 = obj.GetComponent<RectTransform>();
			RectTransform component3 = referenceButton.GetComponent<RectTransform>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)component3 != (Object)null)
			{
				component2.anchoredPosition = component3.anchoredPosition + new Vector2(0f, 50f);
			}
		}

		private static void InjectToMainMenu()
		{
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfo((object)"Injecting ECDA configuration menu into main menu...");
			GameObject menuContainer = GameObject.Find("MenuContainer");
			if (!Object.op_Implicit((Object)(object)menuContainer))
			{
				string[] array = new string[3] { "Menu Container", "MainMenuContainer", "UI" };
				foreach (string text in array)
				{
					menuContainer = GameObject.Find(text);
					if (Object.op_Implicit((Object)(object)menuContainer))
					{
						Plugin.LogInfo("Found menu container with alternative name: " + text);
						break;
					}
				}
				if (!Object.op_Implicit((Object)(object)menuContainer))
				{
					throw new InvalidOperationException("MenuContainer not found! Available GameObjects: " + string.Join(", ", from go in Object.FindObjectsOfType<GameObject>().Take(10)
						select ((Object)go).name));
				}
			}
			Transform val = menuContainer.transform.Find("MainButtons");
			if (!Object.op_Implicit((Object)(object)val))
			{
				string[] array2 = new string[menuContainer.transform.childCount];
				for (int j = 0; j < menuContainer.transform.childCount; j++)
				{
					array2[j] = ((Object)menuContainer.transform.GetChild(j)).name;
				}
				throw new InvalidOperationException("MainButtons not found! MenuContainer children: " + string.Join(", ", array2));
			}
			Transform quitButton = val.Find("QuitButton");
			if (!Object.op_Implicit((Object)(object)quitButton))
			{
				string[] array3 = new string[val.childCount];
				for (int k = 0; k < val.childCount; k++)
				{
					array3[k] = ((Object)val.GetChild(k)).name;
				}
				throw new InvalidOperationException("QuitButton not found! MainButtons children: " + string.Join(", ", array3));
			}
			GameObject configButtonObj = Object.Instantiate<GameObject>(((Component)quitButton).gameObject, val);
			((Object)configButtonObj).name = "ECDAConfigButton";
			TextMeshProUGUI componentInChildren = configButtonObj.GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = "> EverythingCanDieAlt";
			}
			Button component = configButtonObj.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					MenuManager component3 = menuContainer.GetComponent<MenuManager>();
					if ((Object)(object)component3 != (Object)null && (Object)(object)component3.MenuAudio != (Object)null)
					{
						component3.PlayConfirmSFX();
					}
					ConfigMenuManager.ToggleConfigMenu();
				});
			}
			List<GameObject> source = (from b in ((Component)val).GetComponentsInChildren<Button>()
				select ((Component)b).gameObject).ToList();
			List<float> list = (from t in source.Where((GameObject b) => (Object)(object)b != (Object)(object)configButtonObj).Select(delegate(GameObject b)
				{
					Transform transform = b.transform;
					return (RectTransform)(object)((transform is RectTransform) ? transform : null);
				})
				select t.anchoredPosition.y).ToList();
			float num = list.Zip(list.Skip(1), (float y1, float y2) => Mathf.Abs(y2 - y1)).Min();
			foreach (GameObject item in source.Where((GameObject g) => (Object)(object)g != (Object)(object)((Component)quitButton).gameObject))
			{
				RectTransform component2 = item.GetComponent<RectTransform>();
				component2.anchoredPosition += new Vector2(0f, num);
			}
			configButtonObj.GetComponent<RectTransform>().anchoredPosition = ((Component)quitButton).GetComponent<RectTransform>().anchoredPosition + new Vector2(0f, num);
			Plugin.Log.LogInfo((object)"ECDA config button added to main menu");
		}

		public static void Initialize(Harmony harmony)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(MenuManager), "Start", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(ConfigMenuPatch), "Start", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo3 = AccessTools.Method(typeof(MenuManager), "Awake", (Type[])null, (Type[])null);
				MethodInfo methodInfo4 = AccessTools.Method(typeof(ConfigMenuPatch), "Awake", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, new HarmonyMethod(methodInfo4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo methodInfo5 = AccessTools.Method(typeof(MenuManager), "OnEnable", (Type[])null, (Type[])null);
				MethodInfo methodInfo6 = AccessTools.Method(typeof(ConfigMenuPatch), "OnEnable", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, new HarmonyMethod(methodInfo6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Log.LogInfo((object)"Registered config menu patches with multiple fallback injection points");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error initializing ConfigMenuPatch: " + ex.Message));
			}
		}
	}
	public static class EnemyAliases
	{
		private static readonly Dictionary<string, string[]> StaticAliases = new Dictionary<string, string[]>
		{
			{
				"BABOONHAWK",
				new string[1] { "baboon hawk" }
			},
			{
				"BLOB",
				new string[1] { "hygrodere" }
			},
			{
				"BUTLER",
				new string[1] { "butler" }
			},
			{
				"BUTLERBEES",
				new string[1] { "mask hornets" }
			},
			{
				"MANEATER",
				new string[1] { "maneater" }
			},
			{
				"CENTIPEDE",
				new string[1] { "snare flea" }
			},
			{
				"CLAYSURGEON",
				new string[1] { "barber" }
			},
			{
				"CRAWLER",
				new string[1] { "thumper" }
			},
			{
				"DOCILELOCUSTBEES",
				new string[1] { "roaming locusts" }
			},
			{
				"MANTICOIL",
				new string[1] { "manticoil" }
			},
			{
				"TULIPSNAKE",
				new string[1] { "tulip snake" }
			},
			{
				"REDLOCUSTBEES",
				new string[1] { "circuit bees" }
			},
			{
				"FLOWERMAN",
				new string[1] { "bracken" }
			},
			{
				"FORESTGIANT",
				new string[1] { "forest giant" }
			},
			{
				"GIANTKIWI",
				new string[1] { "giant sapsucker" }
			},
			{
				"HOARDINGBUG",
				new string[1] { "hoarding bug" }
			},
			{
				"JESTER",
				new string[1] { "jester" }
			},
			{
				"LASSO",
				new string[1] { "lasso" }
			},
			{
				"MOUTHDOG",
				new string[1] { "eyeless dog" }
			},
			{
				"NUTCRACKER",
				new string[1] { "nutcracker" }
			},
			{
				"PUFFER",
				new string[1] { "spore lizard" }
			},
			{
				"RADMECH",
				new string[1] { "old bird" }
			},
			{
				"BUNKERSPIDER",
				new string[1] { "bunker spider" }
			},
			{
				"EARTHLEVIATHAN",
				new string[1] { "earth leviathan" }
			},
			{
				"SPRING",
				new string[1] { "coil-head" }
			},
			{
				"BUSHWOLF",
				new string[1] { "kidnapper fox" }
			}
		};

		private static Dictionary<string, string> _persistedScanNames = null;

		private static Dictionary<string, string> PersistedScanNames
		{
			get
			{
				if (_persistedScanNames == null)
				{
					LoadPersistedAliases();
				}
				return _persistedScanNames;
			}
		}

		private static void LoadPersistedAliases()
		{
			if (_persistedScanNames == null)
			{
				_persistedScanNames = new Dictionary<string, string>();
			}
			_persistedScanNames.Clear();
			string path = Path.Combine(Paths.ConfigPath, "nwnt.EverythingCanDieAlternative.cfg");
			if (!File.Exists(path))
			{
				return;
			}
			bool flag = false;
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.StartsWith("["))
				{
					flag = text == "[EnemyAliases]";
				}
				else
				{
					if (!flag || string.IsNullOrWhiteSpace(text) || text.StartsWith("#"))
					{
						continue;
					}
					int num = text.IndexOf('=');
					if (num <= 0)
					{
						continue;
					}
					string text2 = text.Substring(0, num).Trim();
					string text3 = text.Substring(num + 1).Trim();
					if (!string.IsNullOrWhiteSpace(text2) && !string.IsNullOrWhiteSpace(text3))
					{
						string text4 = Plugin.RemoveInvalidCharacters(text2).ToUpper();
						if (!string.IsNullOrEmpty(text4))
						{
							_persistedScanNames[text4] = text3.ToLower();
						}
					}
				}
			}
			Plugin.LogInfo($"[EnemyAliases] Loaded {_persistedScanNames.Count} persisted scan names");
		}

		public static void ScanAndPersistDisplayNames()
		{
			Plugin instance = Plugin.Instance;
			if (((instance != null) ? ((BaseUnityPlugin)instance).Config : null) == null || Plugin.enemies == null)
			{
				return;
			}
			LoadPersistedAliases();
			int num = 0;
			foreach (EnemyType enemy in Plugin.enemies)
			{
				if ((Object)(object)enemy?.enemyPrefab == (Object)null || string.IsNullOrWhiteSpace(enemy.enemyName))
				{
					continue;
				}
				string enemyName = enemy.enemyName;
				if (string.IsNullOrWhiteSpace(enemyName))
				{
					continue;
				}
				string text = Plugin.RemoveInvalidCharacters(enemyName).ToUpper();
				if (!string.IsNullOrEmpty(text) && !PersistedScanNames.ContainsKey(text))
				{
					ScanNodeProperties componentInChildren = enemy.enemyPrefab.GetComponentInChildren<ScanNodeProperties>();
					if (!((Object)(object)componentInChildren == (Object)null) && !string.IsNullOrWhiteSpace(componentInChildren.headerText))
					{
						string text2 = componentInChildren.headerText.Trim();
						((BaseUnityPlugin)Plugin.Instance).Config.Bind<string>("EnemyAliases", text, text2, "Display name discovered from prefab for " + enemyName + ". Used as a search alias.");
						PersistedScanNames[text] = text2.ToLower();
						num++;
					}
				}
			}
			if (num > 0)
			{
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
			}
		}

		public static bool MatchesAlias(string enemyName, string searchText)
		{
			string key = enemyName.ToUpper();
			if (StaticAliases.TryGetValue(key, out var value))
			{
				string[] array = value;
				for (int i = 0; i < array.Length; i++)
				{
					if (array[i].Contains(searchText))
					{
						return true;
					}
				}
			}
			if (PersistedScanNames.TryGetValue(key, out var value2) && value2.Contains(searchText))
			{
				return true;
			}
			return false;
		}

		public static string GetDisplayName(string enemyName)
		{
			string key = enemyName.ToUpper();
			if (PersistedScanNames.TryGetValue(key, out var value))
			{
				return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(value);
			}
			if (StaticAliases.TryGetValue(key, out var value2) && value2.Length != 0)
			{
				return CultureInfo.CurrentCulture.TextInfo.ToTitleCase(value2[0]);
			}
			return null;
		}
	}
	public class EnemyConfigData
	{
		public string Name;

		public string SanitizedName;

		public bool IsEnabled;

		public bool CanDie;

		public bool ShouldDespawn;

		public float Health;

		public EnemyConfigData(string name, bool isEnabled, bool canDie, bool shouldDespawn, float health)
		{
			Name = name;
			SanitizedName = Plugin.RemoveInvalidCharacters(name).ToUpper();
			IsEnabled = isEnabled;
			CanDie = canDie;
			ShouldDespawn = shouldDespawn;
			Health = health;
		}

		public Color GetStatusColor()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			if (!IsEnabled)
			{
				return Color.red;
			}
			if (!CanDie)
			{
				return Color.yellow;
			}
			return Color.green;
		}

		public string GetStatusText()
		{
			if (!IsEnabled)
			{
				return "ECDA will ignore this enemy, this will preserve their original behavior";
			}
			if (!CanDie)
			{
				return "Immortal to hits, ignores health config, immune to insta-kill effects depending on global setting";
			}
			return "Killable";
		}
	}
	public class EnemyHealthBarUI : MonoBehaviour
	{
		public EnemyAI Enemy;

		private Canvas _canvas;

		private GameObject _barRoot;

		private Image _bgImage;

		private Image _fillImage;

		private RectTransform _fillRT;

		private TextMeshProUGUI _text;

		private float _offsetY = 2.5f;

		private UIConfiguration.HealthBarDisplayMode _appliedMode = (UIConfiguration.HealthBarDisplayMode)(-1);

		private const float BAR_WIDTH = 180f;

		private const float BAR_HEIGHT = 22f;

		private const float BAR_PADDING = 2f;

		private const float FILL_MAX_WIDTH = 176f;

		private const float CANVAS_SCALE = 0.0035f;

		private const float RANGE_CLOSE_SQR = 49f;

		private const float RANGE_MEDIUM_SQR = 169f;

		private const float RANGE_FAR_SQR = 400f;

		private const float TOWARD_PLAYER_OFFSET = 0.8f;

		private static TMP_FontAsset _cachedFont;

		private static float GetMaxVisibleDistanceSqr()
		{
			return ((UIConfiguration.HealthBarRange != null) ? UIConfiguration.HealthBarRange.Value : UIConfiguration.HealthBarVisibilityDistance.Close) switch
			{
				UIConfiguration.HealthBarVisibilityDistance.Medium => 169f, 
				UIConfiguration.HealthBarVisibilityDistance.Far => 400f, 
				_ => 49f, 
			};
		}

		private static float GetSizeMultiplier()
		{
			return ((UIConfiguration.HealthBarSizeOption == null) ? UIConfiguration.HealthBarSize.Medium : UIConfiguration.HealthBarSizeOption.Value) switch
			{
				UIConfiguration.HealthBarSize.Small => 1.5f, 
				UIConfiguration.HealthBarSize.Large => 2.5f, 
				_ => 2f, 
			};
		}

		public static void Attach(EnemyAI enemy)
		{
			//IL_003f: 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)
			if (!((Object)(object)enemy == (Object)null) && !((Object)(object)((Component)enemy).GetComponentInChildren<EnemyHealthBarUI>(true) != (Object)null))
			{
				GameObject val = new GameObject("ECDA_HealthBar", new Type[2]
				{
					typeof(RectTransform),
					typeof(Canvas)
				});
				val.transform.SetParent(((Component)enemy).transform, false);
				EnemyHealthBarUI enemyHealthBarUI = val.AddComponent<EnemyHealthBarUI>();
				enemyHealthBarUI.Enemy = enemy;
				enemyHealthBarUI.Build();
			}
		}

		private void Build()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			NavMeshAgent componentInChildren = ((Component)Enemy).GetComponentInChildren<NavMeshAgent>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				_offsetY = componentInChildren.height + 0.5f;
			}
			_canvas = ((Component)this).GetComponent<Canvas>();
			_canvas.renderMode = (RenderMode)2;
			RectTransform val = (RectTransform)((Component)this).transform;
			val.sizeDelta = new Vector2(200f, 60f);
			((Transform)val).localScale = Vector3.one * 0.0035f;
			((Transform)val).localPosition = new Vector3(0f, _offsetY, 0f);
			_barRoot = new GameObject("Bar", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform val2 = (RectTransform)_barRoot.transform;
			((Transform)val2).SetParent((Transform)(object)val, false);
			val2.sizeDelta = new Vector2(180f, 22f);
			val2.anchoredPosition = new Vector2(0f, -12f);
			_bgImage = _barRoot.GetComponent<Image>();
			((Graphic)_bgImage).color = new Color(0f, 0f, 0f, 0.75f);
			GameObject val3 = new GameObject("Fill", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_fillRT = (RectTransform)val3.transform;
			((Transform)_fillRT).SetParent((Transform)(object)val2, false);
			_fillRT.anchorMin = new Vector2(0f, 0.5f);
			_fillRT.anchorMax = new Vector2(0f, 0.5f);
			_fillRT.pivot = new Vector2(0f, 0.5f);
			_fillRT.anchoredPosition = new Vector2(2f, 0f);
			_fillRT.sizeDelta = new Vector2(176f, 18f);
			_fillImage = val3.GetComponent<Image>();
			((Graphic)_fillImage).color = new Color(0.2f, 1f, 0.2f, 0.95f);
			GameObject val4 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			RectTransform val5 = (RectTransform)val4.transform;
			((Transform)val5).SetParent((Transform)(object)val, false);
			val5.sizeDelta = new Vector2(220f, 28f);
			val5.anchoredPosition = new Vector2(0f, 18f);
			_text = val4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
			((TMP_Text)_text).fontSize = 18f;
			((TMP_Text)_text).fontStyle = (FontStyles)1;
			((Graphic)_text).color = Color.white;
			((TMP_Text)_text).text = string.Empty;
			((TMP_Text)_text).enableWordWrapping = false;
			((TMP_Text)_text).outlineWidth = 0.2f;
			((TMP_Text)_text).outlineColor = Color32.op_Implicit(Color.black);
			TMP_FontAsset val6 = ResolveFont();
			if ((Object)(object)val6 != (Object)null)
			{
				((TMP_Text)_text).font = val6;
			}
		}

		private static TMP_FontAsset ResolveFont()
		{
			if ((Object)(object)_cachedFont != (Object)null)
			{
				return _cachedFont;
			}
			if ((Object)(object)TMP_Settings.defaultFontAsset != (Object)null)
			{
				_cachedFont = TMP_Settings.defaultFontAsset;
				return _cachedFont;
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			if (array != null && array.Length != 0)
			{
				_cachedFont = array[0];
				return _cachedFont;
			}
			return null;
		}

		private void LateUpdate()
		{
			//IL_0188: 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_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: 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_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: 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_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: 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_0297: 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_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: 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_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Enemy == (Object)null)
			{
				if ((Object)(object)_canvas != (Object)null && ((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			UIConfiguration.HealthBarDisplayMode healthBarDisplayMode = ((UIConfiguration.HealthBarMode != null) ? UIConfiguration.HealthBarMode.Value : UIConfiguration.HealthBarDisplayMode.Off);
			if (healthBarDisplayMode == UIConfiguration.HealthBarDisplayMode.Off || Enemy.isEnemyDead)
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			if (!HealthManager.IsEnemyTracked(Enemy))
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			float enemyMaxHealth = HealthManager.GetEnemyMaxHealth(Enemy);
			float enemyHealth = HealthManager.GetEnemyHealth(Enemy);
			if (enemyMaxHealth <= 0f)
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			if ((UIConfiguration.HideHealthBarForFullHpEnemies == null || UIConfiguration.HideHealthBarForFullHpEnemies.Value) && enemyHealth >= enemyMaxHealth)
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			Camera val = null;
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.localPlayerController != (Object)null)
			{
				val = (instance.localPlayerController.isPlayerDead ? instance.spectateCamera : instance.localPlayerController.gameplayCamera);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Camera.main;
			}
			if ((Object)(object)val == (Object)null)
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			Vector3 val2 = ((Component)val).transform.position - ((Component)this).transform.position;
			if (((Vector3)(ref val2)).sqrMagnitude > GetMaxVisibleDistanceSqr())
			{
				if (((Behaviour)_canvas).enabled)
				{
					((Behaviour)_canvas).enabled = false;
				}
				return;
			}
			if (!((Behaviour)_canvas).enabled)
			{
				((Behaviour)_canvas).enabled = true;
			}
			if (healthBarDisplayMode != _appliedMode)
			{
				_appliedMode = healthBarDisplayMode;
				_barRoot.SetActive(healthBarDisplayMode == UIConfiguration.HealthBarDisplayMode.BarOnly || healthBarDisplayMode == UIConfiguration.HealthBarDisplayMode.Both);
				((Component)_text).gameObject.SetActive(healthBarDisplayMode == UIConfiguration.HealthBarDisplayMode.NumberOnly || healthBarDisplayMode == UIConfiguration.HealthBarDisplayMode.Both);
			}
			Vector3 val3 = ((Component)Enemy).transform.position + Vector3.up * _offsetY;
			Vector3 val4 = ((Component)val).transform.position - ((Component)Enemy).transform.position;
			val4.y = 0f;
			if (((Vector3)(ref val4)).sqrMagnitude > 0.0001f)
			{
				val3 += ((Vector3)(ref val4)).normalized * 0.8f;
			}
			((Component)this).transform.position = val3;
			((Component)this).transform.localScale = Vector3.one * (0.0035f * GetSizeMultiplier());
			Vector3 val5 = ((Component)this).transform.position - ((Component)val).transform.position;
			if (((Vector3)(ref val5)).sqrMagnitude > 0.0001f)
			{
				((Component)this).transform.rotation = Quaternion.LookRotation(val5, ((Component)val).transform.up);
			}
			float num = Mathf.Clamp01(enemyHealth / enemyMaxHealth);
			if ((Object)(object)_fillRT != (Object)null)
			{
				Vector2 sizeDelta = _fillRT.sizeDelta;
				sizeDelta.x = 176f * num;
				_fillRT.sizeDelta = sizeDelta;
			}
			if ((Object)(object)_fillImage != (Object)null)
			{
				((Graphic)_fillImage).color = Color.Lerp(new Color(1f, 0.15f, 0.15f, 0.95f), new Color(0.2f, 1f, 0.2f, 0.95f), num);
			}
			if ((Object)(object)_text != (Object)null && ((Component)_text).gameObject.activeSelf)
			{
				((TMP_Text)_text).text = $"{Mathf.CeilToInt(enemyHealth)} / {Mathf.CeilToInt(enemyMaxHealth)}";
			}
		}
	}
	public static class EnemyImageLoader
	{
		private static Dictionary<string, Texture2D> textureCache = new Dictionary<string, Texture2D>();

		private static string uiImagesPath;

		private static bool isInitialized = false;

		public static void Initialize()
		{
			if (isInitialized)
			{
				return;
			}
			try
			{
				string directoryName = Path.GetDirectoryName(typeof(Plugin).Assembly.Location);
				uiImagesPath = Path.Combine(directoryName);
				if (!Directory.Exists(uiImagesPath))
				{
					Directory.CreateDirectory(uiImagesPath);
				}
				isInitialized = true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error initializing EnemyImageLoader: " + ex.Message));
			}
		}

		public static void ClearCache()
		{
			foreach (Texture2D value in textureCache.Values)
			{
				Object.Destroy((Object)(object)value);
			}
			textureCache.Clear();
			Plugin.LogInfo("Enemy image cache cleared");
		}

		public static Texture2D GetEnemyTexture(string enemyName)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if (!isInitialized)
			{
				Initialize();
			}
			if (textureCache.TryGetValue(enemyName, out var value))
			{
				return value;
			}
			try
			{
				string text = Plugin.RemoveInvalidCharacters(enemyName);
				string path = Path.Combine(uiImagesPath, text + ".png");
				if (!File.Exists(path))
				{
					path = Path.Combine(uiImagesPath, text + ".jpg");
					if (!File.Exists(path))
					{
						return null;
					}
				}
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, array))
				{
					textureCache[enemyName] = val;
					return val;
				}
				return null;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error loading enemy image for " + enemyName + ": " + ex.Message));
				return null;
			}
		}
	}
	public class NormalizedScrollRect : MonoBehaviour, IScrollHandler, IEventSystemHandler
	{
		private ScrollRect scrollRect;

		[SerializeField]
		private float maxScrollDelta = 0.1f;

		[SerializeField]
		private float scrollSpeed = 0.15f;

		private void Awake()
		{
			scrollRect = ((Component)this).GetComponent<ScrollRect>();
			if ((Object)(object)scrollRect != (Object)null)
			{
				scrollRect.scrollSensitivity = 0f;
			}
		}

		public void OnScroll(PointerEventData eventData)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)scrollRect == (Object)null) && !((Object)(object)scrollRect.content == (Object)null))
			{
				float num = Mathf.Clamp(eventData.scrollDelta.y, -1f, 1f) * scrollSpeed;
				num = Mathf.Clamp(num, 0f - maxScrollDelta, maxScrollDelta);
				float num2 = scrollRect.verticalNormalizedPosition + num;
				num2 = Mathf.Clamp01(num2);
				scrollRect.verticalNormalizedPosition = num2;
			}
		}

		public static void ApplyTo(GameObject scrollViewObj, float scrollSpeed = 0.15f, float maxDelta = 0.1f)
		{
			if (!((Object)(object)scrollViewObj == (Object)null))
			{
				NormalizedScrollRect normalizedScrollRect = scrollViewObj.GetComponent<NormalizedScrollRect>();
				if ((Object)(object)normalizedScrollRect == (Object)null)
				{
					normalizedScrollRect = scrollViewObj.AddComponent<NormalizedScrollRect>();
				}
				normalizedScrollRect.scrollSpeed = scrollSpeed;
				normalizedScrollRect.maxScrollDelta = maxDelta;
			}
		}
	}
	public static class UIHelper
	{
		public class StateHolder : MonoBehaviour
		{
			public bool IsYes;

			public Button YesButton;

			public Button NoButton;

			public Image YesImage;

			public Image NoImage;

			public TextMeshProUGUI YesText;

			public TextMeshProUGUI NoText;

			public void SetInteractable(bool interactable)
			{
				//IL_0030: 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_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				((Selectable)YesButton).interactable = interactable;
				((Selectable)NoButton).interactable = interactable;
				if (!interactable)
				{
					((Graphic)YesImage).color = new Color(0.4f, 0.4f, 0.4f);
					((Graphic)NoImage).color = new Color(0.4f, 0.4f, 0.4f);
					((Graphic)YesText).color = new Color(0.5f, 0.5f, 0.5f);
					((Graphic)NoText).color = new Color(0.5f, 0.5f, 0.5f);
				}
				else
				{
					((Graphic)YesImage).color = (IsYes ? UITheme.PositiveColor : UITheme.NeutralColor);
					((Graphic)NoImage).color = ((!IsYes) ? UITheme.NegativeColor : UITheme.NeutralColor);
					((Graphic)YesText).color = (Color)(IsYes ? Color.white : new Color(0.7f, 0.7f, 0.7f));
					((Graphic)NoText).color = (Color)((!IsYes) ? Color.white : new Color(0.7f, 0.7f, 0.7f));
				}
			}

			public void UpdateVisualState(bool isYes)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: 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)
				IsYes = isYes;
				if (((Selectable)YesButton).interactable)
				{
					((Graphic)YesImage).color = (isYes ? UITheme.PositiveColor : UITheme.NeutralColor);
					((Graphic)NoImage).color = ((!isYes) ? UITheme.NegativeColor : UITheme.NeutralColor);
					((Graphic)YesText).color = (Color)(isYes ? Color.white : new Color(0.7f, 0.7f, 0.7f));
					((Graphic)NoText).color = (Color)((!isYes) ? Color.white : new Color(0.7f, 0.7f, 0.7f));
				}
			}
		}

		public class NumericInputState : MonoBehaviour
		{
			public float CurrentValue;

			public float MinValue;

			public float MaxValue;

			public TMP_InputField InputField;

			public Button UpButton;

			public Button DownButton;

			public UnityAction<float> OnValueChanged;

			public void SetInteractable(bool interactable)
			{
				((Selectable)InputField).interactable = interactable;
				((Selectable)UpButton).interactable = interactable;
				((Selectable)DownButton).interactable = interactable;
			}

			public void SetValue(float value)
			{
				CurrentValue = Mathf.Clamp(value, MinValue, MaxValue);
				InputField.text = ((int)CurrentValue).ToString();
			}
		}

		public static GameObject CreatePanel(Transform parent, string name, Vector2 sizeDelta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.sizeDelta = sizeDelta;
			((Graphic)val.AddComponent<Image>()).color = UITheme.PanelColor;
			return val;
		}

		public static GameObject CreateText(Transform parent, string name, string text, TextAlignmentOptions alignment = 514)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0086: 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_0097: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			TextMeshProUGUI obj2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = text;
			((TMP_Text)obj2).fontSize = UITheme.NormalFontSize;
			((TMP_Text)obj2).alignment = alignment;
			((Graphic)obj2).color = UITheme.TextColor;
			return val;
		}

		public static GameObject CreateButton(Transform parent, string name, string text, UnityAction onClick)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0089: 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_0098: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.sizeDelta = new Vector2(160f, UITheme.ButtonHeight);
			((Graphic)val.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button val2 = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)val2).colors;
			((ColorBlock)(ref colors)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors)).pressedColor = UITheme.ButtonPressedColor;
			((ColorBlock)(ref colors)).disabledColor = UITheme.DisabledColor;
			((Selectable)val2).colors = colors;
			if (onClick != null)
			{
				((UnityEvent)val2.onClick).AddListener(onClick);
			}
			CreateText(val.transform, "Text", text, (TextAlignmentOptions)514);
			return val;
		}

		public static GameObject CreateInputField(Transform parent, string name, string placeholder, string value, UnityAction<string> onValueChanged, ContentType contentType = 0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.sizeDelta = new Vector2(0f, 30f);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f);
			TMP_InputField val2 = val.AddComponent<TMP_InputField>();
			val2.contentType = contentType;
			TextMeshProUGUI component = CreateText(val.transform, "Placeholder", placeholder, (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			((Graphic)component).color = new Color(0.5f, 0.5f, 0.5f);
			((Behaviour)component).enabled = string.IsNullOrEmpty(value);
			val2.placeholder = (Graphic)(object)component;
			TextMeshProUGUI component2 = CreateText(val.transform, "Text", value, (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			val2.textComponent = (TMP_Text)(object)component2;
			val2.text = value;
			if (onValueChanged != null)
			{
				((UnityEvent<string>)(object)val2.onValueChanged).AddListener(onValueChanged);
			}
			return val;
		}

		public static GameObject CreateScrollView(Transform parent, string name, Vector2 sizeDelta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0081: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.sizeDelta = sizeDelta;
			((Graphic)val.AddComponent<Image>()).color = UITheme.PanelColor;
			ScrollRect val2 = val.AddComponent<ScrollRect>();
			GameObject val3 = new GameObject("Viewport");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.pivot = new Vector2(0.5f, 0.5f);
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = UITheme.PanelColor;
			val3.AddComponent<Mask>().showMaskGraphic = false;
			GameObject val5 = new GameObject("Content");
			val5.transform.SetParent(val3.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			val6.sizeDelta = new Vector2(0f, 0f);
			val2.viewport = val4;
			val2.content = val6;
			val2.horizontal = false;
			val2.vertical = true;
			ContentSizeFitter obj2 = val5.AddComponent<ContentSizeFitter>();
			obj2.verticalFit = (FitMode)2;
			obj2.horizontalFit = (FitMode)0;
			VerticalLayoutGroup obj3 = val5.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 5f;
			((LayoutGroup)obj3).padding = new RectOffset(5, 5, 5, 5);
			((LayoutGroup)obj3).childAlignment = (TextAnchor)1;
			return val;
		}

		public static GameObject CreateYesNoSelector(Transform parent, string name, string label, bool isYes, UnityAction<bool> onValueChanged)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e2: 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_00f7: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.sizeDelta = new Vector2(0f, UITheme.InputHeight);
			HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
			CreateText(val.transform, "Label", label, (TextAlignmentOptions)513).GetComponent<RectTransform>().sizeDelta = new Vector2(230f, UITheme.InputHeight);
			GameObject val2 = new GameObject("ButtonContainer");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<RectTransform>().sizeDelta = new Vector2(120f, UITheme.InputHeight);
			HorizontalLayoutGroup obj3 = val2.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 5f;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = true;
			((LayoutGroup)obj3).childAlignment = (TextAnchor)4;
			GameObject val3 = new GameObject("YesButton");
			val3.transform.SetParent(val2.transform, false);
			val3.AddComponent<RectTransform>();
			Image yesImage = val3.AddComponent<Image>();
			((Graphic)yesImage).color = (isYes ? UITheme.PositiveColor : UITheme.NeutralColor);
			Button val4 = val3.AddComponent<Button>();
			GameObject val5 = CreateText(val3.transform, "Text", "YES", (TextAlignmentOptions)514);
			TextMeshProUGUI yesTextComp = val5.GetComponent<TextMeshProUGUI>();
			((TMP_Text)yesTextComp).fontSize = UITheme.SmallFontSize;
			((Graphic)yesTextComp).color = (Color)(isYes ? Color.white : new Color(0.7f, 0.7f, 0.7f));
			GameObject val6 = new GameObject("NoButton");
			val6.transform.SetParent(val2.transform, false);
			val6.AddComponent<RectTransform>();
			Image noImage = val6.AddComponent<Image>();
			((Graphic)noImage).color = ((!isYes) ? UITheme.NegativeColor : UITheme.NeutralColor);
			Button val7 = val6.AddComponent<Button>();
			GameObject val8 = CreateText(val6.transform, "Text", "NO", (TextAlignmentOptions)514);
			TextMeshProUGUI noTextComp = val8.GetComponent<TextMeshProUGUI>();
			((TMP_Text)noTextComp).fontSize = UITheme.SmallFontSize;
			((Graphic)noTextComp).color = (Color)((!isYes) ? Color.white : new Color(0.7f, 0.7f, 0.7f));
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				if (!isYes)
				{
					isYes = true;
					((Graphic)yesImage).color = UITheme.PositiveColor;
					((Graphic)yesTextComp).color = Color.white;
					((Graphic)noImage).color = UITheme.NeutralColor;
					((Graphic)noTextComp).color = new Color(0.7f, 0.7f, 0.7f);
					if (onValueChanged != null)
					{
						onValueChanged.Invoke(true);
					}
				}
			});
			((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				if (isYes)
				{
					isYes = false;
					((Graphic)yesImage).color = UITheme.NeutralColor;
					((Graphic)yesTextComp).color = new Color(0.7f, 0.7f, 0.7f);
					((Graphic)noImage).color = UITheme.NegativeColor;
					((Graphic)noTextComp).color = Color.white;
					if (onValueChanged != null)
					{
						onValueChanged.Invoke(false);
					}
				}
			});
			StateHolder stateHolder = val.AddComponent<StateHolder>();
			stateHolder.IsYes = isYes;
			stateHolder.YesButton = val4;
			stateHolder.NoButton = val7;
			stateHolder.YesImage = yesImage;
			stateHolder.NoImage = noImage;
			stateHolder.YesText = yesTextComp;
			stateHolder.NoText = noTextComp;
			return val;
		}

		public static GameObject CreateVerticalScrollbar(Transform parent, string name, ScrollRect scrollRect)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0041: 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_0077: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.05f, 0.05f, 0.05f, 0.6f);
			Scrollbar val2 = val.AddComponent<Scrollbar>();
			val2.direction = (Direction)2;
			GameObject val3 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.pivot = new Vector2(0.5f, 0.5f);
			val4.offsetMin = new Vector2(2f, 2f);
			val4.offsetMax = new Vector2(-2f, -2f);
			GameObject val5 = new GameObject("Handle", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(val3.transform, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.pivot = new Vector2(0.5f, 0.5f);
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Image val7 = val5.AddComponent<Image>();
			((Graphic)val7).color = new Color(0.55f, 0.55f, 0.55f, 0.95f);
			((Selectable)val2).targetGraphic = (Graphic)(object)val7;
			val2.handleRect = val6;
			ColorBlock colors = ((Selectable)val2).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.55f, 0.55f, 0.55f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.7f, 0.7f, 0.7f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.4f, 0.4f, 0.4f, 1f);
			((Selectable)val2).colors = colors;
			if ((Object)(object)scrollRect != (Object)null)
			{
				scrollRect.verticalScrollbar = val2;
				scrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			}
			return val;
		}

		public static GameObject CreateCycleSelector(Transform parent, string name, string label, string[] options, int initialIndex, UnityAction<int> onValueChanged)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e2: 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_00f7: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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_0142: 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_015a: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.sizeDelta = new Vector2(0f, UITheme.InputHeight);
			HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
			CreateText(val.transform, "Label", label, (TextAlignmentOptions)513).GetComponent<RectTransform>().sizeDelta = new Vector2(230f, UITheme.InputHeight);
			GameObject val2 = new GameObject("CycleButton");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<RectTransform>().sizeDelta = new Vector2(120f, UITheme.InputHeight);
			((Graphic)val2.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button obj3 = val2.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj3).colors;
			((ColorBlock)(ref colors)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors)).pressedColor = UITheme.ButtonPressedColor;
			((ColorBlock)(ref colors)).disabledColor = UITheme.DisabledColor;
			((Selectable)obj3).colors = colors;
			int num = ((options == null || options.Length == 0) ? 1 : options.Length);
			int currentIndex = Mathf.Clamp(initialIndex, 0, num - 1);
			GameObject val3 = CreateText(text: (options != null && options.Length != 0) ? options[currentIndex] : string.Empty, parent: val2.transform, name: "Text", alignment: (TextAlignmentOptions)514);
			TextMeshProUGUI buttonText = val3.GetComponent<TextMeshProUGUI>();
			((TMP_Text)buttonText).fontSize = UITheme.SmallFontSize;
			((Graphic)buttonText).color = Color.white;
			((UnityEvent)obj3.onClick).AddListener((UnityAction)delegate
			{
				if (options != null && options.Length != 0)
				{
					currentIndex = (currentIndex + 1) % options.Length;
					((TMP_Text)buttonText).text = options[currentIndex];
					onValueChanged?.Invoke(currentIndex);
				}
			});
			return val;
		}

		public static GameObject CreateNumericInputWithArrows(Transform parent, string name, string label, float initialValue, float minValue, float maxValue, UnityAction<float> onValueChanged)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Expected O, but got Unknown
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.sizeDelta = new Vector2(0f, UITheme.InputHeight);
			HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
			CreateText(val.transform, "Label", label, (TextAlignmentOptions)513).GetComponent<RectTransform>().sizeDelta = new Vector2(80f, 30f);
			GameObject val2 = new GameObject("InputField");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<RectTransform>().sizeDelta = new Vector2(60f, 30f);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.12f, 0.12f, 0.12f, 1f);
			TMP_InputField inputField = val2.AddComponent<TMP_InputField>();
			inputField.contentType = (ContentType)2;
			TextMeshProUGUI component = CreateText(val2.transform, "Text", ((int)initialValue).ToString(), (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).alignment = (TextAlignmentOptions)514;
			inputField.textComponent = (TMP_Text)(object)component;
			inputField.text = ((int)initialValue).ToString();
			TextMeshProUGUI component2 = CreateText(val2.transform, "Placeholder", "Enter value", (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			((Graphic)component2).color = new Color(0.5f, 0.5f, 0.5f);
			((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
			((Behaviour)component2).enabled = string.IsNullOrEmpty(((int)initialValue).ToString());
			inputField.placeholder = (Graphic)(object)component2;
			float currentValue = initialValue;
			GameObject val3 = new GameObject("ArrowsContainer");
			val3.transform.SetParent(val.transform, false);
			val3.AddComponent<RectTransform>().sizeDelta = new Vector2(30f, 30f);
			VerticalLayoutGroup obj3 = val3.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 2f;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = true;
			((LayoutGroup)obj3).childAlignment = (TextAnchor)4;
			((LayoutGroup)obj3).padding = new RectOffset(0, 0, 0, 0);
			GameObject val4 = new GameObject("UpButton");
			val4.transform.SetParent(val3.transform, false);
			val4.AddComponent<RectTransform>();
			((Graphic)val4.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button val5 = val4.AddComponent<Button>();
			ColorBlock colors = ((Selectable)val5).colors;
			((ColorBlock)(ref colors)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors)).pressedColor = UITheme.ButtonPressedColor;
			((Selectable)val5).colors = colors;
			((TMP_Text)CreateText(val4.transform, "Text", "▲", (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>()).fontSize = 12f;
			GameObject val6 = new GameObject("DownButton");
			val6.transform.SetParent(val3.transform, false);
			val6.AddComponent<RectTransform>();
			((Graphic)val6.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button val7 = val6.AddComponent<Button>();
			ColorBlock colors2 = ((Selectable)val7).colors;
			((ColorBlock)(ref colors2)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors2)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors2)).pressedColor = UITheme.ButtonPressedColor;
			((Selectable)val7).colors = colors2;
			((TMP_Text)CreateText(val6.transform, "Text", "▼", (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>()).fontSize = 12f;
			((UnityEvent)val5.onClick).AddListener((UnityAction)delegate
			{
				currentValue = Mathf.Min(currentValue + 1f, maxValue);
				inputField.text = ((int)currentValue).ToString();
				if (onValueChanged != null)
				{
					onValueChanged.Invoke(currentValue);
				}
			});
			((UnityEvent)val7.onClick).AddListener((UnityAction)delegate
			{
				currentValue = Mathf.Max(currentValue - 1f, minValue);
				inputField.text = ((int)currentValue).ToString();
				if (onValueChanged != null)
				{
					onValueChanged.Invoke(currentValue);
				}
			});
			((UnityEvent<string>)(object)inputField.onEndEdit).AddListener((UnityAction<string>)delegate(string newValue)
			{
				if (int.TryParse(newValue, out var result))
				{
					currentValue = Mathf.Clamp((float)result, minValue, maxValue);
				}
				else
				{
					if (!float.TryParse(newValue, out var result2))
					{
						inputField.text = ((int)currentValue).ToString();
						return;
					}
					currentValue = Mathf.Clamp(result2, minValue, maxValue);
				}
				inputField.text = ((int)currentValue).ToString();
				if (onValueChanged != null)
				{
					onValueChanged.Invoke(currentValue);
				}
			});
			NumericInputState numericInputState = val.AddComponent<NumericInputState>();
			numericInputState.CurrentValue = currentValue;
			numericInputState.InputField = inputField;
			numericInputState.UpButton = val5;
			numericInputState.DownButton = val7;
			numericInputState.MinValue = minValue;
			numericInputState.MaxValue = maxValue;
			numericInputState.OnValueChanged = onValueChanged;
			return val;
		}

		public static GameObject CreateBulkActionSelector(Transform parent, string name, string label, string option1Text, string option2Text, UnityAction<bool> onOption1Selected, UnityAction<bool> onOption2Selected)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_003b: 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_0065: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00e3: 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_00f8: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: 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)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: 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_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: 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_0258: 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_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Expected O, but got Unknown
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 0.5f);
			obj.anchorMax = new Vector2(1f, 0.5f);
			obj.pivot = new Vector2(0f, 0.5f);
			obj.sizeDelta = new Vector2(0f, UITheme.InputHeight);
			HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 10f;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
			CreateText(val.transform, "Label", label, (TextAlignmentOptions)513).GetComponent<RectTransform>().sizeDelta = new Vector2(200f, UITheme.InputHeight);
			GameObject val2 = new GameObject("ButtonContainer");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<RectTransform>().sizeDelta = new Vector2(200f, UITheme.InputHeight);
			HorizontalLayoutGroup obj3 = val2.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj3).spacing = 5f;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj3).childForceExpandHeight = true;
			((LayoutGroup)obj3).childAlignment = (TextAnchor)4;
			GameObject val3 = new GameObject("Option1Button");
			val3.transform.SetParent(val2.transform, false);
			val3.AddComponent<RectTransform>();
			((Graphic)val3.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button val4 = val3.AddComponent<Button>();
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors)).pressedColor = UITheme.ButtonPressedColor;
			((Selectable)val4).colors = colors;
			TextMeshProUGUI component = CreateText(val3.transform, "Text", option1Text, (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).fontSize = UITheme.SmallFontSize;
			((Graphic)component).color = new Color(1f, 0.9f, 0.5f, 1f);
			GameObject val5 = new GameObject("Option2Button");
			val5.transform.SetParent(val2.transform, false);
			val5.AddComponent<RectTransform>();
			((Graphic)val5.AddComponent<Image>()).color = UITheme.ButtonColor;
			Button val6 = val5.AddComponent<Button>();
			ColorBlock colors2 = ((Selectable)val6).colors;
			((ColorBlock)(ref colors2)).normalColor = UITheme.ButtonColor;
			((ColorBlock)(ref colors2)).highlightedColor = UITheme.ButtonHighlightColor;
			((ColorBlock)(ref colors2)).pressedColor = UITheme.ButtonPressedColor;
			((Selectable)val6).colors = colors2;
			TextMeshProUGUI component2 = CreateText(val5.transform, "Text", option2Text, (TextAlignmentOptions)514).GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).fontSize = UITheme.SmallFontSize;
			((Graphic)component2).color = new Color(1f, 0.9f, 0.5f, 1f);
			((UnityEvent)val4.onClick).AddListener((UnityAction)delegate
			{
				if (onOption1Selected != null)
				{
					onOption1Selected.Invoke(true);
				}
			});
			((UnityEvent)val6.onClick).AddListener((UnityAction)delegate
			{
				if (onOption2Selected != null)
				{
					onOption2Selected.Invoke(true);
				}
			});
			return val;
		}

		public static void CreateConfirmationDialog(Transform parent, string message, UnityAction onYes, UnityAction onNo)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			GameObject overlayObj = new GameObject("ConfirmationOverlay");
			overlayObj.transform.SetParent(parent, false);
			RectTransform obj = overlayObj.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			((Graphic)overlayObj.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.8f);
			GameObject val = CreatePanel(overlayObj.transform, "DialogPanel", new Vector2(400f, 200f));
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			GameObject obj2 = CreateText(val.transform, "Message", message, (TextAlignmentOptions)514);
			RectTransform component2 = obj2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.1f, 0.4f);
			component2.anchorMax = new Vector2(0.9f, 0.8f);
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			TextMeshProUGUI component3 = obj2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component3).fontSize = 16f;
			((TMP_Text)component3).alignment = (TextAlignmentOptions)514;
			GameObject val2 = new GameObject("ButtonsContainer");
			val2.transform.SetParent(val.transform, false);
			RectTransform obj3 = val2.AddComponent<RectTransform>();
			obj3.anchorMin = new Vector2(0.1f, 0.1f);
			obj3.anchorMax = new Vector2(0.9f, 0.4f);
			obj3.offsetMin = Vector2.zero;
			obj3.offsetMax = Vector2.zero;
			HorizontalLayoutGroup obj4 = val2.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj4).spacing = 20f;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = true;
			((LayoutGroup)obj4).childAlignment = (TextAnchor)4;
			CreateButton(val2.transform, "YesButton", "Yes", (UnityAction)delegate
			{
				Object.Destroy((Object)(object)overlayObj);
				if (onYes != null)
				{
					onYes.Invoke();
				}
			});
			CreateButton(val2.transform, "NoButton", "No", (UnityAction)delegate
			{
				Object.Destroy((Object)(object)overlayObj);
				if (onNo != null)
				{
					onNo.Invoke();
				}
			});
		}
	}
	public static class UITheme
	{
		public static readonly Color BackgroundColor = new Color(0.1f, 0.1f, 0.1f, 0.95f);

		public static readonly Color PanelColor = new Color(0.15f, 0.15f, 0.15f, 0.95f);

		public static readonly Color ButtonColor = new Color(0.2f, 0.2f, 0.2f, 1f);

		public static readonly Color ButtonHighlightColor = new Color(0.3f, 0.3f, 0.3f, 1f);

		public static readonly Color ButtonPressedColor = new Color(0.1f, 0.1f, 0.1f, 1f);

		public static readonly Color TextColor = new Color(0.9f, 0.9f, 0.9f, 1f);

		public static readonly Color HeaderColor = new Color(1f, 0.9f, 0.5f, 1f);

		public static readonly Color PositiveColor = new Color(0.2f, 0.8f, 0.2f, 1f);

		public static readonly Color NegativeColor = new Color(0.8f, 0.2f, 0.2f, 1f);

		public static readonly Color NeutralColor = new Color(0.3f, 0.3f, 0.3f, 1f);

		public static readonly Color DisabledColor = new Color(0.4f, 0.4f, 0.4f, 0.6f);

		public static readonly float HeaderFontSize = 22f;

		public static readonly float NormalFontSize = 16f;

		public static readonly float SmallFontSize = 14f;

		public static readonly float PanelPadding = 20f;

		public static readonly float ElementSpacing = 15f;

		public static readonly float ButtonHeight = 40f;

		public static readonly float InputHeight = 30f;

		public static void ApplyButtonTheme(Button button)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock colors = ((Selectable)button).colors;
			((ColorBlock)(ref colors)).normalColor = ButtonColor;
			((ColorBlock)(ref colors)).highlightedColor = ButtonHighlightColor;
			((ColorBlock)(ref colors)).pressedColor = ButtonPressedColor;
			((ColorBlock)(ref colors)).disabledColor = DisabledColor;
			((Selectable)button).colors = colors;
			TextMeshProUGUI componentInChildren = ((Component)button).GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Graphic)componentInChildren).color = TextColor;
				((TMP_Text)componentInChildren).fontSize = NormalFontSize;
			}
		}

		public static void ApplyPanelTheme(Image panelImage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)panelImage).color = PanelColor;
		}

		public static TextMeshProUGUI CreateStyledHeader(GameObject textObject)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI component = textObject.GetComponent<TextMeshProUGUI>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = HeaderColor;
				((TMP_Text)component).fontSize = HeaderFontSize;
				((TMP_Text)component).fontStyle = (FontStyles)1;
			}
			return component;
		}

		public static TextMeshProUGUI CreateStyledText(GameObject textObject)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI component = textObject.GetComponent<TextMeshProUGUI>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = TextColor;
				((TMP_Text)component).fontSize = NormalFontSize;
			}
			return component;
		}

		public static void ApplyScrollViewTheme(ScrollRect scrollRect)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Component)scrollRect).GetComponent<Image>() != (Object)null)
			{
				((Graphic)((Component)scrollRect).GetComponent<Image>()).color = PanelColor;
			}
			if ((Object)(object)((Component)scrollRect.viewport).GetComponent<Image>() != (Object)null)
			{
				((Graphic)((Component)scrollRect.viewport).GetComponent<Image>()).color = PanelColor;
			}
		}

		public static void ApplyInputFieldTheme(TMP_InputField inputField)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Component)inputField).GetComponent<Image>() != (Object)null)
			{
				((Graphic)((Component)inputField).GetComponent<Image>()).color = new Color(0.12f, 0.12f, 0.12f, 1f);
			}
			if ((Object)(object)inputField.textComponent != (Object)null)
			{
				((Graphic)inputField.textComponent).color = TextColor;
				inputField.textComponent.fontSize = NormalFontSize;
			}
			if ((Object)(object)inputField.placeholder != (Object)null)
			{
				inputField.placeholder.color = new Color(0.5f, 0.5f, 0.5f, 1f);
			}
		}
	}
}
namespace EverythingCanDieAlternative.ModCompatibility
{
	public interface IModCompatibility
	{
		string ModId { get; }

		string ModName { get; }

		bool IsInstalled { get; }

		void Initialize();
	}
	public abstract class BaseModCompatibility : IModCompatibility
	{
		public abstract string ModId { get; }

		public abstract string ModName { get; }

		public virtual bool IsInstalled
		{
			get
			{
				try
				{
					return AppDomain.CurrentDomain.GetAssemblies().Any((Assembly a) => a.GetName().Name == ModId || a.GetTypes().Any((Type t) => t.Namespace?.Contains(ModId) ?? false));
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting mod " + ModName + ": " + ex.Message));
					return false;
				}
			}
		}

		public virtual void Initialize()
		{
			if (IsInstalled)
			{
				OnModInitialize();
			}
		}

		protected abstract void OnModInitialize();
	}
	public class ModCompatibilityManager
	{
		private static ModCompatibilityManager _instance;

		private readonly Dictionary<string, IModCompatibility> _handlers = new Dictionary<string, IModCompatibility>();

		public static ModCompatibilityManager Instance => _instance ?? (_instance = new ModCompatibilityManager());

		public HitmarkerCompatibility Hitmarker { get; private set; }

		public LethalHandsCompatibility LethalHands { get; private set; }

		public SellBodiesCompatibility SellBodies { get; private set; }

		public BrutalCompanyMinusCompatibility BrutalCompanyMinus { get; private set; }

		public LastResortKillerCompatibility LastResortKiller { get; private set; }

		public NaturalSelectionCompatibility NaturalSelection { get; private set; }

		private ModCompatibilityManager()
		{
		}

		public void Initialize()
		{
			try
			{
				RegisterKnownHandlers();
				Hitmarker = GetHandler<HitmarkerCompatibility>("com.github.zehsteam.Hitmarker");
				LethalHands = GetHandler<LethalHandsCompatibility>("SlapitNow.LethalHands");
				SellBodies = GetHandler<SellBodiesCompatibility>("Entity378.sellbodies");
				BrutalCompanyMinus = GetHandler<BrutalCompanyMinusCompatibility>("SoftDiamond.BrutalCompanyMinusExtraReborn");
				LastResortKiller = GetHandler<LastResortKillerCompatibility>("nwnt.EverythingCanDieAlternative.LastResortKiller");
				NaturalSelection = GetHandler<NaturalSelectionCompatibility>("fandovec03.NaturalSelection");
				foreach (IModCompatibility value in _handlers.Values)
				{
					try
					{
						value.Initialize();
						if (value.IsInstalled)
						{
							Plugin.Log.LogInfo((object)("[Compat] " + value.ModName + " detected and active"));
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error initializing compatibility for " + value.ModName + ": " + ex.Message));
						Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)("Fatal error in compatibility framework initialization: " + ex2.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex2.StackTrace));
			}
		}

		private void RegisterKnownHandlers()
		{
			try
			{
				SafeRegisterHandler(() => new SellBodiesCompatibility(), "SellBodies");
				SafeRegisterHandler(() => new LethalHandsCompatibility(), "LethalHands");
				SafeRegisterHandler(() => new BrutalCompanyMinusCompatibility(), "BrutalCompanyMinus");
				SafeRegisterHandler(() => new EnemyVsEnemyCompatibility(), "EnemyVsEnemy");
				SafeRegisterHandler(() => new LastResortKillerCompatibility(), "LastResortKiller");
				SafeRegisterHandler(() => new HitmarkerCompatibility(), "Hitmarker");
				SafeRegisterHandler(() => new LethalMinCompatibility(), "NoteBoxz.LethalMin");
				SafeRegisterHandler(() => new HexiBetterShotgunCompatibility(), "HexiBetterShotgunFixed");
				SafeRegisterHandler(() => new NaturalSelectionCompatibility(), "fandovec03.NaturalSelection");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error registering known handlers: " + ex.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}

		private void SafeRegisterHandler(Func<IModCompatibility> handlerFactory, string handlerName)
		{
			try
			{
				IModCompatibility handler = handlerFactory();
				RegisterHandler(handler);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error creating compatibility handler for " + handlerName + ": " + ex.Message));
			}
		}

		public void RegisterHandler(IModCompatibility handler)
		{
			try
			{
				if (!_handlers.ContainsKey(handler.ModId))
				{
					_handlers.Add(handler.ModId, handler);
				}
				else
				{
					Plugin.Log.LogWarning((object)("Compatibility handler for " + handler.ModName + " already registered"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error registering handler for " + handler.ModName + ": " + ex.Message));
			}
		}

		public bool IsModInstalled(string modId)
		{
			try
			{
				IModCompatibility value;
				return _handlers.TryGetValue(modId, out value) && value.IsInstalled;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error checking if mod " + modId + " is installed: " + ex.Message));
				return false;
			}
		}

		public T GetHandler<T>(string modId) where T : class, IModCompatibility
		{
			try
			{
				if (_handlers.TryGetValue(modId, out var value) && value is T result)
				{
					return result;
				}
				return null;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error getting handler for " + modId + ": " + ex.Message));
				return null;
			}
		}

		public IEnumerable<IModCompatibility> GetAllHandlers()
		{
			return _handlers.Values;
		}
	}
}
namespace EverythingCanDieAlternative.ModCompatibility.Handlers
{
	public class BrutalCompanyMinusCompatibility : BaseModCompatibility
	{
		private static readonly Dictionary<string, Type> typeCache = new Dictionary<string, Type>();

		private static readonly Dictionary<string, FieldInfo> fieldCache = new Dictionary<string, FieldInfo>();

		private static readonly Dictionary<string, Assembly> assemblyCache = new Dictionary<string, Assembly>();

		private bool? _isInstalled;

		private int? _cachedBonusHp;

		private FieldInfo _bonusEnemyHpField;

		private bool _fieldsInitialized;

		public override string ModId => "SoftDiamond.BrutalCompanyMinusExtraReborn";

		public override string ModName => "BrutalCompanyMinusExtraReborn";

		public override bool IsInstalled
		{
			get
			{
				if (_isInstalled.HasValue)
				{
					return _isInstalled.Value;
				}
				try
				{
					if (!assemblyCache.TryGetValue("BrutalCompanyMinus", out var value))
					{
						Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
						foreach (Assembly assembly in assemblies)
						{
							try
							{
								string name = assembly.GetName().Name;
								if (name == "BrutalCompanyMinus" || name.Contains("BrutalCompanyMinusExtraReborn"))
								{
									value = assembly;
									assemblyCache["BrutalCompanyMinus"] = assembly;
									break;
								}
							}
							catch
							{
							}
						}
					}
					if (value != null)
					{
						_isInstalled = true;
						return true;
					}
					bool flag = Chainloader.PluginInfos.ContainsKey(ModId);
					_isInstalled = flag;
					return flag;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting BrutalCompanyMinus mod: " + ex.Message));
					_isInstalled = false;
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
			InitializeReflectionFields();
		}

		private void InitializeReflectionFields()
		{
			if (_fieldsInitialized || !IsInstalled)
			{
				return;
			}
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					try
					{
						if (!(assembly.GetName().Name == "BrutalCompanyMinus") && !assembly.GetName().Name.Contains("BrutalCompanyMinusExtraReborn"))
						{
							continue;
						}
						Type type = assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "Manager" && t.Namespace == "BrutalCompanyMinus.Minus");
						if (type != null)
						{
							_bonusEnemyHpField = type.GetField("bonusEnemyHp", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
							if (_bonusEnemyHpField != null)
							{
								Plugin.LogInfo("Successfully located BrutalCompanyMinus.Minus.Manager.bonusEnemyHp field");
								_fieldsInitialized = true;
								return;
							}
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Error inspecting assembly " + assembly.GetName().Name + ": " + ex.Message));
					}
				}
				Plugin.Log.LogWarning((object)"Could not find all required BrutalCompanyMinus fields");
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)("Error initializing reflection fields for BrutalCompanyMinus: " + ex2.Message));
			}
		}

		public int GetBonusHp()
		{
			if (_cachedBonusHp.HasValue)
			{
				return _cachedBonusHp.Value;
			}
			try
			{
				if (!IsInstalled)
				{
					return 0;
				}
				if (!_fieldsInitialized)
				{
					InitializeReflectionFields();
				}
				if (_bonusEnemyHpField != null)
				{
					object value = _bonusEnemyHpField.GetValue(null);
					if (value != null)
					{
						_cachedBonusHp = Convert.ToInt32(value);
						Plugin.LogInfo($"Retrieved BrutalCompanyMinus bonus HP: {_cachedBonusHp}");
						return _cachedBonusHp.Value;
					}
				}
				_cachedBonusHp = CheckForStrongEnemiesEvent();
				return _cachedBonusHp.Value;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error getting BrutalCompanyMinus bonus HP: " + ex.Message));
				_cachedBonusHp = 0;
				return 0;
			}
		}

		private int CheckForStrongEnemiesEvent()
		{
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					try
					{
						if (!(assembly.GetName().Name == "BrutalCompanyMinus") && !assembly.GetName().Name.Contains("BrutalCompanyMinusExtraReborn"))
						{
							continue;
						}
						Type type = assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "StrongEnemies" && t.Namespace == "BrutalCompanyMinus.Minus.Events");
						if (!(type != null))
						{
							continue;
						}
						FieldInfo field = type.GetField("Instance", BindingFlags.Static | BindingFlags.Public);
						if (!(field != null))
						{
							continue;
						}
						object value = field.GetValue(null);
						if (value != null)
						{
							PropertyInfo property = type.GetProperty("Active", BindingFlags.Instance | BindingFlags.Public);
							if (property != null && Convert.ToBoolean(property.GetValue(value)))
							{
								Plugin.LogInfo("BrutalCompanyMinus StrongEnemies event is active");
								return 3;
							}
						}
					}
					catch (Exception)
					{
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)("Error checking for StrongEnemies event: " + ex2.Message));
			}
			return 0;
		}

		public void InvalidateCache()
		{
			_cachedBonusHp = null;
		}

		public void RefreshBonusHp()
		{
			InvalidateCache();
			int bonusHp = GetBonusHp();
			Plugin.LogInfo($"Refreshed BrutalCompanyMinus bonus HP: {bonusHp}");
		}

		public float ApplyBonusHp(float baseHealth)
		{
			int bonusHp = GetBonusHp();
			if (bonusHp > 0)
			{
				Plugin.LogInfo($"Applying BrutalCompanyMinus bonus HP: +{bonusHp} to base health {baseHealth}");
				return baseHealth + (float)bonusHp;
			}
			return baseHealth;
		}
	}
	public class EnemyVsEnemyCompatibility : BaseModCompatibility
	{
		private static MethodInfo originalHitEnemyMethod;

		public override string ModId => "nwnt.EnemyVsEnemyCompat";

		public override string ModName => "Enemy Vs Enemy Combat";

		public override bool IsInstalled => true;

		protected override void OnModInitialize()
		{
			try
			{
				PatchHitEnemyMethod();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to initialize " + ModName + " compatibility: " + ex.Message));
				Plugin.Log.LogError((object)ex.StackTrace);
			}
		}

		private void PatchHitEnemyMethod()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			originalHitEnemyMethod = AccessTools.Method(typeof(EnemyAI), "HitEnemy", new Type[4]
			{
				typeof(int),
				typeof(PlayerControllerB),
				typeof(bool),
				typeof(int)
			}, (Type[])null);
			if (originalHitEnemyMethod == null)
			{
				Plugin.Log.LogError((object)"Could not find EnemyAI.HitEnemy method for patching");
				return;
			}
			try
			{
				Plugin.Harmony.Patch((MethodBase)originalHitEnemyMethod, new HarmonyMethod(typeof(EnemyVsEnemyCompatibility), "HitEnemyPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to patch EnemyAI.HitEnemy: " + ex.Message));
			}
		}

		public static bool HitEnemyPrefix(EnemyAI __instance, int force, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
		{
			try
			{
				HexiBetterShotgunCompatibility handler = ModCompatibilityManager.Instance.GetHandler<HexiBetterShotgunCompatibility>("HexiBetterShotgun");
				if (handler != null && handler.IsInstalled && HexiBetterShotgunCompatibility.IsHexiBetterShotgunDamage(__instance, force, playerWhoHit))
				{
					Plugin.Log.LogInfo((object)$"HexiBetterShotgun damage detected: {force} to {__instance.enemyType.enemyName}");
					HealthManager.DirectHealthChange(__instance, force, playerWhoHit);
					return true;
				}
				if ((Object)(object)playerWhoHit == (Object)null)
				{
					Plugin.Log.LogInfo((object)$"Enemy vs enemy hit detected on {__instance.enemyType.enemyName} with force {force}");
					HealthManager.ProcessHit(__instance, force, null);
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in HitEnemyPrefix: " + ex.Message));
				return true;
			}
		}
	}
	public class HexiBetterShotgunCompatibility : BaseModCompatibility
	{
		public override string ModId => "HexiBetterShotgun";

		public override string ModName => "HexiBetterShotgun";

		public override bool IsInstalled
		{
			get
			{
				try
				{
					return Chainloader.PluginInfos.ContainsKey("HexiBetterShotgun");
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting " + ModName + ": " + ex.Message));
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
		}

		public static bool IsHexiBetterShotgunDamage(EnemyAI enemy, int damage, PlayerControllerB playerWhoHit)
		{
			if ((Object)(object)playerWhoHit == (Object)null)
			{
				return false;
			}
			if (playerWhoHit.currentlyHeldObjectServer is ShotgunItem && damage >= 1 && damage <= 10)
			{
				Plugin.Log.LogInfo((object)$"Detected HexiBetterShotgun damage: {damage} to {enemy.enemyType.enemyName}");
				return true;
			}
			return false;
		}
	}
	public class HitmarkerCompatibility : BaseModCompatibility
	{
		private Dictionary<int, PlayerControllerB> _lastDamageSources;

		private Type _hitmarkerCanvasBehaviourType;

		private FieldInfo _instanceField;

		private MethodInfo _showHitmarkerMethod;

		private MethodInfo _showKillMessageMethod;

		private Assembly _hitmarkerAssembly;

		private bool _initialized;

		private bool? _isInstalled;

		public override string ModId => "com.github.zehsteam.Hitmarker";

		public override string ModName => "Hitmarker";

		public override bool IsInstalled
		{
			get
			{
				if (_isInstalled.HasValue)
				{
					return _isInstalled.Value;
				}
				try
				{
					Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "com.github.zehsteam.Hitmarker");
					if (assembly == null)
					{
						_isInstalled = false;
						return false;
					}
					if (assembly.GetTypes().Any((Type t) => t.GetCustomAttributes(typeof(BepInPlugin), inherit: false).Cast<BepInPlugin>().Any((BepInPlugin attr) => attr.GUID == "com.github.zehsteam.Hitmarker")))
					{
						_hitmarkerAssembly = assembly;
						_isInstalled = true;
						return true;
					}
					_isInstalled = false;
					return false;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error during Hitmarker mod detection: " + ex.Message));
					_isInstalled = false;
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
			try
			{
				if (!IsInstalled)
				{
					return;
				}
				_lastDamageSources = new Dictionary<int, PlayerControllerB>();
				if (_hitmarkerAssembly != null)
				{
					try
					{
						Type[] types = _hitmarkerAssembly.GetTypes();
						foreach (Type type in types)
						{
							if (type.Name == "HitmarkerCanvasBehaviour")
							{
								_hitmarkerCanvasBehaviourType = type;
								break;
							}
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Error inspecting Hitmarker assembly: " + ex.Message));
					}
				}
				if (_hitmarkerCanvasBehaviourType != null)
				{
					_instanceField = _hitmarkerCanvasBehaviourType.GetField("Instance", BindingFlags.Static | BindingFlags.Public);
					if (!(_instanceField != null))
					{
						Plugin.Log.LogWarning((object)"Could not find Instance field, looking for fields:");
						FieldInfo[] fields = _hitmarkerCanvasBehaviourType.GetFields(BindingFlags.Static | BindingFlags.Public);
						foreach (FieldInfo fieldInfo in fields)
						{
							Plugin.Log.LogWarning((object)("  - " + fieldInfo.Name));
						}
					}
					_showHitmarkerMethod = _hitmarkerCanvasBehaviourType.GetMethod("ShowHitmarker", BindingFlags.Instance | BindingFlags.Public);
					if (!(_showHitmarkerMethod != null))
					{
						Plugin.Log.LogWarning((object)"Could not find ShowHitmarker method");
					}
					_showKillMessageMethod = _hitmarkerCanvasBehaviourType.GetMethod("ShowKillMessage", BindingFlags.Instance | BindingFlags.Public);
					if (!(_showKillMessageMethod != null))
					{
						Plugin.Log.LogWarning((object)"Could not find ShowKillMessage method");
					}
					if (_instanceField != null && _showHitmarkerMethod != null && _showKillMessageMethod != null)
					{
						_initialized = true;
					}
					else
					{
						Plugin.Log.LogWarning((object)("Could not find all required methods for " + ModName + " compatibility"));
					}
				}
				else
				{
					Plugin.Log.LogWarning((object)("Could not find HitmarkerCanvasBehaviour class for " + ModName + " compatibility"));
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogError((object)("Error initializing " + ModName + " compatibility: " + ex2.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex2.StackTrace));
			}
		}

		public void TrackDamageSource(int enemyInstanceId, PlayerControllerB playerWhoHit)
		{
			if (!_initialized || _lastDamageSources == null || (Object)(object)playerWhoHit == (Object)null)
			{
				return;
			}
			try
			{
				_lastDamageSources[enemyInstanceId] = playerWhoHit;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error tracking damage source: " + ex.Message));
			}
		}

		public PlayerControllerB GetLastDamageSource(int enemyInstanceId)
		{
			if (!_initialized || _lastDamageSources == null)
			{
				return null;
			}
			if (_lastDamageSources.TryGetValue(enemyInstanceId, out var value))
			{
				return value;
			}
			return null;
		}

		public void ClearTracking()
		{
			if (_lastDamageSources != null)
			{
				_lastDamageSources.Clear();
			}
		}

		public void NotifyEnemyKilled(EnemyAI enemy, PlayerControllerB playerWhoKilled)
		{
			if (!_initialized || (Object)(object)enemy == (Object)null)
			{
				return;
			}
			try
			{
				object value = _instanceField.GetValue(null);
				if (value == null)
				{
					Plugin.Log.LogWarning((object)"Hitmarker canvas instance is null, cannot notify of kill");
					return;
				}
				bool flag = false;
				string text = "Unknown";
				if ((Object)(object)playerWhoKilled != (Object)null)
				{
					flag = (Object)(object)playerWhoKilled == (Object)(object)StartOfRound.Instance.localPlayerController;
					text = playerWhoKilled.playerUsername;
				}
				Plugin.LogInfo($"Notifying Hitmarker: Enemy {enemy.enemyType.enemyName} killed by {text} (local: {flag})");
				_showHitmarkerMethod.Invoke(value, new object[1] { true });
				_showKillMessageMethod.Invoke(value, new object[3]
				{
					enemy.enemyType.enemyName,
					flag,
					text
				});
				Plugin.LogInfo("Successfully notified Hitmarker of kill: " + enemy.enemyType.enemyName + " by " + (flag ? "local player" : text));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error notifying Hitmarker of enemy kill: " + ex.Message));
				Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
			}
		}
	}
	public class LastResortKillerCompatibility : BaseModCompatibility
	{
		[CompilerGenerated]
		private sealed class <CheckIfEnemyDied>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemyAI enemy;

			public LastResortKillerCompatibility <>4__this;

			public bool allowDespawn;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				LastResortKillerCompatibility lastResortKillerCompatibility = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)enemy != (Object)null && !enemy.isEnemyDead)
					{
						Plugin.Log.LogWarning((object)("Kill attempt failed for " + enemy.enemyType.enemyName + ", will try again with more force"));
						lastResortKillerCompatibility.AttemptToKillEnemy(enemy, allowDespawn);
					}
					else
					{
						EnemyAI obj = enemy;
						int num2 = ((obj != null) ? ((Object)obj).GetInstanceID() : 0);
						if (num2 != 0 && lastResortKillerCompatibility.enemyKillAttempts.ContainsKey(num2))
						{
							lastResortKillerCompatibility.enemyKillAttempts.Remove(num2);
							Plugin.LogInfo("Enemy " + (((Object)(object)enemy != (Object)null) ? enemy.enemyType.enemyName : "unknown") + " successfully killed");
						}
					}
					return false;
				}
			}

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

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

		private Dictionary<int, int> enemyKillAttempts = new Dictionary<int, int>();

		private const float RETRY_DELAY = 0.5f;

		public override string ModId => "nwnt.EverythingCanDieAlternative.LastResortKiller";

		public override string ModName => "Last Resort Enemy Killer";

		public override bool IsInstalled => true;

		protected override void OnModInitialize()
		{
			enemyKillAttempts.Clear();
		}

		public bool AttemptToKillEnemy(EnemyAI enemy, bool allowDespawn)
		{
			if ((Object)(object)enemy == (Object)null || enemy.isEnemyDead)
			{
				return false;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!enemyKillAttempts.ContainsKey(instanceID))
			{
				enemyKillAttempts[instanceID] = 1;
			}
			else
			{
				enemyKillAttempts[instanceID]++;
			}
			int num = enemyKillAttempts[instanceID];
			Plugin.LogInfo($"Kill attempt #{num} for {enemy.enemyType.enemyName} (Despawn allowed: {allowDespawn})");
			switch (num)
			{
			case 1:
				Plugin.LogInfo("Standard kill attempt for " + enemy.enemyType.enemyName);
				enemy.KillEnemyOnOwnerClient(false);
				ScheduleKillCheck(enemy);
				return true;
			case 2:
				Plugin.LogInfo("Destroy-enabled kill attempt for " + enemy.enemyType.enemyName);
				enemy.KillEnemyOnOwnerClient(true);
				if (allowDespawn && enemy.thisEnemyIndex >= 0)
				{
					Plugin.LogInfo("Notifying clients to despawn enemy " + enemy.enemyType.enemyName);
					HealthManager.NotifyClientsOfDestroy(enemy.thisEnemyIndex);
				}
				ScheduleKillCheck(enemy);
				return true;
			case 3:
				ForceDeadState(enemy);
				DisableAllComponents(enemy);
				if (allowDespawn)
				{
					if ((Object)(object)((NetworkBehaviour)enemy).NetworkObject != (Object)null && ((NetworkBehaviour)enemy).NetworkObject.IsSpawned)
					{
						try
						{
							Plugin.LogInfo("Forcing network despawn for " + enemy.enemyType.enemyName);
							((NetworkBehaviour)enemy).NetworkObject.Despawn(true);
						}
						catch (Exception ex)
						{
							Plugin.LogError("Failed to force despawn: " + ex.Message);
						}
					}
					if (enemy.thisEnemyIndex >= 0)
					{
						HealthManager.NotifyClientsOfDestroy(enemy.thisEnemyIndex);
					}
				}
				ScheduleKillCheck(enemy);
				return true;
			default:
				Plugin.LogInfo("Final solution: Destroying game object for " + enemy.enemyType.enemyName);
				if (allowDespawn && enemy.thisEnemyIndex >= 0)
				{
					Plugin.LogInfo("Informing clients to destroy " + enemy.enemyType.enemyName);
					HealthManager.NotifyClientsOfDestroy(enemy.thisEnemyIndex);
				}
				Object.Destroy((Object)(object)((Component)enemy).gameObject);
				enemyKillAttempts.Remove(instanceID);
				return true;
			}
		}

		private void ScheduleKillCheck(EnemyAI enemy)
		{
			if ((Object)(object)StartOfRound.Instance != (Object)null)
			{
				bool allowDespawn = DespawnConfiguration.Instance.ShouldDespawnEnemy(enemy.enemyType.enemyName);
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(CheckIfEnemyDied(enemy, allowDespawn));
			}
		}

		[IteratorStateMachine(typeof(<CheckIfEnemyDied>d__11))]
		private IEnumerator CheckIfEnemyDied(EnemyAI enemy, bool allowDespawn)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CheckIfEnemyDied>d__11(0)
			{
				<>4__this = this,
				enemy = enemy,
				allowDespawn = allowDespawn
			};
		}

		private void ForceDeadState(EnemyAI enemy)
		{
			try
			{
				enemy.isEnemyDead = true;
				if ((Object)(object)enemy.agent != (Object)null && ((Behaviour)enemy.agent).enabled)
				{
					enemy.agent.isStopped = true;
					((Behaviour)enemy.agent).enabled = false;
				}
				if ((Object)(object)enemy.creatureAnimator != (Object)null)
				{
					try
					{
						enemy.creatureAnimator.SetTrigger("Death");
					}
					catch (Exception)
					{
					}
					try
					{
						enemy.creatureAnimator.SetTrigger("death");
					}
					catch (Exception)
					{
					}
					try
					{
						enemy.creatureAnimator.SetBool("Dead", true);
					}
					catch (Exception)
					{
					}
					try
					{
						enemy.creatureAnimator.SetBool("dead", true);
					}
					catch (Exception)
					{
					}
				}
				enemy.enemyHP = 0;
				Collider[] componentsInChildren = ((Component)enemy).GetComponentsInChildren<Collider>();
				foreach (Collider val in componentsInChildren)
				{
					if (val.enabled)
					{
						val.enabled = false;
					}
				}
				enemy.KillEnemyOnOwnerClient(true);
			}
			catch (Exception ex5)
			{
				Plugin.Log.LogError((object)("Error during force-state kill attempt: " + ex5.Message));
			}
		}

		private void DisableAllComponents(EnemyAI enemy)
		{
			//IL_00e5: 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)
			try
			{
				MonoBehaviour[] componentsInChildren = ((Component)enemy).GetComponentsInChildren<MonoBehaviour>();
				foreach (MonoBehaviour val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)(object)enemy && ((Behaviour)val).enabled)
					{
						((Behaviour)val).enabled = false;
					}
				}
				Collider[] componentsInChildren2 = ((Component)enemy).GetComponentsInChildren<Collider>();
				foreach (Collider val2 in componentsInChildren2)
				{
					if (val2.enabled)
					{
						val2.enabled = false;
					}
				}
				Renderer[] componentsInChildren3 = ((Component)enemy).GetComponentsInChildren<Renderer>();
				foreach (Renderer val3 in componentsInChildren3)
				{
					if (val3.enabled)
					{
						val3.enabled = false;
					}
				}
				AudioSource[] componentsInChildren4 = ((Component)enemy).GetComponentsInChildren<AudioSource>();
				foreach (AudioSource val4 in componentsInChildren4)
				{
					if (((Behaviour)val4).enabled)
					{
						((Behaviour)val4).enabled = false;
						if (val4.isPlaying)
						{
							val4.Stop();
						}
					}
				}
				Rigidbody[] componentsInChildren5 = ((Component)enemy).GetComponentsInChildren<Rigidbody>();
				foreach (Rigidbody val5 in componentsInChildren5)
				{
					if (!val5.isKinematic)
					{
						val5.velocity = Vector3.zero;
						val5.angularVelocity = Vector3.zero;
						val5.isKinematic = true;
					}
				}
				ParticleSystem[] componentsInChildren6 = ((Component)enemy).GetComponentsInChildren<ParticleSystem>();
				foreach (ParticleSystem val6 in componentsInChildren6)
				{
					if (val6.isPlaying)
					{
						val6.Stop(true, (ParticleSystemStopBehavior)0);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error disabling components: " + ex.Message));
			}
		}

		public void Reset()
		{
			enemyKillAttempts.Clear();
		}
	}
	public class LethalHandsCompatibility : BaseModCompatibility
	{
		private bool? _isInstalled;

		private float? _punchDamage;

		public override string ModId => "SlapitNow.LethalHands";

		public override string ModName => "Lethal Hands";

		public override bool IsInstalled
		{
			get
			{
				if (_isInstalled.HasValue)
				{
					return _isInstalled.Value;
				}
				try
				{
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly in assemblies)
					{
						try
						{
							if (assembly.GetName().Name == "LethalHands" || assembly.GetName().Name.Contains("LethalHands"))
							{
								_isInstalled = true;
								return true;
							}
						}
						catch
						{
						}
					}
					if (Type.GetType("LethalHands.LethalHands, LethalHands") != null)
					{
						_isInstalled = true;
						return true;
					}
					if (Type.GetType("LethalHands.LethalHandsNetworker, LethalHands") != null)
					{
						_isInstalled = true;
						return true;
					}
					bool flag = Chainloader.PluginInfos.ContainsKey(ModId);
					_isInstalled = flag;
					return flag;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting LethalHands mod: " + ex.Message));
					_isInstalled = false;
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
			TryGetPunchDamageValue();
		}

		public float GetPunchDamage()
		{
			if (_punchDamage.HasValue)
			{
				return _punchDamage.Value;
			}
			return 1f;
		}

		private void TryGetPunchDamageValue()
		{
			try
			{
				if (!IsInstalled)
				{
					return;
				}
				string path = Path.Combine(Paths.ConfigPath, "SlapitNow.LethalHands.cfg");
				if (File.Exists(path))
				{
					try
					{
						string[] array = File.ReadAllLines(path);
						foreach (string text in array)
						{
							if (text.StartsWith("EnemyPunchDamage = ") && float.TryParse(text.Substring("EnemyPunchDamage = ".Length).Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
							{
								_punchDamage = result;
								Plugin.LogInfo($"Found LethalHands punch damage from config: {_punchDamage}");
								return;
							}
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Error reading LethalHands config file: " + ex.Message));
					}
				}
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					try
					{
						if (!assembly.GetName().Name.Contains("LethalHands"))
						{
							continue;
						}
						Type type = assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "LethalHands");
						if (type != null)
						{
							PropertyInfo property = type.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public);
							if (property != null)
							{
								object value = property.GetValue(null);
								if (value != null)
								{
									FieldInfo field = type.GetField("enemyPunchDamage", BindingFlags.Instance | BindingFlags.Public);
									if (field != null)
									{
										object value2 = field.GetValue(value);
										if (value2 != null)
										{
											_punchDamage = Convert.ToSingle(value2);
											Plugin.LogInfo($"Found LethalHands punch damage: {_punchDamage}");
											return;
										}
									}
								}
							}
						}
						Type[] array2 = new Type[2]
						{
							assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "LocalConfig"),
							assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "NetworkConfig")
						};
						foreach (Type type2 in array2)
						{
							if (!(type2 != null))
							{
								continue;
							}
							FieldInfo field2 = type2.GetField("enemyPunchDamage", BindingFlags.Static | BindingFlags.Public);
							if (field2 != null)
							{
								object value3 = field2.GetValue(null);
								if (value3 != null)
								{
									_punchDamage = Convert.ToSingle(value3);
									Plugin.LogInfo($"Found LethalHands punch damage from config: {_punchDamage}");
									return;
								}
							}
						}
					}
					catch (Exception ex2)
					{
						Plugin.Log.LogWarning((object)("Error inspecting LethalHands assembly: " + ex2.Message));
					}
				}
				_punchDamage = 1f;
				Plugin.LogInfo($"Using default LethalHands punch damage: {_punchDamage}");
			}
			catch (Exception ex3)
			{
				Plugin.Log.LogError((object)("Error getting LethalHands punch damage: " + ex3.Message));
				_punchDamage = 1f;
			}
		}

		public float ConvertPunchForceToDamage(float force)
		{
			if (force == -22f)
			{
				return GetPunchDamage();
			}
			return force;
		}
	}
	public class LethalMinCompatibility : BaseModCompatibility
	{
		private Type _pikminEnemyType;

		private Type _leaderType;

		private bool _patchApplied;

		public override string ModId => "NoteBoxz.LethalMin";

		public override string ModName => "LethalMin";

		public override bool IsInstalled
		{
			get
			{
				try
				{
					return Chainloader.PluginInfos.ContainsKey("NoteBoxz.LethalMin");
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting " + ModName + ": " + ex.Message));
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
			try
			{
				Assembly assembly = ((object)Chainloader.PluginInfos["NoteBoxz.LethalMin"].Instance).GetType().Assembly;
				_pikminEnemyType = assembly.GetType("LethalMin.PikminEnemy");
				_leaderType = assembly.GetType("LethalMin.Leader");
				if (_pikminEnemyType == null || _leaderType == null)
				{
					Plugin.Log.LogWarning((object)("Could not find required " + ModName + " types"));
				}
				else
				{
					ApplyPatches();
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to initialize " + ModName + " compatibility: " + ex.Message));
			}
		}

		private void ApplyPatches()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			try
			{
				MethodInfo method = _pikminEnemyType.GetMethod("DamageEnemy", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
				{
					typeof(float),
					_leaderType
				}, null);
				if (method == null)
				{
					Plugin.Log.LogWarning((object)("Could not find DamageEnemy method in " + ModName));
					return;
				}
				Plugin.Harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(typeof(LethalMinCompatibility), "DamageEnemyPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_patchApplied = true;
				Plugin.LogInfo("Successfully patched " + ModName + " DamageEnemy method with postfix");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to patch " + ModName + " methods: " + ex.Message));
			}
		}

		[HarmonyPostfix]
		private static void DamageEnemyPostfix(object __instance, float Counter, object pikminLeader)
		{
			try
			{
				LethalMinCompatibility handler = ModCompatibilityManager.Instance.GetHandler<LethalMinCompatibility>("NoteBoxz.LethalMin");
				if (handler == null || !handler._patchApplied)
				{
					return;
				}
				object? obj = handler._pikminEnemyType.GetField("enemyScript")?.GetValue(__instance);
				EnemyAI val = (EnemyAI)((obj is EnemyAI) ? obj : null);
				if (val == null || val.isEnemyDead)
				{
					return;
				}
				int num = Mathf.FloorToInt(Counter);
				if (num > 0)
				{
					PlayerControllerB val2 = null;
					if (pikminLeader != null)
					{
						object? obj2 = handler._leaderType.GetProperty("Controller")?.GetValue(pikminLeader);
						val2 = (PlayerControllerB)((obj2 is PlayerControllerB) ? obj2 : null);
					}
					Plugin.LogInfo(string.Format("LethalMin damage: {0} to {1} from {2}", num, val.enemyType.enemyName, val2?.playerUsername ?? "pikmin"));
					HealthManager.DirectHealthChange(val, num, val2);
					Plugin.LogInfo("LethalMin damage applied directly to network health");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Error in LethalMin postfix: " + ex.Message));
			}
		}

		public bool IsPatchWorking()
		{
			return _patchApplied;
		}
	}
	public class NaturalSelectionCompatibility : BaseModCompatibility
	{
		private static readonly Dictionary<int, int> _forestGiantHpSnapshot = new Dictionary<int, int>();

		public override string ModId => "fandovec03.NaturalSelection";

		public override string ModName => "NaturalSelection";

		public override bool IsInstalled
		{
			get
			{
				try
				{
					return Chainloader.PluginInfos.ContainsKey("fandovec03.NaturalSelection");
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting " + ModName + ": " + ex.Message));
					return false;
				}
			}
		}

		protected override void OnModInitialize()
		{
			try
			{
				Assembly assembly = ((object)Chainloader.PluginInfos["fandovec03.NaturalSelection"].Instance).GetType().Assembly;
				PatchHoarderBugCustomOnHit(assembly);
				PatchPufferCustomOnHit(assembly);
				PatchForestGiantUpdate();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Failed to initialize " + ModName + " compatibility: " + ex.Message));
				Plugin.Log.LogError((object)ex.StackTrace);
			}
		}

		private void PatchHoarderBugCustomOnHit(Assembly assembly)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			Type type = assembly.GetType("NaturalSelection.EnemyPatches.HoarderBugPatch");
			if (type == null)
			{
				Plugin.Log.LogWarning((object)("[" + ModName + "] Could not find HoarderBugPatch type — skipping HoarderBug patch"));
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "CustomOnHit", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogWarning((object)("[" + ModName + "] Could not find HoarderBugPatch.CustomOnHit — skipping HoarderBug patch"));
				return;
			}
			Plugin.Harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NaturalSelectionCompatibility), "HoarderBugCustomOnHitPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Log.LogInfo((object)("[" + ModName + "] Patched HoarderBugPatch.CustomOnHit"));
		}

		private void PatchPufferCustomOnHit(Assembly assembly)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			Type type = assembly.GetType("NaturalSelection.EnemyPatches.PufferAIPatch");
			if (type == null)
			{
				Plugin.Log.LogWarning((object)("[" + ModName + "] Could not find PufferAIPatch type — skipping Puffer patch"));
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "CustomOnHit", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogWarning((object)("[" + ModName + "] Could not find PufferAIPatch.CustomOnHit — skipping Puffer patch"));
				return;
			}
			Plugin.Harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NaturalSelectionCompatibility), "PufferCustomOnHitPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Log.LogInfo((object)("[" + ModName + "] Patched PufferAIPatch.CustomOnHit"));
		}

		private void PatchForestGiantUpdate()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0078: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(ForestGiantAI), "Update", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogWarning((object)("[" + ModName + "] Could not find ForestGiantAI.Update — skipping ForestGiant patch"));
				return;
			}
			Plugin.Harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NaturalSelectionCompatibility), "ForestGiantUpdatePrefix", (Type[])null), new HarmonyMethod(typeof(NaturalSelectionCompatibility), "ForestGiantUpdatePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Log.LogInfo((object)("[" + ModName + "] Patched ForestGiantAI.Update for burning-HP monitoring"));
		}

		public static void HoarderBugCustomOnHitPrefix(int __0, HoarderBugAI __3)
		{
			try
			{
				if (!((Object)(object)__3 == (Object)null) && !((EnemyAI)__3).isEnemyDead && __0 > 0)
				{
					Plugin.LogInfo($"[NaturalSelection] HoarderBug hit detected: {__0} damage from enemy-vs-enemy");
					HealthManager.ProcessHit((EnemyAI)(object)__3, __0, null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NaturalSelection] HoarderBugCustomOnHitPrefix error: " + ex.Message));
			}
		}

		public static void PufferCustomOnHitPrefix(int __0, PufferAI __3)
		{
			try
			{
				if (!((Object)(object)__3 == (Object)null) && !((EnemyAI)__3).isEnemyDead && __0 > 0)
				{
					Plugin.LogInfo($"[NaturalSelection] Puffer hit detected: {__0} damage from enemy-vs-enemy");
					HealthManager.ProcessHit((EnemyAI)(object)__3, __0, null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NaturalSelection] PufferCustomOnHitPrefix error: " + ex.Message));
			}
		}

		public static void ForestGiantUpdatePrefix(ForestGiantAI __instance)
		{
			try
			{
				if (!((Object)(object)__instance == (Object)null) && !((EnemyAI)__instance).isEnemyDead)
				{
					_forestGiantHpSnapshot[((Object)__instance).GetInstanceID()] = ((EnemyAI)__instance).enemyHP;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NaturalSelection] ForestGiantUpdatePrefix error: " + ex.Message));
			}
		}

		public static void ForestGiantUpdatePostfix(ForestGiantAI __instance)
		{
			try
			{
				int instanceID = ((Object)__instance).GetInstanceID();
				if (!_forestGiantHpSnapshot.TryGetValue(instanceID, out var value))
				{
					return;
				}
				if (!((Object)(object)__instance == (Object)null) && !((EnemyAI)__instance).isEnemyDead)
				{
					int num = value - ((EnemyAI)__instance).enemyHP;
					if (num > 0)
					{
						Plugin.LogInfo($"[NaturalSelection] ForestGiant burning mechanic: {num} HP removed (routing to ECDA)");
						HealthManager.ProcessHit((EnemyAI)(object)__instance, num, null);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NaturalSelection] ForestGiantUpdatePostfix error: " + ex.Message));
			}
		}
	}
	public class SellBodiesCompatibility : BaseModCompatibility
	{
		[CompilerGenerated]
		private sealed class <SpawnLootAfterDelay>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int powerLevel;

			public SellBodiesCompatibility <>4__this;

			public string enemyName;

			public Vector3 position;

			public Quaternion rotation;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SellBodiesCompatibility sellBodiesCompatibility = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						string text = $"ModdedEnemyPowerLevel{powerLevel}Body";
						GameObject val = sellBodiesCompatibility.FindPrefabAtRuntime(text);
						if ((Object)(object)val == (Object)null)
						{
							Plugin.Log.LogError((object)("SellBodies: Could not find prefab " + text + " for " + enemyName));
							return false;
						}
						Vector3 val2 = position + new Vector3(0f, 1f, 0f);
						GameObject val3 = Object.Instantiate<GameObject>(val, val2, rotation, RoundManager.Instance.mapPropsContainer.transform);
						NetworkObject component = val3.GetComponent<NetworkObject>();
						if ((Object)(object)component != (Object)null)
						{
							component.Spawn(true);
							Plugin.LogInfo("SellBodies: Successfully spawned SellBodies loot for " + enemyName);
						}
						else
						{
							Plugin.Log.LogError((object)"SellBodies: Loot object has no NetworkObject component, destroying it");
							Object.Destroy((Object)(object)val3);
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error spawning SellBodies loot: " + ex.Message));
						Plugin.Log.LogError((object)("Stack trace: " + ex.StackTrace));
					}
					return false;
				}
			}

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

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

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

		private bool? _isInstalled;

		private static HashSet<int> _handledEnemies = new HashSet<int>();

		public override string ModId => "Entity378.sellbodies";

		public override string ModName => "Sell Bodies";

		public override bool IsInstalled
		{
			get
			{
				if (_isInstalled.HasValue)
				{
					return _isInstalled.Value;
				}
				try
				{
					Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
					foreach (Assembly assembly in assemblies)
					{
						try
						{
							if (assembly.GetName().Name == "SellBodies" || assembly.GetName().Name.Contains("sellbodies"))
							{
								_isInstalled = true;
								return true;
							}
						}
						catch
						{
						}
					}
					bool flag = Chainloader.PluginInfos.ContainsKey(ModId);
					_isInstalled = flag;
					return flag;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error detecting SellBodies mod: " + ex.Message));
					_isInstalled = Plugin.Instance.IsSellBodiesModDetected;
					return _isInstalled.Value;
				}
			}
		}

		protected override void OnModInitialize()
		{
			InitializeProblemEnemies();
			_handledEnemies.Clear();
		}

		private void InitializeProblemEnemies()
		{
			_problemEnemyPowerLevels.Add("Baldi", 2);
			_problemEnemyPowerLevels.Add("The Fiend", 2);
			_problemEnemyPowerLevels.Add("Gorefield", 2);
			_problemEnemyPowerLevels.Add("Rabbit?", 1);
			_problemEnemyPowerLevels.Add("Light Eater", 2);
			_problemEnemyPowerLevels.Add("SCP682", 2);
			_problemEnemyPowerLevels.Add("Nancy", 1);
		}

		public float GetDespawnDelay()
		{
			return 4.5f;
		}

		public bool IsProblemEnemy(string enemyName)
		{
			return _problemEnemyPowerLevels.ContainsKey(enemyName);
		}

		public void HandleProblemEnemyDeath(EnemyAI enemy)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)enemy == (Object)null || !IsInstalled)
			{
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (_handledEnemies.Contains(instanceID))
			{
				Plugin.LogInfo($"SellBodies: Already handled enemy {enemy.enemyType.enemyName} (ID: {instanceID}), skipping");
				return;
			}
			_handledEnemies.Add(instanceID);
			string enemyName = enemy.enemyType.enemyName;
			if (IsProblemEnemy(enemyName))
			{
				Vector3 position = ((Component)enemy).transform.position;
				Quaternion rotation = ((Component)enemy).transform.rotation;
				int num = _problemEnemyPowerLevels[enemyName];
				Plugin.LogInfo($"SellBodies: Handling problem enemy death for {enemyName} with power level {num}");
				if ((Object)(object)StartOfRound.Instance != (Object)null)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(SpawnLootAfterDelay(enemyName, position, rotation, num));
				}
			}
		}

		[IteratorStateMachine(typeof(<SpawnLootAfterDelay>d__14))]
		private IEnumerator SpawnLootAfterDelay(string enemyName, Vector3 position, Quaternion rotation, int powerLevel)
		{
			//IL_0015: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnLootAfterDelay>d__14(0)
			{
				<>4__this = this,
				enemyName = enemyName,
				position = position,
				rotation = rotation,
				powerLevel = powerLevel
			};
		}

		private GameObject FindPrefabAtRuntime(string prefabName)
		{
			string value = prefabName.Replace("Body", "");
			try
			{
				if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.allItemsList == (Object)null)
				{
					Plugin.Log.LogError((object)"SellBodies: StartOfRound.Instance or allItemsList is null");
					return null;
				}
				foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
				{
					if (!((Object)(object)items == (Object)null) && ((((Object)items).name != null && ((Object)items).name.Contains(value)) || (items.itemName != null && items.itemName.Contains(value)) || ((Object)(object)items.spawnPrefab != (Object)null && ((Object)items.spawnPrefab).name.Contains(value))))
					{
						return items.spawnPrefab;
					}
				}
				if (prefabName.Contains("PowerLevel"))
				{
					int num = 1;
					if (prefabName.Contains("PowerLevel2"))
					{
						num = 2;
					}
					else if (prefabName.Contains("PowerLevel3"))
					{
						num = 3;
					}
					foreach (Item items2 in StartOfRound.Instance.allItemsList.itemsList)
					{
						if (!((Object)(object)items2 == (Object)null) && ((Object)items2).name.Contains($"PowerLevel{num}"))
						{
							return items2.spawnPrefab;
						}
					}
				}
				return null;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("SellBodies: Error finding prefab: " + ex.Message));
				return null;
			}
		}

		public void CreateSellBodyLoot(string enemyName, Vector3 position, Quaternion rotation)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (IsInstalled && IsProblemEnemy(enemyName))
			{
				int powerLevel = _problemEnemyPowerLevels[enemyName];
				if ((Object)(object)StartOfRound.Instance != (Object)null)
				{
					((MonoBehaviour)StartOfRound.Instance).StartCoroutine(SpawnLootAfterDelay(enemyName, position, rotation, powerLevel));
				}
			}
		}
	}
	public class TemplateCompatibility : BaseModCompatibility
	{
		public override string ModId => "ModAuthor.ModName";

		public override string ModName => "User Friendly Mod Name";

		public override bool IsInstalled => base.IsInstalled;

		protected override void OnModInitialize()
		{
			Plugin.LogInfo(ModName + " compatibility initialized");
		}

		public void ExampleMethod()
		{
		}

		public void ProcessEnemy(EnemyAI enemy)
		{
			if (!((Object)(object)enemy == (Object)null))
			{
				Plugin.LogInfo("Processing " + enemy.enemyType.enemyName + " for " + ModName + " compatibility");
			}
		}
	}
}