using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Notiffy.API;
using NukeLib.Game;
using NukeLib.UI;
using NukeLib.Utils;
using TMPro;
using ThornClient.Core;
using ThornClient.Core.ConfigurableElements;
using ThornClient.Core.DataTypes;
using ThornClient.HUD;
using ThornClient.HUD.HUDComponents;
using ThornClient.Managers;
using ThornClient.Modules.Utility;
using ThornClient.Patches;
using ThornClient.System;
using ThornClient.System.ClickGUIComponents;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ThornClient
{
	[BepInPlugin("com.github.end-4.thornClient", "Thorn", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		public static string workingPath = Assembly.GetExecutingAssembly().Location;

		public static string workingDir = Path.GetDirectoryName(workingPath);

		public const string PluginGUID = "com.github.end-4.thornClient";

		public const string PluginName = "Thorn";

		public const string PluginVersion = "0.1.0";

		public static string PluginIconPath = Path.Combine(workingDir, "icon.png");

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				AssetManager.Initialize();
				HudManager.Initialize();
				EffectManager.Initialize();
				ModuleManager.Initialize();
				RenderManager.Initialize();
				ConfigManager.LoadAll();
				ConfigManager.SetupFileWatcher();
				new Harmony("com.github.end-4.thornClient").PatchAll(typeof(OptionsManagerPatches));
				Log.LogInfo((object)"Thorn is loaded");
			}
		}

		private void Update()
		{
			ConfigManager.UpdateMainThreadQueue();
			InputManager.Update();
			foreach (ThornClient.Core.Module item in ModuleManager.Items)
			{
				if (item.IsEnabled)
				{
					try
					{
						item.OnUpdate();
					}
					catch (Exception ex)
					{
						NotificationSystem.NotifySend("Thorn > " + item.Name, "Error in update loop of " + item.Name + ", disabling to prevent further issues. Check the logs for further details.", (Sprite)null, PluginIconPath, (Urgency)1, "Thorn", 0u, (Dictionary<string, string>)null, -1);
						Log.LogError((object)("Error in module '" + item.Name + "' during Update! Disabling to prevent log spam/crashes"));
						Log.LogError((object)ex);
						item.Toggle();
					}
				}
			}
		}

		private void OnRenderObject()
		{
			RenderManager.RenderPipeline();
		}
	}
}
namespace ThornClient.System
{
	public class ClickGUI : SystemModule
	{
		internal static ClickGUI? Instance;

		private const string PauseGameStateKey = "Thorn_ClickGUI";

		private static readonly string BundlePath = Path.Combine(Plugin.workingDir, "assets", "thorn_clickgui.bundle");

		public static readonly string BundleKey = "clickGui";

		private static GameObject? _layoutedPagePrefab;

		private bool _isInitialized;

		private GameObject? _canvas;

		private GameObject? _tabBar;

		private GameObject? _modulePage;

		private GameObject? _hudPage;

		private GameObject? _settingsPage;

		private GameObject? _configPopupPage;

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

		private GameObject? _tooltip;

		private GameObject? _tabBarButtonRow;

		private ModuleSearchWindowController? _moduleSearchController;

		private ModuleSearchWindowController? _hudModuleSearchController;

		private List<Tuple<string, GameObject>> _tabPages = new List<Tuple<string, GameObject>>();

		private const string ModuleTabName = "Modules";

		private const string HudTabName = "HUD";

		private static readonly Vector2 PageHiddenOffset = Vector2.down * 15f;

		private static string _lastTabName = "";

		private static OptionsManager? opts => MonoSingleton<OptionsManager>.Instance;

		public ClickGUI()
			: base("thorn.clickGui", "ClickGUI", "The main interaction panel")
		{
			AssetManager.LoadBundle(BundleKey, BundlePath);
			SceneUtils.SafeSceneLoaded += delegate
			{
				_isInitialized = InitializeIfNeeded();
				if (IsEnabled)
				{
					Toggle();
				}
			};
		}

		private bool InitializeIfNeeded()
		{
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: 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_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: 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_0421: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			if (Instance != null || (_isInitialized && (Object)(object)_canvas != (Object)null))
			{
				return true;
			}
			Instance = this;
			GameObject val = AssetManager.Get<GameObject>(BundleKey, "ThornClickGUICanvas");
			GameObject val2 = AssetManager.Get<GameObject>(BundleKey, "TabBar");
			_layoutedPagePrefab = AssetManager.Get<GameObject>(BundleKey, "LayoutedPage");
			GameObject val3 = AssetManager.Get<GameObject>(BundleKey, "Tooltip");
			GameObject val4 = AssetManager.Get<GameObject>(BundleKey, "TabButton");
			GameObject val5 = AssetManager.Get<GameObject>(BundleKey, "ModuleCategory");
			GameObject val6 = AssetManager.Get<GameObject>(BundleKey, "SearchWindow");
			_canvas = Object.Instantiate<GameObject>(val);
			((Object)_canvas).hideFlags = (HideFlags)52;
			Object.DontDestroyOnLoad((Object)(object)_canvas);
			_canvas.SetActive(true);
			_tabBar = Object.Instantiate<GameObject>(val2, _canvas.transform);
			_tabBar.SetActive(true);
			GameObjectExtensions.GetOrAddComponent<TabBarController>(_tabBar);
			_modulePage = Object.Instantiate<GameObject>(_layoutedPagePrefab, _canvas.transform);
			_hudPage = Object.Instantiate<GameObject>(_layoutedPagePrefab, _canvas.transform);
			_settingsPage = Object.Instantiate<GameObject>(_layoutedPagePrefab, _canvas.transform);
			_tabPages.Add(Tuple.Create<string, GameObject>("Modules", _modulePage));
			_tabPages.Add(Tuple.Create<string, GameObject>("HUD", _hudPage));
			_tabPages.Add(Tuple.Create<string, GameObject>("Settings", _settingsPage));
			_lastTabName = "Modules";
			for (int i = 0; i < Enum.GetValues(typeof(ModuleCategory)).Length; i++)
			{
				ModuleCategory moduleCategory = (ModuleCategory)i;
				if (moduleCategory != ModuleCategory.Hud)
				{
					GameObject val7 = Object.Instantiate<GameObject>(val5);
					AddToLayoutedPage(_modulePage, val7);
					ModuleCategoryController orAddComponent = GameObjectExtensions.GetOrAddComponent<ModuleCategoryController>(val7);
					orAddComponent.Category = moduleCategory;
					orAddComponent.SetupModules();
					UIUtils.UnfuckLayoutHack(val7);
				}
			}
			GameObject val8 = Object.Instantiate<GameObject>(val6);
			AddToLayoutedPage(_modulePage, val8);
			_moduleSearchController = val8.AddComponent<ModuleSearchWindowController>();
			_moduleSearchController.ModuleFilter = (ThornClient.Core.Module module) => !(module is SystemModule) && !(module is HudModule);
			UIUtils.UnfuckLayoutHack(_modulePage);
			GameObject val9 = Object.Instantiate<GameObject>(val5);
			AddToLayoutedPage(_hudPage, val9);
			ModuleCategoryController orAddComponent2 = GameObjectExtensions.GetOrAddComponent<ModuleCategoryController>(val9);
			orAddComponent2.Category = ModuleCategory.Hud;
			orAddComponent2.SetupModules();
			UIUtils.UnfuckLayoutHack(val9);
			RectTransform val10 = (RectTransform)val9.transform;
			UIUtils.UnfuckLayoutHack(val9);
			val10.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val10).localPosition = new Vector3(0f, 0f, 0f);
			GameObject val11 = Object.Instantiate<GameObject>(val6);
			AddToLayoutedPage(_hudPage, val11);
			_hudModuleSearchController = val11.AddComponent<ModuleSearchWindowController>();
			_hudModuleSearchController.ModuleFilter = (ThornClient.Core.Module module) => module is HudModule;
			UIUtils.UnfuckLayoutHack(_hudPage);
			GameObject val12 = Object.Instantiate<GameObject>(val5);
			AddToLayoutedPage(_settingsPage, val12);
			RectTransform val13 = (RectTransform)val12.transform;
			val13.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val13).localPosition = new Vector3(0f, 0f, 0f);
			GameObjectExtensions.GetOrAddComponent<ConfigurableWindowController>(val12).TargetConfigurable = ThornModule.Instance;
			UIUtils.UnfuckLayoutHack(_settingsPage);
			_tabBarButtonRow = UIUtils.FindRecursive(_tabBar, "Tabs");
			foreach (Tuple<string, GameObject> tabPage in _tabPages)
			{
				string key = tabPage.Item1;
				GameObject obj = Object.Instantiate<GameObject>(val4, _tabBarButtonRow.transform);
				((TMP_Text)UIUtils.FindRecursive(obj, "Text").GetComponent<TextMeshProUGUI>()).text = key;
				((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					SetTab(key);
				});
				SlideFadeToggleEffectExtensions.SetActiveAnimated(tabPage.Item2, false, PageHiddenOffset, 25f);
			}
			UIUtils.UnfuckLayoutHack(_tabBarButtonRow);
			_tooltip = Object.Instantiate<GameObject>(val3, _canvas.transform);
			_tooltip.SetActive(false);
			CanvasGroup component = _canvas.GetComponent<CanvasGroup>();
			if ((Object)(object)component != (Object)null)
			{
				component.alpha = 1f;
			}
			SetTab("Modules", animated: false);
			_canvas.SetActive(false);
			return true;
		}

		private static GameObject AddToLayoutedPage(GameObject page, GameObject item)
		{
			GameObject obj = UIUtils.FindRecursive(page, "Layout");
			Transform val = ((obj != null) ? obj.transform : null);
			if ((Object)(object)val == (Object)null || (Object)(object)item == (Object)null)
			{
				return item;
			}
			item.transform.SetParent(val, false);
			UIUtils.UnfuckLayoutHack(((Component)val).gameObject);
			return item;
		}

		protected override void OnEnable()
		{
			if (!((Object)(object)_canvas == (Object)null))
			{
				_canvas.transform.SetAsLastSibling();
				_canvas.SetActive(true);
				Canvas component = _canvas.GetComponent<Canvas>();
				if ((Object)(object)component != (Object)null)
				{
					component.sortingOrder = 69;
				}
				UIUtils.UnfuckLayoutHack(_canvas);
				ThornModule? instance = ThornModule.Instance;
				if (instance == null || instance.MenuPausesGame.Value)
				{
					Pauser.Pause(true, "Thorn_ClickGUI");
				}
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				PerformInitialFocus();
			}
		}

		protected override void OnDisable()
		{
			if (!((Object)(object)_canvas == (Object)null))
			{
				_canvas.SetActive(false);
				Pauser.Pause(true, "Thorn_ClickGUI");
				Pauser.Pause(false, "Thorn_ClickGUI");
				if ((Object)(object)_tooltip != (Object)null)
				{
					_tooltip.SetActive(false);
				}
			}
		}

		public override void OnUpdate()
		{
			UpdateTooltipPos();
		}

		private void UpdateTooltipPos()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_tooltip == (Object)null) && _tooltip.activeInHierarchy)
			{
				RectTransform val = (RectTransform)_tooltip.transform;
				((Transform)val).position = Input.mousePosition + new Vector3(70f + val.sizeDelta.x / 2f, -40f - val.sizeDelta.y / 2f, 0f);
				_tooltip.transform.SetAsLastSibling();
			}
		}

		public static string GetTooltipText()
		{
			if (Instance == null || (Object)(object)Instance._tooltip == (Object)null)
			{
				return "";
			}
			GameObject val = UIUtils.FindRecursive(Instance._tooltip, "Text");
			if ((Object)(object)val == (Object)null)
			{
				return "";
			}
			return ((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text;
		}

		public static void SetTooltipText(string text)
		{
			string text2 = TextUtils.WrapText(text, 30);
			if (Instance != null && !((Object)(object)Instance._tooltip == (Object)null))
			{
				GameObject val = UIUtils.FindRecursive(Instance._tooltip, "Text");
				if (!((Object)(object)val == (Object)null))
				{
					((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text = text2;
					Instance._tooltip.SetActive(true);
					UIUtils.UnfuckLayoutHack(Instance._tooltip);
					Instance.UpdateTooltipPos();
				}
			}
		}

		public static void SurrenderTooltipText(string text, bool force = false)
		{
			string text2 = TextUtils.WrapText(text, 30);
			if (Instance == null || (Object)(object)Instance._tooltip == (Object)null)
			{
				return;
			}
			GameObject val = UIUtils.FindRecursive(Instance._tooltip, "Text");
			if (!((Object)(object)val == (Object)null))
			{
				TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
				if (((TMP_Text)component).text == text2 || force)
				{
					Instance._tooltip.SetActive(false);
					((TMP_Text)component).text = "";
				}
			}
		}

		public static void SetTab(string tabName, bool animated = true)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00ed: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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)
			if (Instance == null)
			{
				return;
			}
			List<Tuple<string, GameObject>> tabPages = Instance._tabPages;
			GameObject tabBarButtonRow = Instance._tabBarButtonRow;
			int num = 0;
			for (int i = 0; i < tabPages.Count; i++)
			{
				tabPages[i].Deconstruct(out var item, out var item2);
				string text = item;
				GameObject val = item2;
				bool flag = tabName == text;
				if (animated)
				{
					SlideFadeToggleEffectExtensions.SetActiveAnimated(val, flag, PageHiddenOffset, 25f);
				}
				else
				{
					val.SetActive(flag);
				}
				UIUtils.UnfuckLayoutHack(val);
				if ((Object)(object)val != (Object)null && tabName == text)
				{
					_lastTabName = tabName;
					num = i;
				}
			}
			if ((Object)(object)tabBarButtonRow != (Object)null)
			{
				for (int j = 0; j < tabBarButtonRow.transform.childCount; j++)
				{
					bool flag2 = j == num;
					bool atLeft = j == 0;
					bool atRight = j + 1 == tabPages.Count;
					Sprite sprite = ConnectedButtonGroupSettingController.GetSprite(atLeft, atRight, flag2);
					Color color = (flag2 ? ThornModule.AccentColor : Color.white);
					Color color2 = (flag2 ? Color.black : Color.white);
					Transform child = tabBarButtonRow.transform.GetChild(j);
					Image val2 = ((child != null) ? ((Component)child).GetComponent<Image>() : null);
					GameObject val3 = ((child != null) ? UIUtils.FindRecursive(((Component)child).gameObject, "Text") : null);
					if (!((Object)(object)child == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
					{
						val2.sprite = sprite;
						((Graphic)val2).color = color;
						((Graphic)val3.GetComponent<TextMeshProUGUI>()).color = color2;
					}
				}
			}
			Instance.PerformInitialFocus();
		}

		private void PerformInitialFocus()
		{
			if (_lastTabName == "Modules")
			{
				if ((Object)(object)_moduleSearchController != (Object)null)
				{
					_moduleSearchController.FocusSearch();
				}
			}
			else if (_lastTabName == "HUD" && (Object)(object)_hudModuleSearchController != (Object)null)
			{
				_hudModuleSearchController.FocusSearch();
			}
		}

		public static void CycleTab(int diff)
		{
			if (Instance != null && Instance._tabPages.Count != 0 && Instance.IsEnabled)
			{
				int num = Instance._tabPages.FindIndex((Tuple<string, GameObject> p) => p.Item1 == _lastTabName);
				if (num == -1)
				{
					num = 0;
				}
				int count = Instance._tabPages.Count;
				int index = ((num + diff) % count + count) % count;
				SetTab(Instance._tabPages[index].Item1);
			}
		}

		public static void NestPanel(GameObject panelContent)
		{
			//IL_004f: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (Instance == null || (Object)(object)Instance._canvas == (Object)null || (Object)(object)_layoutedPagePrefab == (Object)null)
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(_layoutedPagePrefab, Instance._canvas.transform);
			AddToLayoutedPage(val, panelContent);
			RectTransform val2 = (RectTransform)panelContent.transform;
			val2.pivot = new Vector2(0.5f, 0.5f);
			((Transform)val2).localPosition = Vector3.zero;
			if ((Object)(object)Instance._tabBarButtonRow != (Object)null)
			{
				Instance._tabBarButtonRow.SetActive(false);
			}
			if (Instance._panelStack.Count > 0)
			{
				SlideFadeToggleEffectExtensions.SetActiveAnimated(Instance._panelStack.Peek(), false, PageHiddenOffset, 25f);
			}
			else
			{
				Instance._tabPages.ForEach(delegate(Tuple<string, GameObject> p)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					SlideFadeToggleEffectExtensions.SetActiveAnimated(p.Item2, false, PageHiddenOffset, 25f);
				});
			}
			SlideFadeToggleEffectExtensions.SetActiveAnimated(val, true, PageHiddenOffset, 25f);
			Instance._panelStack.Push(val);
			SurrenderTooltipText("", force: true);
		}

		public static void SpawnContent(GameObject content)
		{
			if (Instance != null && !((Object)(object)content == (Object)null))
			{
				GameObject val = null;
				val = (GameObject)((Instance._panelStack.Count <= 0) ? ((object)Instance._tabPages.FirstOrDefault((Tuple<string, GameObject> p) => p.Item1 == _lastTabName)?.Item2) : ((object)Instance._panelStack.Peek()));
				if (!((Object)(object)val == (Object)null))
				{
					AddToLayoutedPage(val, content);
				}
			}
		}

		public static void NavigateBack()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (Instance == null || !Instance.IsEnabled)
			{
				return;
			}
			if (Instance._panelStack.Count > 0)
			{
				Object.Destroy((Object)(object)Instance._panelStack.Pop());
				if (Instance._panelStack.Count > 0)
				{
					SlideFadeToggleEffectExtensions.SetActiveAnimated(Instance._panelStack.Peek(), true, PageHiddenOffset, 25f);
				}
				else
				{
					SetTab(_lastTabName);
					if ((Object)(object)Instance._tabBarButtonRow != (Object)null)
					{
						Instance._tabBarButtonRow.SetActive(true);
					}
				}
			}
			else if (Instance.IsEnabled)
			{
				Instance.Toggle();
			}
			SurrenderTooltipText("", force: true);
		}

		public static void NestConfigPanel(Configurable? config)
		{
			if (config != null)
			{
				GameObject val = CreateConfigPanel(config);
				if ((Object)(object)val != (Object)null)
				{
					NestPanel(val);
				}
				SurrenderTooltipText("", force: true);
			}
		}

		private static GameObject? CreateConfigPanel(Configurable config)
		{
			if ((Object)(object)AssetManager.Get<GameObject>(BundleKey, "ModuleCategory") == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(BundleKey, "ModuleCategory"));
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			ConfigurableWindowController orAddComponent = GameObjectExtensions.GetOrAddComponent<ConfigurableWindowController>(val);
			orAddComponent.IsPopup = true;
			orAddComponent.TargetConfigurable = config;
			return val;
		}
	}
	internal static class PauseMenuButton
	{
		private const string PauseNotifToggleButtonName = "ThornToggleClickGUI";

		private static GameObject? _clickGuiToggleButton;

		public static void Initialize()
		{
		}

		static PauseMenuButton()
		{
			SceneUtils.SafeSceneLoadedNoParam += PatchPauseMenu;
		}

		private static void PatchPauseMenu()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_00b7: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_0129: 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)
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
				where ((Object)obj).name == "Canvas"
				select obj).FirstOrDefault();
			if ((Object)(object)val == (Object)null || (Object)(object)_clickGuiToggleButton != (Object)null)
			{
				return;
			}
			GameObject val2 = UIUtils.FindRecursive(val, "PauseMenu");
			GameObject val3 = ((val2 != null) ? UIUtils.FindRecursive(val2, "Resume") : null);
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
			{
				_clickGuiToggleButton = Object.Instantiate<GameObject>(val3, val2.transform);
				((Object)_clickGuiToggleButton).name = "ThornToggleClickGUI";
				Button component = _clickGuiToggleButton.GetComponent<Button>();
				component.onClick = new ButtonClickedEvent();
				if (ClickGUI.Instance != null)
				{
					((UnityEvent)component.onClick).AddListener(new UnityAction(ClickGUI.Instance.Toggle));
				}
				GameObject val4 = UIUtils.FindRecursive(_clickGuiToggleButton, "Text");
				if ((Object)(object)val4 != (Object)null)
				{
					Object.Destroy((Object)(object)val4);
				}
				RectTransform component2 = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ThornClickGUIToggleIcon"), _clickGuiToggleButton.transform).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0.3f, 0.3f);
				component2.anchorMax = new Vector2(0.7f, 0.7f);
				UpdateAppearance();
			}
		}

		public static void UpdateAppearance()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_clickGuiToggleButton == (Object)null)
			{
				return;
			}
			RectTransform component = _clickGuiToggleButton.GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			component.sizeDelta = new Vector2(component.sizeDelta.y, component.sizeDelta.y);
			ThornModule? instance = ThornModule.Instance;
			int num;
			int num2;
			if (instance == null)
			{
				num = 0;
			}
			else
			{
				num = (instance.MenuButtonPositionForceConfiggyNicePosition.Value ? 1 : 0);
				if (num != 0)
				{
					num2 = -115;
					goto IL_0063;
				}
			}
			num2 = -107;
			goto IL_0063;
			IL_0063:
			float num3 = num2;
			((Transform)component).localPosition = new Vector3(num3, -90f, 0f);
			if (num != 0)
			{
				GameObject val = UIUtils.FindRecursive(((Component)_clickGuiToggleButton.transform.parent).gameObject, "UI_Button_Image(Clone)");
				if ((Object)(object)val != (Object)null)
				{
					RectTransform component2 = val.GetComponent<RectTransform>();
					((Transform)component2).localPosition = new Vector3(115f, ((Transform)component2).localPosition.y, ((Transform)component2).localPosition.z);
				}
			}
		}
	}
	public class ThornModule : SystemModule
	{
		public static ThornModule? Instance;

		public static Color AccentColor => Instance?.Accent.Value ?? Color.white;

		public Setting<Keybind> OpenClickGUI { get; }

		public Setting<Keybind> SwitchTabLeft { get; }

		public Setting<Keybind> SwitchTabRight { get; }

		public Setting<Color> Accent { get; }

		public Setting<bool> MenuPausesGame { get; }

		public Setting<bool> MenuButtonPositionForceConfiggyNicePosition { get; }

		public Setting<string> LastVersion { get; }

		public override bool IsEnabled => true;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "settings");

		public ThornModule()
			: base("thorn.thorn", "Thorn", "General settings")
		{
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			if (Instance != null)
			{
				return;
			}
			Instance = this;
			UserHints.Initialize();
			OpenClickGUI = CreateSetting("openClickGui", "Open menu keybind", "Keybind to open Thorn's ClickGUI interface", new Keybind((KeyCode)303, (KeyCode)0));
			OpenClickGUI.OnPress += delegate
			{
				if (ClickGUI.Instance != null)
				{
					ClickGUI.Instance.Toggle();
				}
			};
			SettingGroup parent = CreateGroup("otherBinds", "Other keybinds", "Less important keybinds are here");
			SwitchTabLeft = CreateSetting("switchTabLeft", "Switch to tab on the left", "Switch to tab on the left", new Keybind((KeyCode)280, (KeyCode)306), parent);
			SwitchTabLeft.OnPress += delegate
			{
				ClickGUI.CycleTab(-1);
			};
			SwitchTabRight = CreateSetting("switchTabRight", "Switch to tab on the right", "Switch to tab on the right", new Keybind((KeyCode)281, (KeyCode)306), parent);
			SwitchTabRight.OnPress += delegate
			{
				ClickGUI.CycleTab(1);
			};
			MenuPausesGame = CreateSetting("menuPausesGame", "Menu pauses game", "Makes the game paused when you open the ClickGUI", defaultValue: true);
			MenuButtonPositionForceConfiggyNicePosition = CreateSetting("menuButtonPosition", "Force nice menu button position", "Tries to move the Configgy button a bit so it has proper spacing", defaultValue: false);
			MenuButtonPositionForceConfiggyNicePosition.OnChanged += PauseMenuButton.UpdateAppearance;
			Accent = CreateSetting<Color>("accentColor", "Accent Color", "Color used for highlighting certain elements, preferably a bright one", new Color(0.65f, 0.95f, 0.89f));
			SettingGroup parent2 = CreateGroup("devGroup", "Developer", "Developer options, not so interesting");
			LastVersion = CreateSetting("lastVersion", "Last Thorn Version", "The version of Thorn run in the previous/current session", "0.0.0", parent2);
			CreateHeader("about", "About", "Thorn is an open-source, extensible utility mod for ULTRAKILL with a powerful configuration system.");
			ConfigButtonRow configButtonRow = CreateButtonRow("engagementButtons", "Links", "Links to Thorn stuff", new string[3] { "GitHub", "Docs 4 mod devs", "Donations" });
			configButtonRow.OnClick = (Action<int>)Delegate.Combine(configButtonRow.OnClick, (Action<int>)delegate(int i)
			{
				switch (i)
				{
				case 0:
					Application.OpenURL("https://github.com/end-4/ultrakill-thorn-client");
					break;
				case 1:
					Application.OpenURL("https://github.com/end-4/ultrakill-thorn-client/wiki");
					break;
				case 2:
					Application.OpenURL("https://github.com/sponsors/end-4");
					break;
				}
			});
			PauseMenuButton.Initialize();
		}

		public override void OnUpdate()
		{
		}
	}
	internal static class UserHints
	{
		internal static void SendLaunchNotifsIfNecessary()
		{
			ThornModule instance = ThornModule.Instance;
			if (instance != null)
			{
				Version value = new Version(instance.LastVersion.Value ?? "999.999.999");
				Version version = new Version("0.1.0");
				if (version.CompareTo(value) == 1)
				{
					instance.LastVersion.Value = version.ToString();
					NotificationSystem.NotifySend("Thorn::<color=#a5f2e2>Hello</color>", "To access the config menu, press " + instance.OpenClickGUI.Value.ToString(pretty: true), (Sprite)null, Path.Combine(Plugin.workingDir, "icon.png"), (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, 10000);
				}
				SceneManager.sceneLoaded -= SendLaunchNotifsIfNecessary;
			}
		}

		internal static void SendLaunchNotifsIfNecessary(Scene _, LoadSceneMode __)
		{
			SendLaunchNotifsIfNecessary();
		}

		internal static void Initialize()
		{
		}

		static UserHints()
		{
			SceneManager.sceneLoaded += SendLaunchNotifsIfNecessary;
		}
	}
}
namespace ThornClient.System.ClickGUIComponents
{
	internal class BoolSettingController : MonoBehaviour
	{
		public Setting<bool>? TargetSetting;

		private GameObject? _checkMark;

		private void Start()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleSetting));
			if (TargetSetting != null)
			{
				Setting<bool>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<bool>)Delegate.Combine(targetSetting.OnValueChanged, new Action<bool>(UpdateCheckmark));
				_checkMark = UIUtils.FindRecursive(((Component)this).gameObject, "Checkbox/Mark");
				UpdateCheckmark(TargetSetting.Value);
			}
		}

		private void OnDestroy()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).RemoveListener(new UnityAction(ToggleSetting));
			if (TargetSetting != null)
			{
				Setting<bool>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<bool>)Delegate.Remove(targetSetting.OnValueChanged, new Action<bool>(UpdateCheckmark));
			}
		}

		private void ToggleSetting()
		{
			if (TargetSetting != null)
			{
				TargetSetting.Value = !TargetSetting.Value;
			}
		}

		private void UpdateCheckmark(bool value)
		{
			if ((Object)(object)_checkMark != (Object)null)
			{
				_checkMark.SetActive(value);
			}
		}
	}
	internal class ButtonRowSettingController : MonoBehaviour
	{
		public ConfigButtonRow? TargetButtonRow;

		private void Start()
		{
			if (TargetButtonRow != null)
			{
				Populate();
			}
		}

		private void Populate()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			if (TargetButtonRow == null)
			{
				return;
			}
			for (int i = 0; i < TargetButtonRow.Texts.Count; i++)
			{
				string text = TargetButtonRow.Texts[i];
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ButtonRowButton"), ((Component)this).transform);
				GameObject val = UIUtils.FindRecursive(obj, "Text");
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text = text;
				}
				int iCopied = i;
				((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					Trigger(iCopied);
				});
			}
		}

		private void Trigger(int idx)
		{
			if (TargetButtonRow != null)
			{
				TargetButtonRow.OnClick?.Invoke(idx);
			}
		}
	}
	internal class ClickGUITooltipHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public string Text = "";

		public void OnPointerEnter(PointerEventData eventData)
		{
			ClickGUI.SetTooltipText(Text);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			ClickGUI.SurrenderTooltipText(Text);
		}
	}
	public class Colorizer : MonoBehaviour
	{
		private TextMeshProUGUI? _textComp;

		private Image? _imageComp;

		private Color? _overrideColor;

		private Color? _overrideNormalColor;

		private bool _highlighted;

		public Color HighlightColor
		{
			get
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				return (Color)(((??)_overrideColor) ?? ThornModule.Instance.Accent.Value);
			}
			set
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_imageComp == (Object)null)
				{
					_overrideColor = value;
				}
			}
		}

		public Color NormalColor
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				return (Color)(((??)_overrideNormalColor) ?? Color.white);
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				_overrideNormalColor = value;
			}
		}

		public bool Highlighted
		{
			get
			{
				return _highlighted;
			}
			set
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: 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_002d: 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)
				_highlighted = value;
				Color color = (value ? HighlightColor : NormalColor);
				if ((Object)(object)_textComp != (Object)null)
				{
					((Graphic)_textComp).color = color;
				}
				else if ((Object)(object)_imageComp != (Object)null)
				{
					((Graphic)_imageComp).color = color;
				}
			}
		}

		private void Start()
		{
			_textComp = ((Component)this).GetComponent<TextMeshProUGUI>();
			_imageComp = ((Component)this).GetComponent<Image>();
			if (!_overrideColor.HasValue)
			{
				ThornModule.Instance.Accent.OnChanged += UpdateHighlight;
			}
			UpdateHighlight();
		}

		private void OnDestroy()
		{
			if (!_overrideColor.HasValue)
			{
				ThornModule.Instance.Accent.OnChanged -= UpdateHighlight;
			}
		}

		private void UpdateHighlight()
		{
			Highlighted = _highlighted;
		}
	}
	internal class ColorSettingController : MonoBehaviour
	{
		public Setting<Color>? TargetSetting;

		private Image? _colorPreview;

		private TMP_InputField? _hexInput;

		private Slider?[] _sliders;

		private TMP_InputField?[] _valueInputs;

		private void Start()
		{
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			if (TargetSetting == null)
			{
				return;
			}
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/PreviewColumn/ColorBorder/ColorPreview");
			_colorPreview = ((obj != null) ? obj.GetComponent<Image>() : null);
			GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/PreviewColumn/HexInput");
			_hexInput = ((obj2 != null) ? obj2.GetComponent<TMP_InputField>() : null);
			Slider[] array = new Slider[4];
			GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Red/Slider");
			array[0] = ((obj3 != null) ? obj3.GetComponent<Slider>() : null);
			GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Green/Slider");
			array[1] = ((obj4 != null) ? obj4.GetComponent<Slider>() : null);
			GameObject obj5 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Blue/Slider");
			array[2] = ((obj5 != null) ? obj5.GetComponent<Slider>() : null);
			GameObject obj6 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Alpha/Slider");
			array[3] = ((obj6 != null) ? obj6.GetComponent<Slider>() : null);
			_sliders = (Slider?[])(object)array;
			TMP_InputField[] array2 = new TMP_InputField[4];
			GameObject obj7 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Red/Input");
			array2[0] = ((obj7 != null) ? obj7.GetComponent<TMP_InputField>() : null);
			GameObject obj8 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Green/Input");
			array2[1] = ((obj8 != null) ? obj8.GetComponent<TMP_InputField>() : null);
			GameObject obj9 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Blue/Input");
			array2[2] = ((obj9 != null) ? obj9.GetComponent<TMP_InputField>() : null);
			GameObject obj10 = UIUtils.FindRecursive(((Component)this).gameObject, "PickerRow/ValueColumn/Alpha/Input");
			array2[3] = ((obj10 != null) ? obj10.GetComponent<TMP_InputField>() : null);
			_valueInputs = (TMP_InputField?[])(object)array2;
			if ((Object)(object)_hexInput != (Object)null)
			{
				((UnityEvent<string>)(object)_hexInput.onEndEdit).AddListener((UnityAction<string>)TrySaveNewHex);
				ComponentExtensions.GetOrAddComponent<InputFocusGrab>((Component)(object)_hexInput);
			}
			for (int i = 0; i < _sliders.Length; i++)
			{
				Slider val = _sliders[i];
				if ((Object)(object)val != (Object)null)
				{
					val.minValue = 0f;
					val.maxValue = 1f;
					int i2 = i;
					((UnityEvent<float>)(object)val.onValueChanged).AddListener((UnityAction<float>)delegate(float value)
					{
						TrySaveNewValue(value, i2);
					});
				}
			}
			for (int num = 0; num < _valueInputs.Length; num++)
			{
				TMP_InputField val2 = _valueInputs[num];
				ComponentExtensions.GetOrAddComponent<InputFocusGrab>((Component)(object)val2);
				if (!((Object)(object)val2 != (Object)null))
				{
					continue;
				}
				int i3 = num;
				((UnityEvent<string>)(object)val2.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
				{
					if (int.TryParse(s, out var result))
					{
						TrySaveNewValue((float)result / 255f, i3);
					}
				});
			}
			Setting<Color>? targetSetting = TargetSetting;
			targetSetting.OnValueChanged = (Action<Color>)Delegate.Combine(targetSetting.OnValueChanged, new Action<Color>(UpdateDisplay));
			UpdateDisplay(TargetSetting.Value);
		}

		private void TrySaveNewHex(string hex)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00a7: 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_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)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (TargetSetting != null)
			{
				if (!hex.StartsWith("#"))
				{
					hex = "#" + hex;
				}
				Color val = default(Color);
				if (ColorUtility.TryParseHtmlString(hex, ref val))
				{
					TargetSetting.Value = new Color(val.r, val.g, val.b, TargetSetting.Value.a);
				}
				else
				{
					TargetSetting.Value = new Color(TargetSetting.Value.r, TargetSetting.Value.g, TargetSetting.Value.b, TargetSetting.Value.a);
				}
				UpdateDisplay(TargetSetting.Value);
			}
		}

		private void TrySaveNewValue(float value, int index)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (TargetSetting != null)
			{
				float[] source = new float[4] { 0f, 1f, 2f, 3f };
				source = source.Select((float i) => ((int)i != index) ? ColorUtils.GetValues(TargetSetting.Value)[(int)i] : value).ToArray();
				TargetSetting.Value = new Color(source[0], source[1], source[2], source[3]);
			}
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				Setting<Color>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<Color>)Delegate.Remove(targetSetting.OnValueChanged, new Action<Color>(UpdateDisplay));
			}
		}

		private void UpdateDisplay(Color col)
		{
			//IL_0023: 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)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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)
			if (TargetSetting == null)
			{
				return;
			}
			if ((Object)(object)_colorPreview != (Object)null)
			{
				((Graphic)_colorPreview).color = TargetSetting.Value;
			}
			if ((Object)(object)_hexInput != (Object)null)
			{
				_hexInput.text = ColorUtility.ToHtmlStringRGB(col);
			}
			float[] array = new float[4] { col.r, col.g, col.b, col.a };
			for (int i = 0; i < _sliders.Length; i++)
			{
				Slider val = _sliders[i];
				if ((Object)(object)val != (Object)null)
				{
					val.value = array[i];
				}
			}
			for (int j = 0; j < _valueInputs.Length; j++)
			{
				TMP_InputField val2 = _valueInputs[j];
				if ((Object)(object)val2 != (Object)null)
				{
					val2.text = $"{(int)(255f * array[j])}";
				}
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}
	}
	public static class ConfigurableElementUICreators
	{
		public static readonly Dictionary<SettingType, Func<Setting, Transform, GameObject>> SettingUICreators = new Dictionary<SettingType, Func<Setting, Transform, GameObject>>
		{
			[SettingType.Bind] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "KeybindSetting"), parent);
				obj.AddComponent<KeybindSettingController>().TargetSetting = (Setting<Keybind>)setting;
				return obj;
			},
			[SettingType.Bool] = delegate(Setting setting, Transform parent)
			{
				InterfaceHints? hints = setting.Hints;
				if ((object)hints != null && hints.BoolPreferCheckmark == true)
				{
					GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "BoolSetting"), parent);
					obj.AddComponent<BoolSettingController>().TargetSetting = (Setting<bool>)setting;
					return obj;
				}
				GameObject obj2 = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "SwitchBoolSetting"), parent);
				obj2.AddComponent<SwitchBoolSettingController>().TargetSetting = (Setting<bool>)setting;
				return obj2;
			},
			[SettingType.Color] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ColorSetting"), parent);
				obj.AddComponent<ColorSettingController>().TargetSetting = (Setting<Color>)setting;
				return obj;
			},
			[SettingType.EnemyList] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "EnemyListSetting"), parent);
				obj.AddComponent<EnemyListSettingController>().TargetSetting = (Setting<EnemyList>)setting;
				return obj;
			},
			[SettingType.Enum] = delegate(Setting setting, Transform parent)
			{
				int num = Enum.GetNames(setting.GetValue().GetType()).Sum((string name) => name.Length);
				InterfaceHints? hints = setting.Hints;
				if ((object)hints == null || hints.EnumPreferButtonGroup != true)
				{
					if (num <= 20)
					{
						InterfaceHints? hints2 = setting.Hints;
						if ((object)hints2 == null || hints2.EnumPreferButtonGroup != false)
						{
							goto IL_007f;
						}
					}
					GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "DropdownSetting"), parent);
					obj.AddComponent<DropdownSettingController>().TargetSetting = setting;
					return obj;
				}
				goto IL_007f;
				IL_007f:
				GameObject obj2 = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ConnectedButtonGroupSetting"), parent);
				obj2.AddComponent<ConnectedButtonGroupSettingController>().TargetSetting = setting;
				return obj2;
			},
			[SettingType.Float] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "NumberSetting"), parent);
				obj.AddComponent<FloatSettingController>().TargetSetting = (Setting<float>)setting;
				return obj;
			},
			[SettingType.Int] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "NumberSetting"), parent);
				obj.AddComponent<IntSettingController>().TargetSetting = (Setting<int>)setting;
				return obj;
			},
			[SettingType.Text] = delegate(Setting setting, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "TextSetting"), parent);
				obj.AddComponent<TextSettingController>().TargetSetting = (Setting<string>)setting;
				return obj;
			}
		};

		public static readonly Dictionary<Type, Func<IConfigurableElement, Transform, GameObject>> MenuUICreators = new Dictionary<Type, Func<IConfigurableElement, Transform, GameObject>>
		{
			[typeof(ConfigButtonRow)] = delegate(IConfigurableElement configurableElement, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ButtonRowSetting"), parent);
				obj.AddComponent<ButtonRowSettingController>().TargetButtonRow = (ConfigButtonRow)configurableElement;
				return obj;
			},
			[typeof(SettingGroup)] = delegate(IConfigurableElement configurableElement, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "WindowedGroupSetting"), parent);
				obj.AddComponent<WindowedGroupSettingController>().TargetGroup = (SettingGroup)configurableElement;
				return obj;
			},
			[typeof(ConfigHeader)] = delegate(IConfigurableElement configurableElement, Transform parent)
			{
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "HeaderSetting"), parent);
				obj.AddComponent<HeaderSettingController>().TargetElement = (ConfigHeader)configurableElement;
				return obj;
			}
		};
	}
	internal class ConfigurableWindowController : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__NavigateBack;
		}

		private bool _doneSetup;

		public bool IsPopup;

		public Configurable? TargetConfigurable;

		private void Start()
		{
			SetupStuff();
		}

		public void SetupStuff()
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			if (_doneSetup)
			{
				return;
			}
			_doneSetup = true;
			if (TargetConfigurable == null)
			{
				return;
			}
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton/TitleIcon");
			Image val = ((obj != null) ? obj.GetComponent<Image>() : null);
			GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleName");
			TextMeshProUGUI obj3 = ((obj2 != null) ? obj2.GetComponent<TextMeshProUGUI>() : null);
			if (TargetConfigurable is ThornClient.Core.Module module && (Object)(object)val != (Object)null)
			{
				val.sprite = module.Icon;
			}
			((TMP_Text)obj3).text = TargetConfigurable.Name;
			GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "Header");
			if (obj4 != null)
			{
				obj4.AddComponent<TitlebarDragHandler>();
			}
			GameObject obj5 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton");
			Button val2 = ((obj5 != null) ? obj5.GetComponent<Button>() : null);
			((Selectable)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton").GetComponent<Button>()).interactable = IsPopup;
			GameObject obj6 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton/BackIcon");
			if (obj6 != null)
			{
				obj6.SetActive(IsPopup);
			}
			if (IsPopup)
			{
				ButtonClickedEvent onClick = val2.onClick;
				object obj7 = <>O.<0>__NavigateBack;
				if (obj7 == null)
				{
					UnityAction val3 = ClickGUI.NavigateBack;
					<>O.<0>__NavigateBack = val3;
					obj7 = (object)val3;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj7);
			}
			Transform transform = UIUtils.FindRecursive(((Component)this).gameObject, "Scroll View/Viewport/Content/Modules").transform;
			((TMP_Text)UIUtils.FindRecursive(Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ModuleDescription"), transform), "DescText").GetComponent<TextMeshProUGUI>()).text = TargetConfigurable.Description;
			if (!(TargetConfigurable is SystemModule))
			{
				Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "EnabledButton"), transform).AddComponent<EnabledButtonController>().Configurable = TargetConfigurable;
			}
			if (TargetConfigurable is HudModule hudModule)
			{
				HudElementPositioningController hudElementPositioningController = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "RemoteDrag"), transform).AddComponent<HudElementPositioningController>();
				hudElementPositioningController.TargetModule = hudModule;
				if ((Object)(object)hudModule.UIElement != (Object)null)
				{
					ref RectTransform? target = ref hudElementPositioningController.target;
					Transform transform2 = hudModule.UIElement.transform;
					target = (RectTransform?)(object)((transform2 is RectTransform) ? transform2 : null);
				}
			}
			Populate(transform, TargetConfigurable.Elements);
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private void Populate(Transform parent, IEnumerable<IConfigurableElement> elements)
		{
			foreach (IConfigurableElement element in elements)
			{
				GameObject val = null;
				if (element is Setting setting)
				{
					val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "SettingRowWrapper"), parent);
					val.AddComponent<SettingRowController>().TargetSetting = setting;
					if (ConfigurableElementUICreators.SettingUICreators.TryGetValue(setting.Type, out Func<Setting, Transform, GameObject> value))
					{
						value(setting, val.transform).AddComponent<SettingDescriptionController>().TargetSetting = setting;
					}
				}
				else if ((element is SettingGroup || element is ConfigButtonRow || element is ConfigHeader) ? true : false)
				{
					val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "SettingRowWrapper"), parent);
					if (ConfigurableElementUICreators.MenuUICreators.TryGetValue(element.GetType(), out Func<IConfigurableElement, Transform, GameObject> value2))
					{
						GameObject val2 = value2(element, val.transform);
						if (!(element is ConfigHeader))
						{
							val2.AddComponent<SettingDescriptionController>().TargetSetting = element;
						}
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					UIUtils.UnfuckLayoutHack(val);
					if (element.Hints?.Hidden == true)
					{
						val.SetActive(false);
					}
				}
			}
		}
	}
	internal class ConnectedButtonGroupSettingController : MonoBehaviour
	{
		private Type? _enumType;

		private GameObject? _btnRow;

		private string[] _enumNames = Array.Empty<string>();

		private readonly List<(Image image, TMP_Text text)> _cachedButtons = new List<(Image, TMP_Text)>();

		public Setting? TargetSetting { get; set; }

		private void Start()
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			if (TargetSetting == null)
			{
				return;
			}
			object value = TargetSetting.GetValue();
			_enumType = value.GetType();
			if (!_enumType.IsEnum)
			{
				Plugin.Log.LogError((object)("[EnumSettingController] Setting " + TargetSetting.Name + " is not an enum!"));
				return;
			}
			TargetSetting.OnChanged += UpdateDisplay;
			_btnRow = UIUtils.FindRecursive(((Component)this).gameObject, "ButtonRow");
			if ((Object)(object)_btnRow != (Object)null)
			{
				_enumNames = Enum.GetNames(_enumType);
				_cachedButtons.Clear();
				for (int i = 0; i < _enumNames.Length; i++)
				{
					GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ConnectedChoiceButton"), _btnRow.transform);
					TMP_Text component = UIUtils.FindRecursive(obj, "Text").GetComponent<TMP_Text>();
					Image component2 = obj.GetComponent<Image>();
					component.text = _enumNames[i];
					_cachedButtons.Add((component2, component));
					int i2 = i;
					((UnityEvent)obj.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						TargetSetting.SetValue(Enum.Parse(_enumType, _enumNames[i2]));
					});
				}
			}
			UpdateDisplay();
		}

		private void UpdateDisplay()
		{
			//IL_008b: 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_0090: 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_0096: 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_00b6: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			if (TargetSetting == null || _enumType == null || _cachedButtons.Count == 0)
			{
				return;
			}
			string text = TargetSetting.GetValue().ToString();
			int count = _cachedButtons.Count;
			for (int i = 0; i < count; i++)
			{
				(Image image, TMP_Text text) tuple = _cachedButtons[i];
				Image item = tuple.image;
				TMP_Text item2 = tuple.text;
				bool flag = _enumNames[i] == text;
				bool atLeft = i == 0;
				bool atRight = i == count - 1;
				Color val = (flag ? ThornModule.AccentColor : Color.white);
				Color val2 = (flag ? Color.black : Color.white);
				item.sprite = GetSprite(atLeft, atRight, flag);
				if (((Graphic)item).color != val)
				{
					((Graphic)item).color = val;
				}
				if (((Graphic)item2).color != val2)
				{
					((Graphic)item2).color = val2;
				}
			}
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				TargetSetting.OnChanged -= UpdateDisplay;
			}
		}

		public static Sprite GetSprite(bool atLeft, bool atRight, bool active)
		{
			string assetName = ((atLeft || atRight) ? "Round_" : "") + (active ? "Fill" : "Border") + "Large" + (atLeft ? "Left" : (atRight ? "Right" : ""));
			return AssetManager.Get<Sprite>(ClickGUI.BundleKey, assetName);
		}
	}
	internal class DropdownSettingController : MonoBehaviour
	{
		private TMP_Dropdown? _dropdown;

		private Type? _enumType;

		public Setting? TargetSetting { get; set; }

		private void Start()
		{
			if (TargetSetting == null)
			{
				return;
			}
			object value = TargetSetting.GetValue();
			_enumType = value.GetType();
			if (!_enumType.IsEnum)
			{
				Plugin.Log.LogError((object)("[EnumSettingController] Setting " + TargetSetting.Name + " is not an enum!"));
				return;
			}
			_dropdown = UIUtils.FindRecursive(((Component)this).gameObject, "Dropdown").GetComponent<TMP_Dropdown>();
			if ((Object)(object)_dropdown != (Object)null)
			{
				string[] names = Enum.GetNames(_enumType);
				_dropdown.ClearOptions();
				_dropdown.AddOptions(names.ToList());
				((UnityEvent<int>)(object)_dropdown.onValueChanged).AddListener((UnityAction<int>)OnDropdownValueChanged);
			}
			UpdateDisplay();
			TargetSetting.OnChanged += UpdateDisplay;
		}

		private void UpdateDisplay()
		{
			if (TargetSetting != null && !((Object)(object)_dropdown == (Object)null) && !(_enumType == null))
			{
				object value = TargetSetting.GetValue();
				int num = Array.IndexOf<string>(Enum.GetNames(_enumType), value.ToString());
				if (num >= 0)
				{
					_dropdown.value = num;
					_dropdown.RefreshShownValue();
				}
			}
		}

		private void OnDropdownValueChanged(int index)
		{
			string text = _dropdown.options[index].text;
			object value = Enum.Parse(_enumType, text);
			TargetSetting?.SetValue(value);
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				TargetSetting.OnChanged -= UpdateDisplay;
			}
			if ((Object)(object)_dropdown != (Object)null)
			{
				((UnityEvent<int>)(object)_dropdown.onValueChanged).RemoveListener((UnityAction<int>)OnDropdownValueChanged);
			}
		}
	}
	internal class EnabledButtonController : MonoBehaviour
	{
		public Configurable? Configurable;

		private TextMeshProUGUI? _textComp;

		private Image? _buttonImageComp;

		private Colorizer? _colorizer;

		private void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (Configurable != null)
			{
				((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleIt));
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Text");
				_textComp = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				_buttonImageComp = ((Component)this).gameObject.GetComponent<Image>();
				_colorizer = GameObjectExtensions.GetOrAddComponent<Colorizer>(((Component)this).gameObject);
				Configurable.OnToggleStateChanged += UpdateAppearance;
				UpdateAppearance(Configurable.IsEnabled);
			}
		}

		private void OnDestroy()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (Configurable != null)
			{
				((UnityEvent)((Component)this).GetComponent<Button>().onClick).RemoveListener(new UnityAction(ToggleIt));
				Configurable.OnToggleStateChanged -= UpdateAppearance;
			}
		}

		private void ToggleIt()
		{
			Configurable?.Toggle();
		}

		private void UpdateAppearance(bool isEnabled)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_textComp != (Object)null)
			{
				((TMP_Text)_textComp).text = (isEnabled ? "Enabled" : "Disabled");
				((Graphic)_textComp).color = (isEnabled ? Color.black : Color.white);
			}
			if ((Object)(object)_buttonImageComp != (Object)null)
			{
				_buttonImageComp.sprite = AssetManager.Get<Sprite>(ClickGUI.BundleKey, isEnabled ? "Round_FillLarge" : "Round_BorderLarge");
			}
			if ((Object)(object)_colorizer != (Object)null)
			{
				_colorizer.Highlighted = isEnabled;
			}
		}
	}
	internal class EnemyListController : MonoBehaviour
	{
		private bool _doneSetup;

		public bool IsPopup = true;

		public Setting<EnemyList>? TargetList;

		private Transform? _falseList;

		private Transform? _trueList;

		private void Start()
		{
			UIUtils.FindRecursive(((Component)this).gameObject, "Header").AddComponent<TitlebarDragHandler>();
			SetupModules();
		}

		public void SetupModules()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (_doneSetup)
			{
				return;
			}
			_doneSetup = true;
			if (TargetList != null)
			{
				((TMP_Text)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleName").GetComponent<TextMeshProUGUI>()).text = TargetList.Name;
				((UnityEvent)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton").GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				});
				_falseList = UIUtils.FindRecursive(((Component)this).gameObject, "Columns/FalseScrollView/Viewport/Content").transform;
				_trueList = UIUtils.FindRecursive(((Component)this).gameObject, "Columns/TrueScrollView/Viewport/Content").transform;
				PopulateLists();
				Setting<EnemyList>? targetList = TargetList;
				targetList.OnValueChanged = (Action<EnemyList>)Delegate.Combine(targetList.OnValueChanged, (Action<EnemyList>)delegate
				{
					PopulateLists();
				});
			}
		}

		private void OnDestroy()
		{
			if (TargetList != null)
			{
				Setting<EnemyList>? targetList = TargetList;
				targetList.OnValueChanged = (Action<EnemyList>)Delegate.Remove(targetList.OnValueChanged, (Action<EnemyList>)delegate
				{
					PopulateLists();
				});
			}
		}

		private unsafe void PopulateLists()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			if (TargetList == null || (Object)(object)_falseList == (Object)null || (Object)(object)_trueList == (Object)null)
			{
				return;
			}
			foreach (Transform @false in _falseList)
			{
				Object.Destroy((Object)(object)((Component)@false).gameObject);
			}
			foreach (Transform @true in _trueList)
			{
				Object.Destroy((Object)(object)((Component)@true).gameObject);
			}
			foreach (EnemyType enemyType in ((EnemyType[])Enum.GetValues(typeof(EnemyType))).OrderBy((EnemyType e) => ((object)(*(EnemyType*)(&e))/*cast due to .constrained prefix*/).ToString()))
			{
				bool flag = TargetList.Value.Includes(enemyType);
				Transform val = (flag ? _trueList : _falseList);
				GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "EnemyListItem"), val);
				UIUtils.FindRecursive(obj, "Icon").AddComponent<EnemyIconController>().enemyType = enemyType;
				((TMP_Text)UIUtils.FindRecursive(obj, "Name").GetComponent<TextMeshProUGUI>()).text = ((object)Unsafe.As<EnemyType, EnemyType>(ref enemyType)/*cast due to .constrained prefix*/).ToString();
				UIUtils.FindRecursive(obj, "ToggleButton/Icon").GetComponent<Image>().sprite = AssetManager.Get<Sprite>(ClickGUI.BundleKey, flag ? "minus" : "plus");
				((UnityEvent)UIUtils.FindRecursive(obj, "ToggleButton").GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					OnItemClick(enemyType);
				});
				UIUtils.UnfuckLayoutHack(obj);
			}
			UIUtils.UnfuckLayoutHack(((Component)_falseList).gameObject);
			UIUtils.UnfuckLayoutHack(((Component)_trueList).gameObject);
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private void OnItemClick(EnemyType enemyType)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (TargetList != null)
			{
				EnemyList enemyList = TargetList.Value.Clone();
				enemyList.Toggle(enemyType);
				TargetList.Value = enemyList;
			}
		}
	}
	internal class EnemyListSettingController : MonoBehaviour
	{
		public Setting<EnemyList>? TargetSetting;

		private TextMeshProUGUI? text;

		private void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (TargetSetting != null)
			{
				((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener(new UnityAction(OpenList));
				text = UIUtils.FindRecursive(((Component)this).gameObject, "Name").GetComponent<TextMeshProUGUI>();
				Setting<EnemyList>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<EnemyList>)Delegate.Combine(targetSetting.OnValueChanged, new Action<EnemyList>(UpdateText));
				UpdateText(TargetSetting.Value);
			}
		}

		private void UpdateText(EnemyList elist)
		{
			if ((Object)(object)text != (Object)null && TargetSetting != null)
			{
				((TMP_Text)text).text = $"{TargetSetting.Name} ({elist.Count()})";
			}
		}

		private void OnDestroy()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			if (TargetSetting != null)
			{
				Setting<EnemyList>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<EnemyList>)Delegate.Remove(targetSetting.OnValueChanged, new Action<EnemyList>(UpdateText));
			}
			Button component = ((Component)this).GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEvent)component.onClick).RemoveListener(new UnityAction(OpenList));
			}
		}

		private void OpenList()
		{
			GameObject val = CreateConfigPanel(TargetSetting);
			if ((Object)(object)val != (Object)null)
			{
				ClickGUI.SpawnContent(val);
			}
			ClickGUI.SurrenderTooltipText(TargetSetting?.Description ?? "");
		}

		private GameObject? CreateConfigPanel(Setting<EnemyList>? setting)
		{
			GameObject val = AssetManager.Get<GameObject>(ClickGUI.BundleKey, "EnemyList");
			if ((Object)(object)val == (Object)null || setting == null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			EnemyListController orAddComponent = GameObjectExtensions.GetOrAddComponent<EnemyListController>(val2);
			orAddComponent.IsPopup = true;
			orAddComponent.TargetList = setting;
			return val2;
		}
	}
	internal class FloatSettingController : NumberSettingController<float>
	{
		protected override void UpdateScrub(float baseValue, float valueDiff)
		{
			if (TargetSetting != null)
			{
				TargetSetting.Value = baseValue + valueDiff;
			}
		}
	}
	internal class FreeMoveDragHandler : MonoBehaviour, IDragHandler, IEventSystemHandler
	{
		public RectTransform? target;

		protected Canvas? _canvas;

		private void Awake()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			try
			{
				if ((Object)(object)target == (Object)null)
				{
					target = (RectTransform)((Component)this).transform;
				}
				_canvas = ((Component)target).GetComponentInParent<Canvas>();
			}
			catch (Exception)
			{
				Plugin.Log.LogWarning((object)"[FreeMoveDragHandler] may have been added to a root element");
			}
		}

		public virtual void OnDrag(PointerEventData eventData)
		{
			//IL_0031: 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_003c: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				float num = (((Object)(object)_canvas != (Object)null) ? _canvas.scaleFactor : 1f);
				Vector2 val = eventData.delta / num;
				RectTransform? obj = target;
				obj.anchoredPosition += val;
			}
		}
	}
	internal class HeaderSettingController : MonoBehaviour
	{
		public ConfigHeader? TargetElement;

		private void Start()
		{
			if (TargetElement != null)
			{
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Name", false);
				TextMeshProUGUI val = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)val).text = TargetElement.Name;
					((TMP_Text)val).fontSize = TargetElement.FontSize;
				}
				GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "DescLayout/Description", false);
				TextMeshProUGUI val2 = ((obj2 != null) ? obj2.GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					((TMP_Text)val2).text = TargetElement.Description;
				}
				GameObject val3 = UIUtils.FindRecursive(((Component)((Component)this).transform.parent).gameObject, "RevertButtonWrapper");
				if ((Object)(object)val3 != (Object)null)
				{
					val3.SetActive(false);
				}
			}
		}
	}
	internal class InputFocusGrab : MonoBehaviour
	{
		private TMP_InputField? _input;

		private void OnEnable()
		{
			_input = ((Component)this).gameObject.GetComponent<TMP_InputField>();
			if (!((Object)(object)_input == (Object)null))
			{
				((UnityEvent<string>)(object)_input.onSelect).AddListener((UnityAction<string>)Grab);
				((UnityEvent<string>)(object)_input.onDeselect).AddListener((UnityAction<string>)Release);
			}
		}

		private void OnDisable()
		{
			if (!((Object)(object)_input == (Object)null))
			{
				((UnityEvent<string>)(object)_input.onSelect).RemoveListener((UnityAction<string>)Grab);
				((UnityEvent<string>)(object)_input.onDeselect).RemoveListener((UnityAction<string>)Release);
			}
		}

		private void Grab(string _)
		{
			InputManager.BlockInput = true;
		}

		private void Release(string _)
		{
			InputManager.BlockInput = false;
		}
	}
	internal class IntSettingController : NumberSettingController<int>
	{
		protected override void UpdateScrub(int baseValue, float valueDiff)
		{
			if (TargetSetting != null)
			{
				TargetSetting.Value = (int)((float)baseValue + valueDiff);
			}
		}
	}
	internal class KeybindSettingController : MonoBehaviour
	{
		private const string PauseKey = "Thorn_ClickGUI_KeybindListener";

		private static readonly Color NormalColor = new Color(1f, 1f, 1f);

		private static KeybindSettingController? _listeningInstance = null;

		private Button? _activateButton;

		private Colorizer? _keyBorder;

		private TextMeshProUGUI? _displayText;

		public Setting<Keybind> TargetSetting;

		private KeyCode _caughtModifier;

		private KeyCode _caughtKey;

		private static Color ListeningColor => (Color)(((??)ThornModule.Instance?.Accent.Value) ?? new Color(1f, 0.4048f, 0f));

		private static OptionsManager? opts => MonoSingleton<OptionsManager>.Instance;

		private void Start()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			_activateButton = ((Component)this).gameObject.GetComponent<Button>();
			_keyBorder = GameObjectExtensions.GetOrAddComponent<Colorizer>(UIUtils.FindRecursive(((Component)this).gameObject, "ValueDisplay"));
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "ValueDisplay/Text");
			_displayText = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
			((UnityEvent)_activateButton.onClick).AddListener(new UnityAction(ActivateKeyListen));
			UpdateKeyDisplay();
			Setting<Keybind> targetSetting = TargetSetting;
			targetSetting.OnValueChanged = (Action<Keybind>)Delegate.Combine(targetSetting.OnValueChanged, new Action<Keybind>(UpdateKeyDisplay));
		}

		private void SetBorderColor(bool highlighted)
		{
			if (!((Object)(object)_keyBorder == (Object)null))
			{
				_keyBorder.Highlighted = highlighted;
			}
		}

		private void ActivateKeyListen()
		{
			//IL_0038: 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)
			InputManager.BlockInput = true;
			Pauser.Pause(true, "Thorn_ClickGUI_KeybindListener");
			if ((Object)(object)_listeningInstance != (Object)null)
			{
				_listeningInstance.SetBorderColor(highlighted: false);
			}
			_listeningInstance = this;
			SetBorderColor(highlighted: true);
			_caughtModifier = (KeyCode)0;
			_caughtKey = (KeyCode)0;
		}

		private void DeactivateKeyListen()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			InputManager.BlockInput = false;
			GameStateManager.Instance.PopState("Thorn_ClickGUI_KeybindListener");
			if (IsListening())
			{
				_listeningInstance = null;
				SetBorderColor(highlighted: false);
				if ((int)_caughtModifier != 0 && (int)_caughtKey == 0)
				{
					_caughtKey = _caughtModifier;
					_caughtModifier = (KeyCode)0;
				}
				TargetSetting.Value = new Keybind(_caughtKey, _caughtModifier);
			}
		}

		private bool IsListening()
		{
			return (Object)(object)_listeningInstance == (Object)(object)this;
		}

		private unsafe void UpdateKeyDisplay()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_003d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			bool num = IsListening();
			KeyCode val = (num ? _caughtModifier : TargetSetting.Value.Modifier);
			KeyCode val2 = (num ? _caughtKey : TargetSetting.Value.Key);
			if ((int)val != 0)
			{
				text += ((object)(*(KeyCode*)(&val))/*cast due to .constrained prefix*/).ToString();
			}
			if ((int)val2 != 0)
			{
				if (text.Length > 0)
				{
					text += "+";
				}
				text += ((object)(*(KeyCode*)(&val2))/*cast due to .constrained prefix*/).ToString();
			}
			if (text.Length == 0)
			{
				text = "--";
			}
			if (((TMP_Text)_displayText).text != text)
			{
				((TMP_Text)_displayText).text = text;
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private void UpdateKeyDisplay(Keybind _)
		{
			UpdateKeyDisplay();
		}

		private void OnDestroy()
		{
			DeactivateKeyListen();
			Setting<Keybind> targetSetting = TargetSetting;
			targetSetting.OnValueChanged = (Action<Keybind>)Delegate.Remove(targetSetting.OnValueChanged, new Action<Keybind>(UpdateKeyDisplay));
		}

		private void OnGUI()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0018: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0087: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0095: Invalid comparison between Unknown and I4
			//IL_0068: 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_007a: 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_0071: 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)
			if (!IsListening())
			{
				return;
			}
			Event current = Event.current;
			if (current.isKey && (int)current.keyCode == 0)
			{
				return;
			}
			if ((int)current.keyCode == 27)
			{
				DeactivateKeyListen();
				return;
			}
			EventType type = current.type;
			if (((int)type == 0 || (int)type == 4 || (int)type == 6) ? true : false)
			{
				KeyCode val = current.keyCode;
				if (current.isMouse)
				{
					val = (KeyCode)(323 + current.button);
				}
				if (KeyUtils.IsModifier(val))
				{
					_caughtModifier = val;
				}
				else
				{
					_caughtKey = val;
				}
				UpdateKeyDisplay();
			}
			type = current.type;
			if (((int)type == 1 || type - 5 <= 1) ? true : false)
			{
				DeactivateKeyListen();
			}
		}
	}
	internal class ModuleButtonController : MonoBehaviour, IPointerClickHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler, ISelectHandler, IDeselectHandler
	{
		public ThornClient.Core.Module? TargetModule;

		private Colorizer? _iconColorizer;

		private Colorizer? _textColorizer;

		private GameObject? _settingIcon;

		private void Start()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_0172: 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_012e: Expected O, but got Unknown
			if (TargetModule == null)
			{
				Plugin.Log.LogWarning((object)"[ModuleButtonController] TargetModule not assigned!");
				return;
			}
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Icon");
			Image val = ((obj != null) ? obj.GetComponent<Image>() : null);
			try
			{
				if ((Object)(object)val != (Object)null)
				{
					val.sprite = TargetModule.Icon;
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Failed to load icon for module '{TargetModule.Name}': {arg}");
			}
			GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Name");
			TextMeshProUGUI val2 = ((obj2 != null) ? obj2.GetComponent<TextMeshProUGUI>() : null);
			if (val2 != null)
			{
				((TMP_Text)val2).SetText(TargetModule.Name, true);
			}
			((UnityEvent)((Component)this).gameObject.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				TargetModule.Toggle();
			});
			_settingIcon = UIUtils.FindRecursive(((Component)this).gameObject, "ConfigButton/Icon");
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(false);
			}
			GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "ConfigButton");
			Button val3 = ((obj3 != null) ? obj3.GetComponent<Button>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
				{
					ClickGUI.NestConfigPanel(TargetModule);
				});
			}
			string name = TargetModule.GetType().Assembly.GetName().Name;
			((Component)this).gameObject.AddComponent<ClickGUITooltipHandler>().Text = TargetModule.Description + "<size=8>\n\n</size><size=10>[<color=#" + ColorUtility.ToHtmlStringRGB(ThornModule.AccentColor) + ">" + name + "</color>]</size>";
			UIUtils.FindRecursive(((Component)this).gameObject, "ConfigButton/Icon");
			_iconColorizer = ComponentExtensions.GetOrAddComponent<Colorizer>((Component)(object)val);
			_textColorizer = ComponentExtensions.GetOrAddComponent<Colorizer>((Component)(object)val2);
			TargetModule.OnToggleStateChanged += UpdateVisualState;
			UpdateVisualState(TargetModule.IsEnabled);
		}

		private void OnDestroy()
		{
			if (TargetModule != null)
			{
				TargetModule.OnToggleStateChanged -= UpdateVisualState;
			}
		}

		private void OnDisable()
		{
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(false);
			}
		}

		private void UpdateVisualState(bool isEnabled)
		{
			if ((Object)(object)_iconColorizer != (Object)null)
			{
				_iconColorizer.Highlighted = isEnabled;
			}
			if ((Object)(object)_textColorizer != (Object)null)
			{
				_textColorizer.Highlighted = isEnabled;
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 1)
			{
				ClickGUI.NestConfigPanel(TargetModule);
				GameObject? settingIcon = _settingIcon;
				if (settingIcon != null)
				{
					settingIcon.SetActive(false);
				}
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(true);
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(false);
			}
		}

		public void OnSelect(BaseEventData eventData)
		{
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(true);
			}
		}

		public void OnDeselect(BaseEventData eventData)
		{
			GameObject? settingIcon = _settingIcon;
			if (settingIcon != null)
			{
				settingIcon.SetActive(false);
			}
		}
	}
	internal class ModuleCategoryController : MonoBehaviour
	{
		private bool _doneSetup;

		public ModuleCategory Category;

		private static readonly Dictionary<ModuleCategory, string> _iconNameMap = new Dictionary<ModuleCategory, string>
		{
			{
				ModuleCategory.Utility,
				"compass"
			},
			{
				ModuleCategory.Render,
				"eye"
			},
			{
				ModuleCategory.Gameplay,
				"options"
			},
			{
				ModuleCategory.Misc,
				"shapes"
			},
			{
				ModuleCategory.Hud,
				"hud"
			}
		};

		private void Start()
		{
			SetupModules();
		}

		public void SetupModules()
		{
			if (_doneSetup)
			{
				return;
			}
			_doneSetup = true;
			GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Scroll View/Viewport/Content/Modules");
			((Selectable)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton").GetComponent<Button>()).interactable = false;
			Image component = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton/TitleIcon").GetComponent<Image>();
			TextMeshProUGUI component2 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleName").GetComponent<TextMeshProUGUI>();
			component.sprite = AssetManager.Get<Sprite>(ClickGUI.BundleKey, _iconNameMap[Category]);
			((TMP_Text)component2).text = Category.ToString().ToUpper();
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Header");
			if (obj != null)
			{
				GameObjectExtensions.GetOrAddComponent<TitlebarDragHandler>(obj);
			}
			if ((Object)(object)AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ModuleButton") == (Object)null)
			{
				Plugin.Log.LogError((object)"ModuleButtonPrefab is null, cannot populate modules");
				return;
			}
			foreach (ThornClient.Core.Module item in from m in ModuleManager.GetByCategory(Category)
				where !(m is SystemModule)
				select m)
			{
				GameObjectExtensions.GetOrAddComponent<ModuleButtonController>(Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ModuleButton"), val.transform)).TargetModule = item;
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}
	}
	internal class ModuleSearchWindowController : MonoBehaviour
	{
		public int maxResults = 10;

		private bool _populated;

		private TMP_InputField? _input;

		private GameObject? _results;

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

		private Searchable[]? _searchables;

		[CompilerGenerated]
		private Predicate<ThornClient.Core.Module> <ModuleFilter>k__BackingField = (ThornClient.Core.Module _) => true;

		public Predicate<ThornClient.Core.Module> ModuleFilter
		{
			[CompilerGenerated]
			get
			{
				return <ModuleFilter>k__BackingField;
			}
			set
			{
				<ModuleFilter>k__BackingField = value;
				Repopulate();
			}
		}

		private void Awake()
		{
			_results = UIUtils.FindRecursive(((Component)this).gameObject, "Modules/Results");
		}

		private void Start()
		{
			GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Modules/Input");
			if ((Object)(object)val != (Object)null)
			{
				_input = val.GetComponent<TMP_InputField>();
			}
			PopulateIfNeeded();
			if ((Object)(object)_input != (Object)null)
			{
				((UnityEvent<string>)(object)_input.onValueChanged).AddListener((UnityAction<string>)Query);
			}
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Header");
			if (obj != null)
			{
				GameObjectExtensions.GetOrAddComponent<TitlebarDragHandler>(obj);
			}
			Query("");
		}

		private void OnDestroy()
		{
			if ((Object)(object)_input != (Object)null)
			{
				((UnityEvent<string>)(object)_input.onValueChanged).RemoveListener((UnityAction<string>)Query);
			}
		}

		private void Repopulate()
		{
			_populated = false;
			foreach (GameObject value in _allModules.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			_allModules.Clear();
			_searchables = null;
			PopulateIfNeeded();
			Query(((Object)(object)_input != (Object)null) ? _input.text : "");
		}

		public void FocusSearch()
		{
			if ((Object)(object)_input != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject(((Component)_input).gameObject, (BaseEventData)null);
				_input.ActivateInputField();
			}
		}

		private void PopulateIfNeeded()
		{
			if (_populated)
			{
				return;
			}
			_populated = true;
			List<ThornClient.Core.Module> list = ModuleManager.Items.Where((ThornClient.Core.Module m) => ModuleFilter(m)).ToList();
			foreach (ThornClient.Core.Module item in list)
			{
				GameObject obj = AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ModuleButton");
				GameObject? results = _results;
				GameObject val = Object.Instantiate<GameObject>(obj, (results != null) ? results.transform : null);
				UIUtils.UnfuckLayoutHack(val);
				val.SetActive(false);
				GameObjectExtensions.GetOrAddComponent<ModuleButtonController>(val).TargetModule = item;
				try
				{
					_allModules.TryAdd(item.Name, val);
				}
				catch (Exception arg)
				{
					Plugin.Log.LogWarning((object)$"Failed to add module {item.Name} to search, are there two with the same name?\n{arg}");
				}
			}
			_searchables = ((IEnumerable<ThornClient.Core.Module>)list).Select((Func<ThornClient.Core.Module, Searchable>)((ThornClient.Core.Module module) => new Searchable
			{
				Primary = module.Name,
				Secondaries = new Dictionary<string, string>
				{
					{ "description", module.Description },
					{
						"tags",
						string.Join(" ", module.Tags ?? Array.Empty<string>())
					}
				}
			})).ToArray();
		}

		private void Query(string query)
		{
			if (_searchables == null)
			{
				return;
			}
			Searchable[] array = ((query.Length > 0) ? Search.Invoke(query, _searchables) : Array.Empty<Searchable>());
			foreach (GameObject value2 in _allModules.Values)
			{
				if (!((Object)(object)value2 == (Object)null))
				{
					UIUtils.UnfuckLayoutHack(value2);
					value2.SetActive(false);
				}
			}
			for (int i = 0; i < array.Length && i < maxResults; i++)
			{
				Searchable val = array[i];
				if (_allModules.TryGetValue(val.Primary, out GameObject value) && !((Object)(object)value == (Object)null))
				{
					value.SetActive(true);
					value.transform.SetAsLastSibling();
				}
			}
			if ((Object)(object)_results != (Object)null)
			{
				UIUtils.UnfuckLayoutHack(_results);
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}
	}
	internal abstract class NumberSettingController<T> : MonoBehaviour
	{
		public Setting<T>? TargetSetting;

		private TMP_InputField? _inputField;

		private ValueScrubController? _scrubController;

		private Slider? _slider;

		private string _lastString = string.Empty;

		private int _decimals = 1;

		private T _beforeScrub;

		private void Start()
		{
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "MainField/Input");
			_inputField = ((obj != null) ? obj.GetComponent<TMP_InputField>() : null);
			if ((Object)(object)_inputField == (Object)null)
			{
				return;
			}
			ComponentExtensions.GetOrAddComponent<InputFocusGrab>((Component)(object)_inputField);
			((UnityEvent<string>)(object)_inputField.onSelect).AddListener((UnityAction<string>)SavePrevValue);
			((UnityEvent<string>)(object)_inputField.onEndEdit).AddListener((UnityAction<string>)SaveNewValue);
			if (TargetSetting == null)
			{
				return;
			}
			if (TargetSetting.Hints != null && TargetSetting.Hints.Range != null)
			{
				if (TargetSetting.Hints.Decimals.HasValue)
				{
					_decimals = TargetSetting.Hints.Decimals.Value;
				}
				Tuple<float, float> range = TargetSetting.Hints.Range;
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Slider");
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(true);
					_slider = val.GetComponent<Slider>();
					_slider.minValue = Math.Min(range.Item1, range.Item2);
					_slider.maxValue = Math.Max(range.Item1, range.Item2);
					((UnityEvent<float>)(object)_slider.onValueChanged).AddListener((UnityAction<float>)delegate(float x)
					{
						SaveNewValue(Math.Round(x, _decimals).ToString());
					});
				}
			}
			else
			{
				_scrubController = GameObjectExtensions.GetOrAddComponent<ValueScrubController>(((Component)this).gameObject);
				_scrubController.OnScrubStart += SavePrevValue;
				_scrubController.OnValueScrub += UpdateScrub;
			}
			Setting<T>? targetSetting = TargetSetting;
			targetSetting.OnValueChanged = (Action<T>)Delegate.Combine(targetSetting.OnValueChanged, new Action<T>(UpdateFieldValue));
			UpdateFieldValue(TargetSetting.Value);
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				Setting<T>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<T>)Delegate.Remove(targetSetting.OnValueChanged, new Action<T>(UpdateFieldValue));
			}
			if (!((Object)(object)_inputField == (Object)null))
			{
				((UnityEvent<string>)(object)_inputField.onSelect).RemoveListener((UnityAction<string>)SavePrevValue);
				((UnityEvent<string>)(object)_inputField.onEndEdit).RemoveListener((UnityAction<string>)SaveNewValue);
				if ((Object)(object)_scrubController != (Object)null)
				{
					_scrubController.OnScrubStart -= SavePrevValue;
					_scrubController.OnValueScrub -= UpdateScrub;
				}
			}
		}

		private void SavePrevValue()
		{
			if (TargetSetting != null)
			{
				_beforeScrub = TargetSetting.Value;
			}
		}

		protected abstract void UpdateScrub(T baseValue, float valueDiff);

		private void UpdateScrub(float valueDiff)
		{
			UpdateScrub(_beforeScrub, valueDiff);
		}

		private void UpdateFieldValue(T value)
		{
			if ((Object)(object)_inputField == (Object)null)
			{
				return;
			}
			try
			{
				_inputField.text = value.ToString();
				if ((Object)(object)_slider != (Object)null && float.TryParse(value.ToString(), out var result))
				{
					_slider.value = result;
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"{typeof(T)} cannot be converted to string: {arg}");
			}
		}

		private void SavePrevValue(string str)
		{
			_lastString = str;
		}

		private void SaveNewValue(string str)
		{
			if (TargetSetting != null)
			{
				if (double.TryParse(str, out var result))
				{
					TargetSetting.Value = (T)Convert.ChangeType(result, typeof(T));
				}
				else
				{
					UpdateFieldValue(TargetSetting.Value);
				}
			}
		}
	}
	internal class SettingDescriptionController : MonoBehaviour
	{
		public IConfigurableElement TargetSetting;

		private void Start()
		{
			GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Name", false);
			if ((Object)(object)val == (Object)null)
			{
				val = UIUtils.FindRecursive(((Component)this).gameObject, "TopRow/Name", false);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = UIUtils.FindRecursive(((Component)this).gameObject, "MainField/Name");
			}
			if (!((Object)(object)val == (Object)null))
			{
				((TMP_Text)val.GetComponent<TextMeshProUGUI>()).text = TargetSetting.Name;
				GameObjectExtensions.GetOrAddComponent<ClickGUITooltipHandler>(((Component)this).gameObject).Text = TargetSetting.Description;
			}
		}
	}
	internal class SettingGroupWindowController : MonoBehaviour
	{
		private bool _doneSetup;

		public SettingGroup TargetGroup;

		private void Start()
		{
			SetupStuff();
		}

		public void SetupStuff()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			if (_doneSetup)
			{
				return;
			}
			_doneSetup = true;
			if (TargetGroup != null)
			{
				UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton/TitleIcon").SetActive(false);
				((TMP_Text)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleName").GetComponent<TextMeshProUGUI>()).text = TargetGroup.Name;
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Header");
				if (obj != null)
				{
					obj.AddComponent<TitlebarDragHandler>();
				}
				GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton");
				Button obj3 = ((obj2 != null) ? obj2.GetComponent<Button>() : null);
				((Selectable)UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton").GetComponent<Button>()).interactable = true;
				GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "Header/TitleButton/BackIcon");
				if (obj4 != null)
				{
					obj4.SetActive(true);
				}
				((UnityEvent)obj3.onClick).AddListener((UnityAction)delegate
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				});
				Transform transform = UIUtils.FindRecursive(((Component)this).gameObject, "Scroll View/Viewport/Content/Modules").transform;
				Populate(transform, TargetGroup.Elements);
				UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
			}
		}

		private void Populate(Transform parent, IEnumerable<IConfigurableElement> elements)
		{
			foreach (IConfigurableElement element in elements)
			{
				GameObject val = null;
				if (element is Setting setting)
				{
					val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "SettingRowWrapper"), parent);
					val.AddComponent<SettingRowController>().TargetSetting = setting;
					if (ConfigurableElementUICreators.SettingUICreators.TryGetValue(setting.Type, out Func<Setting, Transform, GameObject> value))
					{
						value(setting, val.transform).AddComponent<SettingDescriptionController>().TargetSetting = setting;
					}
				}
				else if (element is SettingGroup || element is ConfigButtonRow)
				{
					val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(ClickGUI.BundleKey, "SettingRowWrapper"), parent);
					if (ConfigurableElementUICreators.MenuUICreators.TryGetValue(element.GetType(), out Func<IConfigurableElement, Transform, GameObject> value2))
					{
						value2(element, val.transform).AddComponent<SettingDescriptionController>().TargetSetting = element;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					UIUtils.UnfuckLayoutHack(val);
					if (element.Hints?.Hidden == true)
					{
						val.SetActive(false);
					}
				}
			}
		}
	}
	internal class SettingRowController : MonoBehaviour
	{
		public Setting? TargetSetting;

		private GameObject? _resetButton;

		private Image? _resetButtonIconImage;

		private Button _resetButtonComp;

		private void Start()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (TargetSetting != null)
			{
				_resetButton = UIUtils.FindRecursive(((Component)this).gameObject, "RevertButtonWrapper/RevertButton");
				_resetButtonIconImage = UIUtils.FindRecursive(_resetButton, "Icon").GetComponent<Image>();
				if (!((Object)(object)_resetButton == (Object)null))
				{
					_resetButtonComp = _resetButton.GetComponent<Button>();
					UpdateResetVisibility();
					((UnityEvent)_resetButtonComp.onClick).AddListener(new UnityAction(ResetSetting));
					TargetSetting.OnChanged += UpdateResetVisibility;
				}
			}
		}

		private void OnDestroy()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			if (TargetSetting != null)
			{
				TargetSetting.OnChanged -= UpdateResetVisibility;
			}
			if ((Object)(object)_resetButtonComp != (Object)null)
			{
				((UnityEvent)_resetButtonComp.onClick).RemoveListener(new UnityAction(ResetSetting));
			}
		}

		private void UpdateResetVisibility()
		{
			if (TargetSetting != null && !((Object)(object)_resetButton == (Object)null) && !((Object)(object)_resetButtonIconImage == (Object)null))
			{
				bool flag = !TargetSetting.IsDefault;
				_resetButtonIconImage.sprite = AssetManager.Get<Sprite>(ClickGUI.BundleKey, flag ? "revert" : "dot");
				((Selectable)_resetButtonComp).interactable = flag;
			}
		}

		private void ResetSetting()
		{
			if (TargetSetting != null)
			{
				TargetSetting.Reset();
			}
		}
	}
	internal class SwitchBoolSettingController : MonoBehaviour
	{
		public Setting<bool>? TargetSetting;

		private GameObject? _off;

		private GameObject? _on;

		private void Start()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener(new UnityAction(ToggleSetting));
			if (TargetSetting != null)
			{
				Setting<bool>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<bool>)Delegate.Combine(targetSetting.OnValueChanged, new Action<bool>(UpdateDisplay));
				_on = UIUtils.FindRecursive(((Component)this).gameObject, "Base/On");
				_off = UIUtils.FindRecursive(((Component)this).gameObject, "Base/Off");
				UpdateDisplay(TargetSetting.Value);
			}
		}

		private void OnDestroy()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).RemoveListener(new UnityAction(ToggleSetting));
			if (TargetSetting != null)
			{
				Setting<bool>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<bool>)Delegate.Remove(targetSetting.OnValueChanged, new Action<bool>(UpdateDisplay));
			}
		}

		private void ToggleSetting()
		{
			if (TargetSetting != null)
			{
				TargetSetting.Value = !TargetSetting.Value;
			}
		}

		private void UpdateDisplay(bool value)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_on != (Object)null)
			{
				SlideFadeToggleEffectExtensions.SetActiveAnimated(_on, value, 10f * Vector2.left, 25f);
			}
			if ((Object)(object)_off != (Object)null)
			{
				SlideFadeToggleEffectExtensions.SetActiveAnimated(_off, !value, 10f * Vector2.right, 25f);
			}
		}
	}
	internal class TabBarController : MonoBehaviour
	{
		private TextMeshProUGUI? _numberText;

		private TextMeshProUGUI? _amPmText;

		private Image? _iconImage;

		private GameObject? _battObj;

		private Image? _battIcon;

		private TextMeshProUGUI? _battNum;

		private Sprite _sunIcon;

		private Sprite _moonIcon;

		private void Awake()
		{
			_sunIcon = AssetManager.Get<Sprite>(ClickGUI.BundleKey, "sun");
			_moonIcon = AssetManager.Get<Sprite>(ClickGUI.BundleKey, "moon");
		}

		private void Start()
		{
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "InfoRow/InfoCol/Version");
			TextMeshProUGUI val = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val).text = "v0.1.0";
			}
			GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "SystemStatus/Clock/Time/Number");
			_numberText = ((obj2 != null) ? obj2.GetComponent<TextMeshProUGUI>() : null);
			GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "SystemStatus/Clock/Time/AmPm");
			_amPmText = ((obj3 != null) ? obj3.GetComponent<TextMeshProUGUI>() : null);
			GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "SystemStatus/Clock/Icon");
			_iconImage = ((obj4 != null) ? obj4.GetComponent<Image>() : null);
			_battObj = UIUtils.FindRecursive(((Component)this).gameObject, "SystemStatus/Battery");
			if (Object.op_Implicit((Object)(object)_battObj))
			{
				GameObject obj5 = UIUtils.FindRecursive(_battObj, "Icon");
				_battIcon = ((obj5 != null) ? obj5.GetComponent<Image>() : null);
				GameObject obj6 = UIUtils.FindRecursive(_battObj, "Value/Number");
				_battNum = ((obj6 != null) ? obj6.GetComponent<TextMeshProUGUI>() : null);
			}
		}

		private void Update()
		{
			if (((Component)this).gameObject.activeInHierarchy)
			{
				UpdateTimeDisplay();
				UpdateBattery();
			}
		}

		private void UpdateTimeDisplay()
		{
			DateTime now = DateTime.Now;
			string text = now.ToString("hh:mm");
			string text2 = now.ToString("tt");
			int hour = now.Hour;
			Sprite val = ((hour >= 6 && hour < 18) ? _sunIcon : _moonIcon);
			if ((Object)(object)_numberText != (Object)null && ((TMP_Text)_numberText).text != text)
			{
				((TMP_Text)_numberText).text = text;
			}
			if ((Object)(object)_amPmText != (Object)null && ((TMP_Text)_amPmText).text != text2)
			{
				((TMP_Text)_amPmText).text = text2;
			}
			if ((Object)(object)_iconImage != (Object)null && (Object)(object)_iconImage.sprite != (Object)(object)val)
			{
				_iconImage.sprite = val;
			}
		}

		private void UpdateBattery()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			BatteryStatus batteryStatus = SystemInfo.batteryStatus;
			if ((int)batteryStatus == 0)
			{
				if ((Object)(object)_battObj != (Object)null && _battObj.activeSelf)
				{
					_battObj.SetActive(false);
				}
				return;
			}
			bool num = (int)batteryStatus == 1 || (int)batteryStatus == 4;
			float num2 = SystemInfo.batteryLevel * 100f;
			string text = $"{num2}";
			int num3 = (int)Math.Round(num2 / 25f);
			string text2 = ((num3 == 0) ? "low" : $"{num3 * 25}");
			string text3 = (num ? "_charge" : "");
			string text4 = "battery_" + text2 + text3;
			if ((Object)(object)_battNum != (Object)null && ((TMP_Text)_battNum).text != text)
			{
				((TMP_Text)_battNum).text = text;
			}
			if ((Object)(object)_battIcon != (Object)null)
			{
				Sprite sprite = _battIcon.sprite;
				if (((sprite != null) ? ((Object)sprite).name : null) != text4)
				{
					_battIcon.sprite = AssetManager.Get<Sprite>(ClickGUI.BundleKey, text4);
				}
			}
		}
	}
	internal class TextSettingController : MonoBehaviour
	{
		public Setting<string>? TargetSetting;

		private TMP_InputField? _inputField;

		private string _lastString = string.Empty;

		private void Start()
		{
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Input");
			_inputField = ((obj != null) ? obj.GetComponent<TMP_InputField>() : null);
			if (!((Object)(object)_inputField == (Object)null))
			{
				ComponentExtensions.GetOrAddComponent<InputFocusGrab>((Component)(object)_inputField);
				((UnityEvent<string>)(object)_inputField.onSelect).AddListener((UnityAction<string>)SavePrevValue);
				((UnityEvent<string>)(object)_inputField.onEndEdit).AddListener((UnityAction<string>)SaveNewValue);
				if (TargetSetting != null)
				{
					Setting<string>? targetSetting = TargetSetting;
					targetSetting.OnValueChanged = (Action<string>)Delegate.Combine(targetSetting.OnValueChanged, new Action<string>(UpdateFieldValue));
					UpdateFieldValue(TargetSetting.Value);
				}
			}
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				Setting<string>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<string>)Delegate.Remove(targetSetting.OnValueChanged, new Action<string>(UpdateFieldValue));
			}
			if (!((Object)(object)_inputField == (Object)null))
			{
				((UnityEvent<string>)(object)_inputField.onSelect).RemoveListener((UnityAction<string>)SavePrevValue);
				((UnityEvent<string>)(object)_inputField.onEndEdit).RemoveListener((UnityAction<string>)SaveNewValue);
			}
		}

		private void UpdateFieldValue(string value)
		{
			if (!((Object)(object)_inputField == (Object)null))
			{
				_inputField.text = value ?? string.Empty;
			}
		}

		private void SavePrevValue(string str)
		{
			_lastString = str;
		}

		private void SaveNewValue(string str)
		{
			try
			{
				if (TargetSetting != null)
				{
					TargetSetting.Value = str;
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogWarning((object)$"Failed to set text setting: {arg}");
				if ((Object)(object)_inputField != (Object)null)
				{
					_inputField.text = _lastString;
				}
			}
		}
	}
	internal class TitlebarDragHandler : FreeMoveDragHandler
	{
		private void Start()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			try
			{
				target = (RectTransform)((Component)((Component)this).transform.parent).transform;
			}
			catch (Exception)
			{
				Plugin.Log.LogWarning((object)"[TitlebarDragHandler] may have been added to a root element");
			}
		}
	}
	public class ValueScrubController : MonoBehaviour, IDragHandler, IEventSystemHandler, IBeginDragHandler, IEndDragHandler, IPointerEnterHandler, IPointerExitHandler
	{
		public float scaleFactor = 0.1f;

		private Vector2 _hotspot = new Vector2(48f, 48f);

		private Vector2 _cumulatedDelta;

		private bool _dragging;

		private bool _hovering;

		public event Action<float> OnValueScrub;

		public event Action OnScrubStart;

		public void OnDisable()
		{
			_hovering = false;
			_dragging = false;
			UpdateCursor();
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			_cumulatedDelta += eventData.delta * scaleFactor;
			this.OnValueScrub?.Invoke(_cumulatedDelta.x);
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//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)
			_cumulatedDelta = Vector2.zero;
			this.OnScrubStart?.Invoke();
			_dragging = true;
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//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)
			_cumulatedDelta = Vector2.zero;
			this.OnScrubStart?.Invoke();
			_dragging = false;
			UpdateCursor();
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_hovering = true;
			UpdateCursor();
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_hovering = false;
			UpdateCursor();
		}

		private void UpdateCursor()
		{
			//IL_0020: 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)
			if (_hovering || _dragging)
			{
				Cursor.SetCursor(AssetManager.Get<Texture2D>(ClickGUI.BundleKey, "move_horizontal_cursor"), _hotspot, (CursorMode)0);
			}
			else
			{
				Cursor.SetCursor((Texture2D)null, Vector2.zero, (CursorMode)0);
			}
		}
	}
	internal class WindowedGroupSettingController : MonoBehaviour
	{
		public SettingGroup? TargetGroup;

		private TextMeshProUGUI? text;

		private void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (TargetGroup != null)
			{
				((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener(new UnityAction(OpenWindow));
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Name");
				text = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)text != (Object)null)
				{
					((TMP_Text)text).text = TargetGroup.Name;
				}
			}
		}

		private void OnDestroy()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Button component = ((Component)this).GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEvent)component.onClick).RemoveListener(new UnityAction(OpenWindow));
			}
		}

		private void OpenWindow()
		{
			GameObject val = CreateConfigPanel(TargetGroup);
			if ((Object)(object)val != (Object)null)
			{
				ClickGUI.SpawnContent(val);
			}
			ClickGUI.SurrenderTooltipText(TargetGroup?.Description ?? "");
		}

		private GameObject? CreateConfigPanel(SettingGroup? settingGroup)
		{
			GameObject val = AssetManager.Get<GameObject>(ClickGUI.BundleKey, "ModuleCategory");
			if ((Object)(object)val == (Object)null || settingGroup == null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObjectExtensions.GetOrAddComponent<SettingGroupWindowController>(val2).TargetGroup = settingGroup;
			return val2;
		}
	}
}
namespace ThornClient.Patches
{
	[HarmonyPatch(typeof(OptionsManager))]
	internal static class OptionsManagerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("UnPause")]
		internal static bool UnPause_Prefix(OptionsManager __instance)
		{
			try
			{
				return !InputManager.BlockInput;
			}
			catch
			{
				return true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Pause")]
		internal static bool Pause_Prefix(OptionsManager __instance)
		{
			try
			{
				return !InputManager.BlockInput;
			}
			catch
			{
				return true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Freeze")]
		internal static bool Freeze_Prefix(OptionsManager __instance)
		{
			try
			{
				return !InputManager.BlockInput;
			}
			catch
			{
				return true;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UnFreeze")]
		internal static bool UnFreeze_Prefix(OptionsManager __instance)
		{
			try
			{
				return !InputManager.BlockInput;
			}
			catch
			{
				return true;
			}
		}
	}
}
namespace ThornClient.Modules.Utility
{
	public class EnemyTracers : ThornClient.Core.Module
	{
		public Setting<Color> TracerColor;

		public Setting<float> LineThickness;

		public Setting<bool> AlwaysOnTop;

		public Setting<int> EnemyCountThreshold;

		public Setting<EnemyList> ForceTraceEnemies;

		private readonly Dictionary<int, Collider> _colliderCache = new Dictionary<int, Collider>();

		private readonly Queue<int> _cacheHistory = new Queue<int>();

		private const int MaxCacheSize = 1000;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "point_dot");

		public override string[] Tags => new string[4] { "lines", "position", "indicator", "path" };

		public EnemyTracers()
			: base("thorn.enemyTracers", "Enemy Tracers", "Draws lines from you to enemies", ModuleCategory.Utility, (KeyCode)0, (KeyCode)0)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			TracerColor = CreateSetting<Color>("tracerColor", "Tracer Color", "Color used for the trace lines", new Color(0.65f, 0.95f, 0.89f, 0.5f));
			LineThickness = CreateSetting("lineThickness", "Line Thickness", "The pixel width of the tracer lines", 2f);
			AlwaysOnTop = CreateSetting("alwaysOnTop", "Always On Top", "Render tracer lines through walls and world geometry", defaultValue: true);
			EnemyCountThreshold = CreateSetting("enemyCountThreshold", "Enemy Count Threshold", "Display tracers when there are this many enemies left", 5);
			ForceTraceEnemies = CreateSetting("forceTraceEnemies", "Force Trace Enemies", "Always trace these enemy types regardless of the total count/threshold. Useful for e.g. Mindflayers", new EnemyList());
		}

		private Vector3 GetEnemyPosition(EnemyIdentifier enemy)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)enemy == (Object)null || (Object)(object)((Component)enemy).transform == (Object)null)
			{
				return Vector3.zero;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!_colliderCache.TryGetValue(instanceID, out Collider value))
			{
				value = ((Component)enemy).GetComponent<Collider>();
				if ((Object)(object)value != (Object)null)
				{
					_colliderCache[instanceID] = value;
					_cacheHistory.Enqueue(instanceID);
					if (_cacheHistory.Count > 1000)
					{
						int key = _cacheHistory.Dequeue();
						_colliderCache.Remove(key);
					}
				}
			}
			if ((Object)(object)value == (Object)null)
			{
				return ((Component)enemy).transform.position;
			}
			Bounds bounds = value.bounds;
			float y = (((Bounds)(ref bounds)).center - ((Component)enemy).transform.position).y;
			bounds = value.bounds;
			float num = y + ((Bounds)(ref bounds)).extents.y;
			return ((Component)enemy).transform.position + num / 2f * Vector3.up;
		}

		private bool IsEnemyMeaningful(EnemyIdentifier enemy)
		{
			if ((Object)(object)enemy != (Object)null && !enemy.dead && (Object)(object)((Component)enemy).gameObject != (Object)null)
			{
				return ((Component)enemy).gameObject.activeInHierarchy;
			}
			return false;
		}

		public override void OnRender()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00b7: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_0155: 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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			EnemyTracker instance = MonoSingleton<EnemyTracker>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			Material val = (AlwaysOnTop.Value ? RenderManager.LineTop : RenderManager.Line);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			val.SetPass(0);
			GL.PushMatrix();
			GL.MultMatrix(main.worldToCameraMatrix);
			GL.LoadProjectionMatrix(main.projectionMatrix);
			GL.Begin(7);
			GL.Color(TracerColor.Value);
			float num = LineThickness.Value * 0.01f;
			Vector3 position = ((Component)main).transform.position;
			Vector3 forward = ((Component)main).transform.forward;
			Vector3 val2 = position + forward * 1.5f;
			int count = instance.enemies.Count;
			int num2 = 0;
			for (int i = 0; i < count; i++)
			{
				EnemyIdentifier enemy = instance.enemies[i];
				num2 += (IsEnemyMeaningful(enemy) ? 1 : 0);
			}
			for (int j = 0; j < count; j++)
			{
				EnemyIdentifier val3 = instance.enemies[j];
				if (IsEnemyMeaningful(val3) && (num2 < EnemyCountThreshold.Value || ForceTraceEnemies.Value.Includes(val3.enemyType)))
				{
					Vector3 enemyPosition = GetEnemyPosition(val3);
					Vector3 val4 = enemyPosition - val2;
					Vector3 val5 = val2 - position;
					Vector3 normalized = ((Vector3)(ref val5)).normalized;
					val5 = Vector3.Cross(val4, normalized);
					Vector3 val6 = ((Vector3)(ref val5)).normalized * (num / 2f);
					GL.Vertex(val2 - val6);
					GL.Vertex(val2 + val6);
					GL.Vertex(enemyPosition + val6);
					GL.Vertex(enemyPosition - val6);
				}
			}
			GL.End();
			GL.PopMatrix();
		}
	}
	public class FreezeframeRocketRideHint : ThornClient.Core.Module
	{
		public enum RocketHintShowWhen
		{
			Freezeframe,
			RocketLauncher,
			Always
		}

		public Setting<RocketHintShowWhen> ShowWhen { get; }

		public Setting<Color> LineColor { get; }

		public Setting<float> LineThickness { get; }

		public Setting<float> LineWidth { get; }

		public Setting<float> Distance { get; }

		public Setting<float> UpperAngle { get; }

		public Setting<float> LowerAngle { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "rocket_ride");

		public override string[] Tags => new string[2] { "movement", "freezeframe" };

		private GunControl? gc => MonoSingleton<GunControl>.Instance;

		public FreezeframeRocketRideHint()
			: base("thorn.freezeframeRocketRideHint", "Rocket Ride Hint", "Draws assist lines to help with Freezeframe rocket ride aiming", ModuleCategory.Utility, (KeyCode)0, (KeyCode)0)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			ShowWhen = CreateSetting("showWhen", "Show when holding", "When to show the hint lines", RocketHintShowWhen.Freezeframe);
			LineColor = CreateSetting<Color>("lineColor", "Line Color", "Color used for the hint line.", new Color(0.2509804f, 0.9098039f, 1f));
			LineThickness = CreateSetting("lineThickness", "Line Thickness", "How thicc the line is", 2f);
			LineWidth = CreateSetting("lineWidth", "Line Width", "How long the line is", 1f);
			Distance = CreateSetting("distance", "Distance", "How far away from the camera to show the lines", 3f);
			UpperAngle = CreateSetting("upperAngle", "Upper Angle", "The vertical angle of the upper line, in degrees.", 7f);
			UpperAngle.Hints = new InterfaceHints
			{
				Range = Tuple.Create(-90f, 90f)
			};
			LowerAngle = CreateSetting("lowerAngle", "Lower Angle", "The vertical angle of the lower line, in degrees.", 34f);
			LowerAngle.Hints = new InterfaceHints
			{
				Range = Tuple.Create(-90f, 90f)
			};
		}

		public override void OnRender()
		{
			//IL_00e0: 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)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: 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_014b: 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_0154: 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_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			switch (ShowWhen.Value)
			{
			case RocketHintShowWhen.RocketLauncher:
				if ((Object)(object)gc == (Object)null || (Object)(object)gc.currentWeapon == (Object)null || (Object)(object)gc.currentWeapon.GetComponent<RocketLauncher>() == (Object)null)
				{
					return;
				}
				break;
			case RocketHintShowWhen.Freezeframe:
				if ((Object)(object)gc == (Object)null || (Object)(object)gc.currentWeapon == (Object)null || (Object)(object)gc.currentWeapon.GetComponent<RocketLauncher>() == (Object)null || gc.currentWeapon.GetComponent<RocketLauncher>().variation != 0)
				{
					return;
				}
				break;
			}
			Camera main = Camera.main;
			if (!((Object)(object)main == (Object)null) && !((Object)(object)RenderManager.LineTop == (Object)null))
			{
				RenderManager.LineTop.SetPass(0);
				GL.PushMatrix();
				GL.MultMatrix(main.worldToCameraMatrix);
				GL.LoadProjectionMatrix(main.projectionMatrix);
				GL.Begin(7);
				GL.Color(LineColor.Value);
				float thickness = LineThickness.Value * 0.01f;
				Vector3 position = ((Component)main).transform.position;
				Vector3 forward = ((Component)main).transform.forward;
				Vector3 val = new Vector3(forward.x, 0f, forward.z);
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				DrawHintLine(UpperAngle.Value, position, normalized, thickness);
				DrawHintLine(LowerAngle.Value, position, normalized, thickness);
				GL.End();
				GL.PopMatrix();
			}
		}

		private void DrawHintLine(float angleDegrees, Vector3 cameraPos, Vector3 flatForward, float thickness)
		{
			//IL_000e: 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_001a: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00aa: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00bd: 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_00cf: 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_00d2: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			float num = angleDegrees * -1f * (MathF.PI / 180f);
			Vector3 val = flatForward * Mathf.Cos(num) + Vector3.up * Mathf.Sin(num);
			Vector3 val2 = cameraPos + val * Distance.Value;
			Vector3 val3 = Vector3.Cross(Vector3.up, flatForward);
			Vector3 normalized = ((Vector3)(ref val3)).normalized;
			Vector3 val4 = val2 - normalized * (LineWidth.Value / 2f);
			Vector3 val5 = val2 + normalized * (LineWidth.Value / 2f);
			val3 = val2 - cameraPos;
			Vector3 normalized2 = ((Vector3)(ref val3)).normalized;
			val3 = Vector3.Cross(val5 - val4, normalized2);
			Vector3 val6 = ((Vector3)(ref val3)).normalized * (thickness / 2f);
			GL.Vertex(val4 - val6);
			GL.Vertex(val4 + val6);
			GL.Vertex(val5 + val6);
			GL.Vertex(val5 - val6);
		}
	}
	public class FullBright : ThornClient.Core.Module
	{
		private bool _lastFogEnabled;

		private Color _lastAmbientColor = Color.black;

		private bool _isStateSaved;

		public Setting<float> Brightness { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "light_bulb");

		public override string[] Tags => new string[6] { "light", "vision", "sight", "clear", "see", "illuminate" };

		public override string? CheatReason
		{
			get
			{
				List<string> list = new List<string>(2) { "Level 0-S", "Level 4-3" };
				if (!IsEnabled || !list.Contains(SceneHelper.CurrentScene))
				{
					return "";
				}
				return "Darkness is a core challenge of this level";
			}
		}

		public FullBright()
			: base("thorn.fullBright", "FullBright", "Adjust brightness for accessibility", ModuleCategory.Utility, (KeyCode)0, (KeyCode)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)
			Brightness = CreateSetting("brightness", "Brightness", "How bright the world should be", 0.2f);
		}

		protected override void OnEnable()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			SceneUtils.SafeSceneLoaded += OnSceneLoaded;
			Setting<float> brightness = Brightness;
			brightness.OnValueChanged = (Action<float>)Delegate.Combine(brightness.OnValueChanged, new Action<float>(UpdateAmbientLightColor));
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).isLoaded)
			{
				ApplyFullBright();
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_isStateSaved = false;
			ApplyFullBright();
		}

		private void ApplyFullBright()
		{
			try
			{
				if (!_isStateSaved)
				{
					_lastFogEnabled = RenderSettings.fog;
					_isStateSaved = true;
				}
				RenderSettings.fog = false;
				UpdateAmbientLightColor(Brightness.Value);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[FullBright] RenderSettings not ready yet: {arg}");
			}
		}

		private void UpdateAmbientLightColor(float brightness)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (_isStateSaved)
			{
				RenderSettings.ambientLight = Color.white * brightness;
				CheatManager.UpdateCheatiness();
			}
		}

		protected override void OnDisable()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			SceneUtils.SafeSceneLoaded -= OnSceneLoaded;
			Setting<float> brightness = Brightness;
			brightness.OnValueChanged = (Action<float>)Delegate.Remove(brightness.OnValueChanged, new Action<float>(UpdateAmbientLightColor));
			if (_isStateSaved)
			{
				RenderSettings.fog = _lastFogEnabled;
				RenderSettings.ambientLight = _lastAmbientColor;
				_isStateSaved = false;
			}
		}
	}
	public class WeaponVariantBinds : ThornClient.Core.Module
	{
		public static WeaponVariantBinds? Instance;

		public const int NumWeapons = 5;

		public const int NumVariants = 3;

		public static readonly string[,] GunIds = new string[5, 3]
		{
			{ "revolver_piercer", "revolver_marksman", "revolver_sharpshooter" },
			{ "shotgun_core_eject", "shotgun_pump_charge", "shotgun_sawed_on" },
			{ "nailgun_attractor", "nailgun_overheat", "nailgun_jumpstart" },
			{ "railcannon_electric", "railcannon_screwdriver", "railcannon_malicious" },
			{ "rocket_freezeframe", "rocket_srs", "rocket_firestarter" }
		};

		private static readonly string[,] GunNamesRaw = new string[5, 3]
		{
			{ "Piercer Revolver", "Marksman Revolver", "Sharpshooter Revolver" },
			{ "Core Eject Shotgun (or Hammer)", "Pump Charge Shotgun (or Hammer)", "Sawed-on Shotgun (or Hammer)" },
			{ "Attractor Nailgun (or Sawblade Launcher)", "Overheat Nailgun (or Sawblade Launcher)", "Jumpstart Nailgun (or Sawblade Launcher)" },
			{ "Electric Railcannon", "Screwdriver Railcannon", "Malicious Railcannon" },
			{ "Freezeframe Rocket Launcher", "S.R.S. Cannon Rocket Launcher", "Firestarter Rocket Launcher" }
		};

		private static readonly string[,] GunNames = new string[5, 3]
		{
			{ "<color=#9c9c9c>Revolver   :</color> <color=#40e7ff>Piercer</color>", "<color=#9c9c9c>Revolver   :</color> <color=#44ff45>Marksman</color>", "<color=#9c9c9c>Revolver   :</color> <color=#f00>Sharpshooter</color>" },
			{ "<color=#ffffff>Shotgun    :</color> <color=#40e7ff>Core</color>", "<color=#ffffff>Shotgun    :</color> <color=#44ff45>Pump</color>", "<color=#ffffff>Shotgun    :</color> <color=#f00>Sawed-on</color>" },
			{ "<color=#9c9c9c>Nailgun    :</color> <color=#40e7ff>Attractor</color>", "<color=#9c9c9c>Nailgun    :</color> <color=#44ff45>Overheat</color>", "<color=#9c9c9c>Nailgun    :</color> <color=#f00>Jumpstart</color>" },
			{ "<color=#ffffff>Railcannon :</color> <color=#40e7ff>Electric</color>", "<color=#ffffff>Railcannon :</color> <color=#44ff45>Screwdriver</color>", "<color=#ffffff>Railcannon :</color> <color=#f00>Malicious</color>" },
			{ "<color=#9c9c9c>Rocket     :</color> <color=#40e7ff>Freezeframe</color>", "<color=#9c9c9c>Rocket     :</color> <color=#44ff45>S.R.S.</color>", "<color=#9c9c9c>Rocket     :</color> <color=#f00>Firestarter</color>" }
		};

		public Setting<Keybind>[,] Binds = new Setting<Keybind>[5, 3];

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "gun");

		private GunControl? gcon => MonoSingleton<GunControl>.Instance;

		public WeaponVariantBinds()
			: base("thorn.weaponVariantBinds", "Weapon Variant Binds", "Allows you to bind keys to specific weapons", ModuleCategory.Utility, (KeyCode)0, (KeyCode)0)
		{
			if (Instance != null)
			{
				return;
			}
			Instance = this;
			for (int i = 0; i < 5; i++)
			{
				for (int j = 0; j < 3; j++)
				{
					Binds[i, j] = CreateSetting(GunIds[i, j], GunNames[i, j], "Keybind to switch to " + GunNamesRaw[i, j], new Keybind((KeyCode)0, (KeyCode)0));
					int i2 = i;
					int j2 = j;
					Binds[i, j].OnPress += delegate
					{
						Switch(i2, j2);
					};
				}
			}
		}

		private void Switch(int weaponIndex, int variantIndex)
		{
			if (!IsEnabled || Time.timeScale == 0f)
			{
				return;
			}
			bool flag = ((weaponIndex >= 5 || weaponIndex < 0) ? true : false);
			bool flag2 = flag;
			if (!flag2)
			{
				bool flag3 = ((variantIndex >= 3 || variantIndex < 0) ? true : false);
				flag2 = flag3;
			}
			if (flag2 || (Object)(object)gcon == (Object)null || gcon.slots.Count <= weaponIndex)
			{
				return;
			}
			List<GameObject> list = gcon.slots[weaponIndex];
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				GameObject val = list[i];
				if (GunHelper.GetVariation(val, weaponIndex) == variantIndex)
				{
					gcon.ForceWeapon(val, true);
					break;
				}
			}
		}
	}
	public class Zoom : ThornClient.Core.Module
	{
		public Setting<float> ZoomFov { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "loupe");

		public override string[] Tags => new string[3] { "magnifier", "close", "see" };

		public Zoom()
			: base("thorn.zoom", "Zoom", "Look more closely. Note: zooming only happens when the game is running, so use a keybind to toggle it", ModuleCategory.Utility, (KeyCode)0, (KeyCode)0, defaultToggleOnRelease: true)
		{
			ZoomFov = CreateSetting("zoomFov", "Zoom FOV", "Zoom amount. Lower = more zoomed in", 30f);
		}

		protected override void OnEnable()
		{
			UpdateZoom(ZoomFov.Value);
			Setting<float> zoomFov = ZoomFov;
			zoomFov.OnValueChanged = (Action<float>)Delegate.Combine(zoomFov.OnValueChanged, new Action<float>(UpdateZoom));
		}

		private void UpdateZoom(float value)
		{
			CameraController instance = MonoSingleton<CameraController>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.Zoom(ZoomFov.Value);
			}
		}

		protected override void OnDisable()
		{
			Setting<float> zoomFov = ZoomFov;
			zoomFov.OnValueChanged = (Action<float>)Delegate.Remove(zoomFov.OnValueChanged, new Action<float>(UpdateZoom));
			CameraController instance = MonoSingleton<CameraController>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.StopZoom();
			}
		}
	}
}
namespace ThornClient.Modules.Render
{
	public class Edges : ThornClient.Core.Module
	{
		private class EnemyWireframizer : MonoBehaviour
		{
			public EnemyType? TargetEnemyType;

			private Renderer[] _renderers = Array.Empty<Renderer>();

			private void Start()
			{
				if (TargetEnemyType.HasValue)
				{
					ExecutionUtils.RunNextFrame((Action)FindReplacementTargets);
				}
			}

			private void FindReplacementTargets()
			{
				GameObject gameObject = ((Component)this).gameObject;
				_renderers = ((gameObject == null) ? null : gameObject.GetComponentsInChildren<Renderer>(true)?.Where((Renderer r) => (r is MeshRenderer || r is SkinnedMeshRenderer) ? true : false)?.ToArray()) ?? Array.Empty<Renderer>();
			}

			private void Update()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				if (!TargetEnemyType.HasValue || _renderers.Length == 0)
				{
					return;
				}
				Material enemyMat = GetEnemyMat(TargetEnemyType.Value);
				if ((Object)(object)enemyMat == (Object)null)
				{
					return;
				}
				Renderer[] renderers = _renderers;
				foreach (Renderer val in renderers)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					List<Material> list = new List<Material>();
					val.GetSharedMaterials(list);
					int count = list.Count;
					if (count == 0)
					{
						continue;
					}
					bool flag = false;
					for (int j = 0; j < count; j++)
					{
						if ((Object)(object)list[j] != (Object)(object)enemyMat)
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						Material[] array = (Material[])(object)new Material[count];
						for (int k = 0; k < count; k++)
						{
							array[k] = enemyMat;
						}
						val.sharedMaterials = array;
					}
				}
			}
		}

		public static Edges? Instance;

		public Setting<float> EdgeThickness;

		public Setting<Color> FillColor;

		public Setting<bool> SwapEdgeAndFill;

		public Dictionary<EnemyType, Setting<Color>> EnemyEdgeColors = new Dictionary<EnemyType, Setting<Color>>();

		private static readonly Dictionary<EnemyType, Color> _defaultEnemyColors = new Dictionary<EnemyType, Color>
		{
			{
				(EnemyType)0,
				Color32.op_Implicit(ColorUtils.ToColor32(16749570))
			},
			{
				(EnemyType)1,
				Color32.op_Implicit(ColorUtils.ToColor32(10092799))
			},
			{
				(EnemyType)2,
				Color32.op_Implicit(ColorUtils.ToColor32(16739699))
			},
			{
				(EnemyType)3,
				Color32.op_Implicit(ColorUtils.ToColor32(11392369))
			},
			{
				(EnemyType)4,
				Color32.op_Implicit(ColorUtils.ToColor32(16765339))
			},
			{
				(EnemyType)5,
				Color32.op_Implicit(ColorUtils.ToColor32(65483))
			},
			{
				(EnemyType)6,
				Color32.op_Implicit(ColorUtils.ToColor32(16544015))
			},
			{
				(EnemyType)7,
				Color32.op_Implicit(ColorUtils.ToColor32(16762377))
			},
			{
				(EnemyType)8,
				Color32.op_Implicit(ColorUtils.ToColor32(16711680))
			},
			{
				(EnemyType)9,
				Color32.op_Implicit(ColorUtils.ToColor32(43263))
			},
			{
				(EnemyType)10,
				Color32.op_Implicit(ColorUtils.ToColor32(8224125))
			},
			{
				(EnemyType)11,
				Color32.op_Implicit(ColorUtils.ToColor32(15794431))
			},
			{
				(EnemyType)12,
				Color32.op_Implicit(ColorUtils.ToColor32(16777002))
			},
			{
				(EnemyType)13,
				Color32.op_Implicit(ColorUtils.ToColor32(16733770))
			},
			{
				(EnemyType)14,
				Color32.op_Implicit(ColorUtils.ToColor32(12089388))
			},
			{
				(EnemyType)15,
				Color32.op_Implicit(ColorUtils.ToColor32(6138367))
			},
			{
				(EnemyType)16,
				Color32.op_Implicit(ColorUtils.ToColor32(15968822))
			},
			{
				(EnemyType)17,
				Color32.op_Implicit(ColorUtils.ToColor32(10903895))
			},
			{
				(EnemyType)18,
				Color32.op_Implicit(ColorUtils.ToColor32(8829439))
			},
			{
				(EnemyType)19,
				Color32.op_Implicit(ColorUtils.ToColor32(16740789))
			},
			{
				(EnemyType)20,
				Color32.op_Implicit(ColorUtils.ToColor32(13631232))
			},
			{
				(EnemyType)21,
				Color32.op_Implicit(ColorUtils.ToColor32(9404671))
			},
			{
				(EnemyType)22,
				Color32.op_Implicit(ColorUtils.ToColor32(16711680))
			},
			{
				(EnemyType)23,
				Color32.op_Implicit(ColorUtils.ToColor32(4259648))
			},
			{
				(EnemyType)24,
				Color32.op_Implicit(ColorUtils.ToColor32(4259648))
			},
			{
				(EnemyType)25,
				Color32.op_Implicit(ColorUtils.ToColor32(16755403))
			},
			{
				(EnemyType)26,
				Color32.op_Implicit(ColorUtils.ToColor32(50104))
			},
			{
				(EnemyType)27,
				Color32.op_Implicit(ColorUtils.ToColor32(50104))
			},
			{
				(EnemyType)28,
				Color32.op_Implicit(ColorUtils.ToColor32(16726272))
			},
			{
				(EnemyType)29,
				Color32.op_Implicit(ColorUtils.ToColor32(16757538))
			},
			{
				(EnemyType)30,
				Color32.op_Implicit(ColorUtils.ToColor32(16749410))
			},
			{
				(EnemyType)31,
				Color32.op_Implicit(ColorUtils.ToColor32(15779030))
			},
			{
				(EnemyType)32,
				Color32.op_Implicit(ColorUtils.ToColor32(16777215))
			},
			{
				(EnemyType)33,
				Color32.op_Implicit(ColorUtils.ToColor32(16747833))
			},
			{
				(EnemyType)34,
				Color32.op_Implicit(ColorUtils.ToColor32(16722988))
			},
			{
				(EnemyType)35,
				Color32.op_Implicit(ColorUtils.ToColor32(14543091))
			},
			{
				(EnemyType)36,
				Color32.op_Implicit(ColorUtils.ToColor32(13303808))
			},
			{
				(EnemyType)37,
				Color32.op_Implicit(ColorUtils.ToColor32(16716869))
			},
			{
				(EnemyType)38,
				Color32.op_Implicit(ColorUtils.ToColor32(16777178))
			},
			{
				(EnemyType)39,
				Color32.op_Implicit(ColorUtils.ToColor32(16714496))
			},
			{
				(EnemyType)40,
				Color32.op_Implicit(ColorUtils.ToColor32(16304690))
			},
			{
				(EnemyType)41,
				Color32.op_Implicit(ColorUtils.ToColor32(12607913))
			},
			{
				(EnemyType)42,
				Color32.op_Implicit(ColorUtils.ToColor32(16733770))
			}
		};

		private static Dictionary<EnemyType, Material> _enemyMatCache = new Dictionary<EnemyType, Material>();

		private readonly Dictionary<EnemyType, Action<Color>> _onColorChangedActions = new Dictionary<EnemyType, Action<Color>>();

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "icosahedron");

		public unsafe Edges()
			: base("thorn.edges", "Edges", "Applies wireframe shader to stuff", ModuleCategory.Render, (KeyCode)0, (KeyCode)0)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0136: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0180: Unknown result type (might be due to invalid IL or missing references)
			if (Instance != null)
			{
				return;
			}
			Instance = this;
			CreateHeader("enemies", "Enemies", "Changes applied to newly spawned enemies");
			EdgeThickness = CreateSetting("edgeThickness", "Edge thickness", "How thick the edge lines are", 2f);
			FillColor = CreateSetting<Color>("fillColor", "Fill color", "The color that fills the faces", new Color(0f, 0f, 0f, 1f));
			SwapEdgeAndFill = CreateSetting("swapEdgeAndFill", "Swap edge and fill colors", "Makes edge colors apply to fill and fill color apply to edges", defaultValue: false);
			SettingGroup parent = CreateGroup("enemyColors", "Enemy Colors", "Colors for each enemy type");
			foreach (EnemyType item in from EnemyType e in Enum.GetValues(typeof(EnemyType))
				orderby ((object)(*(EnemyType*)(&e))/*cast due to .constrained prefix*/).ToString()
				select e)
			{
				Color value;
				Color defaultValue = (_defaultEnemyColors.TryGetValue(item, out value) ? value : Color.red);
				Setting<Color> value2 = CreateSetting<Color>($"enemyColor_{item}", $"{item}", $"The edge color for {item}", defaultValue, parent);
				EnemyEdgeColors[item] = value2;
			}
			SwapEdgeAndFill.OnChanged += UpdateAllMats;
		}

		private Color GetFillColor(Color edgeColor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return edgeColor;
		}

		private void UpdateAllMats()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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)
			foreach (KeyValuePair<EnemyType, Material> item in _enemyMatCache)
			{
				EnemyType key = item.Key;
				Material value = item.Value;
				value.SetColor(SwapEdgeAndFill.Value ? "_WireframeColor" : "_FillColor", GetFillColor(FillColor.Value));
				value.SetColor(SwapEdgeAndFill.Value ? "_FillColor" : "_WireframeColor", EnemyEdgeColors[key].Value);
				value.SetFloat("_WireframeThickness", EdgeThickness.Value);
			}
		}

		public static Material? GetEnemyMat(EnemyType enemyType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0078: 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_0063: 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_0090: 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_0095: 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_00af: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (Instance == null)
			{
				return null;
			}
			if (_enemyMatCache.TryGetValue(enemyType, out Material value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Material material = EffectManager.GetMaterial("GeometryWireframeMaterial");
			if ((Object)(object)material == (Object)null)
			{
				Plugin.Log.LogError((object)"[Edges] Failed to load GeometryWireframeMaterial asset!");
				return null;
			}
			Color val = Color.red;
			if (Instance.EnemyEdgeColors.TryGetValue(enemyType, out Setting<Color> value2))
			{
				val = value2.Value;
			}
			Material val2 = new Material(material)
			{
				color = val
			};
			Color val3 = val;
			Color val4 = Instance?.FillColor.Value ?? Color.black;
			val2.SetColor("_WireframeColor", Instance.SwapEdgeAndFill.Value ? val4 : val3);
			val2.SetColor("_FillColor", Instance.SwapEdgeAndFill.Value ? val3 : val4);
			val2.SetFloat("_WireframeThickness", Instance.EdgeThickness.Value);
			_enemyMatCache[enemyType] = val2;
			return val2;
		}

		private void OnEnemyColorChanged(EnemyType enemyType, Color newColor)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (_enemyMatCache.TryGetValue(enemyType, out Material value) && (Object)(object)value != (Object)null)
			{
				value.color = newColor;
				value.SetColor(SwapEdgeAndFill.Value ? "_FillColor" : "_WireframeColor", newColor);
				value.SetFloat("_WireframeThickness", EdgeThickness.Value);
			}
		}

		protected override void OnEnable()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			EnemyEvents.OnSpawn += AddWireframizer;
			FillColor.OnChanged += UpdateAllMats;
			EdgeThickness.OnChanged += UpdateAllMats;
			UpdateAllMats();
			foreach (KeyValuePair<EnemyType, Setting<Color>> enemyEdgeColor in EnemyEdgeColors)
			{
				EnemyType enemyType = enemyEdgeColor.Key;
				Setting<Color> value = enemyEdgeColor.Value;
				Action<Color> action = delegate(Color newColor)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					OnEnemyColorChanged(enemyType, newColor);
				};
				_onColorChangedActions[enemyType] = action;
				value.OnValueChanged = (Action<Color>)Delegate.Combine(value.OnValueChanged, action);
				OnEnemyColorChanged(enemyType, value.Value);
			}
		}

		protected override void OnDisable()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			EnemyEvents.OnSpawn -= AddWireframizer;
			FillColor.OnChanged -= UpdateAllMats;
			EdgeThickness.OnChanged += UpdateAllMats;
			foreach (KeyValuePair<EnemyType, Setting<Color>> enemyEdgeColor in EnemyEdgeColors)
			{
				if (_onColorChangedActions.TryGetValue(enemyEdgeColor.Key, out Action<Color> value))
				{
					Setting<Color> value2 = enemyEdgeColor.Value;
					value2.OnValueChanged = (Action<Color>)Delegate.Remove(value2.OnValueChanged, value);
				}
			}
			_onColorChangedActions.Clear();
		}

		private void AddWireframizer(EnemyIdentifier eid)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			((Component)eid).gameObject.AddComponent<EnemyWireframizer>().TargetEnemyType = eid.enemyType;
		}
	}
	public class ParryEffect : ThornClient.Core.Module
	{
		public Setting<float> Fov { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "feedbacker");

		public override string[] Tags => new string[2] { "punch", "fov" };

		public ParryEffect()
			: base("thorn.parryEffect", "Parry Effect", "Adds a slight zoom to make parries feel more impactful", ModuleCategory.Render, (KeyCode)0, (KeyCode)0)
		{
			Fov = CreateSetting("fov", "FOV Adjustment", "The Field of view shift when parrying", -10f);
		}

		protected override void OnEnable()
		{
			PunchEvents.OnParry += PerformEffects;
		}

		protected override void OnDisable()
		{
			PunchEvents.OnParry -= PerformEffects;
		}

		private IEnumerator StopZoomNextFrame()
		{
			yield return null;
			CameraController instance = MonoSingleton<CameraController>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.StopZoom();
			}
		}

		private void PerformEffects()
		{
			CameraController instance = MonoSingleton<CameraController>.Instance;
			if ((Object)(object)instance != (Object)null && !Mathf.Approximately(Fov.Value, 0f))
			{
				float num = instance.cam.fieldOfView + Fov.Value;
				instance.Zoom(num);
				instance.cam.fieldOfView = num;
				((MonoBehaviour)Plugin.Instance).StartCoroutine(StopZoomNextFrame());
			}
		}
	}
	public class UIScaler : ThornClient.Core.Module
	{
		private float _savedDefaultScale;

		public Setting<float> Scale { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "screen_scale");

		public override string[] Tags => new string[2] { "interface", "scale" };

		public UIScaler()
			: base("thorn.uiScaler", "UI Scaler", "Changes the scale of the user interface", ModuleCategory.Render, (KeyCode)0, (KeyCode)0)
		{
			Scale = CreateSetting("scale", "Scale", "Smaller = smaller UI elements", 1f);
		}

		protected override void OnEnable()
		{
			UpdateScale(Scale.Value);
			SceneUtils.SafeSceneLoaded += UpdateScale;
			Setting<float> scale = Scale;
			scale.OnValueChanged = (Action<float>)Delegate.Combine(scale.OnValueChanged, new Action<float>(UpdateScale));
		}

		private void UpdateScale(float value)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			CanvasController instance = MonoSingleton<CanvasController>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				CanvasScaler component = ((Component)instance).gameObject.GetComponent<CanvasScaler>();
				if ((int)component.uiScaleMode == 1)
				{
					_savedDefaultScale = component.scaleFactor;
				}
				component.uiScaleMode = (ScaleMode)(Mathf.Approximately(value, 1f) ? 1 : 0);
				PrefsManager instance2 = MonoSingleton<PrefsManager>.Instance;
				float num = (((Object)(object)instance2 == (Object)null) ? 1920f : instance2.GetFloatLocal("resolutionWidth", 0f));
				if ((int)component.uiScaleMode == 0)
				{
					component.scaleFactor = num / (float)Screen.width * 1.5f * value;
				}
			}
		}

		private void UpdateScale(Scene scene, LoadSceneMode mode)
		{
			UpdateScale(Scale.Value);
		}

		protected override void OnDisable()
		{
			Setting<float> scale = Scale;
			scale.OnValueChanged = (Action<float>)Delegate.Remove(scale.OnValueChanged, new Action<float>(UpdateScale));
			SceneUtils.SafeSceneLoaded -= UpdateScale;
			UpdateScale(1f);
		}
	}
	public class ViewmodelTweaks : ThornClient.Core.Module
	{
		public static ViewmodelTweaks? Instance;

		private static readonly Vector3[,,] BasePositions = new Vector3[2, 5, 2]
		{
			{
				{
					new Vector3(0.42f, -0.6f, 1.49f),
					new Vector3(0.5f, -0.7f, 1.49f)
				},
				{
					new Vector3(0.42f, -0.6f, 1.49f),
					new Vector3(0.42f, -0.6f, 1.49f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				}
			},
			{
				{
					new Vector3(0.09f, -0.9f, 1.49f),
					new Vector3(0.09f, -0.9f, 1.49f)
				},
				{
					new Vector3(0f, -0.85f, 1.65f),
					new Vector3(-0.18f, -0.8f, 1.65f)
				},
				{
					new Vector3(-0.39f, -0.1f, 0.2f),
					new Vector3(-0.5f, -0.1f, 0.2f)
				},
				{
					new Vector3(-0.6f, -0.4f, 0.1f),
					new Vector3(-0.6f, -0.4f, 0.1f)
				},
				{
					new Vector3(-0.37f, -0.15f, 0.2f),
					new Vector3(-0.37f, -0.15f, 0.2f)
				}
			}
		};

		private static readonly Vector3[,,] BaseAngles = new Vector3[2, 5, 2]
		{
			{
				{
					new Vector3(0f, 90f, 20f),
					new Vector3(0f, 92f, 20f)
				},
				{
					new Vector3(0f, 90f, 20f),
					new Vector3(0f, 90f, 20f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				}
			},
			{
				{
					new Vector3(0f, 93f, 30f),
					new Vector3(0f, 93f, 25f)
				},
				{
					new Vector3(0f, 91f, 20f),
					new Vector3(0f, 90f, 25f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(0f, 0f, 0f),
					new Vector3(0f, 0f, 0f)
				},
				{
					new Vector3(5f, 5f, 0f),
					new Vector3(5f, 5f, 0f)
				}
			}
		};

		private static readonly Vector3[,,] BaseScales = new Vector3[2, 5, 2]
		{
			{
				{
					new Vector3(0.29f, 0.29f, 0.33f),
					new Vector3(0.3f, 0.3f, 0.4f)
				},
				{
					new Vector3(0.29f, 0.29f, 0.33f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1f),
					new Vector3(1f, 1f, 1f)
				}
			},
			{
				{
					new Vector3(0.29f, 0.29f, 0.33f),
					new Vector3(0.3f, 0.3f, 0.4f)
				},
				{
					new Vector3(0.29f, 0.29f, 0.33f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1f),
					new Vector3(1f, 1f, 1f)
				},
				{
					new Vector3(1f, 1f, 1.2f),
					new Vector3(1f, 1f, 1.2f)
				}
			}
		};

		public Setting<bool> Bobbing;

		public Setting<bool> WeaponEdges;

		public Setting<float> WeaponEdgeThickness;

		public Setting<Color> WeaponFillColor;

		public Setting<float> ModelRollOffset;

		public Setting<float> ModelPitchOffset;

		public Setting<float> ModelYawOffset;

		public Setting<float> ModelPosXOffset;

		public Setting<float> ModelPosYOffset;

		public Setting<float> ModelPosZOffset;

		public Setting<float> ModelScaleOffset;

		public Setting<float>[] WeaponModelRollOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelPitchOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelYawOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelPosXOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelPosYOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelPosZOffsets = new Setting<float>[8];

		public Setting<float>[] WeaponModelScaleOffsets = new Setting<float>[8];

		public static readonly string[] SettingWeaponNameMap = new string[8] { "Revolver", "Slab Revolver", "Shotgun", "Jackhammer", "Nailgun", "Sawblade Launcher", "Railgun", "Rocket Launcher" };

		private static Material?[] _matCache = (Material?[])(object)new Material[3];

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "axes");

		private static GunControl? gc => MonoSingleton<GunControl>.Instance;

		private static PrefsManager? prefs => MonoSingleton<PrefsManager>.Instance;

		private int GetSpecificWeaponVariantOffsetIndex(int weaponIndex, int altVariantIndex)
		{
			return weaponIndex switch
			{
				0 => altVariantIndex, 
				1 => 2 + altVariantIndex, 
				2 => 4 + altVariantIndex, 
				3 => 6, 
				4 => 7, 
				_ => -1, 
			};
		}

		public static Material? GetVariantMat(int variantIndex)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (variantIndex < 0 || variantIndex > 2 || Instance == null)
			{
				return null;
			}
			if ((Object)(object)_matCache[variantIndex] != (Object)null)
			{
				return _matCache[variantIndex];
			}
			Material material = EffectManager.GetMaterial("GeometryWireframeMaterial");
			if ((Object)(object)material == (Object)null)
			{
				Plugin.Log.LogError((object)"[ViewmodelTweaks] Failed to load GeometryWireframeMaterial asset!");
				return null;
			}
			_matCache[variantIndex] = new Material(material);
			Instance.UpdateVariantColors();
			return _matCache[variantIndex];
		}

		private void UpdateVariantColors()
		{
			//IL_001c: 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)
			for (int i = 0; i < 3; i++)
			{
				Material val = _matCache[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.SetColor("_WireframeColor", ColorUtils.GetWeaponVariantColor(i));
					val.SetColor("_FillColor", WeaponFillColor.Value);
					val.SetFloat("_WireframeThickness", WeaponEdgeThickness.Value);
				}
			}
		}

		public ViewmodelTweaks()
			: base("thorn.viewmodelTweaks", "Viewmodel Tweaks", "The viewmodel is your hands, basically.", ModuleCategory.Render, (KeyCode)0, (KeyCode)0)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (Instance == null)
			{
				Instance = this;
				CreateHeader("generalHeader", "General");
				Bobbing = CreateSetting("bobbing", "Bobbing", "Whether your hands wiggle when walking", defaultValue: true);
				WeaponEdges = CreateSetting("weaponEdges", "Edges skin", "Similar to the popular ULTRAEDGES skin. Cleaner but also more detailed. NOTE: to un-apply, you need to restart the mission", defaultValue: false);
				WeaponEdgeThickness = CreateSetting("weaponEdgeThickness", "Edge thickness", "Thickness of the edges", 2f);
				WeaponFillColor = CreateSetting<Color>("weaponFillColor", "Edges: fill color", "Color to fill surfaces between the lines", Color.black);
				CreateHeader("transformHeader", "Transformations");
				SettingGroup parent = CreateGroup("globalTransform", "Global", "Transformations that apply to all weapons");
				ModelRollOffset = CreateSetting("modelRollOffset", "Roll", "Tilting left/right", 0f, parent);
				ModelPitchOffset = CreateSetting("modelPitchOffset", "Pitch", "Pointing up/down", 0f, parent);
				ModelYawOffset = CreateSetting("modelYawOffset", "Yaw", "Turning left/right", 0f, parent);
				ModelPosXOffset = CreateSetting("modelPosXOffset", "Offset X", "Left/Right position", 0f, parent);
				ModelPosYOffset = CreateSetting("modelPosYOffset", "Offset Y", "Up/Down position", 0f, parent);
				ModelPosZOffset = CreateSetting("modelPosZOffset", "Offset Z", "Forward/Backward position", 0f, parent);
				ModelScaleOffset = CreateSetting("modelScaleOffset", "Scale", "Uniform scale offset", 0f, parent);
				for (int i = 0; i < WeaponModelRollOffsets.Length; i++)
				{
					SettingGroup parent2 = CreateGroup($"transGroup{i}", SettingWeaponNameMap[i], "Transformations that apply to " + SettingWeaponNameMap[i]);
					WeaponModelRollOffsets[i] = CreateSetting($"weapon{i}ModelRollOffset", "Roll", "Tilting left/right", 0f, parent2);
					WeaponModelPitchOffsets[i] = CreateSetting($"weapon{i}ModelPitchOffset", "Pitch", "Pointing up/down", 0f, parent2);
					WeaponModelYawOffsets[i] = CreateSetting($"weapon{i}ModelYawOffset", "Yaw", "Turning left/right", 0f, parent2);
					WeaponModelPosXOffsets[i] = CreateSetting($"weapon{i}ModelPosXOffset", "Offset X", "Left/Right position", 0f, parent2);
					WeaponModelPosYOffsets[i] = CreateSetting($"weapon{i}ModelPosYOffset", "Offset Y", "Up/Down position", 0f, parent2);
					WeaponModelPosZOffsets[i] = CreateSetting($"weapon{i}ModelPosZOffset", "Offset Z", "Forward/Backward position", 0f, parent2);
					WeaponModelScaleOffsets[i] = CreateSetting($"weapon{i}ModelScaleOffset", "Scale", "Uniform scale offset", 0f, parent2);
				}
				SceneUtils.SafeSceneLoadedNoParam += delegate
				{
					gc.OnWeaponChange -= UpdateCurrentNextFrame;
				};
			}
		}

		protected override void OnEnable()
		{
			SceneUtils.SafeSceneLoadedNoParam += OnSceneLoadedWhenEnabled;
			Setting<float> modelRollOffset = ModelRollOffset;
			modelRollOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelRollOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPitchOffset = ModelPitchOffset;
			modelPitchOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelPitchOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelYawOffset = ModelYawOffset;
			modelYawOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelYawOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosXOffset = ModelPosXOffset;
			modelPosXOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelPosXOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosYOffset = ModelPosYOffset;
			modelPosYOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelPosYOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosZOffset = ModelPosZOffset;
			modelPosZOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelPosZOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelScaleOffset = ModelScaleOffset;
			modelScaleOffset.OnValueChanged = (Action<float>)Delegate.Combine(modelScaleOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			for (int i = 0; i < WeaponModelRollOffsets.Length; i++)
			{
				Setting<float> obj = WeaponModelRollOffsets[i];
				obj.OnValueChanged = (Action<float>)Delegate.Combine(obj.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj2 = WeaponModelPitchOffsets[i];
				obj2.OnValueChanged = (Action<float>)Delegate.Combine(obj2.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj3 = WeaponModelYawOffsets[i];
				obj3.OnValueChanged = (Action<float>)Delegate.Combine(obj3.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj4 = WeaponModelPosXOffsets[i];
				obj4.OnValueChanged = (Action<float>)Delegate.Combine(obj4.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj5 = WeaponModelPosYOffsets[i];
				obj5.OnValueChanged = (Action<float>)Delegate.Combine(obj5.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj6 = WeaponModelPosZOffsets[i];
				obj6.OnValueChanged = (Action<float>)Delegate.Combine(obj6.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj7 = WeaponModelScaleOffsets[i];
				obj7.OnValueChanged = (Action<float>)Delegate.Combine(obj7.OnValueChanged, new Action<float>(UpdateCurrent));
			}
			if (!SceneUtils.IsInGame())
			{
				SceneUtils.SafeSceneLoadedNoParam += SubscribeStuffWhenSafe;
			}
			else
			{
				SubscribeStuffWhenSafe();
				UpdateCurrentNextFrame();
			}
			Bobbing.OnChanged += UpdateBobbing;
			WeaponEdges.OnChanged += UpdateCurrentColor;
			WeaponFillColor.OnChanged += UpdateVariantColors;
			WeaponEdgeThickness.OnChanged += UpdateVariantColors;
		}

		private void SubscribeStuffWhenSafe()
		{
			if (SceneUtils.IsInGame() && (Object)(object)gc != (Object)null)
			{
				gc.OnWeaponChange += UpdateCurrentNextFrame;
				UpdateBobbing();
				SceneUtils.SafeSceneLoadedNoParam -= SubscribeStuffWhenSafe;
			}
		}

		protected override void OnDisable()
		{
			WeaponEdges.OnChanged -= UpdateCurrentColor;
			WeaponEdgeThickness.OnChanged -= UpdateVariantColors;
			WeaponFillColor.OnChanged -= UpdateVariantColors;
			Bobbing.OnChanged -= UpdateBobbing;
			SceneUtils.SafeSceneLoadedNoParam -= OnSceneLoadedWhenEnabled;
			Setting<float> modelRollOffset = ModelRollOffset;
			modelRollOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelRollOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPitchOffset = ModelPitchOffset;
			modelPitchOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelPitchOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelYawOffset = ModelYawOffset;
			modelYawOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelYawOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosXOffset = ModelPosXOffset;
			modelPosXOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelPosXOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosYOffset = ModelPosYOffset;
			modelPosYOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelPosYOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelPosZOffset = ModelPosZOffset;
			modelPosZOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelPosZOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			Setting<float> modelScaleOffset = ModelScaleOffset;
			modelScaleOffset.OnValueChanged = (Action<float>)Delegate.Remove(modelScaleOffset.OnValueChanged, new Action<float>(UpdateCurrent));
			for (int i = 0; i < WeaponModelRollOffsets.Length; i++)
			{
				Setting<float> obj = WeaponModelRollOffsets[i];
				obj.OnValueChanged = (Action<float>)Delegate.Remove(obj.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj2 = WeaponModelPitchOffsets[i];
				obj2.OnValueChanged = (Action<float>)Delegate.Remove(obj2.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj3 = WeaponModelYawOffsets[i];
				obj3.OnValueChanged = (Action<float>)Delegate.Remove(obj3.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj4 = WeaponModelPosXOffsets[i];
				obj4.OnValueChanged = (Action<float>)Delegate.Remove(obj4.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj5 = WeaponModelPosYOffsets[i];
				obj5.OnValueChanged = (Action<float>)Delegate.Remove(obj5.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj6 = WeaponModelPosZOffsets[i];
				obj6.OnValueChanged = (Action<float>)Delegate.Remove(obj6.OnValueChanged, new Action<float>(UpdateCurrent));
				Setting<float> obj7 = WeaponModelScaleOffsets[i];
				obj7.OnValueChanged = (Action<float>)Delegate.Remove(obj7.OnValueChanged, new Action<float>(UpdateCurrent));
			}
			SceneUtils.SafeSceneLoadedNoParam -= SubscribeStuffWhenSafe;
			ResetAllTransforms();
		}

		private int GetMiddleIndex()
		{
			if ((Object)(object)prefs == (Object)null)
			{
				return 0;
			}
			return (prefs.GetInt("weaponHoldPosition", 0) == 1) ? 1 : 0;
		}

		private void OnSceneLoadedWhenEnabled()
		{
			UpdateCurrentNextFrame();
			Toggle();
			Toggle();
			if ((Object)(object)gc != (Object)null)
			{
				ExecutionUtils.RunNextFrame((Action)delegate
				{
					gc.ForceWeapon(gc.currentWeapon, true);
				});
			}
		}

		private void UpdateCurrentNextFrame(GameObject _)
		{
			UpdateCurrentNextFrame();
		}

		private void UpdateCurrentNextFrame()
		{
			if (SceneUtils.IsInGame())
			{
				ExecutionUtils.RunNextFrame((Action)UpdateCurrent);
			}
		}

		private void UpdateCurrent(GameObject _)
		{
			UpdateCurrent();
		}

		private void UpdateCurrent(float _)
		{
			UpdateCurrent();
		}

		private void UpdateCurrent()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: 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_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: 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_0214: 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_0224: 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_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_0199: 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_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			if (!SceneUtils.IsInGame() || (Object)(object)gc == (Object)null || (Object)(object)prefs == (Object)null || gc.currentSlotIndex >= 6 || gc.currentVariationIndex >= 3)
			{
				return;
			}
			UpdateCurrentColor();
			int middleIndex = GetMiddleIndex();
			int num = gc.currentSlotIndex - 1;
			int num2 = 0;
			GameObject currentWeapon = gc.currentWeapon;
			if ((Object)(object)currentWeapon == (Object)null)
			{
				return;
			}
			switch (num)
			{
			case 0:
			{
				Revolver component2 = currentWeapon.GetComponent<Revolver>();
				if (component2 != null && component2.altVersion)
				{
					num2 = 1;
				}
				break;
			}
			case 1:
				if ((Object)(object)currentWeapon.GetComponent<ShotgunHammer>() != (Object)null)
				{
					num2 = 1;
				}
				break;
			case 2:
			{
				Nailgun component = currentWeapon.GetComponent<Nailgun>();
				if (component != null && component.altVersion)
				{
					num2 = 1;
				}
				break;
			}
			}
			int specificWeaponVariantOffsetIndex = GetSpecificWeaponVariantOffsetIndex(num, num2);
			currentWeapon.GetComponent<WeaponPos>();
			Vector3 val = BasePositions[middleIndex, num, num2];
			Vector3 val2 = BaseAngles[middleIndex, num, num2];
			Vector3 val3 = BaseScales[middleIndex, num, num2];
			Vector3 val4 = default(Vector3);
			((Vector3)(ref val4))..ctor(ModelPosXOffset.Value, ModelPosYOffset.Value, ModelPosZOffset.Value);
			Vector3 val5 = default(Vector3);
			((Vector3)(ref val5))..ctor(ModelPitchOffset.Value, ModelYawOffset.Value, ModelRollOffset.Value);
			float num3 = ModelScaleOffset.Value;
			if (specificWeaponVariantOffsetIndex != -1)
			{
				val4 += new Vector3(WeaponModelPosXOffsets[specificWeaponVariantOffsetIndex].Value, WeaponModelPosYOffsets[specificWeaponVariantOffsetIndex].Value, WeaponModelPosZOffsets[specificWeaponVariantOffsetIndex].Value);
				val5 += new Vector3(WeaponModelPitchOffsets[specificWeaponVariantOffsetIndex].Value, WeaponModelYawOffsets[specificWeaponVariantOffsetIndex].Value, WeaponModelRollOffsets[specificWeaponVariantOffsetIndex].Value);
				num3 += WeaponModelScaleOffsets[specificWeaponVariantOffsetIndex].Value;
			}
			float num4 = (IsEnabled ? 1 : 0);
			Vector3 targetPos = val + val4 * num4;
			Vector3 targetAngle = val2 + val5 * num4;
			Vector3 targetScale = val3 + Vector3.one * num3 * num4;
			SetTransform(currentWeapon, targetPos, targetAngle, targetScale);
		}

		private void UpdateCurrentColor()
		{
			if (!WeaponEdges.Value || (Object)(object)gc == (Object)null)
			{
				return;
			}
			_ = gc.currentVariationIndex;
			Material variantMat = GetVariantMat(GunHelper.GetVariation(gc.currentWeapon, gc.currentSlotIndex - 1));
			GameObject currentWeapon = gc.currentWeapon;
			Renderer[] array = ((currentWeapon == null) ? null : currentWeapon.GetComponentsInChildren<Renderer>(true)?.Where((Renderer r) => (r is MeshRenderer || r is SkinnedMeshRenderer) ? true : false)?.ToArray()) ?? Array.Empty<Renderer>();
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				List<Material> list = new List<Material>();
				val.GetSharedMaterials(list);
				int count = list.Count;
				if (count == 0)
				{
					continue;
				}
				bool flag = false;
				for (int num2 = 0; num2 < count; num2++)
				{
					if ((Object)(object)list[num2] != (Object)(object)variantMat)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					Material[] array2 = (Material[])(object)new Material[count];
					for (int num3 = 0; num3 < count; num3++)
					{
						array2[num3] = variantMat;
					}
					val.sharedMaterials = array2;
				}
			}
			UpdateVariantColors();
		}

		private void SetTransform(GameObject weapon, Vector3 targetPos, Vector3 targetAngle, Vector3 targetScale)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = weapon.transform;
			transform.localPosition = targetPos;
			transform.localEulerAngles = targetAngle;
			transform.localScale = targetScale;
		}

		private void ResetAllTransforms()
		{
			int middleIndex = GetMiddleIndex();
			ResetTransforms<Revolver>(middleIndex, 0);
			ResetTransforms<Shotgun>(middleIndex, 1);
			ResetTransforms<ShotgunHammer>(middleIndex, 1);
			ResetTransforms<Nailgun>(middleIndex, 2);
			ResetTransforms<Railcannon>(middleIndex, 3);
			ResetTransforms<RocketLauncher>(middleIndex, 4);
		}

		private void ResetTransforms<T>(int middleIndex, int weaponIndex) where T : MonoBehaviour
		{
			//IL_006d: 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_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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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)
			if (middleIndex >= 2 || weaponIndex >= 5)
			{
				return;
			}
			T[] array = Object.FindObjectsByType<T>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			T val;
			int num;
			Vector3 targetPos;
			Vector3 targetAngle;
			Vector3 targetScale;
			for (int i = 0; i < array.Length; targetPos = BasePositions[middleIndex, weaponIndex, num], targetAngle = BaseAngles[middleIndex, weaponIndex, num], targetScale = BaseScales[middleIndex, weaponIndex, num], SetTransform(((Component)(object)val).gameObject, targetPos, targetAngle, targetScale), i++)
			{
				val = array[i];
				num = 0;
				if (!(val is ShotgunHammer))
				{
					object obj = val;
					Revolver val2 = (Revolver)((obj is Revolver) ? obj : null);
					if (val2 == null || !val2.altVersion)
					{
						object obj2 = val;
						Nailgun val3 = (Nailgun)((obj2 is Nailgun) ? obj2 : null);
						if (val3 == null || !val3.altVersion)
						{
							continue;
						}
					}
				}
				num = 1;
			}
		}

		private void UpdateBobbing()
		{
			if (SceneUtils.IsSafe() && !((Object)(object)gc == (Object)null))
			{
				WalkingBob component = ((Component)gc).GetComponent<WalkingBob>();
				if (!((Object)(object)component == (Object)null))
				{
					((Behaviour)component).enabled = Bobbing.Value;
				}
			}
		}
	}
}
namespace ThornClient.Modules.Misc
{
	public class CancelLeaderboard : ThornClient.Core.Module
	{
		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "no_trophy");

		public override string[] Tags => new string[5] { "cheat", "surrender", "fair play", "score", "rank" };

		public override string CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Obviously";
			}
		}

		public CancelLeaderboard()
			: base("thorn.cancelLeaderboard", "Cancel Leaderboard", "Voluntarily exclude scores from the leaderboard. Useful when you're using cheaty mods that don't do this themselves", ModuleCategory.Misc, (KeyCode)0, (KeyCode)0)
		{
		}

		protected override void OnEnable()
		{
			CheatManager.UpdateCheatiness();
		}
	}
	public class RunInBackground : ThornClient.Core.Module
	{
		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "window_play_background");

		public override string[] Tags => new string[4] { "inactive", "afk", "background", "naruto" };

		public RunInBackground()
			: base("thorn.runInBackground", "Run in Background", "Keeps the game running when the window is not focused", ModuleCategory.Misc, (KeyCode)0, (KeyCode)0)
		{
		}

		protected override void OnEnable()
		{
			Application.runInBackground = true;
		}

		protected override void OnDisable()
		{
			Application.runInBackground = false;
		}
	}
	internal abstract class TestModule : ThornClient.Core.Module
	{
		public enum NonEmulatorYuzu
		{
			Yoshino,
			Mako,
			Lena,
			Murasame,
			Roka,
			Koharu
		}

		public enum Baka
		{
			Miku,
			Teto,
			Neru
		}

		public Setting<bool> Bulul { get; }

		public Setting<bool> BululCheck { get; }

		public Setting<int> Inoue { get; }

		public Setting<float> Flatorte { get; }

		public Setting<string> Tung { get; }

		public Setting<Color> Carbonara { get; }

		public Setting<NonEmulatorYuzu> Cutie { get; }

		public Setting<Baka> FavouriteBaka { get; }

		public Setting<EnemyList> Enemiez { get; }

		public Setting<float> Slippery { get; }

		public SettingGroup NestedGroup { get; }

		public SettingGroup DoubleNestedGroup { get; }

		public override string[] Tags => new string[3] { "system", "debug", "developer" };

		public TestModule()
			: base("thorn.test", "Test module", "For UI debugging. This should be removed before release.", ModuleCategory.Misc, (KeyCode)0, (KeyCode)0)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Bulul = CreateSetting("boolField", "Bool setting", "Either \"Brother that is the fakest statement I've ever seen\" or \"holy SHIT\"", defaultValue: false);
			BululCheck = CreateSetting("boolFieldCheck", "Checkmark bool setting", "Either \"Brother that is the fakest statement I've ever seen\" or \"holy SHIT\"", defaultValue: true);
			BululCheck.Hints = new InterfaceHints
			{
				BoolPreferCheckmark = true
			};
			Inoue = CreateSetting("intField", "Int", "int field!!", 2);
			Flatorte = CreateSetting("floatField", "Floatie", "float field!!", 4f);
			Tung = CreateSetting("textField", "Yap field", "Here bro have a tung tung", "sahur");
			Carbonara = CreateSetting<Color>("colorField", "Some color!", "Color field description", new Color(0.86f, 0.82f, 0.71f, 1f));
			Cutie = CreateSetting("favouriteCutie", "Favorite cutie", "h", NonEmulatorYuzu.Mako);
			CreateHeader("beyondBasics", "Beyond basics");
			CreateHeader("subcat", "Subcategory", "", HeaderType.H2);
			NestedGroup = CreateGroup("nestedGroup", "Nested group", "Just a test");
			FavouriteBaka = CreateSetting("favouriteBaka", "Favourite baka", "popipo popipo", Baka.Miku, NestedGroup);
			DoubleNestedGroup = CreateGroup("nestederGroup", "Nestier group", "Nesty testy", NestedGroup);
			CreateHeader("subcat2", "Subcategory 2", "", HeaderType.H2);
			Enemiez = CreateSetting("enemiez", "Funny monsters field", "spooky scary skeleton", new EnemyList(), NestedGroup);
			Slippery = CreateSetting("slippery", "Slider field", "pls slide", 0.7f, DoubleNestedGroup);
			Slippery.Hints = new InterfaceHints
			{
				Range = Tuple.Create(0f, 1f),
				Decimals = 2
			};
			ConfigButtonRow configButtonRow = CreateButtonRow("btnRow", "Button Row Name", "Eyyyyy", new string[4] { "Helium", "Nitrogen", "Tantalum", "Iodine" });
			configButtonRow.OnClick = (Action<int>)Delegate.Combine(configButtonRow.OnClick, (Action<int>)delegate(int x)
			{
				NotificationSystem.NotifySend("Thorn::Debug", $"Clicked button numba {x}", (Sprite)null, "", (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
			});
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[2] { "Foo", "Bar" });
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[1] { "Five" });
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[2] { "Five", "little" });
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[3] { "Five", "little", "Chuddies" });
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[4] { "Five", "little", "Chuddies", "jumping" });
			CreateButtonRow("_", "Overflow", "Useless buttons just to test overflow scrolling", new string[5] { "Five", "little", "Chuddies", "jumping", "on" });
		}

		protected override void OnEnable()
		{
			NotificationSystem.NotifySend("Thorn::Debug", "Enabled", (Sprite)null, "", (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
		}

		protected override void OnDisable()
		{
			NotificationSystem.NotifySend("Thorn::Debug", "Disabled", (Sprite)null, "", (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
		}
	}
}
namespace ThornClient.Modules.HUD
{
	public class ActiveModules : TextHudModule
	{
		private SortedList<string, ThornClient.Core.Module> _modules = new SortedList<string, ThornClient.Core.Module>();

		public override string[] Tags => new string[3] { "module", "control", "system" };

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "list");

		public ActiveModules()
			: base("thorn.activeModules", "Active Modules", "A list of active modules")
		{
		}

		protected override void OnHudModuleEnable()
		{
			ModuleManager.SomeModuleToggled = (Action<ThornClient.Core.Module, bool>)Delegate.Combine(ModuleManager.SomeModuleToggled, new Action<ThornClient.Core.Module, bool>(UpdateWholeList));
			UpdateWholeList();
		}

		protected override void OnHudModuleDisable()
		{
			ModuleManager.SomeModuleToggled = (Action<ThornClient.Core.Module, bool>)Delegate.Remove(ModuleManager.SomeModuleToggled, new Action<ThornClient.Core.Module, bool>(UpdateWholeList));
		}

		private void UpdateWholeList(Scene _, LoadSceneMode __)
		{
			UpdateWholeList();
		}

		private void UpdateWholeList(ThornClient.Core.Module module, bool enabled)
		{
			UpdateWholeList();
		}

		private void UpdateWholeList()
		{
			_modules = new SortedList<string, ThornClient.Core.Module>(ModuleManager.Items.Where((ThornClient.Core.Module m) => m.IsEnabled && !(m is SystemModule) && !(m is HudModule)).ToDictionary((ThornClient.Core.Module m) => m.Name, (ThornClient.Core.Module m) => m));
			SyncText();
		}

		private void SyncText()
		{
			base.Text = string.Join("\n", _modules.Values.Select((ThornClient.Core.Module m) => m.Name));
		}
	}
	public class DPSDisplay : ContinuousCumulatedStatHudModule
	{
		public Setting<bool> ShowDpsText;

		private float _cum;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "fire");

		public override string[] Tags => new string[3] { "damage", "burst", "firepower" };

		public DPSDisplay()
			: base("thorn.dpsDisplay", "DPS", "Shows damage per second")
		{
			ShowDpsText = CreateSetting("showDpsText", "Show \"DPS\" text", "Makes the indicator say \"DPS:20\" instead of \"20\"", defaultValue: true);
		}

		protected override void OnHudModuleEnable()
		{
			EnemyEvents.OnDamageTaken += CumulateDamage;
		}

		protected override void OnHudModuleDisable()
		{
			EnemyEvents.OnDamageTaken -= CumulateDamage;
		}

		private void CumulateDamage(EnemyIdentifier eid, float dmg)
		{
			_cum += dmg;
		}

		protected override float CollectUpdate()
		{
			float cum = _cum;
			_cum = 0f;
			return cum;
		}

		protected override string FormatStat(float value)
		{
			string arg = (ShowDpsText.Value ? "DPS:" : "");
			return $"{arg}{Math.Round(value, 1)}";
		}
	}
	public class Fist : FramedHudModule
	{
		private class FistController : MonoBehaviour
		{
			private Image? _bg;

			private Image? _fg;

			private HudVariantColorSyncer? _bgCol;

			private HudVariantColorSyncer? _fgCol;

			private void OnEnable()
			{
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Background");
				_bg = ((obj != null) ? obj.GetComponent<Image>() : null);
				GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Panel");
				_fg = ((obj2 != null) ? obj2.GetComponent<Image>() : null);
				if (!((Object)(object)_bg == (Object)null) && !((Object)(object)_fg == (Object)null))
				{
					_bgCol = GameObjectExtensions.GetOrAddComponent<HudVariantColorSyncer>(((Component)_bg).gameObject);
					_bgCol.ColorMultiplier = 0.2f;
					_fgCol = GameObjectExtensions.GetOrAddComponent<HudVariantColorSyncer>(((Component)_fg).gameObject);
					if ((Object)(object)MonoSingleton<FistControl>.Instance != (Object)null)
					{
						MonoSingleton<FistControl>.Instance.FistIconUpdated += UpdateIcon;
					}
					UpdateIcon();
				}
			}

			private void OnDisable()
			{
				if ((Object)(object)MonoSingleton<FistControl>.Instance != (Object)null)
				{
					MonoSingleton<FistControl>.Instance.FistIconUpdated -= UpdateIcon;
				}
			}

			private void Update()
			{
				if (!((Object)(object)_fg == (Object)null) && !((Object)(object)MonoSingleton<WeaponCharges>.Instance == (Object)null))
				{
					float num = MonoSingleton<WeaponCharges>.Instance.punchStamina / 2f;
					if (!Mathf.Approximately(num, _fg.fillAmount))
					{
						_fg.fillAmount = num;
					}
				}
			}

			private void UpdateIcon()
			{
				UpdateIcon(PlayerPrefs.GetInt("CurArm", 0));
			}

			private void UpdateIcon(int fistVariant)
			{
				if (fistVariant == 0 || fistVariant == 1)
				{
					int variation = fistVariant * 2;
					if ((Object)(object)_bgCol != (Object)null)
					{
						_bgCol.Variation = variation;
					}
					if ((Object)(object)_fgCol != (Object)null)
					{
						_fgCol.Variation = variation;
					}
					if (!((Object)(object)_bg == (Object)null) && !((Object)(object)_fg == (Object)null))
					{
						string assetName = ((fistVariant == 1) ? "knuckleblaster" : "feedbacker");
						_bg.sprite = AssetManager.Get<Sprite>(HudManager.BundleKey, assetName);
						_fg.sprite = AssetManager.Get<Sprite>(HudManager.BundleKey, assetName);
					}
				}
			}
		}

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "feedbacker");

		public override string[] Tags => new string[4] { "hand", "punch", "feedbacker", "knuckleblaster" };

		public Fist()
			: base("thorn.fist", "Fist", "Shows punch cooldowns")
		{
		}

		protected override GameObject CreateContentObject()
		{
			GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "FistPanel"));
			obj.AddComponent<FistController>();
			return obj;
		}
	}
	public class FPSDisplay : ContinuousCumulatedStatHudModule
	{
		public Setting<bool> ShowFpsText;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "fps");

		public override string[] Tags => new string[2] { "performance", "frame" };

		public FPSDisplay()
			: base("thorn.fpsDisplay", "FPS", "Shows framerate")
		{
			ShowFpsText = CreateSetting("showFpsText", "Show \"FPS\" text", "Makes the indicator say \"FPS:60\" instead of \"60\"", defaultValue: true);
		}

		protected override float CollectUpdate()
		{
			return 1f;
		}

		protected override string FormatStat(float value)
		{
			string arg = (ShowFpsText.Value ? "FPS:" : "");
			return $"{arg}{Math.Round(value)}";
		}
	}
	public class Gun : FramedHudModule
	{
		private class GunIconController : MonoBehaviour
		{
			private Image? _icon;

			private HudVariantColorSyncer? _iconColSyncer;

			private GunControl? Gci => MonoSingleton<GunControl>.Instance;

			private void OnEnable()
			{
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Icon");
				_icon = ((obj != null) ? obj.GetComponent<Image>() : null);
				_iconColSyncer = ComponentExtensions.GetOrAddComponent<HudVariantColorSyncer>((Component)(object)_icon);
				if (!((Object)(object)_icon == (Object)null))
				{
					if ((Object)(object)Gci != (Object)null)
					{
						Gci.OnWeaponChange += UpdateIcon;
					}
					UpdateIcon();
				}
			}

			private void OnDisable()
			{
				if ((Object)(object)Gci != (Object)null)
				{
					Gci.OnWeaponChange -= UpdateIcon;
				}
			}

			private void UpdateIcon()
			{
				UpdateIcon(Gci?.currentWeapon);
			}

			private void UpdateIcon(GameObject? gob)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected I4, but got Unknown
				if ((Object)(object)gob == (Object)null)
				{
					return;
				}
				WeaponIcon component = gob.GetComponent<WeaponIcon>();
				if (!((Object)(object)component == (Object)null))
				{
					Sprite icon = component.weaponDescriptor.icon;
					int variation = (int)component.weaponDescriptor.variationColor;
					if ((Object)(object)_icon != (Object)null)
					{
						_icon.sprite = icon;
					}
					if ((Object)(object)_iconColSyncer != (Object)null)
					{
						_iconColSyncer.Variation = variation;
					}
				}
			}
		}

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "gun");

		public override string[] Tags => new string[3] { "variant", "gun", "weapon" };

		public Gun()
			: base("thorn.gun", "Gun", "Shows currently equipped icon")
		{
		}

		protected override GameObject CreateContentObject()
		{
			GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "GunPanel"));
			obj.AddComponent<GunIconController>();
			return obj;
		}
	}
	public class HammerStats : FramedHudModule
	{
		private class HammerCooldownController : MonoBehaviour
		{
			public HammerStats? ParentModule;

			private GameObject?[] _bgs = (GameObject?[])(object)new GameObject[3];

			private GameObject?[] _fgs = (GameObject?[])(object)new GameObject[3];

			private Image?[] _fgis = (Image?[])(object)new Image[3];

			private HudVariantColorSyncer?[] _bgCols = new HudVariantColorSyncer[3];

			private HudVariantColorSyncer?[] _fgCols = new HudVariantColorSyncer[3];

			private int[] _variantMap = new int[3] { 0, 1, 2 };

			private BatchBoolSettingVisibilitySyncer? _visibilitySyncer;

			private Slider? _heatBar;

			private Image? _heatFill;

			private static float FullVariantHeatCooldown = 7f;

			private static float GlobalYellowCooldown = 3f;

			private void Start()
			{
				if (ParentModule != null)
				{
					_visibilitySyncer = GameObjectExtensions.GetOrAddComponent<BatchBoolSettingVisibilitySyncer>(((Component)this).gameObject);
					_visibilitySyncer.SyncPairs = new Dictionary<Setting<bool>, string> { { ParentModule.ShowYellowHeatBar, "YellowHeatBar" } };
				}
			}

			private void OnEnable()
			{
				for (int i = 0; i < 3; i++)
				{
					_bgs[i] = UIUtils.FindRecursive(((Component)this).gameObject, $"Variants/{i}");
					HudVariantColorSyncer?[] bgCols = _bgCols;
					int num = i;
					GameObject? obj = _bgs[i];
					bgCols[num] = ((obj != null) ? GameObjectExtensions.GetOrAddComponent<HudVariantColorSyncer>(obj) : null);
					GameObject?[] fgs = _fgs;
					int num2 = i;
					GameObject? obj2 = _bgs[i];
					fgs[num2] = ((obj2 != null) ? UIUtils.FindRecursive(obj2, "Fill") : null);
					HudVariantColorSyncer?[] fgCols = _fgCols;
					int num3 = i;
					GameObject? obj3 = _fgs[i];
					fgCols[num3] = ((obj3 != null) ? GameObjectExtensions.GetOrAddComponent<HudVariantColorSyncer>(obj3) : null);
					Image?[] fgis = _fgis;
					int num4 = i;
					GameObject? obj4 = _fgs[i];
					fgis[num4] = ((obj4 != null) ? GameObjectExtensions.GetOrAddComponent<Image>(obj4) : null);
					if ((Object)(object)_bgCols[i] != (Object)null)
					{
						_bgCols[i].ColorMultiplier = 0.2f;
					}
				}
				GameObject obj5 = UIUtils.FindRecursive(((Component)this).gameObject, "YellowHeatBar");
				_heatBar = ((obj5 != null) ? obj5.GetComponent<Slider>() : null);
				GameObject obj6 = UIUtils.FindRecursive(((Component)this).gameObject, "YellowHeatBar/Fill Area/Fill");
				_heatFill = ((obj6 != null) ? obj6.GetComponent<Image>() : null);
				SyncVariantLayout();
				PrefsHelper.Subscribe("weapon.sho.order", (Action)SyncVariantLayout);
				PrefsHelper.Subscribe("weapon.sho0", (Action)SyncVariantLayout);
				PrefsHelper.Subscribe("weapon.sho1", (Action)SyncVariantLayout);
				PrefsHelper.Subscribe("weapon.sho2", (Action)SyncVariantLayout);
			}

			private void OnDisable()
			{
				PrefsHelper.Unsubscribe("weapon.sho.order", (Action)SyncVariantLayout);
				PrefsHelper.Unsubscribe("weapon.sho0", (Action)SyncVariantLayout);
				PrefsHelper.Unsubscribe("weapon.sho1", (Action)SyncVariantLayout);
				PrefsHelper.Unsubscribe("weapon.sho2", (Action)SyncVariantLayout);
			}

			private void Update()
			{
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)wc == (Object)null)
				{
					return;
				}
				for (int i = 0; i < 3; i++)
				{
					GameObject? obj = _bgs[i];
					if (obj == null || obj.activeSelf)
					{
						float num = wc.shoaltcooldowns[_variantMap[i]];
						float num2 = 1f - num / FullVariantHeatCooldown;
						if ((Object)(object)_fgis[i] != (Object)null && !Mathf.Approximately(_fgis[i].fillAmount, num2))
						{
							_fgis[i].fillAmount = num2;
						}
					}
				}
				if (ParentModule == null || !ParentModule.ShowYellowHeatBar.Value || !((Object)(object)_heatBar != (Object)null) || !((Object)(object)_heatFill != (Object)null))
				{
					return;
				}
				int shoAltYellows = wc.shoAltYellows;
				bool num3 = shoAltYellows >= MaxYellowHits;
				float num4 = 0f;
				if (num3)
				{
					if (!ColorUtils.Approximately(((Graphic)_heatFill).color, ParentModule.OverheatBarColor.Value))
					{
						((Graphic)_heatFill).color = ParentModule.OverheatBarColor.Value;
					}
					num4 = wc.shoAltYellowsTimer / GlobalYellowCooldown;
				}
				else
				{
					if (!ColorUtils.Approximately(((Graphic)_heatFill).color, ParentModule.YellowHeatBarColor.Value))
					{
						((Graphic)_heatFill).color = ParentModule.YellowHeatBarColor.Value;
					}
					num4 = (float)shoAltYellows / (float)MaxYellowHits;
				}
				if (!Mathf.Approximately(num4, _heatBar.value))
				{
					_heatBar.value = num4;
				}
			}

			private void SyncVariantLayout()
			{
				if ((Object)(object)prefs == (Object)null)
				{
					return;
				}
				string text = prefs.GetString("weapon.sho.order", "1234").Replace("4", "");
				if (text == null || text.Length != 3 || !text.All(char.IsDigit))
				{
					text = "123";
				}
				for (int i = 0; i < 3; i++)
				{
					int num = Math.Clamp(int.Parse($"{text[i]}") - 1, 0, 2);
					_variantMap[i] = num;
					if ((Object)(object)_bgCols[i] != (Object)null)
					{
						_bgCols[i].Variation = num;
					}
					if ((Object)(object)_fgCols[i] != (Object)null)
					{
						_fgCols[i].Variation = num;
					}
					bool flag = prefs.GetInt($"weapon.sho{num}", 0) == 2;
					if (_bgs[i].activeSelf != flag)
					{
						GameObject? obj = _bgs[i];
						if (obj != null)
						{
							obj.SetActive(flag);
						}
						UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
					}
				}
			}
		}

		public Setting<bool> ShowYellowHeatBar;

		public Setting<Color> YellowHeatBarColor;

		public Setting<Color> OverheatBarColor;

		private GameObject _contentObject;

		public static readonly int MaxYellowHits = 3;

		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "jackhammer");

		public override string[] Tags => new string[3] { "jackhammer", "alternative shotgun", "impact hammer" };

		private static GunControl? gc => MonoSingleton<GunControl>.Instance;

		private static WeaponCharges? wc => MonoSingleton<WeaponCharges>.Instance;

		private static PrefsManager? prefs => MonoSingleton<PrefsManager>.Instance;

		public HammerStats()
			: base("thorn.hammerStats", "Hammer Stats", "Shows Jackhammer heat for individual variants and global cooldown")
		{
			//IL_0052: 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)
			ShowYellowHeatBar = CreateSetting("showYellowHeatBar", "Show global heat bar", "Shows the number of hits before the next one overheats any hammer", defaultValue: true);
			YellowHeatBarColor = CreateSetting<Color>("yellowHeatBarColor", "Heat Bar Color", "The color of the heat bar in its normal state", new Color(1f, 0.9f, 0.3f));
			OverheatBarColor = CreateSetting<Color>("overheatBarColor", "Overheat Color", "The color of the heat bar in its normal state", new Color(1f, 0f, 0f));
		}

		protected override GameObject CreateContentObject()
		{
			_contentObject = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "HammerLayout"));
			GameObjectExtensions.GetOrAddComponent<HammerCooldownController>(_contentObject).ParentModule = this;
			return _contentObject;
		}
	}
	public class HammerYellowHits : BoundedValueHudModule
	{
		public static readonly int MaxYellowHits = 3;

		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "jackhammer");

		public override string[] Tags => new string[3] { "jackhammer", "alternative shotgun", "impact hammer" };

		public HammerYellowHits()
			: base("thorn.hammerYellowHits", "Hammer Yellow Hits", "Basically Hammer Stats without per-variant cooldowns", 3f)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			ValueColor.DefaultValue = new Color(0.82f, 0.698f, 0f);
		}

		public override void OnUpdate()
		{
			WeaponCharges instance = MonoSingleton<WeaponCharges>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				base.Value = Math.Max(MaxYellowHits - instance.shoAltYellows, 0);
				if (base.Value > 0f)
				{
					base.BoundReduction = 0f;
				}
				else
				{
					base.BoundReduction = instance.shoAltYellowsTimer / 3f * (float)MaxYellowHits;
				}
			}
		}
	}
	public class HealthDisplay : BoundedValueHudModule
	{
		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "plus_thick");

		public override string[] Tags => new string[3] { "hp", "hit points", "blood" };

		public HealthDisplay()
			: base("thorn.healthHud", "Health", "Shows health", 100f, "", (Sprite?)null, 1, (Color?)new Color(1f, 0f, 0f), (Color?)null)
		{
		}//IL_002b: Unknown result type (might be due to invalid IL or missing references)


		protected override void OnHudModuleEnable()
		{
			base.DecimalPlaces = 0;
		}

		public override void OnUpdate()
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				base.BoundReduction = instance.antiHp;
				base.Value = instance.hp;
			}
		}
	}
	public class InputGeneral : FramedHudModule
	{
		private class InputGeneralController : MonoBehaviour
		{
			private KeyInputController? _u;

			private KeyInputController? _d;

			private KeyInputController? _l;

			private KeyInputController? _r;

			private KeyInputController? _feedbacker;

			private KeyInputController? _knuckleblaster;

			private KeyInputController? _fistSwap;

			private void HookButtonVanilla(string path, InputActionState targetInput)
			{
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, path);
				if (!((Object)(object)val == (Object)null))
				{
					GameObjectExtensions.GetOrAddComponent<VanillaKeyInputSyncer>(val).TargetInput = targetInput;
				}
			}

			private void UpdateKeyPressed(KeyInputController? keyInputController, bool pressed)
			{
				if (!((Object)(object)keyInputController == (Object)null))
				{
					keyInputController.IsPressed = pressed;
				}
			}

			private void Start()
			{
				InputManager instance = MonoSingleton<InputManager>.Instance;
				PlayerInput val = ((instance != null) ? instance.InputSource : null);
				if (val != null)
				{
					HookButtonVanilla("Col/General/MovementCol/KeyDash", val.Dodge);
					HookButtonVanilla("Col/General/MovementCol/KeySlam", val.Slide);
					HookButtonVanilla("Col/General/MainCol/KeyJump", val.Jump);
					HookButtonVanilla("Col/General/FistCol/KeyWhiplash", val.Hook);
					HookButtonVanilla("Col/General/MainCol/TopRow/VariantSwitch/Prev", val.PreviousVariation);
					HookButtonVanilla("Col/General/MainCol/TopRow/VariantSwitch/Next", val.NextVariation);
					GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/FistCol/PunchRow/KeyFeedbacker");
					_feedbacker = ((obj != null) ? obj.AddComponent<KeyInputController>() : null);
					GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/FistCol/PunchRow/KeyKnuckleblaster");
					_knuckleblaster = ((obj2 != null) ? obj2.AddComponent<KeyInputController>() : null);
					GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/FistCol/SwapRow/KeySwap");
					_fistSwap = ((obj3 != null) ? obj3.AddComponent<KeyInputController>() : null);
					GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/MainCol/TopRow/KeyUp");
					_u = ((obj4 != null) ? obj4.AddComponent<KeyInputController>() : null);
					GameObject obj5 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/MainCol/BottomRow/KeyDown");
					_d = ((obj5 != null) ? obj5.AddComponent<KeyInputController>() : null);
					GameObject obj6 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/MainCol/BottomRow/KeyLeft");
					_l = ((obj6 != null) ? obj6.AddComponent<KeyInputController>() : null);
					GameObject obj7 = UIUtils.FindRecursive(((Component)this).gameObject, "Col/General/MainCol/BottomRow/KeyRight");
					_r = ((obj7 != null) ? obj7.AddComponent<KeyInputController>() : null);
				}
			}

			private void Update()
			{
				//IL_001c: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: 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_00b1: 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_00dc: 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)
				InputManager instance = MonoSingleton<InputManager>.Instance;
				PlayerInput val = ((instance != null) ? instance.InputSource : null);
				if (val != null)
				{
					Vector2 val2 = val.Move.ReadValue<Vector2>();
					UpdateKeyPressed(_u, val2.y > 0f);
					UpdateKeyPressed(_d, val2.y < 0f);
					UpdateKeyPressed(_l, val2.x < 0f);
					UpdateKeyPressed(_r, val2.x > 0f);
					bool isPressed = val.Punch.IsPressed;
					bool isPressed2 = val.ChangeFist.IsPressed;
					int num = PlayerPrefs.GetInt("CurArm", 0);
					FistActions fist = val.Actions.Fist;
					bool pressed = ((FistActions)(ref fist)).PunchFeedbacker.IsPressed() || (isPressed && num == 0);
					fist = val.Actions.Fist;
					bool pressed2 = ((FistActions)(ref fist)).PunchKnuckleblaster.IsPressed() || (isPressed && num == 1);
					UpdateKeyPressed(_feedbacker, pressed);
					UpdateKeyPressed(_knuckleblaster, pressed2);
					UpdateKeyPressed(_fistSwap, isPressed2);
				}
			}
		}

		public Setting<bool> ShowDashSlam;

		public Setting<bool> ShowMovement;

		public Setting<bool> ShowArms;

		private BatchBoolSettingVisibilitySyncer? _visibilitySyncer;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "wasd");

		public override string[] Tags => new string[4] { "keyboard", "movement", "punch", "controller" };

		public InputGeneral()
			: base("thorn.inputGeneral", "Input - General", "Shows movement-related, fist, and variant cycle inputs")
		{
			ShowDashSlam = CreateSetting("showDashSlam", "Show Dash/Slam", "Shows the keys for dashing and slamming on the left", defaultValue: true);
			ShowMovement = CreateSetting("showMovement", "Show Movement Keys", "Shows directional movement (WASD) and jump input", defaultValue: true);
			ShowArms = CreateSetting("showArms", "Show Arms", "Shows Feedbacker/Knuckleblaster/Whiplash", defaultValue: true);
		}

		protected override GameObject CreateContentObject()
		{
			GameObject val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "KeyLayoutGeneral"));
			val.AddComponent<InputGeneralController>();
			_visibilitySyncer = GameObjectExtensions.GetOrAddComponent<BatchBoolSettingVisibilitySyncer>(val);
			_visibilitySyncer.SyncPairs = new Dictionary<Setting<bool>, string>
			{
				{ ShowDashSlam, "Col/General/MovementCol" },
				{ ShowMovement, "Col/General/MainCol" },
				{ ShowArms, "Col/General/FistCol" }
			};
			return val;
		}
	}
	public class InputMouse : FramedHudModule
	{
		private class InputMouseController : MonoBehaviour
		{
			private void HookButtonVanilla(string path, InputActionState targetInput, string spriteName, string spriteNameFilled)
			{
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, path);
				if (!((Object)(object)val == (Object)null))
				{
					VanillaKeyInputSyncer orAddComponent = GameObjectExtensions.GetOrAddComponent<VanillaKeyInputSyncer>(val);
					orAddComponent.TargetInput = targetInput;
					orAddComponent.baseSprite = AssetManager.Get<Sprite>(HudManager.BundleKey, spriteName);
					orAddComponent.baseSpritePressed = AssetManager.Get<Sprite>(HudManager.BundleKey, spriteNameFilled);
				}
			}

			private void Start()
			{
				InputManager instance = MonoSingleton<InputManager>.Instance;
				PlayerInput val = ((instance != null) ? instance.InputSource : null);
				if (val != null)
				{
					HookButtonVanilla("Col/ButtonRow/LMB", val.Fire1, "Round_BorderLargeTopLeft", "Round_FillLargeTopLeft");
					HookButtonVanilla("Col/ButtonRow/RMB", val.Fire2, "Round_BorderLargeTopRight", "Round_FillLargeTopRight");
				}
			}
		}

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "mouse");

		public override string[] Tags => new string[5] { "keyboard", "mouse", "fire", "input overlay", "controller" };

		public InputMouse()
			: base("thorn.inputMouse", "Input - Mouse", "Shows fire and alt fire input indicators")
		{
		}

		protected override GameObject CreateContentObject()
		{
			GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "MouseLayout"));
			obj.AddComponent<InputMouseController>();
			return obj;
		}
	}
	public class InputWeapon : FramedHudModule
	{
		private class InputWeaponController : MonoBehaviour
		{
			private void HookButton(string path, int index)
			{
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, path);
				if (!((Object)(object)val == (Object)null))
				{
					val.AddComponent<WeaponKeyController>().WeaponIndex = index;
				}
			}

			private void Start()
			{
				for (int i = 0; i < 5; i++)
				{
					HookButton($"{i}/KeyWeapon", i);
				}
			}
		}

		private class WeaponKeyController : MonoBehaviour
		{
			public int WeaponIndex;

			private Image? _bg;

			private Image? _fg;

			private InputAction? _vanillaInputAction;

			private bool[] _variantHeld = new bool[3];

			private void Start()
			{
				_bg = ((Component)this).gameObject.GetComponent<Image>();
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Image");
				_fg = ((obj != null) ? obj.GetComponent<Image>() : null);
				Setting<Keybind>[,] array = WeaponVariantBinds.Instance?.Binds;
				if (array != null)
				{
					array[WeaponIndex, 0].OnPress += OnPressVariant0;
					array[WeaponIndex, 0].OnRelease += OnReleaseVariant0;
					array[WeaponIndex, 1].OnPress += OnPressVariant1;
					array[WeaponIndex, 1].OnRelease += OnReleaseVariant1;
					array[WeaponIndex, 2].OnPress += OnPressVariant2;
					array[WeaponIndex, 2].OnRelease += OnReleaseVariant2;
				}
			}

			private void OnDestroy()
			{
				Setting<Keybind>[,] array = WeaponVariantBinds.Instance?.Binds;
				if (array != null)
				{
					array[WeaponIndex, 0].OnPress -= OnPressVariant0;
					array[WeaponIndex, 0].OnRelease -= OnReleaseVariant0;
					array[WeaponIndex, 1].OnPress -= OnPressVariant1;
					array[WeaponIndex, 1].OnRelease -= OnReleaseVariant1;
					array[WeaponIndex, 2].OnPress -= OnPressVariant2;
					array[WeaponIndex, 2].OnRelease -= OnReleaseVariant2;
				}
			}

			private void OnPressVariant0()
			{
				_variantHeld[0] = true;
			}

			private void OnReleaseVariant0()
			{
				_variantHeld[0] = false;
			}

			private void OnPressVariant1()
			{
				_variantHeld[1] = true;
			}

			private void OnReleaseVariant1()
			{
				_variantHeld[1] = false;
			}

			private void OnPressVariant2()
			{
				_variantHeld[2] = true;
			}

			private void OnReleaseVariant2()
			{
				_variantHeld[2] = false;
			}

			private bool IsVanillaSlotHeld()
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: 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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: 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_00a5: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
				InputManager instance = MonoSingleton<InputManager>.Instance;
				PlayerInput val = ((instance != null) ? instance.InputSource : null);
				if (val != null)
				{
					WeaponActions weapon;
					InputAction vanillaInputAction;
					switch (WeaponIndex)
					{
					case 0:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).Revolver;
						break;
					case 1:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).Shotgun;
						break;
					case 2:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).Nailgun;
						break;
					case 3:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).Railcannon;
						break;
					case 4:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).RocketLauncher;
						break;
					case 5:
						weapon = val.Actions.Weapon;
						vanillaInputAction = ((WeaponActions)(ref weapon)).SpawnerArm;
						break;
					default:
						vanillaInputAction = null;
						break;
					}
					_vanillaInputAction = vanillaInputAction;
				}
				if (_vanillaInputAction != null)
				{
					return _vanillaInputAction.IsPressed();
				}
				return false;
			}

			private void Update()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < _variantHeld.Length; i++)
				{
					if (_variantHeld[i])
					{
						Color weaponVariantColor = ColorUtils.GetWeaponVariantColor(i);
						Color contrastedColor = ColorUtils.GetContrastedColor(weaponVariantColor);
						UpdateColors(weaponVariantColor, contrastedColor, baseFill: true);
						return;
					}
				}
				if (IsVanillaSlotHeld())
				{
					UpdateColors(Color.white, Color.black, baseFill: true);
				}
				else
				{
					UpdateColors(Color.white, Color.white, baseFill: false);
				}
			}

			private void UpdateColors(Color baseColor, Color iconColor, bool baseFill)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: 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_006e: 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)
				Sprite val = AssetManager.Get<Sprite>(HudManager.BundleKey, baseFill ? "Round_FillLarge" : "Round_BorderLarge");
				if ((Object)(object)_bg != (Object)null && (Object)(object)_bg.sprite != (Object)(object)val)
				{
					_bg.sprite = val;
				}
				if ((Object)(object)_bg != (Object)null && ((Graphic)_bg).color != baseColor)
				{
					((Graphic)_bg).color = baseColor;
				}
				if ((Object)(object)_fg != (Object)null && ((Graphic)_fg).color != iconColor)
				{
					((Graphic)_fg).color = iconColor;
				}
			}
		}

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "weapon_wheel");

		public override string[] Tags => new string[4] { "keyboard", "mouse", "weapon", "controller" };

		public InputWeapon()
			: base("thorn.inputWeapon", "Input - Weapons", "Shows weapon switching inputs. Variant binds will only show for Thorn's Weapon Variant Binds, not for the standalone mod.")
		{
		}

		protected override GameObject CreateContentObject()
		{
			GameObject obj = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "KeyLayoutWeapon"));
			obj.AddComponent<InputWeaponController>();
			return obj;
		}
	}
	public class RailCharge : BoundedValueHudModule
	{
		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "bolt");

		public override string[] Tags => new string[6] { "charge", "ultimate", "shock", "electric", "thunderbolt", "shot" };

		public RailCharge()
			: base("thorn.railCharge", "Railcannon Charge", "Shows the railcannon charge", 1f, "Railcannon", (Sprite?)null, 1, (Color?)new Color(0.44f, 0.52f, 1f), (Color?)null)
		{
		}//IL_002b: Unknown result type (might be due to invalid IL or missing references)


		public override void OnUpdate()
		{
			WeaponCharges instance = MonoSingleton<WeaponCharges>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				float value = instance.raicharge / 5f;
				base.Value = value;
			}
		}
	}
	public class RocketRides : BoundedValueHudModule
	{
		private Setting<int> EffectiveRides;

		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "rocket_ride");

		public override string[] Tags => new string[4] { "fly", "rocket", "travel", "fuel" };

		public RocketRides()
			: base("thorn.rocketRides", "Rocket Rides", "Shows number of remaining effective rocket rides", 5f, "Rides", AssetManager.Get<Sprite>(HudManager.BundleKey, "rocket_ride"), 1, (Color?)new Color(1f, 0.5f, 0.23f), (Color?)null)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			EffectiveRides = CreateSetting("effectiveRides", "Effective Rides", "Number of effective rocket rides. There is no strict value, but the 6th one droops immediately and noticeably.", 5);
		}

		protected override void OnHudModuleEnable()
		{
			base.DecimalPlaces = 0;
		}

		public override void OnUpdate()
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				base.Value = EffectiveRides.Value - instance.rocketRides;
			}
		}
	}
	public class StaminaDisplay : BoundedValueHudModule
	{
		public Setting<bool> Continuous;

		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "dash");

		public override string[] Tags => new string[4] { "dash", "boost", "fast", "shift" };

		public StaminaDisplay()
			: base("thorn.staminaHud", "Stamina", "Shows stamina", 3f, "", (Sprite?)null, 1, (Color?)new Color(0f, 0.77f, 1f), (Color?)null)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			Continuous = CreateSetting("continuousDisplay", "Continuous Display", "Whether to show the value as continuous or discrete (dash count)", defaultValue: false);
		}

		public override void OnUpdate()
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				float num = instance.boostCharge / 100f;
				base.Value = (Continuous.Value ? num : ((float)Math.Floor(num)));
			}
		}
	}
	public class WallJumps : BoundedValueHudModule
	{
		public static readonly int MaxWallJumps = 3;

		public override Sprite Icon => AssetManager.Get<Sprite>(HudManager.BundleKey, "wall_jump");

		public override string[] Tags => new string[4] { "jump", "cling", "kick", "hang" };

		public WallJumps()
			: base("thorn.wallJumps", "Wall Jumps", "Shows remaining wall jumps before you have to land", (float)MaxWallJumps, "Wall Jumps", (Sprite?)null, 1, (Color?)new Color(0.78f, 0.77f, 0.38f), (Color?)null)
		{
		}//IL_002c: Unknown result type (might be due to invalid IL or missing references)


		protected override void OnHudModuleEnable()
		{
			base.DecimalPlaces = 0;
		}

		public override void OnUpdate()
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				base.Value = MaxWallJumps - instance.currentWallJumps;
			}
		}
	}
}
namespace ThornClient.Modules.Gameplay
{
	public class FloorIsLava : ThornClient.Core.Module
	{
		public SettingGroup DamageGroup;

		public Setting<bool> DamageUnderwater;

		public Setting<float> DamageInterval;

		public Setting<int> DamageAmount;

		private static string InfoLine = "<color=#fff>+ <color=#f57c20>LAVA FLOOR</color>";

		private float _onFloorDuration;

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "lava");

		public override string[] Tags => new string[2] { "hazard", "hot" };

		public override string CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		private static NewMovement nm => MonoSingleton<NewMovement>.Instance;

		private static StatsManager sman => MonoSingleton<StatsManager>.Instance;

		public FloorIsLava()
			: base("thorn.floorIsLava", "Floor is Lava", "..well, magma to be accurate", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
			DamageGroup = CreateGroup("damageGroup", "Damage settings", "Configure damage frequency & amount");
			DamageUnderwater = CreateSetting("damageUnderwater", "Damage underwater", "Whether you get hurt when touching the floor underwater", defaultValue: false);
			DamageInterval = CreateSetting("damageInterval", "Damage interval", "How far apart two damage ticks are, in seconds", 1f, DamageGroup);
			DamageAmount = CreateSetting("damageAmount", "Damage amount", "How much damage to do per tick", 10, DamageGroup);
			DamageAmount.Hints = new InterfaceHints
			{
				Range = Tuple.Create(0f, 100f)
			};
		}

		protected override void OnEnable()
		{
			ResetTimer();
			CheatManager.UpdateCheatiness();
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			FinalRankHelper.RemoveInfoLine(InfoLine);
		}

		private void AddInfoLine()
		{
			FinalRankHelper.AddInfoLine(InfoLine);
		}

		public override void OnUpdate()
		{
			if ((Object)(object)nm == (Object)null || (Object)(object)sman == (Object)null || !sman.timer)
			{
				return;
			}
			if (!nm.gc.touchingGround || (!DamageUnderwater.Value && nm.touchingWaters.Count > 0))
			{
				ResetTimer();
				return;
			}
			_onFloorDuration += Time.deltaTime;
			if (_onFloorDuration >= DamageInterval.Value)
			{
				TickDamage();
				_onFloorDuration %= DamageInterval.Value;
			}
		}

		private void TickDamage()
		{
			if (!((Object)(object)nm == (Object)null))
			{
				nm.GetHurt(DamageAmount.Value, false, 1f, false, false, 0.35f, false);
			}
		}

		private void ResetTimer()
		{
			_onFloorDuration = DamageInterval.Value;
		}
	}
	public class ForcePuppet : ThornClient.Core.Module
	{
		private static string InfoLine = "<color=#fff>- <color=#fa1900>ALL <color=#fff>BLOOD, <color=#fa1900>NO <color=#fff>BALLS";

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "puppet");

		public override string[] Tags => new string[2] { "blood", "zombie" };

		public override string? CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		public ForcePuppet()
			: base("thorn.forcePuppet", "Force Puppet", "Makes enemies puppeted (become blood bois)\nWarning: This breaks Cybergrind", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
		}

		protected override void OnEnable()
		{
			UpdatePuppet(enabled: true);
			CheatManager.UpdateCheatiness();
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			SceneUtils.SafeSceneLoadedDelayedNoParam += UpdatePuppet;
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			UpdatePuppet(enabled: false);
			SceneUtils.SafeSceneLoadedDelayedNoParam -= UpdatePuppet;
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			FinalRankHelper.RemoveInfoLine(InfoLine);
		}

		private void AddInfoLine()
		{
			FinalRankHelper.AddInfoLine(InfoLine);
		}

		private void UpdatePuppet()
		{
			UpdatePuppet(IsEnabled);
		}

		private void UpdatePuppet(bool enabled)
		{
			OptionsManager.forcePuppet = enabled;
			EnemyIdentifier[] array = Object.FindObjectsOfType<EnemyIdentifier>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].UpdateBuffs(false, true);
			}
		}
	}
	public class ForceRadiance : ThornClient.Core.Module
	{
		private static string InfoLine = "<color=#fff>+ <color=#ff5f59>R<color=#ffa347>A<color=#faf56b>D<color=#79f263>I<color=#8ae0ff>A<#bc82ff>N<color=#f37cf7>T CLEAR</color>";

		public Setting<float> RadianceTier { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "rainbow");

		public override string[] Tags => new string[4] { "buff", "strong", "rainbow", "gay" };

		public override string? CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		public ForceRadiance()
			: base("thorn.forceRadiance", "Force Radiance", "Makes all enemies radiant, buffing them", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
			RadianceTier = CreateSetting("radianceTier", "Radiance tier", "How much to buff enemies", 1f);
		}

		protected override void OnEnable()
		{
			UpdateRadiance(enabled: true, RadianceTier.Value);
			CheatManager.UpdateCheatiness();
			Setting<float> radianceTier = RadianceTier;
			radianceTier.OnValueChanged = (Action<float>)Delegate.Combine(radianceTier.OnValueChanged, new Action<float>(UpdateRadiance));
			SceneUtils.SafeSceneLoadedDelayedNoParam += UpdateRadiance;
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			Setting<float> radianceTier = RadianceTier;
			radianceTier.OnValueChanged = (Action<float>)Delegate.Remove(radianceTier.OnValueChanged, new Action<float>(UpdateRadiance));
			UpdateRadiance(enabled: false, RadianceTier.Value);
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			SceneUtils.SafeSceneLoadedDelayedNoParam -= UpdateRadiance;
			FinalRankHelper.RemoveInfoLine(InfoLine);
		}

		private void AddInfoLine()
		{
			FinalRankHelper.AddInfoLine(InfoLine);
		}

		private void UpdateRadiance(float value)
		{
			UpdateRadiance(IsEnabled, value);
		}

		private void UpdateRadiance()
		{
			UpdateRadiance(IsEnabled, RadianceTier.Value);
		}

		private void UpdateRadiance(bool enabled, float value)
		{
			OptionsManager.forceRadiance = enabled;
			OptionsManager.radianceTier = value;
			EnemyIdentifier[] array = Object.FindObjectsOfType<EnemyIdentifier>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].UpdateBuffs(false, true);
			}
		}
	}
	public class ForceSand : ThornClient.Core.Module
	{
		private static string InfoLine = "<color=#fff>+ <color=#fffaa1>DESERTED</color>";

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "sand");

		public override string[] Tags => new string[2] { "buff", "bleed" };

		public override string? CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		public ForceSand()
			: base("thorn.forceSand", "Force Sand", "Makes enemies sanded, removing bleeding. You'll have to rely on parries for healing.", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
		}

		protected override void OnEnable()
		{
			UpdateSand(enabled: true);
			CheatManager.UpdateCheatiness();
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			SceneUtils.SafeSceneLoadedDelayedNoParam += UpdateSand;
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			UpdateSand(enabled: false);
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			SceneUtils.SafeSceneLoadedDelayedNoParam -= UpdateSand;
			FinalRankHelper.RemoveInfoLine(InfoLine);
		}

		private void AddInfoLine()
		{
			FinalRankHelper.AddInfoLine(InfoLine);
		}

		private void UpdateSand()
		{
			UpdateSand(IsEnabled);
		}

		private void UpdateSand(bool enabled)
		{
			OptionsManager.forceSand = enabled;
			EnemyIdentifier[] array = Object.FindObjectsOfType<EnemyIdentifier>();
			for (int i = 0; i < array.Length; i++)
			{
				array[i].UpdateBuffs(false, true);
			}
		}
	}
	public class MultiplyEnemies : ThornClient.Core.Module
	{
		private string? _registeredInfoLine;

		private const string MultipliedTag = "[ThornMultiplied]";

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "copy");

		public override string[] Tags => new string[8] { "mitosis", "double", "triple", "quadruple", "buff", "duplicate", "many", "times" };

		public Setting<int> Multiplier { get; }

		public override string? CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		public MultiplyEnemies()
			: base("thorn.multiplyEnemies", "Multiply Enemies", "Love me some Pain Atrophy (makes enemies duplicate)", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
			Multiplier = CreateSetting("multiplier", "How many?", "1 -> x, where x=", 2);
			Multiplier.Hints = new InterfaceHints
			{
				Range = Tuple.Create(2f, 10f)
			};
		}

		protected override void OnEnable()
		{
			CheatManager.UpdateCheatiness();
			EnemyEvents.OnSpawn += Dupe;
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			EnemyEvents.OnSpawn -= Dupe;
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			RemoveInfoLine();
		}

		private static string GetInfoLine(int multiplier)
		{
			return $"<color=#fff>+ <color=orange>ENEMIES x{multiplier}";
		}

		private void AddInfoLine()
		{
			RemoveInfoLine();
			_registeredInfoLine = GetInfoLine(Multiplier.Value);
			FinalRankHelper.AddInfoLine(_registeredInfoLine);
		}

		private void RemoveInfoLine()
		{
			if (_registeredInfoLine != null && FinalRankHelper.ExtraInfoLines.Contains(_registeredInfoLine))
			{
				FinalRankHelper.RemoveInfoLine(_registeredInfoLine);
				_registeredInfoLine = null;
			}
		}

		private void Dupe(EnemyIdentifier eid)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)((Component)eid).gameObject).name.Contains("[ThornMultiplied]"))
			{
				for (int i = 0; i < Multiplier.Value - 1; i++)
				{
					GameObject obj = Object.Instantiate<GameObject>(((Component)eid).gameObject, ((Component)eid).transform.parent);
					((Object)obj).name = ((Object)((Component)eid).gameObject).name + " [ThornMultiplied]";
					obj.transform.position = ((Component)eid).transform.position;
				}
			}
		}
	}
	public class Speed : ThornClient.Core.Module
	{
		private static readonly float BaseWalkSpeed = 750f;

		public Setting<float> SpeedMultiplier { get; }

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "speed");

		public override string[] Tags => new string[5] { "cheat", "fast", "slow", "movement", "sonic" };

		public override string? CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Adds crazy movement";
			}
		}

		public Speed()
			: base("thorn.speed", "Speed", "Adjusts your speed", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
			SpeedMultiplier = CreateSetting("speedMultiplier", "Speed multiplier", "How much to scale the speed", 2f);
		}

		protected override void OnEnable()
		{
			UpdateSpeed(SpeedMultiplier.Value);
			Setting<float> speedMultiplier = SpeedMultiplier;
			speedMultiplier.OnValueChanged = (Action<float>)Delegate.Combine(speedMultiplier.OnValueChanged, new Action<float>(UpdateSpeed));
		}

		protected override void OnDisable()
		{
			Setting<float> speedMultiplier = SpeedMultiplier;
			speedMultiplier.OnValueChanged = (Action<float>)Delegate.Remove(speedMultiplier.OnValueChanged, new Action<float>(UpdateSpeed));
			UpdateSpeed(1f);
		}

		private void UpdateSpeed(float multiplier)
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.walkSpeed = BaseWalkSpeed * multiplier;
			}
		}
	}
	public class Submerged : ThornClient.Core.Module
	{
		private GameObject? _water;

		public Setting<Color> WaterColor;

		private static string InfoLine = "<color=#fff>+ <color=#1fe4f2>ATLANTIS</color>";

		public override Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "water");

		public override string[] Tags => new string[5] { "water", "wet", "ocean", "sea", "wrath" };

		public override string CheatReason
		{
			get
			{
				if (!IsEnabled)
				{
					return "";
				}
				return "Enables non-standard gameplay";
			}
		}

		public Submerged()
			: base("thorn.submerged", "Submerged", "Makes the world full of water", ModuleCategory.Gameplay, (KeyCode)0, (KeyCode)0)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			WaterColor = CreateSetting<Color>("waterColor", "Water color (re-enable after changing)", "Color of the water", new Color(0f, 0.5f, 1f));
		}

		protected override void OnEnable()
		{
			SceneUtils.SafeSceneLoadedNoParam += EnsureWater;
			SceneUtils.SafeSceneLoadedNoParam += AddInfoLine;
			EnsureWater(on: true);
			Setting<Color> waterColor = WaterColor;
			waterColor.OnValueChanged = (Action<Color>)Delegate.Combine(waterColor.OnValueChanged, new Action<Color>(SyncWaterColor));
			FinalRankHelper.AddInfoLine(InfoLine);
			CheatManager.UpdateCheatiness();
			AddInfoLine();
		}

		protected override void OnDisable()
		{
			SceneUtils.SafeSceneLoadedNoParam -= EnsureWater;
			SceneUtils.SafeSceneLoadedNoParam -= AddInfoLine;
			Setting<Color> waterColor = WaterColor;
			waterColor.OnValueChanged = (Action<Color>)Delegate.Remove(waterColor.OnValueChanged, new Action<Color>(SyncWaterColor));
			EnsureWater(on: false);
			FinalRankHelper.RemoveInfoLine(InfoLine);
		}

		private void AddInfoLine()
		{
			FinalRankHelper.AddInfoLine(InfoLine);
		}

		private void SyncWaterColor(Color color)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (SceneUtils.IsSafe() && !((Object)(object)_water == (Object)null) && !((Object)(object)_water.GetComponent<Water>() == (Object)null))
			{
				_water.GetComponent<Water>().clr = color;
			}
		}

		private void EnsureWater()
		{
			EnsureWater(on: true);
		}

		private void EnsureWater(bool on)
		{
			//IL_006c: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (!SceneUtils.IsSafe())
			{
				return;
			}
			if (on)
			{
				if (!((Object)(object)_water != (Object)null))
				{
					_water = GameObject.CreatePrimitive((PrimitiveType)3);
					((Object)_water).name = "ThornSubmergedWater";
					GameObjectExtensions.GetOrAddComponent<Rigidbody>(_water).isKinematic = true;
					GameObjectExtensions.GetOrAddComponent<Collider>(_water).isTrigger = true;
					GameObjectExtensions.GetOrAddComponent<Water>(_water).clr = WaterColor.Value;
					((Renderer)GameObjectExtensions.GetOrAddComponent<MeshRenderer>(_water)).enabled = false;
					_water.transform.localScale = Vector3.one * 1E+10f;
				}
			}
			else
			{
				Object.Destroy((Object)(object)_water);
			}
		}
	}
}
namespace ThornClient.Managers
{
	public static class AssetManager
	{
		private static readonly Dictionary<string, Object> Objects;

		private static readonly Dictionary<string, AssetBundle> LoadedBundles;

		static AssetManager()
		{
			Objects = new Dictionary<string, Object>(StringComparer.OrdinalIgnoreCase);
			LoadedBundles = new Dictionary<string, AssetBundle>();
		}

		public static void Initialize()
		{
		}

		public static void LoadBundle(string bundleKey, string bundlePath)
		{
			if (LoadedBundles.ContainsKey(bundleKey))
			{
				return;
			}
			AssetBundle val = AssetBundle.LoadFromFile(bundlePath);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogError((object)("[AssetManager] Failed to load bundle at " + bundlePath));
				return;
			}
			LoadedBundles[bundleKey] = val;
			Object[] array = val.LoadAllAssets<Object>();
			foreach (Object val2 in array)
			{
				string key = BuildKey(bundleKey, ((object)val2).GetType(), val2.name);
				if (!Objects.TryAdd(key, val2))
				{
					Plugin.Log.LogWarning((object)("[AssetManager] Duplicate asset key detected: '" + val2.name + "' of type '" + ((object)val2).GetType().Name + "' in bundle '" + bundleKey + "'"));
				}
			}
		}

		public static T Get<T>(string bundleKey, string assetName) where T : Object
		{
			string key = BuildKey(bundleKey, typeof(T), assetName);
			if (Objects.TryGetValue(key, out Object value))
			{
				return (T)(object)value;
			}
			Plugin.Log.LogError((object)("[AssetManager] Asset '" + assetName + "' of type '" + typeof(T).Name + "' not found in bundle '" + bundleKey + "'."));
			return default(T);
		}

		private static string BuildKey(string bundleKey, Type type, string assetName)
		{
			return bundleKey + "/" + type.Name + "/" + assetName;
		}
	}
	public static class CheatManager
	{
		private static bool _cheating;

		private static string _hexColor;

		static CheatManager()
		{
			_cheating = false;
			_hexColor = "#44ff45";
			SceneUtils.SafeSceneLoaded += ResetCheatinessAndUpdate;
		}

		private static void ResetCheatinessAndUpdate(Scene scene, LoadSceneMode mode)
		{
			ResetCheatiness();
			UpdateCheatiness();
		}

		private static void ResetCheatiness()
		{
			_cheating = false;
		}

		public static List<ThornClient.Core.Module> GetActiveCheatyModules()
		{
			return ModuleManager.Items.Where((ThornClient.Core.Module module) => module.CheatReason != null && module.CheatReason.Length > 0).ToList();
		}

		public static void UpdateCheatiness()
		{
			if (SceneHelper.CurrentScene == "Main Menu" || SceneHelper.CurrentScene == "Bootstrap" || (SceneHelper.CurrentScene?.Length ?? 0) <= 0)
			{
				return;
			}
			bool cheating = _cheating;
			List<ThornClient.Core.Module> activeCheatyModules = GetActiveCheatyModules();
			if (activeCheatyModules.Count > 0)
			{
				_cheating = true;
				LeaderboardHelper.DisableLeaderboards();
			}
			if (!cheating && _cheating)
			{
				NotificationSystem.NotifySend("Thorn::<color=" + _hexColor + ">Cheats</color>", "Leaderboard disabled for this run\n" + string.Join("\n", activeCheatyModules.Select((ThornClient.Core.Module module) => "- <color=" + _hexColor + "><u>" + module.Name + "</u></color>: " + module.CheatReason)), (Sprite)null, Plugin.PluginIconPath, (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
			}
		}
	}
	public static class ConfigManager
	{
		private class ConfigDataTransferObject
		{
			public bool IsEnabled { get; set; }

			public Dictionary<string, JToken> Settings { get; set; } = new Dictionary<string, JToken>();
		}

		private static readonly string ConfigFolder = Path.Combine(Paths.ConfigPath, "ThornClient", "Default");

		private static FileSystemWatcher? _watcher;

		private static DateTime _lastRead = DateTime.MinValue;

		private static readonly HashSet<Configurable> ActiveSyncs = new HashSet<Configurable>();

		private static readonly object SyncLock = new object();

		private static bool _isBatchSyncing = false;

		private static readonly ConcurrentQueue<Configurable> MainThreadQueue = new ConcurrentQueue<Configurable>();

		private static readonly JsonSerializerSettings SerializerSettings = new JsonSerializerSettings
		{
			Formatting = (Formatting)1,
			Converters = { (JsonConverter)(object)new ColorJsonConverter() },
			Converters = { (JsonConverter)new StringEnumConverter() }
		};

		public static void RegisterJsonConverter(JsonConverter converter)
		{
			if (!SerializerSettings.Converters.Any((JsonConverter c) => ((object)c).GetType() == ((object)converter).GetType()))
			{
				SerializerSettings.Converters.Add(converter);
			}
		}

		private static List<Configurable> GetAllConfigurables()
		{
			List<ThornClient.Core.Module> items = ModuleManager.Items;
			List<Configurable> list = new List<Configurable>(items.Count);
			foreach (ThornClient.Core.Module item in items)
			{
				list.Add(item);
			}
			return list;
		}

		private static void CollectSettings(IEnumerable<IConfigurableElement> elements, List<Setting> foundSettings)
		{
			foreach (IConfigurableElement element in elements)
			{
				if (element is Setting item)
				{
					foundSettings.Add(item);
				}
				else if (element is SettingGroup settingGroup)
				{
					CollectSettings(settingGroup.Elements, foundSettings);
				}
			}
		}

		public static string GetConfigPath(Configurable configurable)
		{
			return Path.Combine(ConfigFolder, configurable.GUID + ".json");
		}

		public static void SaveConfig(Configurable configurable)
		{
			lock (SyncLock)
			{
				if (_isBatchSyncing || ActiveSyncs.Contains(configurable))
				{
					return;
				}
				ActiveSyncs.Add(configurable);
			}
			try
			{
				if (!Directory.Exists(ConfigFolder))
				{
					Directory.CreateDirectory(ConfigFolder);
				}
				ConfigDataTransferObject configDataTransferObject = new ConfigDataTransferObject
				{
					IsEnabled = configurable.IsEnabled
				};
				List<Setting> list = new List<Setting>();
				CollectSettings(configurable.Elements, list);
				foreach (Setting item in list)
				{
					object value = item.GetValue();
					if (value != null)
					{
						configDataTransferObject.Settings[item.GUID] = JToken.FromObject(value, JsonSerializer.Create(SerializerSettings));
					}
					else
					{
						configDataTransferObject.Settings[item.GUID] = (JToken)(object)JValue.CreateNull();
					}
				}
				string contents = JsonConvert.SerializeObject((object)configDataTransferObject, (Formatting)1, SerializerSettings);
				File.WriteAllText(GetConfigPath(configurable), contents);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[ConfigManager] Failed to save {configurable.Name}: {arg}");
			}
			finally
			{
				lock (SyncLock)
				{
					ActiveSyncs.Remove(configurable);
				}
			}
		}

		public static void LoadConfig(Configurable configurable)
		{
			lock (SyncLock)
			{
				if (ActiveSyncs.Contains(configurable))
				{
					return;
				}
				ActiveSyncs.Add(configurable);
			}
			string configPath = GetConfigPath(configurable);
			if (!File.Exists(configPath))
			{
				lock (SyncLock)
				{
					ActiveSyncs.Remove(configurable);
					return;
				}
			}
			try
			{
				ConfigDataTransferObject configDataTransferObject = JsonConvert.DeserializeObject<ConfigDataTransferObject>(File.ReadAllText(configPath), SerializerSettings);
				if (configDataTransferObject == null)
				{
					return;
				}
				if (configDataTransferObject.IsEnabled != configurable.IsEnabled)
				{
					configurable.Toggle();
				}
				List<Setting> list = new List<Setting>();
				CollectSettings(configurable.Elements, list);
				foreach (Setting item in list)
				{
					if (!configDataTransferObject.Settings.TryGetValue(item.GUID, out JToken value) || value == null)
					{
						continue;
					}
					try
					{
						Type type = item.GetType().GetGenericArguments()[0];
						object obj = value.ToObject(type, JsonSerializer.Create(SerializerSettings));
						if (obj != null)
						{
							item.SetValue(obj);
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("[ConfigManager] Failed to convert setting " + item.GUID + ": " + ex.Message));
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[ConfigManager] Failed to load {configurable.Name}: {arg}");
			}
			finally
			{
				lock (SyncLock)
				{
					ActiveSyncs.Remove(configurable);
				}
			}
		}

		public static void SaveAll()
		{
			lock (SyncLock)
			{
				if (_isBatchSyncing)
				{
					return;
				}
				_isBatchSyncing = true;
			}
			try
			{
				foreach (Configurable allConfigurable in GetAllConfigurables())
				{
					SaveConfig(allConfigurable);
				}
			}
			finally
			{
				lock (SyncLock)
				{
					_isBatchSyncing = false;
				}
			}
		}

		public static void LoadAll()
		{
			lock (SyncLock)
			{
				if (_isBatchSyncing)
				{
					return;
				}
				_isBatchSyncing = true;
			}
			try
			{
				foreach (Configurable allConfigurable in GetAllConfigurables())
				{
					LoadConfig(allConfigurable);
				}
			}
			finally
			{
				lock (SyncLock)
				{
					_isBatchSyncing = false;
				}
			}
		}

		public static void SetupFileWatcher()
		{
			if (!Directory.Exists(ConfigFolder))
			{
				Directory.CreateDirectory(ConfigFolder);
			}
			if (_watcher == null)
			{
				_watcher = new FileSystemWatcher
				{
					Path = ConfigFolder,
					Filter = "*.json",
					NotifyFilter = NotifyFilters.LastWrite
				};
				_watcher.Changed += OnConfigFileChanged;
				_watcher.EnableRaisingEvents = true;
				Plugin.Log.LogInfo((object)"[ConfigManager] Background configuration hot-reload watcher is active");
			}
		}

		private static void OnConfigFileChanged(object sender, FileSystemEventArgs e)
		{
			DateTime lastWriteTime = File.GetLastWriteTime(e.FullPath);
			if (lastWriteTime - _lastRead < TimeSpan.FromMilliseconds(100.0))
			{
				return;
			}
			_lastRead = lastWriteTime;
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(e.Name);
			Configurable configurable = null;
			foreach (Configurable allConfigurable in GetAllConfigurables())
			{
				if (string.Equals(Path.GetFileNameWithoutExtension(GetConfigPath(allConfigurable)), fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
				{
					configurable = allConfigurable;
					break;
				}
			}
			if (configurable != null)
			{
				MainThreadQueue.Enqueue(configurable);
			}
		}

		public static void UpdateMainThreadQueue()
		{
			Configurable result;
			while (MainThreadQueue.TryDequeue(out result))
			{
				LoadConfig(result);
			}
		}
	}
	public static class EffectManager
	{
		private static readonly string BundlePath;

		public static readonly string BundleKey;

		public static void Initialize()
		{
		}

		static EffectManager()
		{
			BundlePath = Path.Combine(Plugin.workingDir, "assets", "thorn_effects.bundle");
			BundleKey = "effects";
			AssetManager.LoadBundle(BundleKey, BundlePath);
		}

		public static Material GetMaterial(string materialName)
		{
			return AssetManager.Get<Material>(BundleKey, materialName);
		}
	}
	public static class HudManager
	{
		private static readonly string BundlePath = Path.Combine(Plugin.workingDir, "assets", "thorn_hud.bundle");

		public static readonly string BundleKey = "hud";

		private static Dictionary<HudSurface, GameObject?> _surfaces = new Dictionary<HudSurface, GameObject>();

		private const string GunCanvasName = "ThornGunCanvas";

		private const string StyleCanvasName = "ThornStyleCanvas";

		public static event Action? ReadyForScene;

		public static void Initialize()
		{
			Plugin.Log.LogInfo((object)"[HUD Manager] Starting...");
			AssetManager.LoadBundle(BundleKey, BundlePath);
			SceneUtils.SafeSceneLoadedDelayed += OnSceneLoaded;
			FinalRankHelper.RankShown += HideHud;
			CheckpointEvents.CheckpointLoadedNoParam += ShowHud;
		}

		private static void ForceEnableHudPanel(GameObject panel)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				HudSidePanelUpdateForcer orAddComponent = GameObjectExtensions.GetOrAddComponent<HudSidePanelUpdateForcer>(panel);
				if (!((Object)(object)orAddComponent == (Object)null))
				{
					orAddComponent.ForceActive = true;
					orAddComponent.ForceUpdate();
				}
			}
		}

		private static void HideHud()
		{
			foreach (GameObject value in _surfaces.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					value.SetActive(false);
				}
			}
		}

		private static void ShowHud()
		{
			foreach (GameObject value in _surfaces.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					ForceEnableHudPanel(value);
				}
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
				GameObject val = rootGameObjects.Where((GameObject obj) => ((Object)obj).name == "Player").FirstOrDefault();
				GameObject val2 = rootGameObjects.Where((GameObject obj) => ((Object)obj).name == "Canvas").FirstOrDefault();
				GameObject val3 = ((val != null) ? UIUtils.FindRecursive(val, "Main Camera/HUD Camera/HUD") : null);
				if ((Object)(object)val3 != (Object)null)
				{
					GameObject val4 = UIUtils.FindRecursive(val3, "ThornGunCanvas", false);
					GameObject val5 = UIUtils.FindRecursive(val3, "GunCanvas");
					if ((Object)(object)val4 == (Object)null && (Object)(object)val5 != (Object)null)
					{
						val4 = Object.Instantiate<GameObject>(val5, val5.transform.parent);
						((Object)val4).name = "ThornGunCanvas";
						foreach (Transform item in val4.transform)
						{
							Object.Destroy((Object)(object)((Component)item).gameObject);
						}
						val4.transform.SetAsLastSibling();
						val4.GetComponent<HUDPos>();
					}
					_surfaces[HudSurface.Left] = val4 ?? val5;
					GameObject val6 = UIUtils.FindRecursive(val3, "ThornStyleCanvas", false);
					GameObject val7 = UIUtils.FindRecursive(val3, "StyleCanvas");
					if ((Object)(object)val6 == (Object)null && (Object)(object)val7 != (Object)null)
					{
						val6 = Object.Instantiate<GameObject>(val7, val7.transform.parent);
						((Object)val6).name = "ThornStyleCanvas";
						foreach (Transform item2 in val6.transform)
						{
							Object.Destroy((Object)(object)((Component)item2).gameObject);
						}
						val6.transform.SetAsLastSibling();
						Object.Destroy((Object)(object)val6.GetComponent<StyleHUD>());
						Object.Destroy((Object)(object)val6.GetComponent<StyleCalculator>());
					}
					_surfaces[HudSurface.Right] = val6 ?? val7;
				}
				_surfaces[HudSurface.Overlay] = ((val2 != null) ? UIUtils.FindRecursive(val2, "Crosshair Filler") : null);
				if (_surfaces.Values.Any((GameObject g) => (Object)(object)g == (Object)null))
				{
					return;
				}
				foreach (GameObject value in _surfaces.Values)
				{
					if (!((Object)(object)value == (Object)null))
					{
						ForceEnableHudPanel(value);
						value.SetActive(SceneUtils.IsInGame());
					}
				}
				Plugin.Log.LogInfo((object)"[HUD Manager] ReadyForScene...]");
				HudManager.ReadyForScene?.Invoke();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[HUD Manager] Scene load hook failed: " + ex.Message));
			}
		}

		public static bool GetSurface(HudSurface hudSurface, out GameObject? surface)
		{
			return _surfaces.TryGetValue(hudSurface, out surface);
		}
	}
	public static class InputManager
	{
		[CompilerGenerated]
		private static bool <BlockInput>k__BackingField = false;

		private static readonly List<Setting<Keybind>> KeybindSettings = new List<Setting<Keybind>>();

		public static bool BlockInput
		{
			get
			{
				return <BlockInput>k__BackingField;
			}
			set
			{
				<BlockInput>k__BackingField = value;
				OptionsManager instance = MonoSingleton<OptionsManager>.Instance;
				if (<BlockInput>k__BackingField)
				{
					if ((Object)(object)instance != (Object)null)
					{
						instance.dontUnpause = true;
					}
				}
				else if ((Object)(object)instance != (Object)null)
				{
					instance.dontUnpause = false;
				}
			}
		}

		public static void RegisterKeybindSetting(Setting<Keybind> setting)
		{
			if (!KeybindSettings.Contains(setting))
			{
				KeybindSettings.Add(setting);
			}
		}

		public static void Update()
		{
			//IL_004c: 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)
			//IL_005c: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			if (BlockInput)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27) || Input.GetMouseButtonDown(3))
			{
				ClickGUI instance = ClickGUI.Instance;
				if (instance != null && instance.IsEnabled)
				{
					ClickGUI.NavigateBack();
				}
			}
			foreach (Setting<Keybind> keybindSetting in KeybindSettings)
			{
				Keybind value = keybindSetting.Value;
				if ((int)value.Key != 0 && ((int)value.Modifier == 0 || Input.GetKey(value.Modifier)))
				{
					if (Input.GetKeyDown(value.Key))
					{
						keybindSetting.RaiseOnPress();
					}
					if (Input.GetKeyUp(value.Key))
					{
						keybindSetting.RaiseOnRelease();
					}
				}
			}
		}
	}
	public static class ModuleManager
	{
		public static Action<ThornClient.Core.Module, bool>? SomeModuleToggled;

		public static List<ThornClient.Core.Module> Items { get; private set; } = new List<ThornClient.Core.Module>();

		internal static void HeyIToggled(ThornClient.Core.Module module, bool enabled)
		{
			SomeModuleToggled?.Invoke(module, enabled);
		}

		public static void Initialize()
		{
			Plugin.Log.LogInfo((object)"[Module Manager] Starting...");
			Type typeFromHandle = typeof(ThornClient.Core.Module);
			List<Type> list = new List<Type>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (IsSystemAssembly(assembly))
				{
					continue;
				}
				foreach (Type item2 in SafeGetTypes(assembly))
				{
					if (SafeIsAssignableFrom(typeFromHandle, item2) && !item2.IsInterface && !item2.IsAbstract)
					{
						list.Add(item2);
					}
				}
			}
			foreach (Type item3 in list)
			{
				try
				{
					if (Activator.CreateInstance(item3) is ThornClient.Core.Module item)
					{
						Items.Add(item);
					}
				}
				catch (Exception arg)
				{
					Plugin.Log.LogError((object)$"Failed to instantiate module '{item3.Name}': {arg}");
				}
			}
			Plugin.Log.LogInfo((object)$"[Module Manager] Loaded {Items.Count} modules");
		}

		private static bool SafeIsAssignableFrom(Type targetType, Type candidateType)
		{
			try
			{
				return targetType.IsAssignableFrom(candidateType);
			}
			catch (TypeLoadException)
			{
				return false;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static IEnumerable<Type> SafeGetTypes(Assembly assembly)
		{
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null);
			}
			catch (Exception)
			{
				return Array.Empty<Type>();
			}
		}

		private static bool IsSystemAssembly(Assembly assembly)
		{
			string fullName = assembly.FullName;
			if (string.IsNullOrEmpty(fullName))
			{
				return true;
			}
			if (!fullName.StartsWith("System") && !fullName.StartsWith("Microsoft") && !fullName.StartsWith("mscorlib") && !fullName.StartsWith("Unity"))
			{
				return fullName.StartsWith("UnityEngine");
			}
			return true;
		}

		public static List<ThornClient.Core.Module> GetByCategory(ModuleCategory category)
		{
			return Items.Where((ThornClient.Core.Module m) => m.Category == category).ToList();
		}

		public static T Get<T>() where T : ThornClient.Core.Module
		{
			return Items.OfType<T>().FirstOrDefault();
		}

		public static ThornClient.Core.Module GetByName(string name)
		{
			return Items.FirstOrDefault((ThornClient.Core.Module m) => m.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
		}
	}
	public static class RenderManager
	{
		public static Shader Colored;

		public static Material Line;

		public static Material LineTop;

		private static readonly int ZTest = Shader.PropertyToID("_ZTest");

		private static readonly int ZWrite = Shader.PropertyToID("_ZWrite");

		public static void Initialize()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			Colored = Shader.Find("Hidden/Internal-Colored");
			if ((Object)(object)Colored != (Object)null)
			{
				Line = new Material(Colored);
				LineTop = new Material(Colored);
				LineTop.SetInt(ZTest, 8);
				LineTop.SetInt(ZWrite, 0);
			}
			else
			{
				Plugin.Log.LogError((object)"Failed to find native rendering shader for RenderManager.");
			}
		}

		public static void RenderPipeline()
		{
			if ((Object)(object)Camera.current != (Object)(object)Camera.main)
			{
				return;
			}
			GL.PushMatrix();
			GL.LoadPixelMatrix();
			foreach (ThornClient.Core.Module item in ModuleManager.Items)
			{
				if (item.IsEnabled)
				{
					try
					{
						item.OnRender();
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error rendering module '" + item.Name + "': " + ex.Message));
					}
				}
			}
			GL.PopMatrix();
		}
	}
}
namespace ThornClient.HUD
{
	public abstract class BoundedValueHudModule : FramedHudModule
	{
		public enum IndicatorStyle
		{
			Progress,
			Circular
		}

		[CompilerGenerated]
		private string <DisplayName>k__BackingField;

		[CompilerGenerated]
		private Sprite <DisplayIcon>k__BackingField;

		[CompilerGenerated]
		private float <Value>k__BackingField;

		[CompilerGenerated]
		private float <Bound>k__BackingField;

		[CompilerGenerated]
		private float <BoundReduction>k__BackingField;

		[CompilerGenerated]
		private int <DecimalPlaces>k__BackingField;

		public Setting<IndicatorStyle> Style;

		public Setting<bool> ShowName;

		public Setting<Color> ValueColor;

		public Setting<Color> SoftBoundColor;

		public SettingGroup ColorGroup;

		private static Dictionary<IndicatorStyle, string> _stylePaths = new Dictionary<IndicatorStyle, string>
		{
			[IndicatorStyle.Progress] = "ProgressStyle",
			[IndicatorStyle.Circular] = "CircularStyle"
		};

		private readonly Dictionary<IndicatorStyle, IBoundedValueController?> _styleComps = new Dictionary<IndicatorStyle, IBoundedValueController>();

		private readonly Dictionary<IndicatorStyle, GameObject?> _styleGameObjects = new Dictionary<IndicatorStyle, GameObject>();

		private GameObject? _contentObject;

		public string DisplayName
		{
			[CompilerGenerated]
			get
			{
				return <DisplayName>k__BackingField;
			}
			set
			{
				if (!(<DisplayName>k__BackingField == value))
				{
					<DisplayName>k__BackingField = value;
					this.NameChanged?.Invoke(value);
				}
			}
		}

		public Sprite DisplayIcon
		{
			[CompilerGenerated]
			get
			{
				return <DisplayIcon>k__BackingField;
			}
			set
			{
				if (!((Object)(object)<DisplayIcon>k__BackingField == (Object)(object)value))
				{
					<DisplayIcon>k__BackingField = value;
					this.IconChanged?.Invoke(value);
				}
			}
		}

		public float Value
		{
			[CompilerGenerated]
			get
			{
				return <Value>k__BackingField;
			}
			set
			{
				if (!Mathf.Approximately(<Value>k__BackingField, value))
				{
					<Value>k__BackingField = value;
					this.ValueChanged?.Invoke(value);
				}
			}
		}

		public float Bound
		{
			[CompilerGenerated]
			get
			{
				return <Bound>k__BackingField;
			}
			set
			{
				if (!Mathf.Approximately(<Bound>k__BackingField, value))
				{
					<Bound>k__BackingField = value;
					this.BoundChanged?.Invoke(value);
				}
			}
		}

		public float BoundReduction
		{
			[CompilerGenerated]
			get
			{
				return <BoundReduction>k__BackingField;
			}
			set
			{
				if (!Mathf.Approximately(<BoundReduction>k__BackingField, value))
				{
					<BoundReduction>k__BackingField = value;
					this.SoftBoundChanged?.Invoke(value);
				}
			}
		}

		public int DecimalPlaces
		{
			[CompilerGenerated]
			get
			{
				return <DecimalPlaces>k__BackingField;
			}
			set
			{
				if (<DecimalPlaces>k__BackingField != value)
				{
					<DecimalPlaces>k__BackingField = value;
					this.DecimalPlacesChanged?.Invoke(value);
				}
			}
		}

		public event Action<string> NameChanged;

		public event Action<Sprite> IconChanged;

		public event Action<float> ValueChanged;

		public event Action<float> BoundChanged;

		public event Action<float> SoftBoundChanged;

		public event Action<int> DecimalPlacesChanged;

		public BoundedValueHudModule(string guid, string name, string description, float bound = 1f, string displayName = "", Sprite? displayIcon = null, int decimalPlaces = 1, Color? defaultValueColor = null, Color? defaultSoftBoundColor = null)
			: base(guid, name, description)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			Style = CreateSetting("indicatorStyle", "Indicator Style", "The style to present the value", IndicatorStyle.Progress);
			ShowName = CreateSetting("showName", "Show Name", "The name of the value", defaultValue: true);
			ColorGroup = CreateGroup("colorGroup", "Colors", "Colors used on the indicator");
			ValueColor = CreateSetting<Color>("valueColor", "Value Color", "The color of the value", (Color)(((??)defaultValueColor) ?? new Color(0.098f, 0.624f, 0.525f)), ColorGroup);
			SoftBoundColor = CreateSetting<Color>("softBoundColor", "Soft Bound Color", "The color of the soft bound, for example HP hard damage", (Color)(((??)defaultSoftBoundColor) ?? new Color(1f, 1f, 1f, 0.36f)), ColorGroup);
			ShowName.OnChanged += UnfuckLayouts;
			SceneUtils.SafeSceneLoadedDelayedNoParam += UnfuckLayouts;
			Setting<IndicatorStyle> style = Style;
			style.OnValueChanged = (Action<IndicatorStyle>)Delegate.Combine(style.OnValueChanged, new Action<IndicatorStyle>(SwitchStyle));
			DisplayName = ((displayName.Length > 0) ? displayName : name);
			DisplayIcon = displayIcon ?? Icon;
			Bound = bound;
			BoundReduction = 0f;
			DecimalPlaces = decimalPlaces;
			SwitchStyle(Style.Value);
		}

		protected override GameObject CreateContentObject()
		{
			_contentObject = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "BoundedValueLayout"));
			foreach (KeyValuePair<IndicatorStyle, string> stylePath in _stylePaths)
			{
				GameObject val = UIUtils.FindRecursive(_contentObject, stylePath.Value);
				_styleGameObjects[stylePath.Key] = val;
				IBoundedValueController boundedValueController = null;
				switch (stylePath.Key)
				{
				case IndicatorStyle.Progress:
					boundedValueController = ((val != null) ? val.AddComponent<ProgressBoundedValueController>() : null);
					break;
				case IndicatorStyle.Circular:
					boundedValueController = ((val != null) ? val.AddComponent<CircularBoundedValueController>() : null);
					break;
				}
				_styleComps[stylePath.Key] = boundedValueController;
				if (boundedValueController != null)
				{
					boundedValueController.TargetModule = this;
				}
			}
			SwitchStyle(Style.Value);
			return _contentObject;
		}

		private void SwitchStyle(IndicatorStyle style)
		{
			foreach (KeyValuePair<IndicatorStyle, GameObject> styleGameObject in _styleGameObjects)
			{
				GameObject value = styleGameObject.Value;
				if (value != null)
				{
					value.SetActive(style == styleGameObject.Key);
				}
			}
			UnfuckLayouts();
		}

		private void UnfuckLayouts()
		{
			if (!SceneUtils.IsSafe() || !IsEnabled || (Object)(object)_contentObject == (Object)null || (Object)(object)_wrapper == (Object)null)
			{
				return;
			}
			UIUtils.UnfuckLayoutHack(_contentObject);
			ContentSizeFitter fitterComp = _wrapper.GetComponent<ContentSizeFitter>();
			if ((Object)(object)fitterComp != (Object)null)
			{
				((Behaviour)fitterComp).enabled = false;
				ExecutionUtils.RunNextFrame((Action)delegate
				{
					((Behaviour)fitterComp).enabled = true;
				});
			}
		}
	}
	public abstract class ContinuousCumulatedStatHudModule : TextHudModule
	{
		public enum DataSmoothing
		{
			None,
			ExpoWeightedMovingAverage
		}

		public SettingGroup MeasurementGroup;

		public Setting<bool> ShowIcon;

		public Setting<float> UpdateInterval;

		public Setting<DataSmoothing> ValueSmoothing;

		public Setting<float> EwmaAlpha;

		private float _accumulatedTime;

		private float _collected;

		private float? _smoothedValue;

		public ContinuousCumulatedStatHudModule(string guid, string name, string description, DataSmoothing smoothing = DataSmoothing.None, float updateInterval = 0.5f, float ewmaAlpha = 0.5f)
			: base(guid, name, description)
		{
			ShowIcon = CreateSetting("showIcon", "Show icon", "Shows an icon next to the text (if available)", defaultValue: true);
			MeasurementGroup = CreateGroup("measurementGroup", "Measurement", "How to measure the data");
			UpdateInterval = CreateSetting("updateInterval", "Update interval", "How fast to update the text", updateInterval, MeasurementGroup);
			ValueSmoothing = CreateSetting("valueSmoothing", "Value smoothing", "Whether to smooth out the value", smoothing, MeasurementGroup);
			EwmaAlpha = CreateSetting("ewmaAlpha", "EWMA Alpha", "Smoothing coefficient for EWMA (0.01 to 1.0)", ewmaAlpha, MeasurementGroup);
			UpdateDisplayIcon();
			ShowIcon.OnChanged += UpdateDisplayIcon;
		}

		public sealed override void OnUpdate()
		{
			_accumulatedTime += Time.unscaledDeltaTime;
			_collected += CollectUpdate();
			if (!(_accumulatedTime >= UpdateInterval.Value))
			{
				return;
			}
			float num = _collected / _accumulatedTime;
			DataSmoothing value = ValueSmoothing.Value;
			float value2;
			if (value != DataSmoothing.None && value == DataSmoothing.ExpoWeightedMovingAverage)
			{
				if (!_smoothedValue.HasValue)
				{
					_smoothedValue = num;
				}
				else
				{
					float num2 = Mathf.Clamp01(EwmaAlpha.Value);
					_smoothedValue = num2 * num + (1f - num2) * _smoothedValue.Value;
				}
				value2 = _smoothedValue.Value;
			}
			else
			{
				_smoothedValue = null;
				value2 = num;
			}
			base.Text = FormatStat(value2);
			_accumulatedTime = 0f;
			_collected = 0f;
		}

		protected abstract float CollectUpdate();

		protected virtual string FormatStat(float value)
		{
			return $"{Math.Round(value)}";
		}

		private void UpdateDisplayIcon()
		{
			DisplayIcon = (ShowIcon.Value ? Icon : null);
		}
	}
	public abstract class FramedHudModule : HudModule
	{
		public Setting<bool> ShowBackground;

		protected GameObject? Background;

		protected HudBackgroundOpacitySyncer? _opacitySyncer;

		public FramedHudModule(string guid, string name, string description)
			: base(guid, name, description)
		{
			ShowBackground = CreateSetting("showBackground", "Show Background", "Whether to show a frame behind the content", defaultValue: true);
			Setting<bool> showBackground = ShowBackground;
			showBackground.OnValueChanged = (Action<bool>)Delegate.Combine(showBackground.OnValueChanged, (Action<bool>)delegate(bool value)
			{
				if ((Object)(object)_opacitySyncer != (Object)null)
				{
					_opacitySyncer.ForceTransparent = !value;
				}
			});
		}

		protected abstract GameObject CreateContentObject();

		protected sealed override GameObject CreateHudObject()
		{
			GameObject val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "Background"));
			GameObject val2 = CreateContentObject();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.transform.SetParent(val.transform);
			}
			if ((Object)(object)_wrapper != (Object)null)
			{
				_wrapper.AddComponent<HorizontalLayoutGroup>();
				ContentSizeFitter obj = _wrapper.AddComponent<ContentSizeFitter>();
				obj.horizontalFit = (FitMode)1;
				obj.verticalFit = (FitMode)1;
			}
			Background = val;
			_opacitySyncer = GameObjectExtensions.GetOrAddComponent<HudBackgroundOpacitySyncer>(Background);
			_opacitySyncer.ForceTransparent = !ShowBackground.Value;
			return val;
		}
	}
	public interface IBoundedValueController
	{
		BoundedValueHudModule? TargetModule { get; set; }
	}
	public abstract class TextHudModule : FramedHudModule
	{
		[CompilerGenerated]
		private string <Text>k__BackingField = "Text module";

		[CompilerGenerated]
		private Sprite? <DisplayIcon>k__BackingField;

		private GameObject? _textObj;

		private TextMeshProUGUI? _textComp;

		private Image? _icon;

		public string Text
		{
			[CompilerGenerated]
			get
			{
				return <Text>k__BackingField;
			}
			set
			{
				if (!(<Text>k__BackingField == value))
				{
					<Text>k__BackingField = value;
					UpdateText(value);
				}
			}
		}

		public virtual Sprite? DisplayIcon
		{
			[CompilerGenerated]
			get
			{
				return <DisplayIcon>k__BackingField;
			}
			set
			{
				if (!((Object)(object)<DisplayIcon>k__BackingField == (Object)(object)value))
				{
					<DisplayIcon>k__BackingField = value;
					UpdateIcon(value);
				}
			}
		}

		public TextHudModule(string guid, string name, string description)
			: base(guid, name, description)
		{
		}

		private void UpdateText(string value)
		{
			if (!((Object)(object)_textComp == (Object)null))
			{
				bool num = value.Length != ((TMP_Text)_textComp).text.Length;
				if (value != ((TMP_Text)_textComp).text)
				{
					((TMP_Text)_textComp).text = value;
					UnfuckAll();
				}
				if (num)
				{
					UnfuckAll();
				}
			}
		}

		private void UpdateIcon(Sprite? icon)
		{
			if (!((Object)(object)_icon == (Object)null))
			{
				if ((Object)(object)icon == (Object)null)
				{
					((Component)_icon).gameObject.SetActive(false);
					return;
				}
				((Component)_icon).gameObject.SetActive(true);
				_icon.sprite = icon;
			}
		}

		private void UnfuckAll()
		{
			if ((Object)(object)_textObj != (Object)null)
			{
				UIUtils.UnfuckLayoutHack(_textObj);
			}
			if ((Object)(object)_content != (Object)null)
			{
				UIUtils.UnfuckLayoutHack(_content);
			}
			if ((Object)(object)_wrapper != (Object)null)
			{
				UIUtils.UnfuckLayoutHack(_wrapper);
			}
		}

		protected sealed override GameObject CreateContentObject()
		{
			GameObject val = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "TextLayout"));
			_textObj = UIUtils.FindRecursive(val, "Text");
			GameObject obj = UIUtils.FindRecursive(val, "Icon");
			_icon = ((obj != null) ? obj.GetComponent<Image>() : null);
			if ((Object)(object)_textObj != (Object)null)
			{
				_textComp = _textObj.GetComponent<TextMeshProUGUI>();
			}
			UpdateText(Text);
			UpdateIcon(DisplayIcon);
			return val;
		}
	}
}
namespace ThornClient.HUD.HUDComponents
{
	public class BatchBoolSettingVisibilitySyncer : MonoBehaviour
	{
		public Dictionary<Setting<bool>, string> SyncPairs = new Dictionary<Setting<bool>, string>();

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

		private void Start()
		{
			foreach (KeyValuePair<Setting<bool>, string> syncPair in SyncPairs)
			{
				syncPair.Key.OnChanged += SyncVisibilities;
			}
			SyncVisibilities();
		}

		private void OnDestroy()
		{
			foreach (KeyValuePair<Setting<bool>, string> syncPair in SyncPairs)
			{
				syncPair.Key.OnChanged -= SyncVisibilities;
			}
		}

		private void SyncVisibilities()
		{
			foreach (KeyValuePair<Setting<bool>, string> syncPair in SyncPairs)
			{
				GameObject objectFromPath = GetObjectFromPath(syncPair.Value);
				if (!((Object)(object)objectFromPath == (Object)null) && objectFromPath.activeSelf != syncPair.Key.Value)
				{
					objectFromPath.SetActive(syncPair.Key.Value);
				}
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private GameObject? GetObjectFromPath(string path)
		{
			if (Cached.ContainsKey(path))
			{
				return Cached[path];
			}
			Cached[path] = UIUtils.FindRecursive(((Component)this).gameObject, path);
			return Cached[path];
		}
	}
	internal class CircularBoundedValueController : MonoBehaviour, IBoundedValueController
	{
		private TextMeshProUGUI? _textName;

		private Image? _fillValue;

		private Image? _fillSoftBound;

		private Image? _icon;

		private BatchBoolSettingVisibilitySyncer? _visibilitySyncer;

		public BoundedValueHudModule? TargetModule { get; set; }

		private void Start()
		{
			if (TargetModule != null)
			{
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Name");
				_textName = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/Icon");
				_icon = ((obj2 != null) ? obj2.GetComponent<Image>() : null);
				GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/Value");
				_fillValue = ((obj3 != null) ? obj3.GetComponent<Image>() : null);
				GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/SoftBound");
				_fillSoftBound = ((obj4 != null) ? obj4.GetComponent<Image>() : null);
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/Value/ValueBase");
				if ((Object)(object)val != (Object)null)
				{
					GameObjectExtensions.GetOrAddComponent<ColorSettingSyncer>(val).TargetSetting = TargetModule.ValueColor;
				}
				GameObject val2 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/SoftBound/SoftBoundBase");
				if ((Object)(object)val2 != (Object)null)
				{
					GameObjectExtensions.GetOrAddComponent<ColorSettingSyncer>(val2).TargetSetting = TargetModule.SoftBoundColor;
				}
				_visibilitySyncer = GameObjectExtensions.GetOrAddComponent<BatchBoolSettingVisibilitySyncer>(((Component)this).gameObject);
				_visibilitySyncer.SyncPairs = new Dictionary<Setting<bool>, string> { { TargetModule.ShowName, "Name" } };
				UpdateName();
				UpdateIcon();
				UpdateValue();
				UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
				TargetModule.NameChanged += UpdateName;
				TargetModule.IconChanged += UpdateIcon;
				TargetModule.ValueChanged += UpdateValue;
				TargetModule.BoundChanged += UpdateValue;
				TargetModule.SoftBoundChanged += UpdateValue;
				TargetModule.DecimalPlacesChanged += UpdateValue;
			}
		}

		private void OnDestroy()
		{
			if (TargetModule != null)
			{
				TargetModule.NameChanged -= UpdateName;
				TargetModule.IconChanged -= UpdateIcon;
				TargetModule.ValueChanged -= UpdateValue;
				TargetModule.BoundChanged -= UpdateValue;
				TargetModule.SoftBoundChanged -= UpdateValue;
				TargetModule.DecimalPlacesChanged -= UpdateValue;
			}
		}

		private void UpdateName()
		{
			UpdateName(TargetModule?.DisplayName ?? "");
		}

		private void UpdateName(string value)
		{
			TextMeshProUGUI? textName = _textName;
			if (textName != null)
			{
				((TMP_Text)textName).SetText(value, true);
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private void UpdateIcon()
		{
			UpdateIcon(TargetModule?.DisplayIcon);
		}

		private void UpdateIcon(Sprite? value)
		{
			if (!((Object)(object)_icon == (Object)null) && !((Object)(object)_icon.sprite == (Object)(object)value))
			{
				_icon.sprite = value;
				if (((Component)_icon).gameObject.activeSelf != ((Object)(object)value == (Object)null))
				{
					((Component)_icon).gameObject.SetActive((Object)(object)value != (Object)null);
				}
			}
		}

		private void UpdateValue(float _)
		{
			UpdateValue();
		}

		private void UpdateValue(int _)
		{
			UpdateValue();
		}

		private void UpdateValue()
		{
			float num = (TargetModule?.Value ?? 0f) / (TargetModule?.Bound ?? 1f);
			float num2 = (TargetModule?.BoundReduction ?? 0f) / (TargetModule?.Bound ?? 1f);
			if (!((Object)(object)_fillValue == (Object)null) && !((Object)(object)_fillSoftBound == (Object)null))
			{
				if (!Mathf.Approximately(_fillValue.fillAmount, num))
				{
					_fillValue.fillAmount = num;
				}
				if (!Mathf.Approximately(_fillSoftBound.fillAmount, num2))
				{
					_fillSoftBound.fillAmount = num2;
				}
			}
		}
	}
	public class ColorSettingSyncer : MonoBehaviour
	{
		public Setting<Color>? TargetSetting;

		private Image? _img;

		private void Start()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (TargetSetting != null)
			{
				_img = ((Component)this).gameObject.GetComponent<Image>();
				Setting<Color>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<Color>)Delegate.Combine(targetSetting.OnValueChanged, new Action<Color>(UpdateColor));
				UpdateColor(TargetSetting.Value);
			}
		}

		private void OnDestroy()
		{
			if (TargetSetting != null)
			{
				Setting<Color>? targetSetting = TargetSetting;
				targetSetting.OnValueChanged = (Action<Color>)Delegate.Remove(targetSetting.OnValueChanged, new Action<Color>(UpdateColor));
			}
		}

		private void UpdateColor(Color color)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_img == (Object)null))
			{
				((Graphic)_img).color = color;
			}
		}
	}
	public class HudBackgroundOpacitySyncer : MonoBehaviour
	{
		private Image? _bg;

		[CompilerGenerated]
		private bool <ForceTransparent>k__BackingField;

		private PrefsManager? _prefs => MonoSingleton<PrefsManager>.Instance;

		public bool ForceTransparent
		{
			[CompilerGenerated]
			get
			{
				return <ForceTransparent>k__BackingField;
			}
			set
			{
				<ForceTransparent>k__BackingField = value;
				UpdateOpacity();
			}
		}

		private void Start()
		{
			_bg = ((Component)this).gameObject.GetComponent<Image>();
			PrefsHelper.Subscribe<float>("hudBackgroundOpacity", (Action<float>)UpdateFromPrefs);
			HudManager.ReadyForScene += UpdateOpacity;
			if ((Object)(object)_prefs != (Object)null)
			{
				UpdateOpacity();
			}
		}

		private void OnDestroy()
		{
			PrefsHelper.Unsubscribe<float>("hudBackgroundOpacity", (Action<float>)UpdateFromPrefs);
			HudManager.ReadyForScene -= UpdateOpacity;
		}

		private void UpdateFromPrefs(float opacity)
		{
			UpdateOpacity(opacity / 100f);
		}

		protected void UpdateOpacity(float opacity)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_bg != (Object)null)
			{
				((Graphic)_bg).color = new Color(0f, 0f, 0f, ForceTransparent ? 0f : opacity);
			}
		}

		protected void UpdateOpacity()
		{
			if (!((Object)(object)_prefs == (Object)null))
			{
				float num = _prefs.GetFloat("hudBackgroundOpacity", 0.5f);
				UpdateOpacity(num / 100f);
			}
		}
	}
	internal class HudElementController : MonoBehaviour
	{
		public HudModule? hudModule;

		private void Start()
		{
			if (hudModule != null)
			{
				GameObjectExtensions.GetOrAddComponent<HudElementPositioningController>(((Component)this).gameObject).TargetModule = hudModule;
				Setting<float> positionX = hudModule.PositionX;
				positionX.OnValueChanged = (Action<float>)Delegate.Combine(positionX.OnValueChanged, new Action<float>(UpdateX));
				Setting<float> positionY = hudModule.PositionY;
				positionY.OnValueChanged = (Action<float>)Delegate.Combine(positionY.OnValueChanged, new Action<float>(UpdateY));
				Setting<float> pivotX = hudModule.PivotX;
				pivotX.OnValueChanged = (Action<float>)Delegate.Combine(pivotX.OnValueChanged, new Action<float>(UpdatePivotX));
				Setting<float> pivotY = hudModule.PivotY;
				pivotY.OnValueChanged = (Action<float>)Delegate.Combine(pivotY.OnValueChanged, new Action<float>(UpdatePivotY));
				Setting<HudSurface> surface = hudModule.Surface;
				surface.OnValueChanged = (Action<HudSurface>)Delegate.Combine(surface.OnValueChanged, new Action<HudSurface>(hudModule.Reparent));
				UpdateX(hudModule.PositionX.Value);
				UpdateY(hudModule.PositionY.Value);
				UpdatePivotX(hudModule.PivotX.Value);
				UpdatePivotY(hudModule.PivotY.Value);
				hudModule.Reparent(hudModule.Surface.Value);
			}
		}

		private void OnDestroy()
		{
			if (hudModule != null)
			{
				Setting<float> positionX = hudModule.PositionX;
				positionX.OnValueChanged = (Action<float>)Delegate.Remove(positionX.OnValueChanged, new Action<float>(UpdateX));
				Setting<float> positionY = hudModule.PositionY;
				positionY.OnValueChanged = (Action<float>)Delegate.Remove(positionY.OnValueChanged, new Action<float>(UpdateY));
				Setting<float> pivotX = hudModule.PivotX;
				pivotX.OnValueChanged = (Action<float>)Delegate.Remove(pivotX.OnValueChanged, new Action<float>(UpdatePivotX));
				Setting<float> pivotY = hudModule.PivotY;
				pivotY.OnValueChanged = (Action<float>)Delegate.Remove(pivotY.OnValueChanged, new Action<float>(UpdatePivotY));
				Setting<HudSurface> surface = hudModule.Surface;
				surface.OnValueChanged = (Action<HudSurface>)Delegate.Remove(surface.OnValueChanged, new Action<HudSurface>(hudModule.Reparent));
			}
		}

		private void UpdateX(float value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = ((Component)this).transform.localPosition;
			((Component)this).transform.localPosition = new Vector3(value, localPosition.y, localPosition.z);
		}

		private void UpdateY(float value)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = ((Component)this).transform.localPosition;
			((Component)this).transform.localPosition = new Vector3(localPosition.x, value, localPosition.z);
		}

		private void UpdatePivotX(float value)
		{
			//IL_0010: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val != null)
			{
				Vector2 pivot = val.pivot;
				val.pivot = new Vector2(value, pivot.y);
			}
		}

		private void UpdatePivotY(float value)
		{
			//IL_0010: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val != null)
			{
				Vector2 pivot = val.pivot;
				val.pivot = new Vector2(pivot.x, value);
			}
		}
	}
	internal class HudElementPositioningController : FreeMoveDragHandler, IEndDragHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler, IPointerClickHandler
	{
		private struct PivotChoice
		{
			public string Path;

			public Button ButtonComp;

			public Image IconComp;
		}

		public HudModule? TargetModule;

		private GameObject? _dragOverlay;

		private string[] _pivotPositions = new string[9] { "TopLeft", "TopRight", "BottomLeft", "BottomRight", "Top", "Bottom", "Left", "Right", "Center" };

		private static Dictionary<string, Vector2> _pivotValues = new Dictionary<string, Vector2>
		{
			{
				"TopLeft",
				new Vector2(0f, 1f)
			},
			{
				"TopRight",
				new Vector2(1f, 1f)
			},
			{
				"BottomLeft",
				new Vector2(0f, 0f)
			},
			{
				"BottomRight",
				new Vector2(1f, 0f)
			},
			{
				"Top",
				new Vector2(0.5f, 1f)
			},
			{
				"Bottom",
				new Vector2(0.5f, 0f)
			},
			{
				"Left",
				new Vector2(0f, 0.5f)
			},
			{
				"Right",
				new Vector2(1f, 0.5f)
			},
			{
				"Center",
				new Vector2(0.5f, 0.5f)
			}
		};

		private Dictionary<string, PivotChoice> _pivotChoices = new Dictionary<string, PivotChoice>();

		private void Start()
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			_dragOverlay = UIUtils.FindRecursive(((Component)this).gameObject, "Overlay", false);
			GameObject? dragOverlay = _dragOverlay;
			Colorizer colorizer = ((dragOverlay != null) ? GameObjectExtensions.GetOrAddComponent<Colorizer>(UIUtils.FindRecursive(dragOverlay, "Image")) : null);
			if ((Object)(object)colorizer != (Object)null)
			{
				colorizer.Highlighted = true;
			}
			_pivotChoices = new Dictionary<string, PivotChoice>();
			string[] pivotPositions = _pivotPositions;
			foreach (string pivotName in pivotPositions)
			{
				string text = "Pivot/" + pivotName;
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, text, false);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Button component = val.GetComponent<Button>();
				GameObject obj = UIUtils.FindRecursive(val, "Image");
				Image val2 = ((obj != null) ? obj.GetComponent<Image>() : null);
				if ((Object)(object)component == (Object)null || (Object)(object)val2 == (Object)null)
				{
					continue;
				}
				_pivotChoices.Add(pivotName, new PivotChoice
				{
					Path = text,
					ButtonComp = component,
					IconComp = val2
				});
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_002e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0056: Unknown result type (might be due to invalid IL or missing references)
					Vector2 val3 = _pivotValues[pivotName];
					if (TargetModule != null)
					{
						TargetModule.PivotX.Value = val3.x;
					}
					if (TargetModule != null)
					{
						TargetModule.PivotY.Value = val3.y;
					}
				});
			}
			if (TargetModule != null)
			{
				Setting<float> pivotX = TargetModule.PivotX;
				pivotX.OnValueChanged = (Action<float>)Delegate.Combine(pivotX.OnValueChanged, new Action<float>(UpdatePivotDisplay));
				Setting<float> pivotY = TargetModule.PivotY;
				pivotY.OnValueChanged = (Action<float>)Delegate.Combine(pivotY.OnValueChanged, new Action<float>(UpdatePivotDisplay));
			}
			UpdatePivotDisplay();
		}

		private void UpdatePivotDisplay(float _)
		{
			UpdatePivotDisplay();
		}

		private void UpdatePivotDisplay()
		{
			//IL_0041: 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_0047: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (TargetModule == null)
			{
				return;
			}
			string[] pivotPositions = _pivotPositions;
			foreach (string key in pivotPositions)
			{
				try
				{
					if (_pivotValues.ContainsKey(key) && _pivotChoices.ContainsKey(key))
					{
						Vector2 val = _pivotValues[key];
						bool flag = Mathf.Approximately(val.x, TargetModule.PivotX.Value) && Mathf.Approximately(val.y, TargetModule.PivotY.Value);
						((Graphic)_pivotChoices[key].IconComp).color = (flag ? ThornModule.AccentColor : Color.white);
					}
				}
				catch (Exception arg)
				{
					Plugin.Log.LogWarning((object)$"[HudElementPositioningController] Couldn't update pivot display: {arg}");
				}
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0028: 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)
			if (TargetModule != null && !((Object)(object)target == (Object)null))
			{
				TargetModule.PositionX.Value = (float)Math.Round(((Transform)target).localPosition.x, 1);
				TargetModule.PositionY.Value = (float)Math.Round(((Transform)target).localPosition.y, 1);
			}
		}

		public override void OnDrag(PointerEventData eventData)
		{
			//IL_0031: 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_003c: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				float num = (((Object)(object)_canvas != (Object)null) ? _canvas.scaleFactor : 1f);
				Vector2 val = eventData.delta / num;
				RectTransform? obj = target;
				obj.anchoredPosition += val;
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!((Object)(object)_dragOverlay == (Object)null))
			{
				_dragOverlay.SetActive(true);
				_dragOverlay.transform.SetAsLastSibling();
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (!((Object)(object)_dragOverlay == (Object)null))
			{
				_dragOverlay.SetActive(false);
			}
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)eventData.button == 1 && (Object)(object)_dragOverlay != (Object)null)
			{
				ClickGUI.NestConfigPanel(TargetModule);
			}
		}
	}
	public class HudSidePanelUpdateForcer : MonoBehaviour
	{
		public bool ForceActive = true;

		private void OnEnable()
		{
			PrefsHelper.Subscribe("weaponHoldPosition", (Action)ForceUpdate);
		}

		private void Start()
		{
			ForceUpdate();
		}

		private void OnDisable()
		{
			PrefsHelper.Unsubscribe("weaponHoldPosition", (Action)ForceUpdate);
		}

		public void ForceUpdate()
		{
			if (ForceActive)
			{
				Canvas component = ((Component)this).gameObject.GetComponent<Canvas>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = true;
				}
			}
			HUDPos component2 = ((Component)this).gameObject.GetComponent<HUDPos>();
			if ((Object)(object)component2 == (Object)null)
			{
				return;
			}
			if (ForceActive)
			{
				component2.active = true;
			}
			component2.CheckPos();
			if (ForceActive)
			{
				ExecutionUtils.RunNextFrame((Action)delegate
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					Transform transform = ((Component)this).gameObject.transform;
					transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, 1f);
				});
			}
		}
	}
	public class HudVariantColorSyncer : MonoBehaviour
	{
		[CompilerGenerated]
		private int <Variation>k__BackingField;

		public float ColorMultiplier = 1f;

		private Image? _target;

		public int Variation
		{
			[CompilerGenerated]
			get
			{
				return <Variation>k__BackingField;
			}
			set
			{
				<Variation>k__BackingField = value;
				UpdateColor();
			}
		}

		private void Start()
		{
			_target = ((Component)this).GetComponent<Image>();
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(CheckAndUpdate));
			UpdateColor();
		}

		private void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(CheckAndUpdate));
		}

		private void CheckAndUpdate(string key, object? obj)
		{
			if (key.StartsWith("hudColor"))
			{
				UpdateColor();
			}
		}

		public void UpdateColor()
		{
			//IL_0015: 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_0025: 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_0032: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_target == (Object)null))
			{
				Color val = ColorUtils.GetWeaponVariantColor(Variation) * ColorMultiplier;
				((Graphic)_target).color = new Color(val.r, val.g, val.b);
			}
		}
	}
	public class KeyInputController : MonoBehaviour
	{
		public Sprite baseSprite = AssetManager.Get<Sprite>(HudManager.BundleKey, "Round_BorderLarge");

		public Sprite baseSpritePressed = AssetManager.Get<Sprite>(HudManager.BundleKey, "Round_FillLarge");

		public Color iconColor = Color.white;

		public Color iconColorPressed = Color.black;

		private Image? _border;

		private Image? _icon;

		[CompilerGenerated]
		private bool <IsPressed>k__BackingField;

		public bool IsPressed
		{
			[CompilerGenerated]
			get
			{
				return <IsPressed>k__BackingField;
			}
			set
			{
				if (<IsPressed>k__BackingField != value)
				{
					<IsPressed>k__BackingField = value;
					UpdateState(value);
				}
			}
		}

		protected virtual void Start()
		{
			_border = ((Component)this).gameObject.GetComponent<Image>();
			GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "Image", false);
			_icon = ((obj != null) ? obj.GetComponent<Image>() : null);
			UpdateState(IsPressed);
		}

		private void UpdateState(bool pressed)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_006a: 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)
			if ((Object)(object)_border != (Object)null)
			{
				Sprite val = (pressed ? baseSpritePressed : baseSprite);
				if ((Object)(object)_border.sprite != (Object)(object)val)
				{
					_border.sprite = val;
				}
			}
			if ((Object)(object)_icon != (Object)null)
			{
				Color val2 = (pressed ? iconColorPressed : iconColor);
				if (((Graphic)_icon).color != val2)
				{
					((Graphic)_icon).color = val2;
				}
			}
		}
	}
	public class ProgressBoundedValueController : MonoBehaviour, IBoundedValueController
	{
		private TextMeshProUGUI? _textName;

		private RectTransform? _transTrough;

		private RectTransform? _transValue;

		private RectTransform? _transSoftBound;

		private Image? _icon;

		private TextMeshProUGUI? _textValue;

		private TextMeshProUGUI? _textCap;

		private BatchBoolSettingVisibilitySyncer? _visibilitySyncer;

		public BoundedValueHudModule? TargetModule { get; set; }

		private void Start()
		{
			if (TargetModule != null)
			{
				GameObject obj = UIUtils.FindRecursive(((Component)this).gameObject, "NameLayout/Name");
				_textName = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				GameObject obj2 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/ValueLayout/Icon");
				_icon = ((obj2 != null) ? obj2.GetComponent<Image>() : null);
				GameObject obj3 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough");
				_transTrough = ((obj3 != null) ? obj3.GetComponent<RectTransform>() : null);
				GameObject obj4 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/Value");
				_transValue = ((obj4 != null) ? obj4.GetComponent<RectTransform>() : null);
				GameObject obj5 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/SoftBoundMask/SoftBound");
				_transSoftBound = ((obj5 != null) ? obj5.GetComponent<RectTransform>() : null);
				GameObject obj6 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/ValueLayout/Value");
				_textValue = ((obj6 != null) ? obj6.GetComponent<TextMeshProUGUI>() : null);
				GameObject obj7 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/ValueLayout/Cap");
				_textCap = ((obj7 != null) ? obj7.GetComponent<TextMeshProUGUI>() : null);
				GameObject val = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/Value");
				if ((Object)(object)val != (Object)null)
				{
					val.AddComponent<ColorSettingSyncer>().TargetSetting = TargetModule.ValueColor;
				}
				GameObject val2 = UIUtils.FindRecursive(((Component)this).gameObject, "Trough/SoftBoundMask/SoftBound");
				if ((Object)(object)val2 != (Object)null)
				{
					val2.AddComponent<ColorSettingSyncer>().TargetSetting = TargetModule.SoftBoundColor;
				}
				_visibilitySyncer = GameObjectExtensions.GetOrAddComponent<BatchBoolSettingVisibilitySyncer>(((Component)this).gameObject);
				_visibilitySyncer.SyncPairs = new Dictionary<Setting<bool>, string> { { TargetModule.ShowName, "NameLayout" } };
				UpdateName();
				UpdateIcon();
				UpdateValue();
				UpdateSoftBound();
				UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
				TargetModule.NameChanged += UpdateName;
				TargetModule.IconChanged += UpdateIcon;
				TargetModule.ValueChanged += UpdateValue;
				TargetModule.BoundChanged += UpdateValue;
				TargetModule.BoundChanged += UpdateSoftBound;
				TargetModule.SoftBoundChanged += UpdateValue;
				TargetModule.SoftBoundChanged += UpdateSoftBound;
				TargetModule.DecimalPlacesChanged += UpdateValue;
				TargetModule.DecimalPlacesChanged += UpdateSoftBound;
			}
		}

		private void OnDestroy()
		{
			if (TargetModule != null)
			{
				TargetModule.NameChanged -= UpdateName;
				TargetModule.IconChanged -= UpdateIcon;
				TargetModule.ValueChanged -= UpdateValue;
				TargetModule.BoundChanged -= UpdateValue;
				TargetModule.BoundChanged -= UpdateSoftBound;
				TargetModule.SoftBoundChanged -= UpdateValue;
				TargetModule.SoftBoundChanged -= UpdateSoftBound;
				TargetModule.DecimalPlacesChanged -= UpdateValue;
				TargetModule.DecimalPlacesChanged -= UpdateSoftBound;
			}
		}

		private void UpdateName()
		{
			UpdateName(TargetModule?.DisplayName ?? "");
		}

		private void UpdateName(string value)
		{
			TextMeshProUGUI? textName = _textName;
			if (textName != null)
			{
				((TMP_Text)textName).SetText(value, true);
			}
			UIUtils.UnfuckLayoutHack(((Component)this).gameObject);
		}

		private void UpdateIcon()
		{
			UpdateIcon(TargetModule?.DisplayIcon);
		}

		private void UpdateIcon(Sprite? value)
		{
			if (!((Object)(object)_icon == (Object)null) && !((Object)(object)_icon.sprite == (Object)(object)value))
			{
				_icon.sprite = value;
				if (((Component)_icon).gameObject.activeSelf != ((Object)(object)value == (Object)null))
				{
					((Component)_icon).gameObject.SetActive((Object)(object)value != (Object)null);
				}
			}
		}

		private void UpdateValue(float _)
		{
			UpdateValue();
		}

		private void UpdateValue(int _)
		{
			UpdateValue();
		}

		private void UpdateValue()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			float num = (TargetModule?.Value ?? 0f) / (TargetModule?.Bound ?? 1f);
			float num2 = (TargetModule?.BoundReduction ?? 0f) / (TargetModule?.Bound ?? 1f);
			if (!((Object)(object)_transTrough == (Object)null) && !((Object)(object)_transValue == (Object)null) && !((Object)(object)_transSoftBound == (Object)null))
			{
				float y = _transValue.sizeDelta.y;
				float x = _transValue.sizeDelta.x;
				float x2 = _transSoftBound.sizeDelta.x;
				float x3 = _transTrough.sizeDelta.x;
				float num3 = x / x3;
				float num4 = x2 / x3;
				if (!Mathf.Approximately(num3, num))
				{
					_transValue.sizeDelta = new Vector2(x3 * num, y);
				}
				if (!Mathf.Approximately(num4, num2))
				{
					_transSoftBound.sizeDelta = new Vector2(x3 * num2, y);
				}
				TextMeshProUGUI? textValue = _textValue;
				if (textValue != null)
				{
					((TMP_Text)textValue).SetText($"{Math.Round(TargetModule?.Value ?? 0f, TargetModule?.DecimalPlaces ?? 1)}", true);
				}
			}
		}

		private void UpdateSoftBound(int _)
		{
			UpdateSoftBound();
		}

		private void UpdateSoftBound(float _)
		{
			UpdateSoftBound();
		}

		private void UpdateSoftBound()
		{
			float num = (TargetModule?.Bound ?? 1f) - (TargetModule?.BoundReduction ?? 0f);
			TextMeshProUGUI? textCap = _textCap;
			if (textCap != null)
			{
				((TMP_Text)textCap).SetText($"/{Math.Round(num, TargetModule?.DecimalPlaces ?? 1)}", true);
			}
		}
	}
	public class ThornKeyInputSyncer : KeyInputController
	{
		public Setting<Keybind>? TargetBind;

		protected void OnEnable()
		{
			if (TargetBind != null)
			{
				TargetBind.OnPress += OnPress;
				TargetBind.OnRelease += OnRelease;
			}
		}

		private void OnDisable()
		{
			if (TargetBind != null)
			{
				TargetBind.OnPress -= OnPress;
				TargetBind.OnRelease -= OnRelease;
			}
		}

		private void OnPress()
		{
			base.IsPressed = true;
		}

		private void OnRelease()
		{
			base.IsPressed = false;
		}
	}
	public class VanillaKeyInputSyncer : KeyInputController
	{
		public InputActionState? TargetInput;

		private void Update()
		{
			UpdateState();
		}

		private void UpdateState()
		{
			if (TargetInput != null)
			{
				base.IsPressed = TargetInput.IsPressed;
			}
		}
	}
}
namespace ThornClient.Core
{
	internal class ColorJsonConverter : JsonConverter<Color>
	{
		public override void WriteJson(JsonWriter writer, Color value, JsonSerializer serializer)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			string text = "#" + ColorUtility.ToHtmlStringRGBA(value);
			writer.WriteValue(text);
		}

		public override Color ReadJson(JsonReader reader, Type objectType, Color existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_001b: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			string text = reader.Value?.ToString();
			if (string.IsNullOrEmpty(text))
			{
				return Color.white;
			}
			Color result = default(Color);
			if (ColorUtility.TryParseHtmlString(text, ref result))
			{
				return result;
			}
			return Color.white;
		}
	}
	public abstract class Configurable
	{
		[JsonIgnore]
		public string GUID;

		[CompilerGenerated]
		private bool <IsEnabled>k__BackingField;

		[JsonIgnore]
		public string Name { get; }

		[JsonIgnore]
		public string Description { get; }

		[JsonIgnore]
		public List<IConfigurableElement> Elements { get; } = new List<IConfigurableElement>();

		[JsonIgnore]
		public Setting<Keybind> ToggleKeybind { get; }

		[JsonIgnore]
		public Setting<bool> ToggleOnRelease { get; }

		public virtual bool IsEnabled
		{
			[CompilerGenerated]
			get
			{
				return <IsEnabled>k__BackingField;
			}
			set
			{
				if (<IsEnabled>k__BackingField != value)
				{
					<IsEnabled>k__BackingField = value;
					this.OnToggleStateChanged?.Invoke(<IsEnabled>k__BackingField);
					if (<IsEnabled>k__BackingField)
					{
						OnEnable();
					}
					else
					{
						OnDisable();
					}
					ConfigManager.SaveConfig(this);
				}
			}
		}

		public event Action<bool>? OnToggleStateChanged;

		protected Configurable(string guid, string name, string description, KeyCode defaultKey = (KeyCode)0, KeyCode defaultModifier = (KeyCode)0, bool defaultToggleOnRelease = false, bool hasToggling = true)
		{
			//IL_002d: 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)
			GUID = guid;
			Name = name;
			Description = description;
			if (hasToggling)
			{
				Keybind defaultValue = new Keybind(defaultKey, defaultModifier);
				ToggleKeybind = CreateSetting("toggleKeybind", "Toggle Keybind", "The key combo used to turn this feature on and off", defaultValue);
				ToggleOnRelease = CreateSetting("toggleOnRelease", "Toggle On Release", "Acts as a temporary hold-to-(de)activate when enabled", defaultToggleOnRelease);
				Setting<bool> toggleOnRelease = ToggleOnRelease;
				toggleOnRelease.InternalOnValueChanged = (Action)Delegate.Combine(toggleOnRelease.InternalOnValueChanged, new Action(UpdateToggleCallbacks));
				Setting<Keybind> toggleKeybind = ToggleKeybind;
				toggleKeybind.InternalOnValueChanged = (Action)Delegate.Combine(toggleKeybind.InternalOnValueChanged, new Action(UpdateToggleCallbacks));
			}
			UpdateToggleCallbacks();
		}

		private void UpdateToggleCallbacks()
		{
			if (ToggleKeybind != null)
			{
				ToggleKeybind.OnPress -= HandlePress;
				ToggleKeybind.OnRelease -= HandleRelease;
				if (ToggleOnRelease.Value)
				{
					ToggleKeybind.OnPress += HandlePress;
					ToggleKeybind.OnRelease += HandleRelease;
				}
				else
				{
					ToggleKeybind.OnPress += HandlePress;
				}
			}
		}

		private void HandlePress()
		{
			IsEnabled = !IsEnabled;
		}

		private void HandleRelease()
		{
			IsEnabled = !IsEnabled;
		}

		protected void RegisterElement(IConfigurableElement element, SettingGroup? parent = null)
		{
			if (parent == null)
			{
				Elements.Add(element);
			}
			else
			{
				parent.Elements.Add(element);
			}
		}

		protected SettingGroup CreateGroup(string guid, string name, string description, SettingGroup? parent = null)
		{
			SettingGroup settingGroup = new SettingGroup(guid, name, description);
			RegisterElement(settingGroup, parent);
			return settingGroup;
		}

		protected Setting<T> CreateSetting<T>(string guid, string name, string description, T defaultValue, SettingGroup? parent = null)
		{
			Setting<T> setting = new Setting<T>(guid, name, description, defaultValue);
			setting.InternalOnValueChanged = (Action)Delegate.Combine(setting.InternalOnValueChanged, (Action)delegate
			{
				ConfigManager.SaveConfig(this);
			});
			if (setting is Setting<Keybind> setting2)
			{
				InputManager.RegisterKeybindSetting(setting2);
			}
			RegisterElement(setting, parent);
			return setting;
		}

		protected ConfigButtonRow CreateButtonRow(string guid, string name, string description, string[] texts, SettingGroup? parent = null)
		{
			ConfigButtonRow configButtonRow = new ConfigButtonRow(guid, name, description, texts);
			RegisterElement(configButtonRow, parent);
			return configButtonRow;
		}

		protected ConfigHeader CreateHeader(string guid, string name, string description = "", HeaderType headerType = HeaderType.H1, SettingGroup? parent = null)
		{
			ConfigHeader configHeader = new ConfigHeader(guid, name, description);
			ConfigHeader configHeader2 = configHeader;
			configHeader2.FontSize = headerType switch
			{
				HeaderType.H1 => 16, 
				HeaderType.H2 => 13, 
				_ => 16, 
			};
			ConfigHeader configHeader3 = configHeader;
			RegisterElement(configHeader3, parent);
			return configHeader3;
		}

		public void Toggle()
		{
			IsEnabled = !IsEnabled;
		}

		protected virtual void OnEnable()
		{
		}

		protected virtual void OnDisable()
		{
		}
	}
	public abstract class HudModule : Module
	{
		public static Dictionary<HudSurface, Vector3> DefaultLocalPosition = new Dictionary<HudSurface, Vector3>
		{
			{
				HudSurface.Left,
				new Vector3(-484f, 344f, 45f)
			},
			{
				HudSurface.Right,
				new Vector3(-232f, -288f, 1f)
			},
			{
				HudSurface.Overlay,
				new Vector3(0f, 0f, 0f)
			}
		};

		public static Dictionary<HudSurface, Vector3> DefaultScale = new Dictionary<HudSurface, Vector3>
		{
			{
				HudSurface.Left,
				new Vector3(4f, 4f, 2f)
			},
			{
				HudSurface.Right,
				new Vector3(1f, 1f, 1f)
			},
			{
				HudSurface.Overlay,
				new Vector3(1f, 1f, 1f)
			}
		};

		protected GameObject? _wrapper;

		protected GameObject? _content;

		protected RectTransform? _wrapperRect;

		protected RectTransform? _contentRect;

		[JsonIgnore]
		public Setting<float> PositionX { get; }

		[JsonIgnore]
		public Setting<float> PositionY { get; }

		[JsonIgnore]
		public Setting<HudSurface> Surface { get; }

		[JsonIgnore]
		public Setting<float> PivotX { get; }

		[JsonIgnore]
		public Setting<float> PivotY { get; }

		public GameObject? UIElement => _wrapper;

		protected HudModule(string guid, string name, string description, float defaultPositionX = 0f, float defaultPositionY = 0f, float defaultPivotX = 0f, float defaultPivotY = 1f)
			: base(guid, name, description, ModuleCategory.Hud, (KeyCode)0, (KeyCode)0)
		{
			PositionX = CreateSetting("positionX", "Position X", "Horizontal position relative to the origin", defaultPositionX);
			PositionY = CreateSetting("positionY", "Position Y", "Vertical position relative to the origin", defaultPositionY);
			Surface = CreateSetting("surface", "Surface", "The surface this component is on. Left is gun panel, Right is style panel, Overlay is normal HUD", HudSurface.Overlay);
			PivotX = CreateSetting("pivotX", "Pivot X", "X (0-1) of origin point that the element expands around", defaultPivotX);
			PivotY = CreateSetting("pivotY", "Pivot Y", "Y (0-1) of origin point that the element expands around", defaultPivotY);
			Setting<HudSurface> surface = Surface;
			surface.OnValueChanged = (Action<HudSurface>)Delegate.Combine(surface.OnValueChanged, new Action<HudSurface>(ResetPositionIfNeeded));
			InterfaceHints hints = new InterfaceHints
			{
				Hidden = true
			};
			PositionX.Hints = hints;
			PositionY.Hints = hints;
			PivotX.Hints = hints;
			PivotY.Hints = hints;
		}

		private void InitializeIfNeeded()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if (IsEnabled && SceneHelper.CurrentScene != null)
			{
				if ((Object)(object)_wrapper == (Object)null)
				{
					_wrapper = Object.Instantiate<GameObject>(AssetManager.Get<GameObject>(HudManager.BundleKey, "Wrapper"));
					ref RectTransform? wrapperRect = ref _wrapperRect;
					Transform transform = _wrapper.transform;
					wrapperRect = (RectTransform?)(object)((transform is RectTransform) ? transform : null);
					GameObjectExtensions.GetOrAddComponent<HudElementController>(_wrapper).hudModule = this;
					_wrapper.SetActive(IsEnabled);
				}
				if ((Object)(object)_content == (Object)null)
				{
					_content = CreateHudObject();
					ref RectTransform? contentRect = ref _contentRect;
					Transform transform2 = _content.transform;
					contentRect = (RectTransform?)(object)((transform2 is RectTransform) ? transform2 : null);
				}
				if (!((Object)(object)_wrapperRect == (Object)null) && !((Object)(object)_contentRect == (Object)null))
				{
					_content.transform.SetParent(_wrapper.transform, false);
					Reparent(Surface.Value);
					_wrapperRect.sizeDelta = new Vector2(_contentRect.sizeDelta.x, _contentRect.sizeDelta.y);
				}
			}
		}

		private void ResetPositionIfNeeded(HudSurface surface)
		{
			//IL_0019: 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 (!string.IsNullOrEmpty(SceneHelper.CurrentScene))
			{
				PositionX.Value = DefaultLocalPosition[surface].x;
				PositionY.Value = DefaultLocalPosition[surface].y;
			}
		}

		protected virtual void OnHudModuleEnable()
		{
		}

		protected virtual void OnHudModuleDisable()
		{
		}

		protected sealed override void OnEnable()
		{
			HudManager.ReadyForScene += InitializeIfNeeded;
			InitializeIfNeeded();
			if ((Object)(object)_wrapper != (Object)null)
			{
				_wrapper.SetActive(true);
			}
			OnHudModuleEnable();
		}

		protected sealed override void OnDisable()
		{
			OnHudModuleDisable();
			if (!((Object)(object)_wrapper == (Object)null))
			{
				_wrapper.SetActive(false);
				HudManager.ReadyForScene -= InitializeIfNeeded;
			}
		}

		public void Reparent(HudSurface newSurface)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_wrapperRect == (Object)null) && HudManager.GetSurface(newSurface, out GameObject surface) && !((Object)(object)surface == (Object)null))
			{
				((Transform)_wrapperRect).SetParent(surface.transform, false);
				((Transform)_wrapperRect).localScale = DefaultScale[newSurface];
				UIUtils.SetLayerRecursive(((Component)_wrapperRect).gameObject, LayerMask.NameToLayer("AlwaysOnTop"));
				Material val = Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/HUDMaterial.mat").WaitForCompletion();
				UIUtils.SetImageMaterialRecursive(((Component)_wrapperRect).gameObject, val);
				Material val2 = Addressables.LoadAssetAsync<Material>((object)"Assets/Fonts/VCR_OSD_MONO Overlay.mat").WaitForCompletion();
				UIUtils.SetTextMaterialRecursive(((Component)_wrapperRect).gameObject, val2);
			}
		}

		protected abstract GameObject CreateHudObject();
	}
	public enum HudSurface
	{
		Left,
		Right,
		Overlay
	}
	public abstract class Module : Configurable
	{
		[JsonIgnore]
		public ModuleCategory Category { get; }

		public virtual string? CheatReason => null;

		public virtual Sprite Icon => AssetManager.Get<Sprite>(ClickGUI.BundleKey, "cube");

		public virtual string[]? Tags { get; }

		protected Module(string guid, string name, string description, ModuleCategory moduleCategory, KeyCode defaultKey = (KeyCode)0, KeyCode defaultModifier = (KeyCode)0, bool defaultToggleOnRelease = false, bool hasToggling = true)
			: base(guid, name, description, defaultKey, defaultModifier, defaultToggleOnRelease, hasToggling)
		{
			//IL_0004: 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)
			Category = moduleCategory;
			base.OnToggleStateChanged += delegate(bool enabled)
			{
				ModuleManager.HeyIToggled(this, enabled);
			};
		}

		public virtual void OnUpdate()
		{
		}

		public virtual void OnRender()
		{
		}
	}
	public enum ModuleCategory
	{
		Utility,
		Render,
		Gameplay,
		Misc,
		Hud
	}
	public enum SettingType
	{
		Bind,
		Bool,
		Color,
		EnemyList,
		Enum,
		Float,
		Int,
		Text,
		Unsupported
	}
	public abstract class SystemModule : Module
	{
		public sealed override string CheatReason => "";

		internal SystemModule(string guid, string name, string description)
			: base(guid, name, description, ModuleCategory.Misc, (KeyCode)0, (KeyCode)0, defaultToggleOnRelease: false, hasToggling: false)
		{
		}
	}
}
namespace ThornClient.Core.DataTypes
{
	[JsonConverter(typeof(EnemyListJsonConverter))]
	public class EnemyList : IEquatable<EnemyList>
	{
		public HashSet<EnemyType> Enemies;

		public EnemyList(params EnemyType[] enemies)
		{
			//IL_0015: 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)
			HashSet<EnemyType> hashSet = new HashSet<EnemyType>();
			foreach (EnemyType item in enemies)
			{
				hashSet.Add(item);
			}
			Enemies = hashSet;
		}

		public EnemyList(IEnumerable<EnemyType> enemies)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			HashSet<EnemyType> hashSet = new HashSet<EnemyType>();
			foreach (EnemyType enemy in enemies)
			{
				hashSet.Add(enemy);
			}
			Enemies = hashSet;
		}

		public EnemyList()
			: this(Array.Empty<EnemyType>())
		{
		}

		public void Add(EnemyType enemyType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Enemies.Add(enemyType);
		}

		public void Remove(EnemyType enemyType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Enemies.Remove(enemyType);
		}

		public void Toggle(EnemyType enemyType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (Includes(enemyType))
			{
				Remove(enemyType);
			}
			else
			{
				Add(enemyType);
			}
		}

		public bool Includes(EnemyType enemyType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Enemies.Contains(enemyType);
		}

		public int Count()
		{
			return Enemies.Count;
		}

		public EnemyList Clone()
		{
			return new EnemyList((IEnumerable<EnemyType>)Enemies);
		}

		public bool Equals(EnemyList? other)
		{
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			return Enemies.SetEquals(other.Enemies);
		}

		public static implicit operator EnemyList(List<EnemyType> list)
		{
			return new EnemyList((IEnumerable<EnemyType>)list);
		}

		public static implicit operator List<EnemyType>(EnemyList enemyList)
		{
			return enemyList.Enemies.ToList();
		}

		public static implicit operator EnemyList(EnemyType[] array)
		{
			return new EnemyList(array);
		}

		public static implicit operator EnemyList(HashSet<EnemyType> set)
		{
			return new EnemyList((IEnumerable<EnemyType>)set);
		}
	}
	internal class EnemyListJsonConverter : JsonConverter<EnemyList>
	{
		public override void WriteJson(JsonWriter writer, EnemyList? value, JsonSerializer serializer)
		{
			//IL_0028: 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)
			if (value == null || value.Enemies == null)
			{
				writer.WriteNull();
				return;
			}
			writer.WriteStartArray();
			foreach (EnemyType enemy in value.Enemies)
			{
				writer.WriteValue(((object)enemy/*cast due to .constrained prefix*/).ToString());
			}
			writer.WriteEndArray();
		}

		public override EnemyList? ReadJson(JsonReader reader, Type objectType, EnemyList? existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00c0: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Invalid comparison between Unknown and I4
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)reader.TokenType == 11)
			{
				return null;
			}
			EnemyList enemyList = existingValue ?? new EnemyList();
			EnemyList enemyList2 = enemyList;
			if (enemyList2.Enemies == null)
			{
				enemyList2.Enemies = new HashSet<EnemyType>();
			}
			if ((int)reader.TokenType == 2)
			{
				while (reader.Read() && (int)reader.TokenType != 14)
				{
					if ((int)reader.TokenType == 9)
					{
						if (Enum.TryParse<EnemyType>(reader.Value?.ToString() ?? "", out EnemyType result))
						{
							enemyList.Enemies.Add(result);
						}
					}
					else if ((int)reader.TokenType == 7)
					{
						int num = Convert.ToInt32(reader.Value);
						if (Enum.IsDefined(typeof(EnemyType), num))
						{
							enemyList.Enemies.Add((EnemyType)num);
						}
					}
				}
				return enemyList;
			}
			throw new JsonSerializationException($"Unexpected token type {reader.TokenType} when parsing EnemyList");
		}
	}
	[JsonConverter(typeof(KeybindJsonConverter))]
	public class Keybind : IEquatable<Keybind>
	{
		public KeyCode Key { get; set; }

		public KeyCode Modifier { get; set; }

		public Keybind(KeyCode key, KeyCode modifier = (KeyCode)0)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			Key = key;
			Modifier = modifier;
		}

		public override string ToString()
		{
			//IL_0001: 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_002c: 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_0045: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Modifier == 0)
			{
				return ((object)Key/*cast due to .constrained prefix*/).ToString() ?? "";
			}
			return ((object)Modifier/*cast due to .constrained prefix*/).ToString() + "+" + ((object)Key/*cast due to .constrained prefix*/).ToString();
		}

		public string ToString(bool pretty)
		{
			if (pretty)
			{
				return "<color=#ff8000>" + ToString() + "</color>";
			}
			return ToString();
		}

		public bool Equals(Keybind? other)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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)
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			if (Key == other.Key)
			{
				return Modifier == other.Modifier;
			}
			return false;
		}
	}
	internal class KeybindJsonConverter : JsonConverter<Keybind>
	{
		public override void WriteJson(JsonWriter writer, Keybind? value, JsonSerializer serializer)
		{
			//IL_0004: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			if (value == null || (int)value.Key == 0)
			{
				writer.WriteValue("None");
				return;
			}
			string text = (((int)value.Modifier != 0) ? $"{value.Modifier}+{value.Key}" : $"{value.Key}");
			writer.WriteValue(text);
		}

		public override Keybind? ReadJson(JsonReader reader, Type objectType, Keybind? existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_0054: 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_006d: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			string text = reader.Value?.ToString();
			if (string.IsNullOrEmpty(text) || text == "None")
			{
				return new Keybind((KeyCode)0, (KeyCode)0);
			}
			try
			{
				string[] array = text.Split('+');
				if (array.Length == 2)
				{
					KeyCode modifier = (KeyCode)Enum.Parse(typeof(KeyCode), array[0], ignoreCase: true);
					return new Keybind((KeyCode)Enum.Parse(typeof(KeyCode), array[1], ignoreCase: true), modifier);
				}
				if (array.Length == 1)
				{
					return new Keybind((KeyCode)Enum.Parse(typeof(KeyCode), array[0], ignoreCase: true), (KeyCode)0);
				}
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[KeybindJsonConverter] Failed to parse Keybind config string \"{text}\": {arg}");
			}
			return new Keybind((KeyCode)0, (KeyCode)0);
		}
	}
	[JsonConverter(typeof(WaypointJsonConverter))]
	public class Waypoint : IEquatable<Waypoint>
	{
		public string SceneName;

		public Vector3 Position;

		public string Name;

		public Waypoint(string sceneName, Vector3 position, string name)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			SceneName = sceneName;
			Position = position;
			Name = name;
		}

		public bool Equals(Waypoint? other)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			if (((Vector3)(ref Position)).Equals(other.Position) && Name == other.Name)
			{
				return SceneName == other.SceneName;
			}
			return false;
		}
	}
	internal class WaypointJsonConverter : JsonConverter<Waypoint>
	{
		public override void WriteJson(JsonWriter writer, Waypoint? value, JsonSerializer serializer)
		{
			if (value == null)
			{
				writer.WriteNull();
				return;
			}
			writer.WriteStartObject();
			writer.WritePropertyName("sceneName");
			writer.WriteValue(value.SceneName);
			writer.WritePropertyName("position");
			writer.WriteStartArray();
			writer.WriteValue(value.Position.x);
			writer.WriteValue(value.Position.y);
			writer.WriteValue(value.Position.z);
			writer.WriteEndArray();
			writer.WritePropertyName("name");
			writer.WriteValue(value.Name);
			writer.WriteEndObject();
		}

		public override Waypoint? ReadJson(JsonReader reader, Type objectType, Waypoint? existingValue, bool hasExistingValue, JsonSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if ((int)reader.TokenType == 11)
			{
				return null;
			}
			try
			{
				JObject obj = JObject.Load(reader);
				string sceneName = ((JToken)obj).Value<string>((object)"sceneName") ?? string.Empty;
				string name = ((JToken)obj).Value<string>((object)"name") ?? string.Empty;
				Vector3 zero = Vector3.zero;
				JToken obj2 = obj["position"];
				JArray val = (JArray)(object)((obj2 is JArray) ? obj2 : null);
				if (val != null && ((JContainer)val).Count >= 3)
				{
					float num = Extensions.Value<float>((IEnumerable<JToken>)val[0]);
					float num2 = Extensions.Value<float>((IEnumerable<JToken>)val[1]);
					float num3 = Extensions.Value<float>((IEnumerable<JToken>)val[2]);
					((Vector3)(ref zero))..ctor(num, num2, num3);
				}
				return new Waypoint(sceneName, zero, name);
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"[WaypointJsonConverter] Failed to parse Waypoint JSON object: {arg}");
			}
			return null;
		}
	}
}
namespace ThornClient.Core.ConfigurableElements
{
	public class ConfigButtonRow : IConfigurableElement
	{
		public List<string> Texts;

		public string GUID { get; }

		public string Name { get; }

		public string Description { get; }

		public InterfaceHints? Hints { get; set; }

		public Action<int> OnClick { get; set; }

		public ConfigButtonRow(string guid, string name, string description, string[] texts)
		{
			GUID = guid;
			Name = name;
			Description = description;
			Texts = texts.ToList();
		}
	}
	public class ConfigHeader : IConfigurableElement
	{
		public string GUID { get; }

		public string Name { get; }

		public string Description { get; }

		public InterfaceHints? Hints { get; }

		public int FontSize { get; set; } = 10;

		public ConfigHeader(string guid, string name, string description = "")
		{
			GUID = guid;
			Name = name;
			Description = description;
		}
	}
	public enum HeaderType
	{
		H1,
		H2
	}
	public interface IConfigurableElement
	{
		string GUID { get; }

		string Name { get; }

		string Description { get; }

		InterfaceHints? Hints { get; }
	}
	public abstract class Setting : IConfigurableElement
	{
		public string GUID { get; }

		public string Name { get; }

		public string Description { get; }

		public InterfaceHints? Hints { get; set; }

		[JsonIgnore]
		public SettingType Type { get; protected set; }

		[JsonIgnore]
		public abstract bool IsDefault { get; }

		[JsonIgnore]
		internal Action? InternalOnValueChanged { get; set; }

		public event Action? OnChanged;

		protected Setting(string guid, string name, string description)
		{
			GUID = guid;
			Name = name;
			Description = description;
		}

		protected void RaiseOnChanged()
		{
			this.OnChanged?.Invoke();
		}

		public abstract object GetValue();

		public abstract void SetValue(object value);

		public abstract void Reset();
	}
	public class Setting<T> : Setting
	{
		public T Value
		{
			[CompilerGenerated]
			get
			{
				return <Value>k__BackingField;
			}
			set
			{
				if (!object.Equals(<Value>k__BackingField, value))
				{
					<Value>k__BackingField = value;
					OnValueChanged?.Invoke(<Value>k__BackingField);
					base.InternalOnValueChanged?.Invoke();
					RaiseOnChanged();
				}
			}
		}

		[JsonIgnore]
		public T DefaultValue { get; set; }

		[JsonIgnore]
		public Action<T>? OnValueChanged { get; set; }

		[JsonIgnore]
		public override bool IsDefault
		{
			get
			{
				//IL_005a: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				if (Value == null && DefaultValue == null)
				{
					return true;
				}
				if (Value == null || DefaultValue == null)
				{
					return false;
				}
				T value = Value;
				if (value is Color val)
				{
					value = DefaultValue;
					if (value is Color val2)
					{
						return ColorUtils.Approximately(val, val2);
					}
				}
				value = Value;
				if (value is float num)
				{
					value = DefaultValue;
					if (value is float num2)
					{
						return Mathf.Approximately(num, num2);
					}
				}
				if (typeof(T).IsEnum)
				{
					return Convert.ToInt64(Value) == Convert.ToInt64(DefaultValue);
				}
				if (Value is ICollection source && DefaultValue is ICollection source2)
				{
					return source.Cast<object>().SequenceEqual(source2.Cast<object>());
				}
				return EqualityComparer<T>.Default.Equals(Value, DefaultValue);
			}
		}

		public event Action? OnPress;

		public event Action? OnRelease;

		public void NotifyChanged()
		{
			OnValueChanged?.Invoke(Value);
			base.InternalOnValueChanged?.Invoke();
			RaiseOnChanged();
		}

		public Setting(string guid, string name, string description, T defaultValue)
			: base(guid, name, description)
		{
			Value = defaultValue;
			DefaultValue = defaultValue;
			Type typeFromHandle = typeof(T);
			if ((object)typeFromHandle == null)
			{
				goto IL_00ec;
			}
			SettingType type;
			if (typeFromHandle == typeof(KeyCode))
			{
				type = SettingType.Bind;
			}
			else if (typeFromHandle == typeof(Keybind))
			{
				type = SettingType.Bind;
			}
			else if (typeFromHandle == typeof(bool))
			{
				type = SettingType.Bool;
			}
			else if (typeFromHandle == typeof(Color))
			{
				type = SettingType.Color;
			}
			else if (typeFromHandle == typeof(EnemyList))
			{
				type = SettingType.EnemyList;
			}
			else if (typeFromHandle.IsEnum)
			{
				type = SettingType.Enum;
			}
			else if (typeFromHandle == typeof(float))
			{
				type = SettingType.Float;
			}
			else if (typeFromHandle == typeof(int))
			{
				type = SettingType.Int;
			}
			else
			{
				if (!(typeFromHandle == typeof(string)))
				{
					goto IL_00ec;
				}
				type = SettingType.Text;
			}
			goto IL_00ee;
			IL_00ec:
			type = SettingType.Unsupported;
			goto IL_00ee;
			IL_00ee:
			base.Type = type;
		}

		internal void RaiseOnPress()
		{
			this.OnPress?.Invoke();
		}

		internal void RaiseOnRelease()
		{
			this.OnRelease?.Invoke();
		}

		public override object GetValue()
		{
			return Value;
		}

		public override void Reset()
		{
			Value = DefaultValue;
		}

		public override void SetValue(object value)
		{
			try
			{
				if (value is T value2)
				{
					Value = value2;
					return;
				}
				JToken val = (JToken)((value is JToken) ? value : null);
				if (val != null)
				{
					Value = val.ToObject<T>();
				}
				else if (value is string text && typeof(T) == typeof(Keybind))
				{
					Value = (T)(object)JsonConvert.DeserializeObject<Keybind>("\"" + text + "\"");
				}
				else if (typeof(T).IsEnum)
				{
					if (value is string value3)
					{
						Value = (T)Enum.Parse(typeof(T), value3, ignoreCase: true);
					}
					else
					{
						Value = (T)Enum.ToObject(typeof(T), Convert.ToInt64(value));
					}
				}
				else
				{
					Value = (T)Convert.ChangeType(value, typeof(T));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)$"[Setting] Failed to set {base.Name}'s value {value} to {typeof(T).Name}: {ex}");
			}
		}
	}
	public class SettingGroup : IConfigurableElement
	{
		public string GUID { get; }

		public string Name { get; }

		public string Description { get; }

		public InterfaceHints? Hints { get; set; }

		public List<IConfigurableElement> Elements { get; } = new List<IConfigurableElement>();

		public SettingGroup(string guid, string name, string description)
		{
			GUID = guid;
			Name = name;
			Description = description;
		}
	}
	public record InterfaceHints
	{
		public Tuple<float, float>? Range;

		public int? Decimals;

		public bool? EnumPreferButtonGroup;

		public bool? BoolPreferCheckmark;

		public bool? Hidden;
	}
}