using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ComputerysModdingUtilities;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ModMenu.Api;
using ModMenu.Behaviours.ModList;
using ModMenu.Behaviours.OptionList;
using ModMenu.Behaviours.OptionList.Dummies;
using ModMenu.Behaviours.OptionList.ValueControllers;
using ModMenu.Mods;
using ModMenu.Options;
using ModMenu.Patches;
using ModMenu.Utils;
using Newtonsoft.Json;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: StraftatMod(true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ModMenu
{
	internal static class ModMenuManager
	{
		public static Mod[] mods;

		public static void Init()
		{
			Dictionary<string, PluginInfo>.ValueCollection values = Chainloader.PluginInfos.Values;
			List<Mod> list = new List<Mod>();
			foreach (PluginInfo item in values)
			{
				ModInfo modInfo = default(ModInfo);
				modInfo.guid = item.Metadata.GUID;
				modInfo.name = item.Metadata.Name;
				modInfo.version = item.Metadata.Version.ToString();
				ModInfo info = modInfo;
				list.Add(new Mod(info));
			}
			mods = list.ToArray();
		}
	}
	public static class PluginInfo
	{
		public const string guid = "kestrel.straftat.modmenu";

		public const string name = "ModMenu";

		public const string version = "1.1.5";
	}
	[BepInPlugin("kestrel.straftat.modmenu", "ModMenu", "1.1.5")]
	public class Plugin : BaseUnityPlugin
	{
		private enum TestEnum
		{
			OptionA,
			OptionB,
			OptionC,
			OptionD,
			AndSoOn
		}

		private enum TestEnum2
		{
			AnotherTestEnum,
			IsntThisCool,
			HeyHiiiiHeyLookAtMe,
			ColonThree
		}

		internal static ManualLogSource Logger;

		private static ConfigEntry<string> m_superSecretConfigEntry;

		public static readonly string loadBearingColonThree = ":3";

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (loadBearingColonThree != ":3")
			{
				Application.Quit();
			}
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			CreateExampleConfigs();
			Assets.Init();
			ModMenuCustomisation.RegisterContentBuilder(CustomContentBuilder);
			ModMenuCustomisation.HideEntry((ConfigEntryBase)(object)m_superSecretConfigEntry);
			ModMenuCustomisation.SetPluginDescription("Configure your mods ingame!");
			ModMenuCustomisation.SetPluginIcon(Assets.ModMenuModIcon);
			new Harmony("kestrel.straftat.modmenu").PatchAll();
			Logger.LogInfo((object)"Hiiiiiiiiiiii :3");
		}

		private void CreateExampleConfigs()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: 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_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			((BaseUnityPlugin)this).Config.Bind<bool>("Examples.Basic", "Bool", false, "A bool");
			((BaseUnityPlugin)this).Config.Bind<string>("Examples.Basic", "String", "Hiiiii", "A string");
			((BaseUnityPlugin)this).Config.Bind<float>("Examples.Numeric", "Unrestricted Float", 0f, "A float");
			((BaseUnityPlugin)this).Config.Bind<float>("Examples.Numeric", "Acceptable Range Float", 0f, new ConfigDescription("A float with a range restriction", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-100f, 100f), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.Bind<float>("Examples.Numeric", "Acceptable List Float", 0f, new ConfigDescription("A float with a list of acceptable values", (AcceptableValueBase)(object)new AcceptableValueList<float>(new float[6] { 0f, 0.5f, 1f, 1.5f, 2f, 10f }), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.Bind<int>("Examples.Numeric", "Unrestricted Int", 0, "An int");
			((BaseUnityPlugin)this).Config.Bind<int>("Examples.Numeric", "Acceptable Range Int", 0, new ConfigDescription("An int with a range restriction", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-10, 10), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.Bind<int>("Examples.Numeric", "Acceptable List Int", 0, new ConfigDescription("An int with a list of acceptable values", (AcceptableValueBase)(object)new AcceptableValueList<int>(new int[7] { 0, 1, 2, 3, 4, 5, 10 }), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.Bind<uint>("Examples.Numeric", "UInt", 0u, "An unsigned int");
			((BaseUnityPlugin)this).Config.Bind<sbyte>("Examples.Numeric", "SByte", (sbyte)0, "A signed byte");
			((BaseUnityPlugin)this).Config.Bind<byte>("Examples.Numeric", "Byte", (byte)0, "A byte");
			((BaseUnityPlugin)this).Config.Bind<Vector2>("Examples.UnityTypes", "Unrestricted Vector2", Vector2.zero, "A Vector2");
			((BaseUnityPlugin)this).Config.Bind<Vector2>("Examples.UnityTypes", "Acceptable List Vector2", Vector2.zero, new ConfigDescription("A Vector2 with a list of acceptable values", (AcceptableValueBase)(object)new AcceptableValueList<Vector2>((Vector2[])(object)new Vector2[6]
			{
				Vector2.zero,
				Vector2.one,
				Vector2.up,
				Vector2.down,
				Vector2.left,
				Vector2.right
			}), Array.Empty<object>()));
			((BaseUnityPlugin)this).Config.Bind<Vector3>("Examples.UnityTypes", "Vector3", Vector3.zero, "A Vector3");
			((BaseUnityPlugin)this).Config.Bind<Vector4>("Examples.UnityTypes", "Vector4", Vector4.zero, "A Vector4");
			((BaseUnityPlugin)this).Config.Bind<Quaternion>("Examples.UnityTypes", "Quaternion", Quaternion.identity, "A Quaternion");
			((BaseUnityPlugin)this).Config.Bind<Color>("Examples.UnityTypes", "Color", Color.white, "A Color");
			((BaseUnityPlugin)this).Config.Bind<TestEnum>("Examples.Other", "Enum", TestEnum.OptionA, "An enum");
			((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Examples.Other", "Keyboard Shortcut", new KeyboardShortcut((KeyCode)285, (KeyCode[])(object)new KeyCode[1] { (KeyCode)308 }), "A keyboard shortcut");
			((BaseUnityPlugin)this).Config.Bind<KeyCode>("Examples.Other", "KeyCode", (KeyCode)97, "A keycode");
			m_superSecretConfigEntry = ((BaseUnityPlugin)this).Config.Bind<string>("Examples.Secret", "Super Secret Entry", ":3", "shhh");
			m_superSecretConfigEntry.SettingChanged += delegate
			{
				PauseManager.Instance.WriteOfflineLog(">:3");
			};
		}

		private static void CustomContentBuilder(OptionListContext c)
		{
			//IL_00c6: 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_013b: 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_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			c.InsertHeader(13, "Custom Section 1");
			((Component)c.InsertTextBox(14, "This section was generated with the Mod Menu API! With it, you can add custom ui elements anywhere in your mod's config page. Go to Assets/Scripts/Plugin.cs in the mod's source code to see example usage of the API.")).GetComponent<LayoutElement>().preferredHeight = 128f;
			c.InsertButton(15, "", "A very interesting button", delegate
			{
				PauseManager.Instance.WriteOfflineLog("Button pressed!");
			});
			c.InsertButton(16, "Plugins Directory", "Show Path", delegate
			{
				string pluginPath = Paths.PluginPath;
				PauseManager.Instance.WriteOfflineLog("Plugins directory: " + pluginPath);
			});
			c.AppendHeader("Custom Section 2");
			c.AppendTextBox("Another custom section!");
			c.AppendTextBox("With some colored text! :3").Color = new Color(0.77f, 0.53f, 1f);
			TestEnum2 dropdownValue = TestEnum2.AnotherTestEnum;
			c.AppendDropdown("Custom Dropdown", () => dropdownValue, delegate(TestEnum2 value)
			{
				dropdownValue = value;
				PauseManager.Instance.WriteOfflineLog($"dropdownValue is {dropdownValue}");
			});
			bool boolValue = false;
			c.AppendCheckbox("Custom Checkbox", () => boolValue, delegate(bool value)
			{
				boolValue = value;
				PauseManager.Instance.WriteOfflineLog($"checkboxValue is {value}");
			});
			Color colorValue = new Color(0.77f, 0.53f, 1f);
			c.AppendColorInput("Custom Color Input", () => colorValue, delegate(Color value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				colorValue = value;
				PauseManager.Instance.WriteOfflineLog($"colorValue is {value}");
			});
			string stringValue = "hiii";
			c.AppendStringInput("Custom String Input", () => stringValue, delegate(string value)
			{
				stringValue = value;
				PauseManager.Instance.WriteOfflineLog("stringValue is " + value);
			});
			KeyboardShortcut keyboardShortcutValue = KeyboardShortcut.Empty;
			c.AppendKeyboardShortcutInput("Custom Keyboard Shortcut Input", () => keyboardShortcutValue, delegate(KeyboardShortcut value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				keyboardShortcutValue = value;
				PauseManager.Instance.WriteOfflineLog($"keyboardShortcutValue is {value}");
			});
			KeyCode keyCodeValue = (KeyCode)0;
			c.AppendKeyCodeInput("Custom KeyCode Input", () => keyCodeValue, delegate(KeyCode value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				keyCodeValue = value;
				PauseManager.Instance.WriteOfflineLog($"keyCodeValue is {value}");
			});
			Quaternion quaternionValue = Quaternion.identity;
			c.AppendQuaternionInput("Custom Quaternion Input", () => quaternionValue, delegate(Quaternion value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				quaternionValue = value;
				PauseManager.Instance.WriteOfflineLog($"quaternionValue is {value}");
			});
			Vector2 vector2Value = Vector2.zero;
			c.AppendVector2Input("Custom Vector2 Input", () => vector2Value, delegate(Vector2 value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				vector2Value = value;
				PauseManager.Instance.WriteOfflineLog($"vector2Value is {value}");
			});
			Vector3 vector3Value = Vector3.zero;
			c.AppendVector3Input("Custom Vector3 Input", () => vector3Value, delegate(Vector3 value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				vector3Value = value;
				PauseManager.Instance.WriteOfflineLog($"vector3Value is {value}");
			});
			Vector4 vector4Value = Vector4.zero;
			c.AppendVector4Input("Custom Vector4 Input", () => vector4Value, delegate(Vector4 value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				vector4Value = value;
				PauseManager.Instance.WriteOfflineLog($"vector4Value is {value}");
			});
			c.AppendTextBox("Some weirder stuff").Color = new Color(0.77254903f, 0.5254902f, 1f);
			float floatValue = 0f;
			Action<float> setter = delegate(float value)
			{
				floatValue = value;
				PauseManager.Instance.WriteOfflineLog($"floatValue is {floatValue}");
			};
			NumericInputFieldValueController inputField = c.AppendNumericInputField("Custom Float Input", () => floatValue, setter);
			NumericSliderValueController slider = c.AppendNumericSlider("Custom Float Slider", () => floatValue, setter, 0f, 100f);
			NumericInputFieldValueController numericInputFieldValueController = inputField;
			numericInputFieldValueController.setter = (Action<object>)Delegate.Combine(numericInputFieldValueController.setter, (Action<object>)delegate
			{
				slider.UpdateAppearance();
			});
			NumericSliderValueController numericSliderValueController = slider;
			numericSliderValueController.setter = (Action<object>)Delegate.Combine(numericSliderValueController.setter, (Action<object>)delegate
			{
				inputField.UpdateAppearance();
			});
			int sliderMin = -200;
			int sliderMax = 200;
			float floatValue2 = 0f;
			NumericSliderValueController floatSlider2 = c.AppendNumericSlider("Custom Float Slider 2", () => floatValue2, delegate(float value)
			{
				floatValue2 = value;
				PauseManager.Instance.WriteOfflineLog($"floatValue2 is {floatValue2}");
			}, sliderMin, sliderMax);
			NumericSliderValueController minSlider = c.AppendNumericSlider("Slider 2 Min (int slider example)", () => sliderMin, delegate(int value)
			{
				sliderMin = value;
				floatSlider2.slider.minValue = sliderMin;
			}, -1000f, sliderMax - 5);
			NumericSliderValueController maxSlider = c.AppendNumericSlider("Slider 2 Max (int slider example)", () => sliderMax, delegate(int value)
			{
				sliderMax = value;
				floatSlider2.slider.maxValue = sliderMax;
			}, sliderMin + 5, 1000f);
			NumericSliderValueController numericSliderValueController2 = minSlider;
			numericSliderValueController2.setter = (Action<object>)Delegate.Combine(numericSliderValueController2.setter, (Action<object>)delegate
			{
				maxSlider.slider.minValue = sliderMin + 5;
			});
			NumericSliderValueController numericSliderValueController3 = maxSlider;
			numericSliderValueController3.setter = (Action<object>)Delegate.Combine(numericSliderValueController3.setter, (Action<object>)delegate
			{
				minSlider.slider.maxValue = sliderMax - 5;
			});
		}
	}
}
namespace ModMenu.Utils
{
	internal static class AcceptableValueBaseExtensions
	{
		public static string HumanizedString(this AcceptableValueBase avb)
		{
			Type type = ((object)avb).GetType();
			if (avb.IsAcceptableValueRange())
			{
				object value = type.GetProperty("MinValue").GetValue(avb);
				object value2 = type.GetProperty("MaxValue").GetValue(avb);
				return "Accepts " + value?.ToString() + " to " + value2;
			}
			if (avb.IsAcceptableValueList())
			{
				object[] array = ((IEnumerable)type.GetProperty("AcceptableValues").GetValue(avb)).Cast<object>().ToArray();
				return "Accepts " + string.Join(", ", from v in array.SkipLast(1)
					select v.ToString()) + " and " + array[^1];
			}
			throw new NotSupportedException($"Type \"{type}\" is not supported.");
		}

		public static bool IsAcceptableValueList(this AcceptableValueBase avb)
		{
			return ((object)avb).GetType().GetGenericTypeDefinition() == typeof(AcceptableValueList<>);
		}

		public static bool IsAcceptableValueRange(this AcceptableValueBase avb)
		{
			return ((object)avb).GetType().GetGenericTypeDefinition() == typeof(AcceptableValueRange<>);
		}
	}
	internal static class Assets
	{
		private static AssetBundle m_bundle;

		public static Sprite DefaultModIcon { get; private set; }

		public static Sprite ModMenuModIcon { get; private set; }

		public static GameObject CategoryHeader { get; private set; }

		public static GameObject IntegralSliderOption { get; private set; }

		public static GameObject FloatingSliderOption { get; private set; }

		public static GameObject IntegralInputFieldOption { get; private set; }

		public static GameObject FloatingInputFieldOption { get; private set; }

		public static GameObject BoolCheckboxOption { get; private set; }

		public static GameObject StringInputFieldOption { get; private set; }

		public static GameObject EnumDropdownOption { get; private set; }

		public static GameObject KeyCodeOption { get; private set; }

		public static GameObject KeyboardShortcutOption { get; private set; }

		public static GameObject AcceptableListDropdownOption { get; private set; }

		public static GameObject Vector2Option { get; private set; }

		public static GameObject Vector3Option { get; private set; }

		public static GameObject Vector4Option { get; private set; }

		public static GameObject QuaternionOption { get; private set; }

		public static GameObject ColorOption { get; private set; }

		public static GameObject TextDummy { get; private set; }

		public static GameObject ButtonDummy { get; private set; }

		internal static T Load<T>(string name) where T : Object
		{
			return m_bundle.LoadAsset<T>(name);
		}

		public static void Init()
		{
			Plugin.Logger.LogInfo((object)"Loading assets...");
			m_bundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "modmenu"));
			DefaultModIcon = Assets.Load<Sprite>("NoIcon");
			ModMenuModIcon = Assets.Load<Sprite>("ModIcon");
			CategoryHeader = Assets.Load<GameObject>("CategoryHeader");
			IntegralSliderOption = Assets.Load<GameObject>("IntegralSliderOption");
			FloatingSliderOption = Assets.Load<GameObject>("FloatingSliderOption");
			IntegralInputFieldOption = Assets.Load<GameObject>("IntegralInputFieldOption");
			FloatingInputFieldOption = Assets.Load<GameObject>("FloatingInputFieldOption");
			BoolCheckboxOption = Assets.Load<GameObject>("BoolCheckboxOption");
			StringInputFieldOption = Assets.Load<GameObject>("StringInputFieldOption");
			EnumDropdownOption = Assets.Load<GameObject>("EnumDropdownOption");
			KeyCodeOption = Assets.Load<GameObject>("KeyCodeOption");
			KeyboardShortcutOption = Assets.Load<GameObject>("KeyboardShortcutOption");
			AcceptableListDropdownOption = Assets.Load<GameObject>("AcceptableListDropdownOption");
			Vector2Option = Assets.Load<GameObject>("Vector2Option");
			Vector3Option = Assets.Load<GameObject>("Vector3Option");
			Vector4Option = Assets.Load<GameObject>("Vector4Option");
			QuaternionOption = Assets.Load<GameObject>("QuaternionOption");
			ColorOption = Assets.Load<GameObject>("ColorOption");
			TextDummy = Assets.Load<GameObject>("TextDummy");
			ButtonDummy = Assets.Load<GameObject>("ButtonDummy");
			Plugin.Logger.LogInfo((object)"Assets loaded!");
		}
	}
	internal static class BepInExUtils
	{
		internal static Dictionary<Assembly, PluginInfo> PluginInfoCache { get; } = new Dictionary<Assembly, PluginInfo>();


		internal static Dictionary<PluginInfo, string> PluginTypeNameCache { get; } = new Dictionary<PluginInfo, string>();


		internal static string GetPluginInfoTypeName(PluginInfo pluginInfo)
		{
			if (PluginTypeNameCache.TryGetValue(pluginInfo, out var value))
			{
				return value;
			}
			value = AccessTools.Property(typeof(PluginInfo), "TypeName").GetValue(pluginInfo) as string;
			PluginTypeNameCache.Add(pluginInfo, value);
			return value;
		}

		internal static PluginInfo GetPluginInfoFromAssembly(Assembly assembly)
		{
			if (PluginInfoCache.TryGetValue(assembly, out var value))
			{
				return value;
			}
			using (IEnumerator<PluginInfo> enumerator = Chainloader.PluginInfos.Values.Where((PluginInfo info) => assembly.GetType(GetPluginInfoTypeName(info)) != null).GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					PluginInfo current = enumerator.Current;
					PluginInfoCache.Add(assembly, current);
					return current;
				}
			}
			PluginInfoCache.Add(assembly, null);
			return null;
		}
	}
	internal static class TypeExtensions
	{
		public static bool IsIntegral(this Type type)
		{
			if (!(type == typeof(sbyte)) && !(type == typeof(byte)) && !(type == typeof(short)) && !(type == typeof(ushort)) && !(type == typeof(int)) && !(type == typeof(uint)) && !(type == typeof(long)))
			{
				return type == typeof(ulong);
			}
			return true;
		}

		public static bool IsFloating(this Type type)
		{
			if (!(type == typeof(float)) && !(type == typeof(double)))
			{
				return type == typeof(decimal);
			}
			return true;
		}
	}
}
namespace ModMenu.Patches
{
	[HarmonyPatch(typeof(PauseManager))]
	internal static class PauseManagerPatch
	{
		public static readonly HashSet<BoxedValueController> currentlyRebindingKeybindContollers = new HashSet<BoxedValueController>();

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void InitModsTab(GameObject ___optionsMenu)
		{
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_010c: 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_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_0158: Expected O, but got Unknown
			//IL_015d: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)___optionsMenu))
			{
				return;
			}
			((Component)___optionsMenu.transform.Find("OPTIONS HUD").GetChild(0).GetChild(3)).gameObject.SetActive(false);
			GameObject pcTab = ((Component)___optionsMenu.transform.Find("PcTab")).gameObject;
			GameObject audioTab = ((Component)___optionsMenu.transform.Find("AudioTab")).gameObject;
			GameObject graphTab = ((Component)___optionsMenu.transform.Find("GraphTab")).gameObject;
			GameObject modsTab = Object.Instantiate<GameObject>(Assets.Load<GameObject>("ModMenu"), ___optionsMenu.transform);
			((Object)modsTab).name = "ModsTab";
			modsTab.SetActive(false);
			Transform val = ___optionsMenu.transform.Find("Tabsbutton");
			Button component = Object.Instantiate<GameObject>(Assets.Load<GameObject>("ModsTabButton"), ((Component)val).transform).GetComponent<Button>();
			UnityAction val2 = default(UnityAction);
			for (int i = 0; i < val.childCount; i++)
			{
				RectTransform component2 = ((Component)val.GetChild(i)).GetComponent<RectTransform>();
				if (component2 == null)
				{
					continue;
				}
				component2.sizeDelta = new Vector2(110f, 63.21f);
				component2.anchoredPosition = new Vector2((float)(-710 + i * 110), 343.8f);
				ButtonClickedEvent onClick = ((Component)component2).GetComponent<Button>().onClick;
				UnityAction obj = val2;
				if (obj == null)
				{
					UnityAction val3 = delegate
					{
						modsTab.SetActive(false);
					};
					UnityAction val4 = val3;
					val2 = val3;
					obj = val4;
				}
				((UnityEvent)onClick).AddListener(obj);
			}
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				modsTab.SetActive(true);
				pcTab.SetActive(false);
				audioTab.SetActive(false);
				graphTab.SetActive(false);
			});
		}

		[HarmonyPatch("Menu")]
		[HarmonyPrefix]
		public static bool DoNotOpenIfRebinding()
		{
			return currentlyRebindingKeybindContollers.Count == 0;
		}
	}
}
namespace ModMenu.Options
{
	internal class AcceptableListDropdownOption : Option
	{
		public AcceptableListDropdownOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.AcceptableListDropdownOption;
		}
	}
	internal class BoolOption : ValueOption<bool>
	{
		public BoolOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.BoolCheckboxOption;
		}
	}
	internal class ColorOption : ValueOption<Color>
	{
		public ColorOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.ColorOption;
		}
	}
	internal class EnumDropdownOption : Option
	{
		public EnumDropdownOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.EnumDropdownOption;
		}
	}
	internal class FloatingInputFieldOption : Option
	{
		public FloatingInputFieldOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.FloatingInputFieldOption;
		}
	}
	internal class FloatingSliderOption : Option
	{
		public FloatingSliderOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.FloatingSliderOption;
		}
	}
	internal class IntegralInputFieldOption : Option
	{
		public IntegralInputFieldOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.IntegralInputFieldOption;
		}
	}
	internal class IntegralSliderOption : Option
	{
		public IntegralSliderOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.IntegralSliderOption;
		}
	}
	internal class KeyboardShortcutOption : ValueOption<KeyboardShortcut>
	{
		public KeyboardShortcutOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.KeyboardShortcutOption;
		}
	}
	internal class KeyCodeOption : ValueOption<KeyCode>
	{
		public KeyCodeOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.KeyCodeOption;
		}
	}
	internal abstract class Option
	{
		public string Name => BaseEntry.Definition.Key;

		public string Section => BaseEntry.Definition.Section;

		public string Description => BaseEntry.Description.Description;

		public AcceptableValueBase AcceptableValues => BaseEntry.Description.AcceptableValues;

		public ConfigEntryBase BaseEntry { get; }

		public object BoxedValue
		{
			get
			{
				return BaseEntry.BoxedValue;
			}
			set
			{
				BaseEntry.BoxedValue = value;
			}
		}

		protected Option(ConfigEntryBase entry)
		{
			BaseEntry = entry;
		}

		public abstract GameObject GetListItemPrefab();

		public void ResetToDefault()
		{
			BoxedValue = BaseEntry.DefaultValue;
		}

		public static Option CreateForEntry(ConfigEntryBase entry)
		{
			Type settingType = entry.SettingType;
			AcceptableValueBase acceptableValues = entry.Description.AcceptableValues;
			if (acceptableValues != null && acceptableValues.IsAcceptableValueList())
			{
				return new AcceptableListDropdownOption(entry);
			}
			if (settingType == typeof(bool))
			{
				return new BoolOption(entry);
			}
			if (settingType == typeof(string))
			{
				return new StringInputFieldOption(entry);
			}
			if (settingType.IsIntegral())
			{
				if (acceptableValues != null && acceptableValues.IsAcceptableValueRange())
				{
					return new IntegralSliderOption(entry);
				}
				return new IntegralInputFieldOption(entry);
			}
			if (settingType.IsFloating())
			{
				if (acceptableValues != null && acceptableValues.IsAcceptableValueRange())
				{
					return new FloatingSliderOption(entry);
				}
				return new FloatingInputFieldOption(entry);
			}
			if (settingType == typeof(KeyCode))
			{
				return new KeyCodeOption(entry);
			}
			if (settingType == typeof(KeyboardShortcut))
			{
				return new KeyboardShortcutOption(entry);
			}
			if (settingType == typeof(Vector2))
			{
				return new Vector2Option(entry);
			}
			if (settingType == typeof(Vector3))
			{
				return new Vector3Option(entry);
			}
			if (settingType == typeof(Vector4))
			{
				return new Vector4Option(entry);
			}
			if (settingType == typeof(Quaternion))
			{
				return new QuaternionOption(entry);
			}
			if (settingType == typeof(Color))
			{
				return new ColorOption(entry);
			}
			if (settingType.IsEnum && !settingType.IsDefined(typeof(FlagsAttribute), inherit: false))
			{
				return new EnumDropdownOption(entry);
			}
			throw new NotSupportedException($"Options of type \"{settingType}\" are not supported.");
		}
	}
	internal abstract class ValueOption<T> : Option
	{
		public T Value
		{
			get
			{
				return (T)base.BaseEntry.BoxedValue;
			}
			set
			{
				base.BaseEntry.BoxedValue = value;
			}
		}

		protected ValueOption(ConfigEntryBase entry)
			: base(entry)
		{
		}
	}
	internal class QuaternionOption : ValueOption<Quaternion>
	{
		public QuaternionOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.QuaternionOption;
		}
	}
	internal class StringInputFieldOption : ValueOption<string>
	{
		public StringInputFieldOption(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.StringInputFieldOption;
		}
	}
	internal class Vector2Option : ValueOption<Vector2>
	{
		public Vector2Option(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.Vector2Option;
		}
	}
	internal class Vector3Option : ValueOption<Vector3>
	{
		public Vector3Option(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.Vector3Option;
		}
	}
	internal class Vector4Option : ValueOption<Vector4>
	{
		public Vector4Option(ConfigEntryBase entry)
			: base(entry)
		{
		}

		public override GameObject GetListItemPrefab()
		{
			return Assets.Vector4Option;
		}
	}
}
namespace ModMenu.Mods
{
	internal class Mod
	{
		public readonly List<Option> config = new List<Option>();

		public ModInfo info;

		public readonly PluginInfo pluginInfo;

		public readonly Action<OptionListContext>? customContentBuilder;

		public bool HasAnyConfigs => config.Count > 0;

		public bool HasAdvancedMetadata { get; private set; }

		public Mod(ModInfo info)
		{
			this.info = info;
			if (Chainloader.PluginInfos.TryGetValue(info.guid, out pluginInfo))
			{
				ModMenuCustomisation.Builders.TryGetValue(info.guid, out customContentBuilder);
				LoadMetadata();
				LoadConfigEntries();
			}
		}

		private void LoadMetadata()
		{
			info.icon = Assets.DefaultModIcon;
			info.description = "No description found.";
			string text = Path.GetFullPath(pluginInfo.Location);
			DirectoryInfo parent = Directory.GetParent(text);
			while (parent != null && !string.Equals(parent.Name, "plugins", StringComparison.OrdinalIgnoreCase))
			{
				text = parent.FullName;
				parent = Directory.GetParent(text);
			}
			if (text.EndsWith(".dll"))
			{
				return;
			}
			if (ModMenuCustomisation.Icons.TryGetValue(info.guid, out var value))
			{
				info.icon = value;
				HasAdvancedMetadata = true;
			}
			else
			{
				string text2 = Directory.EnumerateFiles(text, "icon.png", SearchOption.AllDirectories).FirstOrDefault();
				if (!string.IsNullOrEmpty(text2))
				{
					TryLoadIcon(text2);
				}
			}
			string text3 = Directory.EnumerateFiles(text, "manifest.json", SearchOption.AllDirectories).FirstOrDefault();
			if (!string.IsNullOrEmpty(text3))
			{
				TryLoadManifest(text3);
			}
			if (ModMenuCustomisation.Descriptions.TryGetValue(info.guid, out var value2))
			{
				info.description = value2;
				HasAdvancedMetadata = true;
			}
		}

		private void LoadConfigEntries()
		{
			ConfigFile val = pluginInfo.Instance.Config;
			if (val == null)
			{
				return;
			}
			foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in val)
			{
				try
				{
					if (!ModMenuCustomisation.HiddenConfigEntries.Contains(item.Value))
					{
						config.Add(Option.CreateForEntry(item.Value));
					}
				}
				catch (NotSupportedException ex)
				{
					Plugin.Logger.LogWarning((object)$"Error generating config entry \"{item.Key}\" for \"{info.name}\": {ex.Message}");
				}
			}
		}

		private bool TryLoadIcon(string path)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(256, 256);
			if (!ImageConversion.LoadImage(val, File.ReadAllBytes(path)))
			{
				return false;
			}
			info.icon = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			HasAdvancedMetadata = true;
			return true;
		}

		private bool TryLoadManifest(string path)
		{
			//IL_004d: Expected O, but got Unknown
			try
			{
				ThunderstoreManifest thunderstoreManifest = JsonConvert.DeserializeObject<ThunderstoreManifest>(File.ReadAllText(path));
				info.description = thunderstoreManifest?.Description;
				info.name = thunderstoreManifest?.Name.Replace('_', ' ');
				HasAdvancedMetadata = true;
			}
			catch (JsonException val)
			{
				JsonException val2 = val;
				Plugin.Logger.LogWarning((object)("Error trying to load manifest for \"" + info.name + "\": " + ((Exception)(object)val2).Message));
				return false;
			}
			return true;
		}
	}
	internal struct ModInfo
	{
		public string name;

		public string guid;

		public string description;

		public string version;

		public Sprite icon;
	}
	internal class ThunderstoreManifest
	{
		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("version_number")]
		public string Version { get; set; }

		[JsonProperty("website_url")]
		public string WebsiteUrl { get; set; }

		[JsonProperty("description")]
		public string Description { get; set; }

		[JsonProperty("dependencies")]
		public string[] Dependencies { get; set; }
	}
}
namespace ModMenu.Behaviours
{
	internal class ModMenu : MonoBehaviour
	{
		public ModListPanel modListPanel;

		private void Awake()
		{
			ModMenuManager.Init();
		}
	}
	internal class ShowTooltip : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public string textToShow;

		public void OnPointerEnter(PointerEventData eventData)
		{
			FloatingName.Instance.nameToShow = textToShow;
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			FloatingName.Instance.nameToShow = "";
		}
	}
}
namespace ModMenu.Behaviours.OptionList
{
	internal class OptionInfoPanel : MonoBehaviour
	{
		public TextMeshProUGUI nameText;

		public TextMeshProUGUI categoryText;

		public TextMeshProUGUI descriptionText;

		public Button resetButton;

		private void Awake()
		{
			ClearInfo();
		}

		public void PlayClickSound()
		{
			PauseManager.Instance.PlayMenuClip(PauseManager.Instance.releaseMenuClip);
		}

		public void ShowInfoFor(Option option)
		{
			ClearInfo();
			((TMP_Text)nameText).text = option.Name;
			((TMP_Text)descriptionText).text = option.Description;
			string section = option.Section;
			string name = option.BaseEntry.SettingType.Name;
			((TMP_Text)categoryText).text = section + " | " + name + " | Defaults to " + option.BaseEntry.DefaultValue;
			if (option.AcceptableValues != null)
			{
				TextMeshProUGUI obj = categoryText;
				((TMP_Text)obj).text = ((TMP_Text)obj).text + " | " + option.AcceptableValues.HumanizedString();
			}
		}

		public void ShowResetButtonFor(BoxedValueController controller)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((Component)resetButton).gameObject.SetActive(true);
			((UnityEvent)resetButton.onClick).AddListener((UnityAction)delegate
			{
				controller.ResetValue();
				controller.UpdateAppearance();
			});
		}

		public void ClearInfo()
		{
			((UnityEventBase)resetButton.onClick).RemoveAllListeners();
			((Component)resetButton).gameObject.SetActive(false);
			((TMP_Text)nameText).text = "";
			((TMP_Text)categoryText).text = "";
			((TMP_Text)descriptionText).text = "";
		}
	}
	public class OptionListItem : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public delegate void ItemHoverHandler();

		public TextMeshProUGUI nameText;

		public string NameText
		{
			get
			{
				return ((TMP_Text)nameText).text;
			}
			set
			{
				((TMP_Text)nameText).text = value;
			}
		}

		public event ItemHoverHandler OnItemHovered;

		public event ItemHoverHandler OnItemUnhovered;

		public void OnPointerEnter(PointerEventData eventData)
		{
			this.OnItemHovered?.Invoke();
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			this.OnItemUnhovered?.Invoke();
		}
	}
	internal class OptionListPanel : MonoBehaviour
	{
		public GameObject container;

		public OptionInfoPanel infoPanel;

		private Dictionary<string, GameObject[]> m_optionCache = new Dictionary<string, GameObject[]>();

		private string m_currentEnabledGuid = "";

		private GameObject m_noOptionsText;

		private GameObject m_noOptionsSadFace;

		private void Awake()
		{
			OptionListContext optionListContext = new OptionListContext(container.transform);
			m_noOptionsText = ((Component)optionListContext.AppendHeader("No options found")).gameObject;
			m_noOptionsSadFace = ((Component)optionListContext.AppendHeader(":c")).gameObject;
			((Object)m_noOptionsText).name = "No options found header";
			((Object)m_noOptionsSadFace).name = "No options found sad face";
			((TMP_Text)m_noOptionsSadFace.GetComponent<TextMeshProUGUI>()).fontSize = 24f;
			m_noOptionsText.SetActive(false);
			m_noOptionsSadFace.SetActive(false);
		}

		public void ShowListFor(Mod mod)
		{
			ClearList();
			m_currentEnabledGuid = mod.info.guid;
			if (m_optionCache.TryGetValue(m_currentEnabledGuid, out var value))
			{
				GameObject[] array = value;
				foreach (GameObject obj in array)
				{
					obj.SetActive(true);
					obj.GetComponent<BoxedValueController>()?.UpdateAppearance();
				}
				return;
			}
			List<GameObject> list = new List<GameObject>();
			if (!mod.HasAnyConfigs)
			{
				list.Add(m_noOptionsText);
				list.Add(m_noOptionsSadFace);
				m_noOptionsText.SetActive(true);
				m_noOptionsSadFace.SetActive(true);
			}
			else
			{
				OptionListContext optionListContext = new OptionListContext(container.transform);
				string text = "";
				foreach (Option item in mod.config)
				{
					if (item.Section != text)
					{
						TextDummy textDummy = optionListContext.AppendHeader(item.Section);
						((Object)textDummy).name = mod.info.name + "/" + item.Section;
						list.Add(((Component)textDummy).gameObject);
					}
					text = item.Section;
					GameObject val = optionListContext.AppendControllerForOption(item, infoPanel);
					((Object)val).name = mod.info.name + "/" + item.Section + "/" + item.Name;
					list.Add(val);
				}
				optionListContext = new OptionListContext(container.transform);
				try
				{
					mod.customContentBuilder?.Invoke(optionListContext);
				}
				catch (Exception arg)
				{
					Plugin.Logger.LogError((object)$"Error invoking custom content builder for {mod.info.guid}: {arg}");
				}
				list.AddRange(optionListContext.GetNewChildren());
			}
			m_optionCache[m_currentEnabledGuid] = list.ToArray();
		}

		private void ClearList()
		{
			if (m_optionCache.TryGetValue(m_currentEnabledGuid, out var value))
			{
				GameObject[] array = value;
				for (int i = 0; i < array.Length; i++)
				{
					array[i].SetActive(false);
				}
			}
		}
	}
}
namespace ModMenu.Behaviours.OptionList.ValueControllers
{
	public class BoolValueController : ValueController<bool>
	{
		public Toggle toggle;

		public void OnCheckboxValueChanged(bool value)
		{
			SetValue(value);
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			toggle.SetIsOnWithoutNotify(GetValue());
		}
	}
	public class ColorValueController : ValueController<Color>
	{
		public TMP_InputField inputField;

		public Image preview;

		public void OnInputFieldEndEdit(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Color value2 = default(Color);
			if (ColorUtility.TryParseHtmlString(value, ref value2))
			{
				SetValue(value2);
			}
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			//IL_000c: 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)
			inputField.SetTextWithoutNotify("#" + ColorUtility.ToHtmlStringRGBA(GetValue()).ToLower());
			((Graphic)preview).color = GetValue();
		}
	}
	public class DropdownValueController : BoxedValueController
	{
		public TMP_Dropdown dropdown;

		private string[] m_dropdownNames;

		private object[] m_dropdownValues;

		protected override void Setup()
		{
			dropdown.ClearOptions();
			dropdown.AddOptions(m_dropdownNames.ToList());
		}

		public void OnDropdownValueChanged(int index)
		{
			setter(m_dropdownValues[index]);
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			dropdown.SetValueWithoutNotify(Array.IndexOf(m_dropdownValues, getter()));
		}

		internal override void SetupFromOption(Option option)
		{
			Type settingType = option.BaseEntry.SettingType;
			if (settingType.IsEnum)
			{
				SetValuesFromEnum(settingType);
			}
			else
			{
				if (!option.AcceptableValues.IsAcceptableValueList())
				{
					throw new InvalidOperationException("Cannot setup a dropdown value controller from a non-enum option type with no acceptable value list.");
				}
				SetValuesFromOption(option);
			}
			base.SetupFromOption(option);
		}

		internal override void SetupFromValues<T>(Func<T> getter, Action<T> setter)
		{
			if (!typeof(T).IsEnum)
			{
				throw new InvalidOperationException("Cannot setup a dropdown value controller by values from a non-enum type");
			}
			SetValuesFromEnum(typeof(T));
			base.SetupFromValues(getter, setter);
		}

		private void SetValuesFromEnum(Type enumType)
		{
			m_dropdownNames = Enum.GetNames(enumType);
			m_dropdownValues = Enum.GetValues(enumType).Cast<object>().ToArray();
		}

		private void SetValuesFromOption(Option option)
		{
			AcceptableValueBase acceptableValues = option.AcceptableValues;
			m_dropdownValues = ((IEnumerable)((object)acceptableValues).GetType().GetProperty("AcceptableValues").GetValue(acceptableValues)).Cast<object>().ToArray();
			m_dropdownNames = m_dropdownValues.Select((object v) => v.ToString()).ToArray();
		}
	}
	public abstract class KeybindValueController<T> : ValueController<T>
	{
		public TextMeshProUGUI buttonText;

		protected bool rebinding;

		protected KeyCode[] keysToCheck;

		protected override void Setup()
		{
			keysToCheck = UnityInput.Current.SupportedKeyCodes.Except((IEnumerable<KeyCode>)(object)new KeyCode[3]
			{
				(KeyCode)323,
				default(KeyCode),
				(KeyCode)27
			}).ToArray();
		}

		public void OnRebindButtonPressed()
		{
			if (!rebinding)
			{
				StartRebinding();
			}
			else
			{
				StopRebinding();
			}
			UpdateAppearance();
		}

		public override void ResetValue()
		{
			base.ResetValue();
			StopRebinding();
		}

		public override void UpdateAppearance()
		{
			((TMP_Text)buttonText).text = (rebinding ? "Cancel" : GetValue().ToString());
		}

		protected abstract void UpdateRebinding();

		protected void StartRebinding()
		{
			rebinding = true;
			PauseManagerPatch.currentlyRebindingKeybindContollers.Add(this);
			UpdateAppearance();
		}

		protected void StopRebinding()
		{
			rebinding = false;
			PauseManagerPatch.currentlyRebindingKeybindContollers.Remove(this);
			UpdateAppearance();
		}

		private void OnDisable()
		{
			StopRebinding();
		}

		private void Update()
		{
			if (rebinding)
			{
				UpdateRebinding();
			}
		}
	}
	public class KeyboardShortcutValueController : KeybindValueController<KeyboardShortcut>
	{
		protected override void UpdateRebinding()
		{
			//IL_000a: 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_002a: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)27))
			{
				SetValue(KeyboardShortcut.Empty);
				StopRebinding();
				return;
			}
			KeyCode[] array = keysToCheck;
			foreach (KeyCode val in array)
			{
				if (Input.GetKeyUp(val))
				{
					SetValue(new KeyboardShortcut(val, ((IEnumerable<KeyCode>)keysToCheck).Where((Func<KeyCode, bool>)Input.GetKey).ToArray()));
					StopRebinding();
					break;
				}
			}
		}
	}
	public class KeyCodeValueController : KeybindValueController<KeyCode>
	{
		protected override void UpdateRebinding()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)27))
			{
				SetValue((KeyCode)0);
				StopRebinding();
				return;
			}
			KeyCode[] array = keysToCheck;
			foreach (KeyCode val in array)
			{
				if (Input.GetKeyUp(val))
				{
					SetValue(val);
					StopRebinding();
					break;
				}
			}
		}
	}
	public class NumericInputFieldValueController : BoxedValueController
	{
		public TMP_InputField inputField;

		private bool m_isIntegralType;

		protected override void Setup()
		{
			m_isIntegralType = base.ValueType.IsIntegral();
		}

		public void OnInputFieldEndEdit(string value)
		{
			try
			{
				object obj = Convert.ChangeType(value, base.ValueType);
				if (obj != null)
				{
					setter(obj);
				}
			}
			catch (Exception ex) when (ex is OverflowException || ex is FormatException || ex is InvalidCastException)
			{
			}
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			inputField.SetTextWithoutNotify(m_isIntegralType ? getter().ToString() : $"{getter():F}");
		}
	}
	public class NumericSliderValueController : BoxedValueController
	{
		public Slider slider;

		public TMP_InputField inputField;

		private bool m_boundsSet;

		private bool m_isIntegralType;

		protected override void Setup()
		{
			m_isIntegralType = base.ValueType.IsIntegral();
		}

		internal override void SetupFromOption(Option option)
		{
			AcceptableValueBase acceptableValues = option.AcceptableValues;
			Type type = ((object)acceptableValues).GetType();
			slider.minValue = Convert.ToSingle(type.GetProperty("MinValue").GetValue(acceptableValues));
			slider.maxValue = Convert.ToSingle(type.GetProperty("MaxValue").GetValue(acceptableValues));
			base.SetupFromOption(option);
			m_boundsSet = true;
		}

		public void OnSliderValueChanged(float value)
		{
			if (m_boundsSet)
			{
				object obj = Convert.ChangeType(value, base.ValueType);
				if (obj != null)
				{
					setter(obj);
				}
				UpdateAppearance();
			}
		}

		public void OnInputFieldEndEdit(string value)
		{
			try
			{
				object obj = Convert.ChangeType(value, base.ValueType);
				if (obj != null)
				{
					setter(obj);
				}
			}
			catch (Exception ex) when (ex is OverflowException || ex is FormatException || ex is InvalidCastException)
			{
			}
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			object obj = getter();
			slider.SetValueWithoutNotify(Convert.ToSingle(obj));
			inputField.SetTextWithoutNotify(m_isIntegralType ? obj.ToString() : $"{obj:F}");
		}
	}
	public class QuaternionValueController : ValueController<Quaternion>
	{
		public TMP_InputField xInputField;

		public TMP_InputField yInputField;

		public TMP_InputField zInputField;

		public TMP_InputField wInputField;

		public void OnInputFieldEndEdit()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			Quaternion value = GetValue();
			float num = value.x;
			float num2 = value.y;
			float num3 = value.z;
			float num4 = value.w;
			if (float.TryParse(xInputField.text, out var result))
			{
				num = result;
			}
			if (float.TryParse(yInputField.text, out var result2))
			{
				num2 = result2;
			}
			if (float.TryParse(zInputField.text, out var result3))
			{
				num3 = result3;
			}
			if (float.TryParse(wInputField.text, out var result4))
			{
				num4 = result4;
			}
			SetValue(new Quaternion(num, num2, num3, num4));
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			//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)
			Quaternion value = GetValue();
			xInputField.SetTextWithoutNotify(value.x.ToString("F"));
			yInputField.SetTextWithoutNotify(value.y.ToString("F"));
			zInputField.SetTextWithoutNotify(value.z.ToString("F"));
			wInputField.SetTextWithoutNotify(value.w.ToString("F"));
		}
	}
	public class StringValueController : ValueController<string>
	{
		public TMP_InputField inputField;

		public void OnInputFieldEndEdit(string value)
		{
			SetValue(value);
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			inputField.SetTextWithoutNotify(GetValue());
		}
	}
	public abstract class BoxedValueController : OptionListItem
	{
		public Func<object> getter;

		public Action<object> setter;

		private object m_defaultValue;

		private Tweener m_errorShake;

		public Type ValueType { get; private set; }

		private void Start()
		{
			//IL_0023: 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)
			m_errorShake = (Tweener)(object)TweenExtensions.Pause<TweenerCore<Vector3, Vector3[], Vector3ArrayOptions>>(TweenSettingsExtensions.SetAutoKill<TweenerCore<Vector3, Vector3[], Vector3ArrayOptions>>(DOTween.Shake((DOGetter<Vector3>)(() => ((Component)this).transform.localPosition), (DOSetter<Vector3>)delegate(Vector3 p)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Component)this).transform.localPosition = p;
			}, 0.2f, 15f * Vector3.right, 20, 90f, true, (ShakeRandomnessMode)0), false));
		}

		public virtual void ResetValue()
		{
			setter(m_defaultValue);
		}

		public abstract void UpdateAppearance();

		protected virtual void Setup()
		{
		}

		internal virtual void SetupFromOption(Option option)
		{
			m_defaultValue = option.BaseEntry.DefaultValue;
			ValueType = option.BaseEntry.SettingType;
			getter = () => option.BoxedValue;
			setter = delegate(object value)
			{
				try
				{
					option.BoxedValue = value;
				}
				catch (Exception ex)
				{
					Tweener errorShake = m_errorShake;
					if (errorShake != null)
					{
						TweenExtensions.Restart((Tween)(object)errorShake, true, -1f);
					}
					UpdateAppearance();
					if (!(ex is InvalidOperationException))
					{
						throw;
					}
				}
			};
			Setup();
			UpdateAppearance();
		}

		internal virtual void SetupFromValues<T>(Func<T> getter, Action<T> setter)
		{
			m_defaultValue = default(T);
			ValueType = typeof(T);
			this.getter = () => getter();
			this.setter = delegate(object value)
			{
				setter((T)value);
			};
			Setup();
			UpdateAppearance();
		}
	}
	public abstract class ValueController<T> : BoxedValueController
	{
		public T GetValue()
		{
			return (T)getter();
		}

		public void SetValue(T value)
		{
			setter(value);
		}
	}
	public class Vector2ValueController : ValueController<Vector2>
	{
		public TMP_InputField xInputField;

		public TMP_InputField yInputField;

		public void OnInputFieldEndEdit()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector2 value = GetValue();
			float num = value.x;
			float num2 = value.y;
			if (float.TryParse(xInputField.text, out var result))
			{
				num = result;
			}
			if (float.TryParse(yInputField.text, out var result2))
			{
				num2 = result2;
			}
			SetValue(new Vector2(num, num2));
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			//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)
			Vector2 value = GetValue();
			xInputField.SetTextWithoutNotify(value.x.ToString("F"));
			yInputField.SetTextWithoutNotify(value.y.ToString("F"));
		}
	}
	public class Vector3ValueController : ValueController<Vector3>
	{
		public TMP_InputField xInputField;

		public TMP_InputField yInputField;

		public TMP_InputField zInputField;

		public void OnInputFieldEndEdit()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value = GetValue();
			float num = value.x;
			float num2 = value.y;
			float num3 = value.z;
			if (float.TryParse(xInputField.text, out var result))
			{
				num = result;
			}
			if (float.TryParse(yInputField.text, out var result2))
			{
				num2 = result2;
			}
			if (float.TryParse(zInputField.text, out var result3))
			{
				num3 = result3;
			}
			SetValue(new Vector3(num, num2, num3));
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			//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)
			Vector3 value = GetValue();
			xInputField.SetTextWithoutNotify(value.x.ToString("F"));
			yInputField.SetTextWithoutNotify(value.y.ToString("F"));
			zInputField.SetTextWithoutNotify(value.z.ToString("F"));
		}
	}
	public class Vector4ValueController : ValueController<Vector4>
	{
		public TMP_InputField xInputField;

		public TMP_InputField yInputField;

		public TMP_InputField zInputField;

		public TMP_InputField wInputField;

		public void OnInputFieldEndEdit()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			Vector4 value = GetValue();
			float num = value.x;
			float num2 = value.y;
			float num3 = value.z;
			float num4 = value.w;
			if (float.TryParse(xInputField.text, out var result))
			{
				num = result;
			}
			if (float.TryParse(yInputField.text, out var result2))
			{
				num2 = result2;
			}
			if (float.TryParse(zInputField.text, out var result3))
			{
				num3 = result3;
			}
			if (float.TryParse(wInputField.text, out var result4))
			{
				num4 = result4;
			}
			SetValue(new Vector4(num, num2, num3, num4));
			UpdateAppearance();
		}

		public override void UpdateAppearance()
		{
			//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)
			Vector4 value = GetValue();
			xInputField.SetTextWithoutNotify(value.x.ToString("F"));
			yInputField.SetTextWithoutNotify(value.y.ToString("F"));
			zInputField.SetTextWithoutNotify(value.z.ToString("F"));
			wInputField.SetTextWithoutNotify(value.w.ToString("F"));
		}
	}
}
namespace ModMenu.Behaviours.OptionList.Dummies
{
	public class ButtonDummy : OptionListItem
	{
		public TextMeshProUGUI buttonTextMeshProText;

		public Button button;

		public string ButtonText
		{
			get
			{
				return ((TMP_Text)buttonTextMeshProText).text;
			}
			set
			{
				((TMP_Text)buttonTextMeshProText).text = value;
			}
		}

		private void Start()
		{
			if (string.IsNullOrWhiteSpace(base.NameText))
			{
				((Component)button).GetComponent<LayoutElement>().flexibleWidth = 1f;
				((Component)nameText).gameObject.SetActive(false);
			}
		}
	}
	public class TextDummy : OptionListItem
	{
		public string Text
		{
			get
			{
				return ((TMP_Text)nameText).text;
			}
			set
			{
				((TMP_Text)nameText).text = value;
			}
		}

		public Color Color
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return ((Graphic)nameText).color;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)nameText).color = value;
			}
		}

		public TMP_Style Style
		{
			get
			{
				return ((TMP_Text)nameText).textStyle;
			}
			set
			{
				((TMP_Text)nameText).textStyle = value;
			}
		}

		public float FontSize
		{
			get
			{
				return ((TMP_Text)nameText).fontSize;
			}
			set
			{
				((TMP_Text)nameText).fontSize = value;
			}
		}
	}
}
namespace ModMenu.Behaviours.ModList
{
	internal class ModInfoPanel : MonoBehaviour
	{
		public TextMeshProUGUI descriptionText;

		public TextMeshProUGUI nameText;

		public TextMeshProUGUI extraInfoText;

		public Image icon;

		public ShowTooltip nameTooltip;

		private void Awake()
		{
			ClearInfo();
		}

		public void ShowInfoFor(Mod mod)
		{
			((Behaviour)icon).enabled = true;
			((TMP_Text)nameText).text = mod.info.name;
			((TMP_Text)nameText).ForceMeshUpdate(false, false);
			nameTooltip.textToShow = (((TMP_Text)nameText).isTextTruncated ? mod.info.name : "");
			((TMP_Text)descriptionText).text = mod.info.description;
			icon.sprite = mod.info.icon;
			((TMP_Text)extraInfoText).text = mod.info.guid + "\nv" + mod.info.version;
		}

		public void ClearInfo()
		{
			((Behaviour)icon).enabled = false;
			((TMP_Text)descriptionText).text = "";
			((TMP_Text)nameText).text = "";
			nameTooltip.textToShow = "";
			((TMP_Text)extraInfoText).text = "";
		}
	}
	internal class ModListItem : MonoBehaviour
	{
		public delegate void ModSelectHandler(Mod mod);

		public Image icon;

		public TextMeshProUGUI nameText;

		public TextMeshProUGUI versionText;

		private Mod m_mod;

		public Mod Mod
		{
			get
			{
				return m_mod;
			}
			set
			{
				m_mod = value;
				((TMP_Text)nameText).text = m_mod.info.name;
				((TMP_Text)versionText).text = "v" + m_mod.info.version;
				icon.sprite = m_mod.info.icon;
			}
		}

		public event ModSelectHandler OnModSelected;

		public void OnClick()
		{
			this.OnModSelected?.Invoke(Mod);
		}
	}
	internal class ModListPanel : MonoBehaviour
	{
		public GameObject container;

		public GameObject itemPrefab;

		public OptionListPanel optionListPanel;

		public ModInfoPanel modInfoPanel;

		public OptionInfoPanel optionInfoPanel;

		private void Awake()
		{
			foreach (Mod item in from m in ModMenuManager.mods
				orderby !m.HasAdvancedMetadata, m.info.name, m.info.guid
				select m)
			{
				ModListItem component = Object.Instantiate<GameObject>(itemPrefab, container.transform).GetComponent<ModListItem>();
				((Object)component).name = item.info.name;
				component.Mod = item;
				component.OnModSelected += SelectMod;
			}
		}

		private void SelectMod(Mod mod)
		{
			optionListPanel.ShowListFor(mod);
			optionInfoPanel.ClearInfo();
			modInfoPanel.ShowInfoFor(mod);
		}
	}
}
namespace ModMenu.Api
{
	public static class ModMenuCustomisation
	{
		internal static Dictionary<string, Action<OptionListContext>> Builders { get; private set; } = new Dictionary<string, Action<OptionListContext>>();


		internal static Dictionary<string, Sprite> Icons { get; private set; } = new Dictionary<string, Sprite>();


		internal static Dictionary<string, string> Descriptions { get; private set; } = new Dictionary<string, string>();


		internal static HashSet<ConfigEntryBase> HiddenConfigEntries { get; private set; } = new HashSet<ConfigEntryBase>();


		public static void RegisterContentBuilder(Action<OptionListContext> builder)
		{
			try
			{
				PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(Assembly.GetCallingAssembly());
				if (pluginInfoFromAssembly != null)
				{
					Builders.Add(pluginInfoFromAssembly.Metadata.GUID, builder);
					return;
				}
				throw new InvalidOperationException("RegisterContentBuilder must be called from an assembly containing a BepInEx plugin.");
			}
			catch (ArgumentException)
			{
				throw new InvalidOperationException("RegisterContentBuilder can only be called once per assembly.");
			}
		}

		public static void HideEntry(ConfigEntryBase entry)
		{
			HiddenConfigEntries.Add(entry);
		}

		public static void HideEntries(IEnumerable<ConfigEntryBase> entries)
		{
			foreach (ConfigEntryBase entry in entries)
			{
				HiddenConfigEntries.Add(entry);
			}
		}

		public static void SetPluginIcon(Sprite icon)
		{
			try
			{
				PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(Assembly.GetCallingAssembly());
				if (pluginInfoFromAssembly != null)
				{
					Icons.Add(pluginInfoFromAssembly.Metadata.GUID, icon);
					return;
				}
				throw new InvalidOperationException("SetPluginIcon must be called from an assembly containing a BepInEx plugin.");
			}
			catch (ArgumentException)
			{
				throw new InvalidOperationException("SetPluginIcon can only be called once per assembly.");
			}
		}

		public static void SetPluginDescription(string description)
		{
			try
			{
				PluginInfo pluginInfoFromAssembly = BepInExUtils.GetPluginInfoFromAssembly(Assembly.GetCallingAssembly());
				if (pluginInfoFromAssembly != null)
				{
					Descriptions.Add(pluginInfoFromAssembly.Metadata.GUID, description);
					return;
				}
				throw new InvalidOperationException("SetPluginDescription must be called from an assembly containing a BepInEx plugin.");
			}
			catch (ArgumentException)
			{
				throw new InvalidOperationException("SetPluginDescription can only be called once per assembly.");
			}
		}
	}
	public class OptionListContext
	{
		private HashSet<GameObject> m_originalChildren = new HashSet<GameObject>();

		public Transform Root { get; }

		internal OptionListContext(Transform root)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			Root = root;
			foreach (Transform item in root)
			{
				Transform val = item;
				m_originalChildren.Add(((Component)val).gameObject);
			}
		}

		internal GameObject AppendControllerForOption(Option option, OptionInfoPanel infoPanel)
		{
			GameObject val = Object.Instantiate<GameObject>(option.GetListItemPrefab(), Root);
			BoxedValueController controller = val.GetComponent<BoxedValueController>();
			controller.SetupFromOption(option);
			controller.NameText = option.Name;
			controller.OnItemHovered += delegate
			{
				infoPanel.ShowInfoFor(option);
				infoPanel.ShowResetButtonFor(controller);
			};
			return ((Component)controller).gameObject;
		}

		internal GameObject[] GetNewChildren()
		{
			if (Root.childCount == m_originalChildren.Count)
			{
				return Array.Empty<GameObject>();
			}
			List<GameObject> list = new List<GameObject>();
			for (int i = 0; i < Root.childCount; i++)
			{
				GameObject gameObject = ((Component)Root.GetChild(i)).gameObject;
				if (!m_originalChildren.Contains(gameObject))
				{
					list.Add(gameObject);
				}
			}
			return list.ToArray();
		}

		private int FindActualIndex(int index)
		{
			Transform[] array = (from Transform child in (IEnumerable)Root
				where ((Component)child).gameObject.activeSelf
				select child).ToArray();
			index = Math.Clamp(index, 0, array.Length - 1);
			return ((Component)array[index]).transform.GetSiblingIndex();
		}

		private T PrependItem<T>(T item) where T : OptionListItem
		{
			((Component)item).transform.SetAsFirstSibling();
			return item;
		}

		private T InsertItem<T>(int position, T item) where T : OptionListItem
		{
			((Component)item).transform.SetSiblingIndex(FindActualIndex(position));
			return item;
		}

		public TextDummy AppendHeader(string text)
		{
			TextDummy component = Object.Instantiate<GameObject>(Assets.CategoryHeader, Root).GetComponent<TextDummy>();
			component.Text = text;
			return component;
		}

		public TextDummy PrependHeader(string text)
		{
			return PrependItem(AppendHeader(text));
		}

		public TextDummy InsertHeader(int position, string text)
		{
			return InsertItem(position, AppendHeader(text));
		}

		public TextDummy AppendTextBox(string text)
		{
			TextDummy component = Object.Instantiate<GameObject>(Assets.TextDummy, Root).GetComponent<TextDummy>();
			component.Text = text;
			return component;
		}

		public TextDummy PrependTextBox(string text)
		{
			return PrependItem(AppendTextBox(text));
		}

		public TextDummy InsertTextBox(int position, string text)
		{
			return InsertItem(position, AppendTextBox(text));
		}

		public ButtonDummy AppendButton(string nameText, string buttonText, Action onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ButtonDummy component = Object.Instantiate<GameObject>(Assets.ButtonDummy, Root).GetComponent<ButtonDummy>();
			((UnityEvent)component.button.onClick).AddListener(new UnityAction(onClick.Invoke));
			component.ButtonText = buttonText;
			component.NameText = nameText;
			return component;
		}

		public ButtonDummy PrependButton(string nameText, string buttonText, Action onClick)
		{
			return PrependItem(PrependButton(nameText, buttonText, onClick));
		}

		public ButtonDummy InsertButton(int position, string nameText, string buttonText, Action onClick)
		{
			return InsertItem(position, AppendButton(nameText, buttonText, onClick));
		}

		private TController AppendValueController<TController, TValue>(GameObject prefab, string nameText, Func<TValue> getter, Action<TValue> setter) where TController : ValueController<TValue>
		{
			TController component = Object.Instantiate<GameObject>(prefab, Root).GetComponent<TController>();
			component.SetupFromValues(getter, setter);
			component.NameText = nameText;
			return component;
		}

		public BoolValueController AppendCheckbox(string nameText, Func<bool> getter, Action<bool> setter)
		{
			return AppendValueController<BoolValueController, bool>(Assets.BoolCheckboxOption, nameText, getter, setter);
		}

		public BoolValueController PrependCheckbox(string nameText, Func<bool> getter, Action<bool> setter)
		{
			return PrependItem(AppendCheckbox(nameText, getter, setter));
		}

		public BoolValueController InsertCheckbox(int position, string nameText, Func<bool> getter, Action<bool> setter)
		{
			return InsertItem(position, AppendCheckbox(nameText, getter, setter));
		}

		public StringValueController AppendStringInput(string nameText, Func<string> getter, Action<string> setter)
		{
			return AppendValueController<StringValueController, string>(Assets.StringInputFieldOption, nameText, getter, setter);
		}

		public StringValueController PrependStringInput(string nameText, Func<string> getter, Action<string> setter)
		{
			return PrependItem(AppendStringInput(nameText, getter, setter));
		}

		public StringValueController InsertStringInput(int position, string nameText, Func<string> getter, Action<string> setter)
		{
			return InsertItem(position, AppendStringInput(nameText, getter, setter));
		}

		public ColorValueController AppendColorInput(string nameText, Func<Color> getter, Action<Color> setter)
		{
			return AppendValueController<ColorValueController, Color>(Assets.ColorOption, nameText, getter, setter);
		}

		public ColorValueController PrependColorInput(string nameText, Func<Color> getter, Action<Color> setter)
		{
			return PrependItem(AppendColorInput(nameText, getter, setter));
		}

		public ColorValueController InsertColorInput(int position, string nameText, Func<Color> getter, Action<Color> setter)
		{
			return InsertItem(position, AppendColorInput(nameText, getter, setter));
		}

		public KeyboardShortcutValueController AppendKeyboardShortcutInput(string nameText, Func<KeyboardShortcut> getter, Action<KeyboardShortcut> setter)
		{
			return AppendValueController<KeyboardShortcutValueController, KeyboardShortcut>(Assets.KeyboardShortcutOption, nameText, getter, setter);
		}

		public KeyboardShortcutValueController PrependKeyboardShortcutInput(string nameText, Func<KeyboardShortcut> getter, Action<KeyboardShortcut> setter)
		{
			return PrependItem(AppendKeyboardShortcutInput(nameText, getter, setter));
		}

		public KeyboardShortcutValueController InsertKeyboardShortcutInput(int position, string nameText, Func<KeyboardShortcut> getter, Action<KeyboardShortcut> setter)
		{
			return InsertItem(position, AppendKeyboardShortcutInput(nameText, getter, setter));
		}

		public KeyCodeValueController AppendKeyCodeInput(string nameText, Func<KeyCode> getter, Action<KeyCode> setter)
		{
			return AppendValueController<KeyCodeValueController, KeyCode>(Assets.KeyCodeOption, nameText, getter, setter);
		}

		public KeyCodeValueController PrependKeyCodeInput(string nameText, Func<KeyCode> getter, Action<KeyCode> setter)
		{
			return PrependItem(AppendKeyCodeInput(nameText, getter, setter));
		}

		public KeyCodeValueController InsertKeyCodeInput(int position, string nameText, Func<KeyCode> getter, Action<KeyCode> setter)
		{
			return InsertItem(position, AppendKeyCodeInput(nameText, getter, setter));
		}

		public QuaternionValueController AppendQuaternionInput(string nameText, Func<Quaternion> getter, Action<Quaternion> setter)
		{
			return AppendValueController<QuaternionValueController, Quaternion>(Assets.QuaternionOption, nameText, getter, setter);
		}

		public QuaternionValueController PrependQuaternionInput(string nameText, Func<Quaternion> getter, Action<Quaternion> setter)
		{
			return PrependItem(AppendQuaternionInput(nameText, getter, setter));
		}

		public QuaternionValueController InsertQuaternionInput(int position, string nameText, Func<Quaternion> getter, Action<Quaternion> setter)
		{
			return InsertItem(position, AppendQuaternionInput(nameText, getter, setter));
		}

		public Vector2ValueController AppendVector2Input(string nameText, Func<Vector2> getter, Action<Vector2> setter)
		{
			return AppendValueController<Vector2ValueController, Vector2>(Assets.Vector2Option, nameText, getter, setter);
		}

		public Vector2ValueController PrependVector2Input(string nameText, Func<Vector2> getter, Action<Vector2> setter)
		{
			return PrependItem(AppendVector2Input(nameText, getter, setter));
		}

		public Vector2ValueController InsertVector2Input(int position, string nameText, Func<Vector2> getter, Action<Vector2> setter)
		{
			return InsertItem(position, AppendVector2Input(nameText, getter, setter));
		}

		public Vector3ValueController AppendVector3Input(string nameText, Func<Vector3> getter, Action<Vector3> setter)
		{
			return AppendValueController<Vector3ValueController, Vector3>(Assets.Vector3Option, nameText, getter, setter);
		}

		public Vector3ValueController PrependVector3Input(string nameText, Func<Vector3> getter, Action<Vector3> setter)
		{
			return PrependItem(AppendVector3Input(nameText, getter, setter));
		}

		public Vector3ValueController InsertVector3Input(int position, string nameText, Func<Vector3> getter, Action<Vector3> setter)
		{
			return InsertItem(position, AppendVector3Input(nameText, getter, setter));
		}

		public Vector4ValueController AppendVector4Input(string nameText, Func<Vector4> getter, Action<Vector4> setter)
		{
			return AppendValueController<Vector4ValueController, Vector4>(Assets.Vector4Option, nameText, getter, setter);
		}

		public Vector4ValueController PrependVector4Input(string nameText, Func<Vector4> getter, Action<Vector4> setter)
		{
			return PrependItem(AppendVector4Input(nameText, getter, setter));
		}

		public Vector4ValueController InsertVector4Input(int position, string nameText, Func<Vector4> getter, Action<Vector4> setter)
		{
			return InsertItem(position, AppendVector4Input(nameText, getter, setter));
		}

		public DropdownValueController AppendDropdown<T>(string nameText, Func<T> getter, Action<T> setter) where T : Enum
		{
			DropdownValueController component = Object.Instantiate<GameObject>(Assets.EnumDropdownOption, Root).GetComponent<DropdownValueController>();
			component.SetupFromValues(getter, setter);
			component.NameText = nameText;
			return component;
		}

		public DropdownValueController PrependDropdown<T>(string nameText, Func<T> getter, Action<T> setter) where T : Enum
		{
			return PrependItem(AppendDropdown(nameText, getter, setter));
		}

		public DropdownValueController InsertDropdown<T>(int position, string nameText, Func<T> getter, Action<T> setter) where T : Enum
		{
			return InsertItem(position, AppendDropdown(nameText, getter, setter));
		}

		public NumericInputFieldValueController AppendNumericInputField<T>(string nameText, Func<T> getter, Action<T> setter) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			NumericInputFieldValueController component = Object.Instantiate<GameObject>(typeof(T).IsFloating() ? Assets.FloatingInputFieldOption : Assets.IntegralInputFieldOption, Root).GetComponent<NumericInputFieldValueController>();
			component.SetupFromValues(getter, setter);
			component.NameText = nameText;
			return component;
		}

		public NumericInputFieldValueController PrependNumericInputField<T>(string nameText, Func<T> getter, Action<T> setter) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			return PrependItem(AppendNumericInputField(nameText, getter, setter));
		}

		public NumericInputFieldValueController InsertNumericInputField<T>(int position, string nameText, Func<T> getter, Action<T> setter) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			return InsertItem(position, AppendNumericInputField(nameText, getter, setter));
		}

		public NumericSliderValueController AppendNumericSlider<T>(string nameText, Func<T> getter, Action<T> setter, float minValue, float maxValue) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			if (minValue >= maxValue)
			{
				throw new ArgumentException("minValue must be < maxValue");
			}
			NumericSliderValueController component = Object.Instantiate<GameObject>(typeof(T).IsFloating() ? Assets.FloatingSliderOption : Assets.IntegralSliderOption, Root).GetComponent<NumericSliderValueController>();
			component.SetupFromValues(getter, setter);
			component.slider.minValue = minValue;
			component.slider.maxValue = maxValue;
			component.NameText = nameText;
			return component;
		}

		public NumericSliderValueController PrependNumericSlider<T>(string nameText, Func<T> getter, Action<T> setter, float minValue, float maxValue) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			return PrependItem(AppendNumericSlider(nameText, getter, setter, minValue, maxValue));
		}

		public NumericSliderValueController InsertNumericSlider<T>(int position, string nameText, Func<T> getter, Action<T> setter, float minValue, float maxValue) where T : struct, IComparable, IComparable<T>, IConvertible, IEquatable<T>, IFormattable
		{
			return InsertItem(position, AppendNumericSlider(nameText, getter, setter, minValue, maxValue));
		}
	}
}