using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using NilsHUD;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NilsHUD")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NilsHUD")]
[assembly: AssemblyTitle("NilsHUD")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
public static class HealthBarPatch
{
	private static Dictionary<PlayerControllerB, Vector3> lastPlayerPositions = new Dictionary<PlayerControllerB, Vector3>();

	private const float POSITION_THRESHOLD = 0.1f;

	public static void Postfix(PlayerControllerB __instance)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		if (!PluginConfig.ConfigEnableHealthBar.Value)
		{
			return;
		}
		HealthBar healthBar = HealthBar.GetHealthBar(__instance);
		if ((Object)(object)healthBar != (Object)null)
		{
			Vector3 position = ((Component)__instance).transform.position;
			if (!lastPlayerPositions.ContainsKey(__instance) || Vector3.Distance(position, lastPlayerPositions[__instance]) > 0.1f)
			{
				healthBar.UpdateHealthBarPosition();
				lastPlayerPositions[__instance] = position;
			}
		}
	}
}
public class HealthChangeHelper : MonoBehaviour
{
	private void Awake()
	{
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
	}

	public void HandleHealthChange(Image healthBarImage, Image redHealthBarImage, float currentHealth, float maxHealth, float previousHealth)
	{
		Debug.Log((object)$"HandleHealthChange called, healthBarImage: {healthBarImage}, redHealthBarImage: {redHealthBarImage}");
		float num3 = (redHealthBarImage.fillAmount = (healthBarImage.fillAmount = currentHealth / maxHealth));
		if (currentHealth < previousHealth)
		{
			Debug.Log((object)$"Player is being damaged, fillAmount: {num3}");
		}
		else if (currentHealth > previousHealth)
		{
			Debug.Log((object)$"Player is being healed, fillAmount: {num3}");
		}
	}
}
public class HealthBar : MonoBehaviour
{
	[HarmonyPatch(typeof(PlayerControllerB), "Start")]
	public static class AddHealthBarPatch
	{
		public static void Postfix(PlayerControllerB __instance)
		{
			if ((Object)(object)__instance != (Object)(object)PlayerUtils.GetPlayerControllerB() && healthBarList.Count < initialHealthBarCount)
			{
				GetHealthBar(__instance);
			}
		}
	}

	private PlayerControllerB player;

	public Image healthBarImage;

	public Image redHealthBarImage;

	private CanvasGroup healthBarAlpha;

	private CanvasGroup redHealthBarAlpha;

	private bool isLocalPlayer;

	private GameObject healthBarObject;

	private float lastHealth;

	private float fadeOutDelay;

	private float fadeOutTimer = 0f;

	private RectTransform healthBarTransform;

	private RectTransform redHealthBarTransform;

	private RectTransform healthBarFillTransform;

	private static PlayerControllerB localPlayerController;

	private static Queue<HealthBar> healthBarPool = new Queue<HealthBar>();

	private float previousHealth;

	private Transform usernameBillboard;

	private Transform playerGlobalHead;

	private CanvasGroup usernameAlpha;

	private float fadeInRate;

	private float fadeOutRate;

	private HealthChangeHelper healthChangeHelper;

	private static int initialHealthBarCount = 4;

	private static List<HealthBar> healthBarList = new List<HealthBar>();

	private static Dictionary<PlayerControllerB, HealthBar> playerHealthBarMap = new Dictionary<PlayerControllerB, HealthBar>();

	public static HealthBar GetHealthBar(PlayerControllerB player)
	{
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Expected O, but got Unknown
		if ((Object)(object)localPlayerController == (Object)null)
		{
			localPlayerController = PlayerUtils.GetPlayerControllerB();
		}
		if ((Object)(object)player == (Object)(object)localPlayerController)
		{
			return null;
		}
		if (playerHealthBarMap.TryGetValue(player, out HealthBar value))
		{
			if ((Object)(object)value != (Object)null && ((Component)value).gameObject.activeSelf)
			{
				return value;
			}
			playerHealthBarMap.Remove(player);
		}
		HealthBar healthBar = healthBarList.Find((HealthBar hb) => !((Component)hb).gameObject.activeSelf);
		if ((Object)(object)healthBar != (Object)null)
		{
			healthBar.player = player;
			((Component)healthBar).gameObject.SetActive(true);
			playerHealthBarMap[player] = healthBar;
			return healthBar;
		}
		GameObject val = new GameObject("HealthBar");
		val.SetActive(false);
		HealthBar healthBar2 = val.AddComponent<HealthBar>();
		healthBar2.player = player;
		healthBar2.InitializeHealthBar();
		val.SetActive(true);
		healthBarList.Add(healthBar2);
		playerHealthBarMap[player] = healthBar2;
		return healthBar2;
	}

	private void Awake()
	{
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Expected O, but got Unknown
		if (!PluginConfig.ConfigEnableHealthBar.Value)
		{
			((Component)this).gameObject.SetActive(false);
			return;
		}
		isLocalPlayer = (Object)(object)player == (Object)(object)localPlayerController;
		lastHealth = player.health;
		fadeOutDelay = PluginConfig.ConfigFadeOutDelay.Value;
		usernameBillboard = player.usernameBillboard;
		playerGlobalHead = player.playerGlobalHead;
		usernameAlpha = player.usernameAlpha;
		fadeInRate = 1f / PluginConfig.ConfigFadeInDuration.Value;
		fadeOutRate = 1f / PluginConfig.ConfigFadeOutDuration.Value;
		previousHealth = player.health;
		GameObject val = GameObject.Find("HealthChangeHelper");
		if ((Object)(object)val == (Object)null)
		{
			val = new GameObject("HealthChangeHelper");
			healthChangeHelper = val.AddComponent<HealthChangeHelper>();
			Debug.Log((object)"Created new HealthChangeHelper instance");
		}
		else
		{
			healthChangeHelper = val.GetComponent<HealthChangeHelper>();
			Debug.Log((object)"Found existing HealthChangeHelper instance");
		}
	}

	private void InitializeHealthBar()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c3: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
		if (PluginConfig.ConfigEnableHealthBar.Value && (Object)(object)healthBarObject == (Object)null)
		{
			healthBarObject = new GameObject("HealthBarObject");
			healthBarObject.transform.SetParent(((Component)player.usernameBillboard).transform, false);
			redHealthBarImage = new GameObject("RedHealthBar").AddComponent<Image>();
			((Component)redHealthBarImage).transform.SetParent(healthBarObject.transform, false);
			redHealthBarAlpha = ((Component)redHealthBarImage).gameObject.AddComponent<CanvasGroup>();
			redHealthBarAlpha.alpha = 0f;
			healthBarImage = new GameObject("HealthBar").AddComponent<Image>();
			((Component)healthBarImage).transform.SetParent(healthBarObject.transform, false);
			healthBarAlpha = ((Component)healthBarImage).gameObject.AddComponent<CanvasGroup>();
			healthBarAlpha.alpha = 0f;
			Debug.Log((object)$"Initialized health bar: healthBarImage={healthBarImage}, redHealthBarImage={redHealthBarImage}");
			redHealthBarTransform = ((Component)redHealthBarImage).GetComponent<RectTransform>();
			healthBarTransform = ((Component)healthBarImage).GetComponent<RectTransform>();
			redHealthBarTransform.anchorMin = new Vector2(0.5f, 0f);
			redHealthBarTransform.anchorMax = new Vector2(0.5f, 0f);
			redHealthBarTransform.sizeDelta = new Vector2(PluginConfig.ConfigRedHealthBarWidth.Value, PluginConfig.ConfigRedHealthBarHeight.Value);
			redHealthBarTransform.anchoredPosition = new Vector2(PluginConfig.ConfigHealthBarPositionX.Value, PluginConfig.ConfigHealthBarPositionY.Value);
			healthBarTransform.anchorMin = new Vector2(0f, 0f);
			healthBarTransform.anchorMax = new Vector2(1f, 0f);
			healthBarTransform.sizeDelta = new Vector2(PluginConfig.ConfigHealthBarWidth.Value, PluginConfig.ConfigHealthBarHeight.Value);
			healthBarTransform.anchoredPosition = new Vector2(PluginConfig.ConfigHealthBarPositionX.Value, PluginConfig.ConfigHealthBarPositionY.Value);
			string value = PluginConfig.ConfigHealthBarColorHex.Value;
			Color color = default(Color);
			if (ColorUtility.TryParseHtmlString("#" + value, ref color))
			{
				((Graphic)healthBarImage).color = color;
			}
			string value2 = PluginConfig.ConfigRedHealthBarColorHex.Value;
			Color color2 = default(Color);
			if (ColorUtility.TryParseHtmlString("#" + value2, ref color2))
			{
				((Graphic)redHealthBarImage).color = color2;
			}
		}
	}

	private void LateUpdate()
	{
		if (PluginConfig.ConfigEnableHealthBar.Value)
		{
			UpdateHealthBarFade();
			if ((float)player.health != lastHealth)
			{
				OnHealthChanged();
			}
		}
	}

	private void OnHealthChanged()
	{
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		if (PluginConfig.ConfigEnableHealthBar.Value)
		{
			float num = player.health;
			float num2 = 100f;
			float num3 = lastHealth;
			Debug.Log((object)$"OnHealthChanged called for player: {((Object)player).name}, currentHealth: {num}, previousHealth: {num3}");
			if ((Object)(object)player != (Object)(object)localPlayerController && num != num3)
			{
				healthChangeHelper.HandleHealthChange(healthBarImage, redHealthBarImage, num, num2, num3);
				float num4 = num / num2;
				healthBarTransform.anchorMax = new Vector2(num4, healthBarTransform.anchorMax.y);
				float num5 = num4 * PluginConfig.ConfigHealthBarWidth.Value;
				healthBarTransform.sizeDelta = new Vector2(num5, healthBarTransform.sizeDelta.y);
				lastHealth = num;
			}
		}
	}

	private void UpdateHealthBarFade()
	{
		if (isLocalPlayer)
		{
			healthBarAlpha.alpha = 0f;
			redHealthBarAlpha.alpha = 0f;
			return;
		}
		if (usernameAlpha.alpha > 0f)
		{
			fadeOutTimer = 0f;
			if (healthBarAlpha.alpha < 1f)
			{
				CanvasGroup obj = healthBarAlpha;
				obj.alpha += Time.deltaTime * fadeInRate;
				healthBarAlpha.alpha = Mathf.Clamp01(healthBarAlpha.alpha);
			}
			if (redHealthBarAlpha.alpha < 1f)
			{
				CanvasGroup obj2 = redHealthBarAlpha;
				obj2.alpha += Time.deltaTime * fadeInRate;
				redHealthBarAlpha.alpha = Mathf.Clamp01(redHealthBarAlpha.alpha);
			}
			return;
		}
		fadeOutTimer += Time.deltaTime;
		if (fadeOutTimer >= fadeOutDelay)
		{
			CanvasGroup obj3 = healthBarAlpha;
			obj3.alpha -= Time.deltaTime * fadeOutRate;
			healthBarAlpha.alpha = Mathf.Clamp01(healthBarAlpha.alpha);
			CanvasGroup obj4 = redHealthBarAlpha;
			obj4.alpha -= Time.deltaTime * fadeOutRate;
			redHealthBarAlpha.alpha = Mathf.Clamp01(redHealthBarAlpha.alpha);
			if (healthBarAlpha.alpha <= 0f && redHealthBarAlpha.alpha <= 0f)
			{
				healthBarPool.Enqueue(this);
				((Component)this).gameObject.SetActive(false);
			}
		}
	}

	public void UpdateHealthBarPosition()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: 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_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (PluginConfig.ConfigEnableHealthBar.Value)
		{
			Vector3 position = playerGlobalHead.position;
			usernameBillboard.position = new Vector3(position.x, position.y + 0.55f, position.z);
		}
	}
}
[HarmonyPatch(typeof(UnlockableSuit), "SwitchSuitForPlayer")]
public static class UnlockableSuitPatch
{
	public static class SuitColorCache
	{
		private static Dictionary<int, Color> colorCache = new Dictionary<int, Color>();

		private static Texture2D? readableTexture;

		public static Color GetSuitColor(int suitID, Material suitMaterial)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!colorCache.TryGetValue(suitID, out var value))
			{
				value = GetAverageColorFromMaterial(suitMaterial);
				colorCache[suitID] = value;
			}
			return value;
		}

		public static Color GetAverageColorFromMaterial(Material material)
		{
			//IL_0112: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			if ((Object)(object)material != (Object)null)
			{
				Texture mainTexture = material.mainTexture;
				Texture2D val = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
				if (val != null)
				{
					RenderTexture temporary = RenderTexture.GetTemporary(((Texture)val).width, ((Texture)val).height);
					Graphics.Blit((Texture)(object)val, temporary);
					RenderTexture active = RenderTexture.active;
					RenderTexture.active = temporary;
					if ((Object)(object)readableTexture == (Object)null || ((Texture)readableTexture).width != ((Texture)val).width || ((Texture)readableTexture).height != ((Texture)val).height)
					{
						if ((Object)(object)readableTexture != (Object)null)
						{
							Object.Destroy((Object)(object)readableTexture);
						}
						readableTexture = new Texture2D(((Texture)val).width, ((Texture)val).height);
					}
					readableTexture.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
					readableTexture.Apply();
					Color averageColorFromTexture = GetAverageColorFromTexture(readableTexture);
					RenderTexture.active = active;
					RenderTexture.ReleaseTemporary(temporary);
					return averageColorFromTexture;
				}
			}
			return Color.gray;
		}

		private static Color GetAverageColorFromTexture(Texture2D texture)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0073: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			Color32[] pixels = texture.GetPixels32();
			int num = Mathf.Min(pixels.Length, 1000);
			int num2 = pixels.Length / num;
			float num3 = 0f;
			Color val = Color.clear;
			for (int i = 0; i < pixels.Length; i += num2)
			{
				Color32 val2 = pixels[i];
				float num4 = (float)(val2.r + val2.g + val2.b) / 765f;
				float num5 = Mathf.Clamp01(num4 * 2f);
				val += Color32.op_Implicit(val2) * num5;
				num3 += num5;
			}
			if (num3 > 0f)
			{
				Color val3 = val / num3;
				float value = PluginConfig.ConfigSuitOverlayBrightness.Value;
				return Color.Lerp(Color.black, val3, value);
			}
			return Color.gray;
		}
	}

	private static HUDManager? hudManager;

	private static StartOfRound? startOfRound;

	[HarmonyPostfix]
	public static void SwitchSuitForPlayer_Postfix(PlayerControllerB player, int suitID)
	{
		if ((Object)(object)player != (Object)null && PluginConfig.ConfigEnableSuitColorOverlay.Value)
		{
			UpdateHealthOverlayColor(player, suitID);
		}
	}

	public static void UpdateHealthOverlayColor(PlayerControllerB player, int suitID)
	{
		//IL_00dc: 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_0098: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)hudManager == (Object)null)
		{
			hudManager = HUDManager.Instance;
		}
		if (!((Object)(object)hudManager != (Object)null))
		{
			return;
		}
		CanvasGroup selfRedCanvasGroup = hudManager.selfRedCanvasGroup;
		Image val = default(Image);
		if (selfRedCanvasGroup == null || !((Component)selfRedCanvasGroup).TryGetComponent<Image>(ref val))
		{
			return;
		}
		Color color = default(Color);
		if (PluginConfig.ConfigEnableSuitColorOverlay.Value)
		{
			if ((Object)(object)startOfRound == (Object)null)
			{
				startOfRound = StartOfRound.Instance;
			}
			Material suitMaterial = startOfRound.unlockablesList.unlockables[suitID].suitMaterial;
			Color suitColor = SuitColorCache.GetSuitColor(suitID, suitMaterial);
			((Graphic)val).color = suitColor;
		}
		else if (ColorUtility.TryParseHtmlString("#" + PluginConfig.ConfigOverlayColorHex.Value, ref color))
		{
			((Graphic)val).color = color;
		}
		else
		{
			((Graphic)val).color = Color.red;
		}
	}

	public static void PrecomputeSuitColors()
	{
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Expected O, but got Unknown
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)startOfRound == (Object)null)
		{
			startOfRound = StartOfRound.Instance;
		}
		foreach (UnlockableItem unlockable in startOfRound.unlockablesList.unlockables)
		{
			if (((object)unlockable).GetType().Name == "UnlockableSuit")
			{
				int num = (int)((object)unlockable).GetType().GetProperty("suitID").GetValue(unlockable);
				Material suitMaterial = (Material)((object)unlockable).GetType().GetProperty("suitMaterial").GetValue(unlockable);
				Color suitColor = SuitColorCache.GetSuitColor(num, suitMaterial);
				Debug.Log((object)$"Precomputed color for suit ID {num}: {suitColor}");
			}
		}
	}
}
namespace NilsHUD
{
	public static class PlayerUtils
	{
		private static PlayerControllerB? localPlayerController;

		public static PlayerControllerB? GetPlayerControllerB()
		{
			if ((Object)(object)localPlayerController == (Object)null)
			{
				if ((Object)(object)GameNetworkManager.Instance != (Object)null)
				{
					localPlayerController = GameNetworkManager.Instance.localPlayerController;
					PlayerControllerB? obj = localPlayerController;
					Debug.Log((object)("[NilsHUD] GetPlayerControllerB returned: " + (((obj != null) ? ((Object)obj).name : null) ?? "null")));
				}
				else
				{
					Debug.LogError((object)"[NilsHUD] GameNetworkManager.Instance is null.");
				}
			}
			return localPlayerController;
		}
	}
	public static class HUDManagerPatch
	{
		private const string HealFromCriticalTrigger = "HealFromCritical";

		private const string CriticalHitTrigger = "CriticalHit";

		private const string SmallHitTrigger = "SmallHit";

		private const int CriticalHealthThreshold = 20;

		private static bool playerIsCriticallyInjured;

		private static float targetFillAmount;

		[HarmonyPatch(typeof(HUDManager), "Awake")]
		[HarmonyPostfix]
		public static void AwakePostfix()
		{
			InitializeHealthOverlay();
		}

		[HarmonyPatch(typeof(HUDManager), "UpdateHealthUI")]
		[HarmonyPrefix]
		public static bool UpdateHealthUIPrefix(int health, bool hurtPlayer = true)
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Debug.LogError((object)"HUDManager instance is null!");
				return true;
			}
			if ((Object)(object)instance.selfRedCanvasGroup == (Object)null)
			{
				Debug.LogError((object)"selfRedCanvasGroup is null!");
				return true;
			}
			Image component = ((Component)instance.selfRedCanvasGroup).GetComponent<Image>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogError((object)"Image component not found on selfRedCanvasGroup!");
				return false;
			}
			PlayerControllerB playerControllerB = PlayerUtils.GetPlayerControllerB();
			if ((Object)(object)playerControllerB != (Object)null && playerControllerB.isPlayerDead)
			{
				return false;
			}
			if (PluginConfig.ConfigStartFullyFilled.Value)
			{
				targetFillAmount = (100f - (float)health) / 100f;
			}
			else
			{
				targetFillAmount = (float)health / 100f;
			}
			if (!Object.op_Implicit((Object)(object)((Component)instance).gameObject.GetComponent<HealthIndicatorInitializer>()))
			{
				((Component)instance).gameObject.AddComponent<HealthIndicatorInitializer>();
				if (PluginConfig.ConfigStartFullyFilled.Value)
				{
					component.fillAmount = 1f;
				}
				else
				{
					component.fillAmount = 0f;
				}
			}
			float num;
			float num2;
			if (PluginConfig.ConfigStartFullyFilled.Value)
			{
				num = ((component.fillAmount == 0f) ? 1f : component.fillAmount);
				num2 = (float)health / 100f;
			}
			else
			{
				num = component.fillAmount;
				num2 = (100f - (float)health) / 100f;
			}
			if (Mathf.Approximately(num, num2) && !PlayerUtils.GetPlayerControllerB().isPlayerDead)
			{
				return false;
			}
			component.fillAmount = num;
			ConfigureHealthImage(component, health, playerControllerB);
			StartHealthMonitoring(instance);
			StartSmoothFillTransition(instance, component, num);
			if ((Object)(object)instance.HUDAnimator == (Object)null)
			{
				Debug.LogError((object)"HUDAnimator is null!");
				return false;
			}
			HandlePlayerHealthState(instance, health, hurtPlayer);
			return false;
		}

		public static void InitializeHealthOverlay()
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Debug.LogError((object)"HUDManager instance is null!");
				return;
			}
			if ((Object)(object)instance.selfRedCanvasGroup == (Object)null)
			{
				Debug.LogError((object)"selfRedCanvasGroup is null!");
				return;
			}
			Image component = ((Component)instance.selfRedCanvasGroup).GetComponent<Image>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogError((object)"Image component not found on selfRedCanvasGroup!");
				return;
			}
			instance.selfRedCanvasGroup.alpha = 1f;
			PlayerControllerB playerControllerB = PlayerUtils.GetPlayerControllerB();
			int num = (((Object)(object)playerControllerB != (Object)null) ? playerControllerB.health : 100);
			if (PluginConfig.ConfigStartFullyFilled.Value)
			{
				component.fillAmount = ((num == 100) ? 1f : 0f);
				instance.selfRedCanvasGroup.alpha = (float)num / 100f;
			}
			else
			{
				component.fillAmount = (float)num / 100f;
				instance.selfRedCanvasGroup.alpha = (100f - (float)num) / 100f;
			}
			ConfigureHealthImage(component, num, playerControllerB);
		}

		private static void StartHealthMonitoring(HUDManager hudManager)
		{
			if (!Object.op_Implicit((Object)(object)((Component)hudManager).gameObject.GetComponent<HealthMonitorCoroutine>()))
			{
				((Component)hudManager).gameObject.AddComponent<HealthMonitorCoroutine>();
			}
		}

		private static void StartSmoothFillTransition(HUDManager hudManager, Image image, float previousFillAmount)
		{
			if ((Object)(object)hudManager == (Object)null)
			{
				Debug.LogError((object)"HUDManager instance is null!");
				return;
			}
			((MonoBehaviour)hudManager).StopAllCoroutines();
			if (PluginConfig.ConfigEnableFillAnimation.Value)
			{
				float duration = Mathf.Clamp(PluginConfig.ConfigFillTransitionDuration.Value, 0.01f, 1f);
				bool drainEffect = !PluginConfig.ConfigStartFullyFilled.Value;
				((MonoBehaviour)hudManager).StartCoroutine(SmoothFillTransition(image, previousFillAmount, targetFillAmount, duration, drainEffect));
			}
			else
			{
				image.fillAmount = targetFillAmount;
			}
			if (PluginConfig.ConfigEnableFadeOut.Value)
			{
				float fadeOutDuration = Mathf.Clamp(PluginConfig.ConfigFadeOutDuration.Value, 0f, 5f);
				float smoothFillDuration = Mathf.Clamp(PluginConfig.ConfigFillTransitionDuration.Value, 0.01f, 1f);
				((MonoBehaviour)hudManager).StartCoroutine(SmoothFillAndFadeTransition(image, previousFillAmount, targetFillAmount, smoothFillDuration, fadeOutDuration));
			}
		}

		private static IEnumerator StartFadeOutEffect(Image image, float fadeOutDuration)
		{
			float elapsedTime = 0f;
			Color startColor = ((Graphic)image).color;
			float targetAlpha = Mathf.Clamp01(1f - PluginConfig.ConfigFadeOutIntensity.Value);
			Color targetColor = new Color(startColor.r, startColor.g, startColor.b, targetAlpha);
			while (elapsedTime < fadeOutDuration)
			{
				float t = elapsedTime / fadeOutDuration;
				((Graphic)image).color = Color.Lerp(startColor, targetColor, t);
				elapsedTime += Time.deltaTime;
				yield return null;
			}
			((Graphic)image).color = targetColor;
		}

		private static IEnumerator SmoothFillTransition(Image image, float startFillAmount, float targetFillAmount, float duration, bool drainEffect = false)
		{
			float elapsedTime = 0f;
			Debug.LogFormat("Start fill amount: {0}", new object[1] { startFillAmount });
			Debug.LogFormat("Target fill amount: {0}", new object[1] { targetFillAmount });
			Debug.LogFormat("Fill duration: {0}", new object[1] { duration });
			if (Mathf.Approximately(startFillAmount, targetFillAmount))
			{
				duration = Mathf.Max(duration, 0.1f);
			}
			while (elapsedTime < duration)
			{
				float t = elapsedTime / duration;
				float smoothT = Mathf.SmoothStep(0f, 1f, t);
				if (PluginConfig.ConfigStartFullyFilled.Value)
				{
					if (drainEffect)
					{
						image.fillAmount = Mathf.Lerp(startFillAmount, targetFillAmount, smoothT);
					}
					else
					{
						image.fillAmount = Mathf.Lerp(startFillAmount, targetFillAmount, smoothT);
					}
				}
				else if (drainEffect)
				{
					image.fillAmount = Mathf.Lerp(startFillAmount, targetFillAmount, smoothT);
				}
				else
				{
					image.fillAmount = Mathf.Lerp(startFillAmount, targetFillAmount, smoothT);
				}
				elapsedTime += Time.deltaTime;
				yield return null;
			}
			image.fillAmount = targetFillAmount;
		}

		private static IEnumerator SmoothFillAndFadeTransition(Image image, float startFillAmount, float targetFillAmount, float smoothFillDuration, float fadeOutDuration)
		{
			Debug.LogFormat("Start fill amount: {0}", new object[1] { image.fillAmount });
			Debug.LogFormat("Target fill amount: {0}", new object[1] { targetFillAmount });
			Debug.LogFormat("Fill duration: {0}", new object[1] { smoothFillDuration });
			Debug.LogFormat("Fade-out duration: {0}", new object[1] { fadeOutDuration });
			if (Mathf.Approximately(image.fillAmount, targetFillAmount))
			{
				smoothFillDuration = Mathf.Max(smoothFillDuration, 0.1f);
			}
			yield return SmoothFillTransition(image, startFillAmount, targetFillAmount, smoothFillDuration);
			float elapsedTime = 0f;
			Color startColor = ((Graphic)image).color;
			float targetAlpha = Mathf.Clamp01(1f - PluginConfig.ConfigFadeOutIntensity.Value);
			Color targetColor = new Color(startColor.r, startColor.g, startColor.b, targetAlpha);
			Debug.Log((object)$"Starting fade-out effect. Start color: {startColor}, Target color: {targetColor}, Fade-out duration: {fadeOutDuration}");
			while (elapsedTime < fadeOutDuration)
			{
				float t = elapsedTime / fadeOutDuration;
				((Graphic)image).color = Color.Lerp(startColor, targetColor, t);
				Debug.Log((object)$"Fade-out effect progress: {t}, Current color: {((Graphic)image).color}");
				elapsedTime += Time.deltaTime;
				yield return null;
			}
			((Graphic)image).color = targetColor;
			Debug.Log((object)$"Fade-out effect completed. Final color: {((Graphic)image).color}");
		}

		private static void ConfigureHealthImage(Image image, int health, PlayerControllerB controllerInstance)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if (PluginConfig.ConfigStartFullyFilled.Value)
			{
				targetFillAmount = (float)health / 100f;
				if (health == 100)
				{
					image.fillAmount = 1f;
				}
				else
				{
					image.fillAmount = 0f;
				}
			}
			else
			{
				targetFillAmount = (100f - (float)health) / 100f;
				image.fillAmount = targetFillAmount;
			}
			if ((int)image.type != 3)
			{
				image.type = (Type)3;
				image.fillMethod = (FillMethod)1;
			}
			if (PluginConfig.ConfigFillDirection.Value == FillDirection.TopToBottom)
			{
				image.fillOrigin = 1;
			}
			else
			{
				image.fillOrigin = 0;
			}
			Color color = default(Color);
			if (PluginConfig.ConfigEnableSuitColorOverlay.Value && (Object)(object)controllerInstance != (Object)null)
			{
				int currentSuitID = controllerInstance.currentSuitID;
				Debug.LogFormat("Current Suit ID in HealthIndicatorPatch: {0}", new object[1] { currentSuitID });
				UnlockableSuitPatch.UpdateHealthOverlayColor(controllerInstance, currentSuitID);
				Debug.Log((object)"Health overlay color updated in HealthIndicatorPatch");
			}
			else if (ColorUtility.TryParseHtmlString("#" + PluginConfig.ConfigOverlayColorHex.Value, ref color))
			{
				((Graphic)image).color = color;
			}
			else
			{
				((Graphic)image).color = Color.red;
			}
		}

		private static void HandlePlayerHealthState(HUDManager hudManager, int health, bool hurtPlayer)
		{
			if ((Object)(object)hudManager.selfRedCanvasGroup != (Object)null)
			{
				if (PluginConfig.ConfigStartFullyFilled.Value)
				{
					hudManager.selfRedCanvasGroup.alpha = (float)health / 100f;
				}
				else
				{
					hudManager.selfRedCanvasGroup.alpha = (100f - (float)health) / 100f;
				}
			}
			else
			{
				Debug.LogError((object)"selfRedCanvasGroup is null!");
			}
			if (health >= 20 && playerIsCriticallyInjured)
			{
				playerIsCriticallyInjured = false;
				if ((Object)(object)hudManager.HUDAnimator != (Object)null)
				{
					hudManager.HUDAnimator.SetTrigger("HealFromCritical");
				}
				else
				{
					Debug.LogError((object)"HUDAnimator is null!");
				}
			}
			if (health >= 20 && playerIsCriticallyInjured)
			{
				playerIsCriticallyInjured = false;
				hudManager.HUDAnimator.SetTrigger("HealFromCritical");
			}
			if (hurtPlayer && health > 0)
			{
				ProcessPlayerInjury(hudManager, health);
			}
		}

		private static void ProcessPlayerInjury(HUDManager hudManager, int health)
		{
			if (health < 20)
			{
				playerIsCriticallyInjured = true;
				if (PluginConfig.ConfigEnableCriticalHitEffect.Value)
				{
					if ((Object)(object)hudManager.HUDAnimator != (Object)null)
					{
						hudManager.HUDAnimator.SetTrigger("CriticalHit");
					}
					else
					{
						Debug.LogError((object)"HUDAnimator is null!");
					}
					if ((Object)(object)hudManager.UIAudio != (Object)null && (Object)(object)hudManager.criticalInjury != (Object)null)
					{
						hudManager.UIAudio.PlayOneShot(hudManager.criticalInjury, 1f);
					}
					else
					{
						Debug.LogError((object)"UIAudio or criticalInjury is null!");
					}
				}
			}
			else if (PluginConfig.ConfigEnableSmallHitEffect.Value)
			{
				if ((Object)(object)hudManager.HUDAnimator != (Object)null)
				{
					hudManager.HUDAnimator.SetTrigger("SmallHit");
				}
				else
				{
					Debug.LogError((object)"HUDAnimator is null!");
				}
			}
		}
	}
	public class HealthIndicatorInitializer : MonoBehaviour
	{
		public float StartFillAmount { get; set; }

		public float TargetFillAmount { get; set; }

		public float PreviousStartFillAmount { get; set; }
	}
	public static class PlayerControllerBPatch
	{
		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPrefix]
		public static void KillPlayerPrefix(PlayerControllerB __instance)
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance?.selfRedCanvasGroup == (Object)null)
			{
				Debug.LogError((object)"HUDManager instance or selfRedCanvasGroup is null!");
				return;
			}
			Image component = ((Component)instance.selfRedCanvasGroup).GetComponent<Image>();
			if ((Object)(object)component == (Object)null)
			{
				Debug.LogError((object)"Image component not found on selfRedCanvasGroup!");
				return;
			}
			if ((Object)(object)instance != (Object)null)
			{
				((MonoBehaviour)instance).StopAllCoroutines();
			}
			else
			{
				Debug.LogError((object)"HUDManager instance is null!");
			}
			HealthIndicatorInitializer component2 = ((Component)instance).gameObject.GetComponent<HealthIndicatorInitializer>();
			if ((Object)(object)component2 != (Object)null)
			{
				if (PluginConfig.ConfigStartFullyFilled.Value)
				{
					instance.selfRedCanvasGroup.alpha = 1f;
					component2.StartFillAmount = 1f;
					component2.TargetFillAmount = 1f;
					component.fillAmount = 1f;
				}
				else
				{
					component2.StartFillAmount = 0f;
					component2.TargetFillAmount = 0f;
					component.fillAmount = 0f;
				}
				component2.PreviousStartFillAmount = component2.StartFillAmount;
			}
			Debug.Log((object)"Player died. Setting fill amount to 0 and resetting start/target fill amounts.");
		}
	}
	public class HealthMonitorCoroutine : MonoBehaviour
	{
		private int lastHealth = -1;

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(MonitorHealth());
		}

		private IEnumerator MonitorHealth()
		{
			while (true)
			{
				PlayerControllerB playerController = PlayerUtils.GetPlayerControllerB();
				if ((Object)(object)playerController != (Object)null)
				{
					int currentHealth = playerController.health;
					if (currentHealth != lastHealth)
					{
						lastHealth = currentHealth;
						HUDManagerPatch.UpdateHealthUIPrefix(currentHealth, hurtPlayer: false);
					}
				}
				else
				{
					Debug.LogError((object)"PlayerControllerB is null!");
				}
				yield return (object)new WaitForSeconds(0.01f);
			}
		}
	}
	[BepInPlugin("Nilaier.NilsHUD", "NilsHUD", "1.0.6")]
	public class Plugin : BaseUnityPlugin
	{
		private const string AsciiLogoResourceName = "NilsHUD.Resources.ascii_logo.txt";

		private static readonly Assembly ExecutingAssembly = Assembly.GetExecutingAssembly();

		private static readonly string[] ExcludedScenes = new string[5] { "InitScene", "InitSceneLaunchOptions", "InitSceneLANMode", "MainMenu", "ColdOpen1" };

		private Harmony? harmonyInstance;

		private bool isPluginInitialized = false;

		private void Awake()
		{
			try
			{
				DisplayAsciiLogo();
				PluginConfig.BindConfig(((BaseUnityPlugin)this).Config);
				Debug.Log((object)"[NilsHUD] Config loaded.");
				SceneManager.sceneLoaded += OnSceneLoaded;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error in Awake: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}

		private void DisplayAsciiLogo()
		{
			try
			{
				string text = LoadAsciiLogoFromResource();
				Debug.Log((object)(string.IsNullOrEmpty(text) ? "[NilsHUD] ASCII logo not found or empty." : text));
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error displaying ASCII logo: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}

		private void InitializePlugin()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			try
			{
				harmonyInstance = new Harmony("Nilaier.NilsHUD");
				harmonyInstance.PatchAll(typeof(HUDManagerPatch));
				harmonyInstance.PatchAll(typeof(UnlockableSuitPatch));
				harmonyInstance.PatchAll(typeof(HealthBarPatch));
				harmonyInstance.PatchAll(typeof(PlayerControllerBPatch));
				Debug.Log((object)"[NilsHUD] Harmony patches applied.");
				UnlockableSuitPatch.PrecomputeSuitColors();
				HUDManagerPatch.InitializeHealthOverlay();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error in InitializePlugin: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}

		private string LoadAsciiLogoFromResource()
		{
			try
			{
				using Stream stream = ExecutingAssembly.GetManifestResourceStream("NilsHUD.Resources.ascii_logo.txt");
				if (stream != null)
				{
					using (StreamReader streamReader = new StreamReader(stream))
					{
						return streamReader.ReadToEnd();
					}
				}
			}
			catch (IOException ex)
			{
				Debug.LogError((object)("[NilsHUD] Error loading ASCII logo: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
			return string.Empty;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			try
			{
				Debug.Log((object)("[NilsHUD] Loaded scene: " + ((Scene)(ref scene)).name));
				if (!isPluginInitialized && !ExcludedScenes.Contains(((Scene)(ref scene)).name))
				{
					InitializePlugin();
					isPluginInitialized = true;
					Debug.Log((object)("[NilsHUD] Plugin initialized in scene: " + ((Scene)(ref scene)).name));
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error in OnSceneLoaded: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}
	}
	public class PluginConfig
	{
		private const string DefaultOverlayColor = "FF0000";

		private const float DefaultFillTransitionDuration = 0.1f;

		private const float DefaultFadeOutDuration = 0.5f;

		private const float DefaultFadeOutIntensity = 0.5f;

		private const string DefaultHealthBarColor = "FF8000";

		private const string DefaultRedHealthBarColor = "FF0000";

		private const float DefaultHealthBarPositionX = 0f;

		private const float DefaultHealthBarPositionY = 30f;

		private const float DefaultFadeInDuration = 0.5f;

		private const float DefaultFadeOutDelay = 1f;

		private const float DefaultHealthBarWidth = 300f;

		private const float DefaultHealthBarHeight = 15f;

		private const float DefaultRedHealthBarWidth = 300f;

		private const float DefaultRedHealthBarHeight = 15f;

		public static ConfigEntry<string>? ConfigOverlayColorHex;

		public static ConfigEntry<bool>? ConfigEnableFillAnimation;

		public static ConfigEntry<FillDirection>? ConfigFillDirection;

		public static ConfigEntry<float>? ConfigFillTransitionDuration;

		public static ConfigEntry<bool>? ConfigStartFullyFilled;

		public static ConfigEntry<bool>? ConfigEnableSuitColorOverlay;

		public static ConfigEntry<float>? ConfigSuitOverlayBrightness;

		public static ConfigEntry<bool>? ConfigEnableFadeOut;

		public static ConfigEntry<float>? ConfigFadeOutDuration;

		public static ConfigEntry<float>? ConfigFadeOutIntensity;

		public static ConfigEntry<bool>? ConfigEnableCriticalHitEffect;

		public static ConfigEntry<bool>? ConfigEnableSmallHitEffect;

		public static ConfigEntry<bool>? ConfigEnableHealthBar;

		public static ConfigEntry<string>? ConfigHealthBarColorHex;

		public static ConfigEntry<string>? ConfigRedHealthBarColorHex;

		public static ConfigEntry<float>? ConfigHealthBarPositionX;

		public static ConfigEntry<float>? ConfigHealthBarPositionY;

		public static ConfigEntry<float>? ConfigFadeInDuration;

		public static ConfigEntry<float>? ConfigFadeOutDelay;

		public static ConfigEntry<float>? ConfigHealthBarWidth;

		public static ConfigEntry<float>? ConfigHealthBarHeight;

		public static ConfigEntry<float>? ConfigRedHealthBarWidth;

		public static ConfigEntry<float>? ConfigRedHealthBarHeight;

		private const string ModIconResourceName = "NilsHUD.Resources.icon.png";

		private static readonly Assembly ExecutingAssembly = Assembly.GetExecutingAssembly();

		public static void BindConfig(ConfigFile config)
		{
			try
			{
				ConfigOverlayColorHex = config.Bind<string>("Overlay", "OverlayColorHex", "FF0000", (ConfigDescription)null);
				ConfigEnableFillAnimation = config.Bind<bool>("Overlay", "EnableFillAnimation", true, (ConfigDescription)null);
				ConfigFillDirection = config.Bind<FillDirection>("Overlay", "FillDirection", FillDirection.BottomToTop, (ConfigDescription)null);
				ConfigFillTransitionDuration = config.Bind<float>("Overlay", "FillTransitionDuration", 0.1f, (ConfigDescription)null);
				ConfigStartFullyFilled = config.Bind<bool>("Overlay", "StartFullyFilled", false, (ConfigDescription)null);
				ConfigEnableSuitColorOverlay = config.Bind<bool>("Overlay", "EnableSuitColorOverlay", false, (ConfigDescription)null);
				ConfigSuitOverlayBrightness = config.Bind<float>("Overlay", "SuitOverlayBrightness", 1f, (ConfigDescription)null);
				ConfigEnableFadeOut = config.Bind<bool>("FadeOut", "EnableFadeOut", true, (ConfigDescription)null);
				ConfigFadeOutDuration = config.Bind<float>("FadeOut", "FadeOutDuration", 0.5f, (ConfigDescription)null);
				ConfigFadeOutIntensity = config.Bind<float>("FadeOut", "FadeOutIntensity", 0.5f, (ConfigDescription)null);
				ConfigEnableCriticalHitEffect = config.Bind<bool>("Effects", "EnableCriticalHitEffect", true, (ConfigDescription)null);
				ConfigEnableSmallHitEffect = config.Bind<bool>("Effects", "EnableSmallHitEffect", true, (ConfigDescription)null);
				ConfigEnableHealthBar = config.Bind<bool>("Experimental", "EnableHealthBar", false, (ConfigDescription)null);
				ConfigHealthBarColorHex = config.Bind<string>("Experimental", "HealthBarColorHex", "FF8000", (ConfigDescription)null);
				ConfigRedHealthBarColorHex = config.Bind<string>("Experimental", "RedHealthBarColorHex", "FF0000", (ConfigDescription)null);
				ConfigHealthBarPositionX = config.Bind<float>("Experimental", "HealthBarPositionX", 0f, (ConfigDescription)null);
				ConfigHealthBarPositionY = config.Bind<float>("Experimental", "HealthBarPositionY", 30f, (ConfigDescription)null);
				ConfigFadeInDuration = config.Bind<float>("Experimental", "FadeInDuration", 0.5f, (ConfigDescription)null);
				ConfigFadeOutDelay = config.Bind<float>("Experimental", "FadeOutDelay", 1f, (ConfigDescription)null);
				ConfigHealthBarWidth = config.Bind<float>("Experimental", "HealthBarWidth", 300f, (ConfigDescription)null);
				ConfigHealthBarHeight = config.Bind<float>("Experimental", "HealthBarHeight", 15f, (ConfigDescription)null);
				ConfigRedHealthBarWidth = config.Bind<float>("Experimental", "RedHealthBarWidth", 300f, (ConfigDescription)null);
				ConfigRedHealthBarHeight = config.Bind<float>("Experimental", "RedHealthBarHeight", 15f, (ConfigDescription)null);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error while binding config: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
			try
			{
				Type type = Type.GetType("LethalConfig.LethalConfigManager, LethalConfig");
				if (type != null)
				{
					AddLethalConfigItems();
					SetModIconAndDescription();
				}
				else
				{
					Debug.Log((object)"LethalConfig is not installed. Using default config values.");
				}
			}
			catch (FileNotFoundException)
			{
				Debug.Log((object)"LethalConfig assembly is not found. Using default config values.");
			}
		}

		private static void SetModIconAndDescription()
		{
			try
			{
				Sprite val = LoadModIcon();
				if ((Object)(object)val != (Object)null)
				{
					(Type.GetType("LethalConfig.LethalConfigManager, LethalConfig")?.GetMethod("SetModIcon"))?.Invoke(null, new object[1] { val });
				}
				(Type.GetType("LethalConfig.LethalConfigManager, LethalConfig")?.GetMethod("SetModDescription"))?.Invoke(null, new object[1] { "Better Vanilla-like Health HUD" });
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error while setting mod icon and description: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}

		private static Sprite LoadModIcon()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0064: 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)
			try
			{
				using Stream stream = ExecutingAssembly.GetManifestResourceStream("NilsHUD.Resources.icon.png");
				if (stream != null)
				{
					byte[] array = new byte[stream.Length];
					stream.Read(array, 0, array.Length);
					Texture2D val = new Texture2D(2, 2);
					if (ImageConversion.LoadImage(val, array))
					{
						return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error loading mod icon: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
			return null;
		}

		private static void AddLethalConfigItems()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//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_00b8: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00ca: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_0118: 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_0128: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_013a: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_016c: 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_017c: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_018e: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_01a4: 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_01b4: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01c6: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_028a: Expected O, but got Unknown
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Expected O, but got Unknown
			//IL_02a0: 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_02b0: Expected O, but got Unknown
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c2: Expected O, but got Unknown
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Expected O, but got Unknown
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_02fa: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Expected O, but got Unknown
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Expected O, but got Unknown
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0332: Expected O, but got Unknown
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			//IL_0348: 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_0358: Expected O, but got Unknown
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_036a: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Expected O, but got Unknown
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a2: Expected O, but got Unknown
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected O, but got Unknown
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Expected O, but got Unknown
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_03da: Expected O, but got Unknown
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Expected O, but got Unknown
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0412: Expected O, but got Unknown
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = Type.GetType("LethalConfig.LethalConfigManager, LethalConfig")?.GetMethod("AddConfigItem", new Type[1] { typeof(BaseConfigItem) });
				if (methodInfo != null)
				{
					methodInfo.Invoke(null, new object[1] { (object)new TextInputFieldConfigItem(ConfigOverlayColorHex, true) });
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableFillAnimation, true) });
					methodInfo.Invoke(null, new object[1]
					{
						new EnumDropDownConfigItem<FillDirection>(ConfigFillDirection, new EnumDropDownOptions())
					});
					object[] array = new object[1];
					ConfigEntry<float>? configFillTransitionDuration = ConfigFillTransitionDuration;
					FloatSliderOptions val = new FloatSliderOptions();
					((BaseRangeOptions<float>)val).Min = 0f;
					((BaseRangeOptions<float>)val).Max = 60f;
					array[0] = (object)new FloatSliderConfigItem(configFillTransitionDuration, val);
					methodInfo.Invoke(null, array);
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigStartFullyFilled, true) });
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableSuitColorOverlay, true) });
					object[] array2 = new object[1];
					ConfigEntry<float>? configSuitOverlayBrightness = ConfigSuitOverlayBrightness;
					FloatSliderOptions val2 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val2).Min = 0f;
					((BaseRangeOptions<float>)val2).Max = 2f;
					array2[0] = (object)new FloatSliderConfigItem(configSuitOverlayBrightness, val2);
					methodInfo.Invoke(null, array2);
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableFadeOut, true) });
					object[] array3 = new object[1];
					ConfigEntry<float>? configFadeOutDuration = ConfigFadeOutDuration;
					FloatSliderOptions val3 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val3).Min = 0f;
					((BaseRangeOptions<float>)val3).Max = 60f;
					array3[0] = (object)new FloatSliderConfigItem(configFadeOutDuration, val3);
					methodInfo.Invoke(null, array3);
					object[] array4 = new object[1];
					ConfigEntry<float>? configFadeOutIntensity = ConfigFadeOutIntensity;
					FloatSliderOptions val4 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val4).Min = 0f;
					((BaseRangeOptions<float>)val4).Max = 1f;
					array4[0] = (object)new FloatSliderConfigItem(configFadeOutIntensity, val4);
					methodInfo.Invoke(null, array4);
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableCriticalHitEffect, true) });
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableSmallHitEffect, true) });
					methodInfo.Invoke(null, new object[1] { (object)new BoolCheckBoxConfigItem(ConfigEnableHealthBar, true) });
					methodInfo.Invoke(null, new object[1] { (object)new TextInputFieldConfigItem(ConfigHealthBarColorHex, true) });
					methodInfo.Invoke(null, new object[1] { (object)new TextInputFieldConfigItem(ConfigRedHealthBarColorHex, true) });
					object[] array5 = new object[1];
					ConfigEntry<float>? configHealthBarPositionX = ConfigHealthBarPositionX;
					FloatSliderOptions val5 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val5).Min = -500f;
					((BaseRangeOptions<float>)val5).Max = 500f;
					array5[0] = (object)new FloatSliderConfigItem(configHealthBarPositionX, val5);
					methodInfo.Invoke(null, array5);
					object[] array6 = new object[1];
					ConfigEntry<float>? configHealthBarPositionY = ConfigHealthBarPositionY;
					FloatSliderOptions val6 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val6).Min = -500f;
					((BaseRangeOptions<float>)val6).Max = 500f;
					array6[0] = (object)new FloatSliderConfigItem(configHealthBarPositionY, val6);
					methodInfo.Invoke(null, array6);
					object[] array7 = new object[1];
					ConfigEntry<float>? configFadeInDuration = ConfigFadeInDuration;
					FloatSliderOptions val7 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val7).Min = 0f;
					((BaseRangeOptions<float>)val7).Max = 60f;
					array7[0] = (object)new FloatSliderConfigItem(configFadeInDuration, val7);
					methodInfo.Invoke(null, array7);
					object[] array8 = new object[1];
					ConfigEntry<float>? configFadeOutDelay = ConfigFadeOutDelay;
					FloatSliderOptions val8 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val8).Min = 0f;
					((BaseRangeOptions<float>)val8).Max = 60f;
					array8[0] = (object)new FloatSliderConfigItem(configFadeOutDelay, val8);
					methodInfo.Invoke(null, array8);
					object[] array9 = new object[1];
					ConfigEntry<float>? configHealthBarWidth = ConfigHealthBarWidth;
					FloatSliderOptions val9 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val9).Min = 1f;
					((BaseRangeOptions<float>)val9).Max = 500f;
					array9[0] = (object)new FloatSliderConfigItem(configHealthBarWidth, val9);
					methodInfo.Invoke(null, array9);
					object[] array10 = new object[1];
					ConfigEntry<float>? configHealthBarHeight = ConfigHealthBarHeight;
					FloatSliderOptions val10 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val10).Min = 1f;
					((BaseRangeOptions<float>)val10).Max = 500f;
					array10[0] = (object)new FloatSliderConfigItem(configHealthBarHeight, val10);
					methodInfo.Invoke(null, array10);
					object[] array11 = new object[1];
					ConfigEntry<float>? configRedHealthBarWidth = ConfigRedHealthBarWidth;
					FloatSliderOptions val11 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val11).Min = 1f;
					((BaseRangeOptions<float>)val11).Max = 500f;
					array11[0] = (object)new FloatSliderConfigItem(configRedHealthBarWidth, val11);
					methodInfo.Invoke(null, array11);
					object[] array12 = new object[1];
					ConfigEntry<float>? configRedHealthBarHeight = ConfigRedHealthBarHeight;
					FloatSliderOptions val12 = new FloatSliderOptions();
					((BaseRangeOptions<float>)val12).Min = 1f;
					((BaseRangeOptions<float>)val12).Max = 500f;
					array12[0] = (object)new FloatSliderConfigItem(configRedHealthBarHeight, val12);
					methodInfo.Invoke(null, array12);
				}
				else
				{
					Debug.LogError((object)"[NilsHUD] Failed to find AddConfigItem method in LethalConfig.");
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NilsHUD] Error while adding LethalConfig items: " + ex.Message));
				Debug.LogError((object)("[NilsHUD] Stack trace: " + ex.StackTrace));
			}
		}
	}
	public enum FillDirection
	{
		BottomToTop,
		TopToBottom
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "Nilaier.NilsHUD";

		public const string PLUGIN_NAME = "NilsHUD";

		public const string PLUGIN_VERSION = "1.0.6";
	}
}