using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Imui.Controls;
using Imui.Core;
using Imui.IO;
using Imui.IO.Touch;
using Imui.IO.UGUI;
using Imui.Rendering;
using Imui.Style;
using ImuiBepInEx.API;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WKLib.API;
using WKLib.API.Assets;
using WKLib.API.Input;
using WKLib.API.UI;
using WKLib.Core.Attributes;
using WKLib.Core.Classes;
using WKLib.Core.Config;
using WKLib.Core.Reflection;
using WKLib.Core.UI;
using WKLib.Core.UI.Windows;
using WKLib.Examples.UI;
using WKLib.Utilities;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("WKLib")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.3.0.0")]
[assembly: AssemblyInformationalVersion("0.3.0+783600fdf7a4da27907d61242ace9cff4b43419f")]
[assembly: AssemblyProduct("WKLib")]
[assembly: AssemblyTitle("WKLib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace WKLib
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.monksilly.WKLib", "WKLib", "0.3.0")]
	public class WKLibPlugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__5_0;

			public static UnityAction <>9__5_1;

			internal void <OnSceneLoaded>b__5_0()
			{
				MonoSingleton<RootPanel>.Instance.IsOpen = !MonoSingleton<RootPanel>.Instance.IsOpen;
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}

			internal void <OnSceneLoaded>b__5_1()
			{
				MonoSingleton<RootPanel>.Instance.IsOpen = !MonoSingleton<RootPanel>.Instance.IsOpen;
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
		}

		public const string GUID = "com.monksilly.WKLib";

		public const string NAME = "WKLib";

		public const string VERSION = "0.3.0";

		private static Harmony harmony;

		private void Awake()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			WKLog.Initialize(((BaseUnityPlugin)this).Logger);
			WKLog.Debug("Initalizing reflection...");
			ReflectionUtility.Initialize();
			WKLog.Debug("Initalizing input utility...");
			InputUtility.Initialize();
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			harmony = new Harmony("com.monksilly.WKLib");
			Type[] types = typeof(WKLibPlugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttribute<PatchOnEntryAttribute>() != null)
				{
					harmony.PatchAll(type);
				}
			}
			ConfigManager.CreateEntries(((BaseUnityPlugin)this).Config);
			WKLog.Info("Plugin WKLib v0.3.0 is loaded!");
			SceneManager.sceneLoaded -= OnSceneLoaded;
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_02c0: 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_02cb: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			bool flag = false;
			if (((Scene)(ref scene)).name == "Main-Menu")
			{
				GameObject obj = GameObject.Find("Canvas - Main Menu/Main Menu/Version Text");
				TextMeshProUGUI val = ((obj != null) ? obj.GetComponent<TextMeshProUGUI>() : null);
				if (val != null)
				{
					((TMP_Text)val).text = ((TMP_Text)val).text + string.Format(" (wklib-{0}) ({1} Mods)", "0.3.0", Chainloader.PluginInfos.Count);
				}
				GameObject val2 = GameObject.Find("Canvas - Main Menu/Main Menu/Support Menu/Update Info");
				if (!((Object)(object)val2 != (Object)null))
				{
					return;
				}
				GameObject val3 = Object.Instantiate<GameObject>(val2, val2.transform.parent);
				val3.transform.SetSiblingIndex(0);
				((Object)val3).name = "Toggle Overlay";
				UI_MenuButton component = val3.GetComponent<UI_MenuButton>();
				if (component != null)
				{
					Object.DestroyImmediate((Object)(object)component);
				}
				TextMeshProUGUI componentInChildren = val3.GetComponentInChildren<TextMeshProUGUI>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = "Toggle Overlay";
				}
				Button component2 = val3.GetComponent<Button>();
				if (!((Object)(object)component2 != (Object)null))
				{
					return;
				}
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = component2.onClick;
				object obj2 = <>c.<>9__5_0;
				if (obj2 == null)
				{
					UnityAction val4 = delegate
					{
						MonoSingleton<RootPanel>.Instance.IsOpen = !MonoSingleton<RootPanel>.Instance.IsOpen;
						EventSystem.current.SetSelectedGameObject((GameObject)null);
					};
					<>c.<>9__5_0 = val4;
					obj2 = (object)val4;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj2);
				return;
			}
			GameObject val5 = GameObject.Find("GameManager/Canvas/Pause/Pause Menu/Pause Buttons/Pause Layout");
			if (!((Object)(object)val5 != (Object)null))
			{
				return;
			}
			Transform val6 = val5.transform.Find("Gap.01");
			Transform val7 = val5.transform.Find("Settings");
			if (!((Object)(object)val6 != (Object)null) || !((Object)(object)val7 != (Object)null))
			{
				return;
			}
			GameObject val8 = Object.Instantiate<GameObject>(((Component)val6).gameObject, ((Component)val6).transform.parent);
			val8.transform.SetSiblingIndex(val6.parent.childCount - 1);
			((Object)val8).name = "Gap.03";
			GameObject val9 = Object.Instantiate<GameObject>(((Component)val7).gameObject, ((Component)val7).transform.parent);
			val9.transform.SetSiblingIndex(val7.parent.childCount - 1);
			((Object)val9).name = "Toggle Overlay";
			UI_MenuButton component3 = val9.GetComponent<UI_MenuButton>();
			if (component3 != null)
			{
				Object.DestroyImmediate((Object)(object)component3);
			}
			TextMeshProUGUI componentInChildren2 = val9.GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				((TMP_Text)componentInChildren2).text = "TOGGLE OVERLAY";
			}
			Button component4 = val9.GetComponent<Button>();
			if (!((Object)(object)component4 != (Object)null))
			{
				return;
			}
			((UnityEventBase)component4.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick2 = component4.onClick;
			object obj3 = <>c.<>9__5_1;
			if (obj3 == null)
			{
				UnityAction val10 = delegate
				{
					MonoSingleton<RootPanel>.Instance.IsOpen = !MonoSingleton<RootPanel>.Instance.IsOpen;
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				};
				<>c.<>9__5_1 = val10;
				obj3 = (object)val10;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj3);
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			Object.Destroy((Object)(object)MonoSingleton<RootPanel>.Instance.ImuiPanel.Canvas);
			SceneManager.sceneLoaded -= OnSceneLoaded;
			WKLog.Info("Plugin WKLib unloaded!");
		}
	}
}
namespace WKLib.Utilities
{
	internal static class WKLog
	{
		private static ManualLogSource _log;

		internal static void Initialize(ManualLogSource logSource)
		{
			_log = logSource;
		}

		public static void Info(object msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogInfo((object)$"[WKLib] {msg}");
			}
		}

		public static void Warn(object msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogWarning((object)$"[WKLib] {msg}");
			}
		}

		public static void Error(object msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogError((object)$"[WKLib] {msg}");
			}
		}

		public static void Debug(object msg)
		{
			ManualLogSource log = _log;
			if (log != null)
			{
				log.LogDebug((object)$"[WKLib] {msg}");
			}
		}
	}
}
namespace WKLib.Examples.UI
{
	[Flags]
	internal enum DemoEnumFlags
	{
		None = 0,
		Flag1 = 1,
		Flag2 = 2,
		Flag3 = 4,
		Flag1And3 = 5
	}
	internal struct DemoTreeNode
	{
		public string Name;

		public DemoTreeNode[] Childrens;

		public DemoTreeNode(string name, params DemoTreeNode[] childrens)
		{
			Name = name;
			Childrens = childrens;
		}
	}
	public static class DemoWindow
	{
		private static char[] formatBuffer = new char[256];

		private static bool checkboxValue;

		private static int selectedValue = -1;

		private static float bouncingBallSize = 22f;

		private static float bouncingBallSpeed = 1f;

		private static int bouncingBallTrail = 32;

		private static float bouncingBallTime;

		private static string[] values = new string[12]
		{
			"Value 1", "Value 2", "Value 3", "Value 4", "Value 5", "Value 6", "Value 7", "Value 8", "Value 9", "Value 10",
			"Value 11", "Value 12"
		};

		private static string textWithHint = string.Empty;

		private static string singleLineText = "Single line text edit";

		private static string multiLineText = "Multiline text\nedit";

		private static float floatValue = 10.5f;

		private static int intValue = 105;

		private static bool isReadOnly;

		private static bool customDropdownOpen;

		private static ImDropdownPreviewType dropdownPreview;

		private static bool[] checkboxes = new bool[4];

		private static int clicks;

		private static int nestedFoldouts;

		private static bool showPlusMinusButtons = true;

		private static bool useNumericSlider = false;

		private static DemoEnumFlags demoFlags;

		private static int largeTableRows = 131072;

		private static int largeTableColumns = 512;

		private static float largeTableColumnSize = 150f;

		private static bool largeTableScrollable = true;

		private static bool largeTableResizable = true;

		private static Vector2 vec2 = new Vector2(1f, 2f);

		private static Vector3 vec3 = new Vector3(1f, 2f, 3f);

		private static Vector4 vec4 = new Vector4(1f, 2f, 3f, 4f);

		private static Vector2Int vec2int = new Vector2Int(1, 2);

		private static Vector3Int vec3int = new Vector3Int(1, 2, 3);

		private static bool textEditWrap;

		private static bool selectMultipleValues = false;

		private static HashSet<string> selectedNodes = new HashSet<string>(8);

		private static readonly DemoTreeNode[] treeNodes = new DemoTreeNode[3]
		{
			new DemoTreeNode("Node 0", new DemoTreeNode("Node 1"), new DemoTreeNode("Node 2")),
			new DemoTreeNode("Node 3"),
			new DemoTreeNode("Node 4", new DemoTreeNode("Node 5", new DemoTreeNode("Node 6"), new DemoTreeNode("Node 7")))
		};

		private static HashSet<int> selectedValues = new HashSet<int>(values.Length);

		public static void Draw(ImGui gui, ref bool open)
		{
			//IL_0017: 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_005a: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (ImWindow.BeginWindow(gui, "Demo", ref open, ImSize.op_Implicit((700f, 700f)), (ImWindowFlag)16))
			{
				ImMenuBar.BeginMenuBar(gui);
				DrawMenuBarItems(gui, ref open);
				ImMenuBar.EndMenuBar(gui);
				if (ImFoldout.BeginFoldout(gui, "Controls".AsSpan(), default(ImSize), false))
				{
					ImLayoutUtility.BeginIndent(gui);
					DrawControlsPage(gui, ref open);
					ImLayoutUtility.EndIndent(gui);
					ImFoldout.EndFoldout(gui);
				}
				gui.BeginReadOnly(isReadOnly);
				if (ImFoldout.BeginFoldout(gui, "Layout".AsSpan(), default(ImSize), false))
				{
					ImLayoutUtility.BeginIndent(gui);
					DrawLayoutPage(gui);
					ImLayoutUtility.EndIndent(gui);
					ImFoldout.EndFoldout(gui);
				}
				if (ImFoldout.BeginFoldout(gui, "Tables".AsSpan(), default(ImSize), false))
				{
					ImLayoutUtility.BeginIndent(gui);
					DrawTablesPage(gui);
					ImLayoutUtility.EndIndent(gui);
					ImFoldout.EndFoldout(gui);
				}
				gui.EndReadOnly();
				ImWindow.EndWindow(gui);
			}
		}

		private static void DrawControlsPage(ImGui gui, ref bool open)
		{
			//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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_0156: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0653: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_069d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0704: Unknown result type (might be due to invalid IL or missing references)
			ImCheckbox.Checkbox(gui, ref isReadOnly, "Read Only".AsSpan(), default(ImSize));
			gui.BeginReadOnly(isReadOnly);
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			if (ImButton.Button(gui, Format("Clicks ".AsSpan(), clicks, "0".AsSpan()), ImSize.op_Implicit((ImSizeMode)2), (ImButtonFlag)0))
			{
				clicks++;
			}
			if (ImButton.Button(gui, "Reset Clicks".AsSpan(), ImSize.op_Implicit((ImSizeMode)0), (ImButtonFlag)0))
			{
				clicks = 0;
			}
			ImLayoutUtility.EndHorizontal(gui);
			ImCheckbox.Checkbox(gui, ref checkboxValue, "Checkbox".AsSpan(), default(ImSize));
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			ImText.Text(gui, "Dropdown preview mode: ".AsSpan(), false, (ImTextOverflow)0);
			ImRadio.Radio<ImDropdownPreviewType>(gui, ref dropdownPreview, true);
			ImLayoutUtility.EndHorizontal(gui);
			ReadOnlySpan<string> readOnlySpan = values;
			ReadOnlySpan<char> readOnlySpan2 = "Dropdown without value selected".AsSpan();
			ImDropdownPreviewType val = dropdownPreview;
			ImDropdown.Dropdown(gui, ref selectedValue, readOnlySpan, default(ImSize), val, readOnlySpan2);
			ReadOnlySpan<char> readOnlySpan3 = "Custom Dropdown".AsSpan();
			val = dropdownPreview;
			if (ImDropdown.BeginDropdown(gui, readOnlySpan3, default(ImSize), val))
			{
				if (ImMenu.Menu(gui, "Menu Item".AsSpan()))
				{
					ImDropdown.CloseDropdown(gui);
				}
				ImTooltip.TooltipAtLastControl(gui, "Will close dropdown on click".AsSpan(), (ImTooltipShow)1);
				if (ImMenu.BeginMenu(gui, "Sub Menu Inside Dropdown".AsSpan()))
				{
					ImText.Text(gui, "Hello there".AsSpan(), false, (ImTextOverflow)0);
					ImMenu.EndMenu(gui);
				}
				ImCheckbox.Checkbox(gui, ref checkboxValue, "Checkbox".AsSpan(), default(ImSize));
				ImSeparator.Separator(gui, "Nested dropdown, if that's want you really want".AsSpan());
				ReadOnlySpan<string> readOnlySpan4 = values;
				readOnlySpan2 = "Nothing".AsSpan();
				val = dropdownPreview;
				ImDropdown.Dropdown(gui, ref selectedValue, readOnlySpan4, default(ImSize), val, readOnlySpan2);
				ImDropdown.EndDropdown(gui);
			}
			ImSeparator.Separator(gui, "Text editors".AsSpan());
			readOnlySpan2 = "Write something here".AsSpan();
			ImTextEdit.TextEdit(gui, ref textWithHint, default(ImSize), (bool?)null, 0, (ImTouchKeyboardType)0, readOnlySpan2);
			bool? flag = false;
			ImTextEdit.TextEdit(gui, ref singleLineText, default(ImSize), flag, 0, (ImTouchKeyboardType)0, default(ReadOnlySpan<char>));
			ImCheckbox.Checkbox(gui, ref textEditWrap, "Wrap Text".AsSpan(), default(ImSize));
			ImStyleScope<bool> val2 = ImControlStyleExtensions.StyleScope<bool>(gui, ref gui.Style.TextEdit.TextWrap, ref textEditWrap);
			try
			{
				flag = true;
				ImTextEdit.TextEdit(gui, ref multiLineText, default(ImSize), flag, 0, (ImTouchKeyboardType)0, default(ReadOnlySpan<char>));
			}
			finally
			{
				val2.Dispose();
			}
			ImSeparator.Separator(gui, "Sliders (with tooltips)".AsSpan());
			DrawSlidersDemo(gui);
			ImSeparator.Separator(gui, "Selection list (you can select multiple values)".AsSpan());
			ImList.BeginList(gui, ImSize.op_Implicit((ImLayoutUtility.GetLayoutWidth(gui), ImList.GetEnclosingHeight(gui, ImLayoutUtility.GetRowsHeightWithSpacing(gui, 3)))));
			for (int i = 0; i < values.Length; i++)
			{
				bool flag2 = selectedValues.Contains(i);
				if (ImList.ListItem(gui, flag2, values[i].AsSpan()))
				{
					if (flag2)
					{
						selectedValues.Remove(i);
					}
					else
					{
						selectedValues.Add(i);
					}
				}
			}
			ImList.EndList(gui);
			ImSeparator.Separator(gui, "Numeric editors".AsSpan());
			gui.BeginReadOnly(useNumericSlider);
			ImCheckbox.Checkbox(gui, ref showPlusMinusButtons, "Enable Plus/Minus buttons".AsSpan(), default(ImSize));
			gui.EndReadOnly();
			ImCheckbox.Checkbox(gui, ref useNumericSlider, "Enable Slider".AsSpan(), default(ImSize));
			ImNumericEditFlag val3 = (ImNumericEditFlag)0;
			val3 = (ImNumericEditFlag)(val3 | (showPlusMinusButtons ? 1 : 0));
			val3 = (ImNumericEditFlag)(val3 | (useNumericSlider ? 2 : 0));
			ImNumericEditFlag val4 = val3;
			readOnlySpan2 = "0.0### kg".AsSpan();
			ImNumericEdit.NumericEdit(gui, ref floatValue, default(ImSize), readOnlySpan2, 0.05f, float.MinValue, float.MaxValue, val4);
			val4 = val3;
			readOnlySpan2 = "0 miles".AsSpan();
			ImNumericEdit.NumericEdit(gui, ref intValue, default(ImSize), readOnlySpan2, 1, int.MinValue, int.MaxValue, val4);
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImSeparator.Separator(gui, "Radio buttons (enum flags)".AsSpan());
			ImRadio.Radio<DemoEnumFlags>(gui, ref demoFlags, true);
			ImSeparator.Separator(gui, "Dropdown (enum flags)".AsSpan());
			ImDropdown.Dropdown<DemoEnumFlags>(gui, ref demoFlags, default(ImSize), (ImDropdownPreviewType)0);
			ImSeparator.Separator(gui, "Trees".AsSpan());
			DrawTreeDemo(gui);
			ImSeparator.Separator(gui, "Nested Foldout".AsSpan());
			NestedFoldout(gui, 0, ref nestedFoldouts);
			ImSeparator.Separator(gui, "Floating menu".AsSpan());
			ImRect val5 = ImLayoutUtility.AddLayoutRect(gui, ImLayoutUtility.GetLayoutWidth(gui), ImLayoutUtility.GetRowHeight(gui));
			ImMenuBar.BeginMenuBar(gui, val5);
			DrawMenuBarItems(gui, ref open);
			ImMenuBar.EndMenuBar(gui);
			ImSeparator.Separator(gui, "Tabs".AsSpan());
			ImLayoutUtility.AddSpacing(gui);
			ImTabsPane.BeginTabsPane(gui, ImLayoutUtility.AddLayoutRect(gui, ImLayoutUtility.GetLayoutWidth(gui), ImLayoutUtility.GetRowsHeightWithSpacing(gui, 2)), (ImTabsPaneFlags)0);
			for (int j = 0; j < 4; j++)
			{
				Span<char> span = gui.Formatter.Concat("Tab ".AsSpan(), j);
				if (ImTabsPane.BeginTab(gui, (ReadOnlySpan<char>)span))
				{
					ImText.Text(gui, (ReadOnlySpan<char>)span, false, (ImTextOverflow)0);
					ImTabsPane.EndTab(gui);
				}
			}
			ImTabsPane.EndTabsPane(gui);
			ImSeparator.Separator(gui, "Vectors (float)".AsSpan());
			ImText.Text(gui, "Two component vector".AsSpan(), false, (ImTextOverflow)0);
			ImVector.Vector(gui, ref vec2, default(ImSize));
			ImText.Text(gui, "Three component vector".AsSpan(), false, (ImTextOverflow)0);
			ImVector.Vector(gui, ref vec3, default(ImSize));
			ImText.Text(gui, "Four component vector".AsSpan(), false, (ImTextOverflow)0);
			ImVector.Vector(gui, ref vec4, default(ImSize));
			ImSeparator.Separator(gui, "Vectors (int)".AsSpan());
			ImText.Text(gui, "Two component vector".AsSpan(), false, (ImTextOverflow)0);
			ImVector.Vector(gui, ref vec2int, default(ImSize));
			ImText.Text(gui, "Three component vector".AsSpan(), false, (ImTextOverflow)0);
			ImVector.Vector(gui, ref vec3int, default(ImSize));
			gui.EndReadOnly();
		}

		private static void DrawSelectableTreeDemo(ImGui gui)
		{
			//IL_0020: 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)
			ImCheckbox.Checkbox(gui, ref selectMultipleValues, "Select multiple values".AsSpan(), default(ImSize));
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			ImText.Text(gui, "Selected nodes: ".AsSpan(), false, (ImTextOverflow)0);
			foreach (string selectedNode in selectedNodes)
			{
				ImText.Text(gui, selectedNode.AsSpan(), false, (ImTextOverflow)0);
				ImLayoutUtility.AddSpacing(gui);
			}
			ImLayoutUtility.EndHorizontal(gui);
			for (int i = 0; i < treeNodes.Length; i++)
			{
				Node(ref treeNodes[i]);
			}
			void Node(ref DemoTreeNode node)
			{
				//IL_001a: 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_0040: 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_0049: 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)
				ImTreeNodeFlags val = (ImTreeNodeFlags)((selectMultipleValues ? 1 : 0) | ((node.Childrens.Length == 0) ? 4 : 0));
				bool selected2 = selectedNodes.Contains(node.Name);
				ImGui obj = gui;
				ReadOnlySpan<char> readOnlySpan = node.Name.AsSpan();
				ImTreeNodeFlags val2 = val;
				bool flag = ImTree.BeginTreeNode(obj, ref selected2, readOnlySpan, default(ImSize), val2);
				SetSelected(node.Name, selected2);
				if (flag)
				{
					for (int j = 0; j < node.Childrens.Length; j++)
					{
						Node(ref node.Childrens[j]);
					}
					ImTree.EndTreeNode(gui);
				}
			}
			static void SetSelected(string name, bool selected)
			{
				if (selected)
				{
					if (!selectMultipleValues)
					{
						selectedNodes.Clear();
					}
					selectedNodes.Add(name);
				}
				else
				{
					selectedNodes.Remove(name);
				}
			}
		}

		private static void DrawTreeDemo(ImGui gui)
		{
			//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)
			//IL_0029: 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_00ad: 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_00c8: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0082: 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)
			ImTree.TreeNode(gui, "Node 0".AsSpan(), default(ImSize), (ImTreeNodeFlags)0);
			if (ImTree.BeginTreeNode(gui, "Node 1".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
			{
				ImTree.TreeNode(gui, "Node 3".AsSpan(), default(ImSize), (ImTreeNodeFlags)0);
				if (ImTree.BeginTreeNode(gui, "Node 4".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImTree.TreeNode(gui, "Node 5".AsSpan(), default(ImSize), (ImTreeNodeFlags)0);
					ImTree.EndTreeNode(gui);
				}
				ImTree.EndTreeNode(gui);
			}
			ImTree.TreeNode(gui, "Node 5".AsSpan(), default(ImSize), (ImTreeNodeFlags)0);
			if (ImTree.BeginTreeNode(gui, "Selectable nodes demo".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
			{
				DrawSelectableTreeDemo(gui);
				ImTree.EndTreeNode(gui);
			}
		}

		private static void DrawSlidersDemo(ImGui gui)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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)
			DrawBouncingBall(gui);
			ImSlider.SliderHeader(gui, "Size".AsSpan(), bouncingBallSize, "0.00 px".AsSpan());
			ImSlider.Slider(gui, ref bouncingBallSize, 1f, ImLayoutUtility.GetRowHeight(gui), default(ImSize), 0f, (ImSliderFlag)0);
			ImTooltip.TooltipAtLastControl(gui, "Size of the circles in pixels".AsSpan(), (ImTooltipShow)1);
			ImSlider.SliderHeader(gui, "Speed".AsSpan(), bouncingBallSpeed, "0.##".AsSpan());
			ImSlider.Slider(gui, ref bouncingBallSpeed, -2f, 2f, default(ImSize), 0f, (ImSliderFlag)0);
			ImTooltip.TooltipAtLastControl(gui, "Speed of moving circles".AsSpan(), (ImTooltipShow)1);
			ImSlider.SliderHeader(gui, "Trail Length".AsSpan(), (float)bouncingBallTrail, default(ReadOnlySpan<char>));
			ImSlider.Slider(gui, ref bouncingBallTrail, 1, 256, default(ImSize), 32, (ImSliderFlag)1);
			ImTooltip.TooltipAtLastControl(gui, "Number of circles drawn".AsSpan(), (ImTooltipShow)1);
		}

		private static void DrawMenuBarItems(ImGui gui, ref bool windowOpen)
		{
			if (!ImMenu.BeginMenu(gui, "Demo".AsSpan()))
			{
				return;
			}
			if (ImMenu.BeginMenu(gui, "Custom Menus".AsSpan()))
			{
				ImLayoutUtility.BeginVertical(gui, 300f, 0f);
				DrawSlidersDemo(gui);
				ImLayoutUtility.EndVertical(gui);
				ImMenu.EndMenu(gui);
			}
			if (ImMenu.BeginMenu(gui, "Recursive".AsSpan()))
			{
				DrawMenuBarItems(gui, ref windowOpen);
				ImMenu.EndMenu(gui);
			}
			ImSeparator.Separator(gui);
			if (ImMenu.BeginMenu(gui, "Test".AsSpan()))
			{
				if (ImMenu.BeginMenu(gui, "Same name submenu".AsSpan()))
				{
					ImMenu.Menu(gui, "Item".AsSpan());
					ImMenu.EndMenu(gui);
				}
				gui.PushId("Next Menu".AsSpan());
				if (ImMenu.BeginMenu(gui, "Same name submenu".AsSpan()))
				{
					ImMenu.Menu(gui, "Item".AsSpan());
					ImMenu.EndMenu(gui);
				}
				gui.PopId();
				ImMenu.EndMenu(gui);
			}
			ImSeparator.Separator(gui);
			if (ImMenu.Menu(gui, "Close".AsSpan()))
			{
				windowOpen = false;
			}
			ImMenu.EndMenu(gui);
		}

		private static void DrawLayoutPage(ImGui gui)
		{
			//IL_002a: 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_00a4: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			ImLayoutUtility.AddSpacing(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			for (int i = 0; i < 3; i++)
			{
				ImButton.Button(gui, "Horizontal".AsSpan(), ImSize.op_Implicit((ImSizeMode)2), (ImButtonFlag)0);
			}
			ImLayoutUtility.EndHorizontal(gui);
			ImLayoutUtility.AddSpacing(gui);
			ImLayoutUtility.BeginVertical(gui, 0f, 0f);
			for (int j = 0; j < 3; j++)
			{
				ImButton.Button(gui, "Vertical".AsSpan(), ImSize.op_Implicit((ImSizeMode)2), (ImButtonFlag)0);
			}
			ImLayoutUtility.EndVertical(gui);
			ImLayoutUtility.AddSpacing(gui);
			ImGridState val = ImGrid.BeginGrid(gui, 5, ImLayoutUtility.GetRowHeight(gui));
			for (int k = 0; k < 12; k++)
			{
				ImText.TextAutoSize(gui, Format("Grid cell ".AsSpan(), k, "0".AsSpan()), ImGrid.GridNextCell(gui, ref val), false);
			}
			ImGrid.EndGrid(gui, ref val);
		}

		private static void DrawTablesPage(ImGui gui)
		{
			//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)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: 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_034c: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			if (ImTree.BeginTreeNode(gui, "Simple".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
			{
				_ = ref ImTable.BeginTable(gui, 4, default(ImSize), (ImTableFlag)0);
				for (int i = 0; i < 5; i++)
				{
					ImTable.TableNextRow(gui);
					for (int j = 0; j < 4; j++)
					{
						ImTable.TableNextColumn(gui);
						ImText.Text(gui, (ReadOnlySpan<char>)gui.Formatter.Concat("Hello At ".AsSpan(), gui.Formatter.Format((long)j, default(ReadOnlySpan<char>)), ":".AsSpan(), gui.Formatter.Format((long)i, default(ReadOnlySpan<char>))), false, (ImTextOverflow)0);
					}
				}
				ImTable.EndTable(gui);
				ImSeparator.Separator(gui, "Resizable Columns".AsSpan());
				_ = ref ImTable.BeginTable(gui, 4, default(ImSize), (ImTableFlag)1);
				for (int k = 0; k < 5; k++)
				{
					ImTable.TableNextRow(gui);
					for (int l = 0; l < 4; l++)
					{
						ImTable.TableNextColumn(gui);
						ImText.Text(gui, (ReadOnlySpan<char>)gui.Formatter.Concat("Hello At ".AsSpan(), gui.Formatter.Format((long)l, default(ReadOnlySpan<char>)), ":".AsSpan(), gui.Formatter.Format((long)k, default(ReadOnlySpan<char>))), true, (ImTextOverflow)0);
					}
				}
				ImTable.EndTable(gui);
				ImTree.EndTreeNode(gui);
			}
			if (ImTree.BeginTreeNode(gui, "With Scroll Bars".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
			{
				_ = ref ImTable.BeginTable(gui, 4, ImSize.op_Implicit((ImLayoutUtility.GetLayoutWidth(gui), 200f)), (ImTableFlag)0);
				for (int m = 0; m < 12; m++)
				{
					ImTable.TableNextRow(gui);
					for (int n = 0; n < 4; n++)
					{
						ImTable.TableNextColumn(gui);
						ImText.Text(gui, (ReadOnlySpan<char>)gui.Formatter.Concat("Hello At ".AsSpan(), gui.Formatter.Format((long)n, default(ReadOnlySpan<char>)), ":".AsSpan(), gui.Formatter.Format((long)m, default(ReadOnlySpan<char>))), true, (ImTextOverflow)0);
					}
				}
				ImTable.EndTable(gui);
				ImTree.EndTreeNode(gui);
			}
			if (!ImTree.BeginTreeNode(gui, "Large Tables".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
			{
				return;
			}
			NumEditWithLabel(gui, ref largeTableRows, "Rows".AsSpan(), 1, 4194304);
			NumEditWithLabel(gui, ref largeTableColumns, "Columns".AsSpan(), 1, 4096);
			NumEditWithLabel(gui, ref largeTableColumnSize, "Col. Size".AsSpan(), 50f, 300f);
			ImCheckbox.Checkbox(gui, ref largeTableResizable, "Resizable Columns".AsSpan(), default(ImSize));
			ImCheckbox.Checkbox(gui, ref largeTableScrollable, "Scrollable".AsSpan(), default(ImSize));
			ImSize val = (largeTableScrollable ? new ImSize(ImLayoutUtility.GetLayoutWidth(gui), 300f) : new ImSize((ImSizeMode)0));
			ImTableFlag val2 = (ImTableFlag)(largeTableResizable ? 1 : 0);
			ref ImTableState reference = ref ImTable.BeginTable(gui, largeTableColumns, val, val2);
			ImTable.TableSetRowsHeight(gui, ImLayoutUtility.GetTextLineHeight(gui) + ((ImPadding)(ref gui.Style.Table.CellPadding)).Vertical);
			for (int num = 0; num < largeTableColumns; num++)
			{
				ImTable.TableSetColumnWidth(gui, num, largeTableColumnSize);
			}
			ImTextSettings val3 = default(ImTextSettings);
			((ImTextSettings)(ref val3))..ctor(gui.Style.Layout.TextSize, new ImAlignment(0.5f, 0.5f), false, (ImTextOverflow)1);
			ImTableRowsRange val4 = ImTable.TableGetVisibleRows(gui, largeTableRows);
			ImTableColumnsRange val5 = ImTable.TableGetVisibleColumns(gui);
			for (int num2 = val4.Min; num2 < val4.Max; num2++)
			{
				ImTable.TableSetRow(gui, num2, ref reference);
				for (int num3 = val5.Min; num3 < val5.Max; num3++)
				{
					ImTable.TableSetColumn(gui, num3, ref reference);
					ImText.Text(gui, (ReadOnlySpan<char>)gui.Formatter.Concat(gui.Formatter.Format((long)num3, default(ReadOnlySpan<char>)), "x".AsSpan(), gui.Formatter.Format((long)num2, default(ReadOnlySpan<char>))), ref val3);
				}
			}
			ImTable.EndTable(gui);
			ImTree.EndTreeNode(gui);
		}

		private static void NumEditWithLabel(ImGui gui, ref int value, ReadOnlySpan<char> label, int min, int max)
		{
			//IL_002c: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			ImText.Text(gui, label, gui.Layout.AddRect(150f, ImLayoutUtility.GetRowHeight(gui)), false, (ImTextOverflow)0);
			ImNumericEdit.NumericEdit(gui, ref value, default(ImSize), default(ReadOnlySpan<char>), 1, min, max, (ImNumericEditFlag)1);
			ImLayoutUtility.EndHorizontal(gui);
		}

		private static void NumEditWithLabel(ImGui gui, ref float value, ReadOnlySpan<char> label, float min, float max)
		{
			//IL_002c: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			ImText.Text(gui, label, gui.Layout.AddRect(150f, ImLayoutUtility.GetRowHeight(gui)), false, (ImTextOverflow)0);
			ImNumericEdit.NumericEdit(gui, ref value, default(ImSize), default(ReadOnlySpan<char>), 0.1f, min, max, (ImNumericEditFlag)1);
			ImLayoutUtility.EndHorizontal(gui);
		}

		public static void DrawBouncingBall(ImGui gui)
		{
			//IL_0015: 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_003f: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			ImRect val = ImRectUtility.WithPadding(ImLayoutUtility.AddLayoutRectWithSpacing(gui, ImLayoutUtility.GetLayoutWidth(gui), ImLayoutUtility.GetRowHeight(gui) * 1.25f), bouncingBallSize / 2f, bouncingBallSize / 2f, 0f, 0f);
			float num = Time.unscaledDeltaTime * bouncingBallSpeed;
			bouncingBallTime += num;
			for (int i = 0; i < bouncingBallTrail; i++)
			{
				float num2 = mod(bouncingBallTime + (float)i * 0.01f * bouncingBallSpeed, 2f);
				float num3 = ((num2 <= 1f) ? num2 : (1f - (num2 - 1f)));
				float num4 = 0.5f + Mathf.Sin((bouncingBallTime + (float)i * 0.01f * bouncingBallSpeed) * MathF.PI * 2f) * 0.25f;
				Vector2 pointAtNormalPosition = ((ImRect)(ref val)).GetPointAtNormalPosition(num3, num4);
				Color32 val2 = ImColorUtility.WithAlpha(gui.Style.Text.Color, Mathf.Pow((float)(i + 1) / (float)bouncingBallTrail, 6f));
				gui.Canvas.Circle(pointAtNormalPosition, bouncingBallSize * 0.5f, val2);
			}
			static float mod(float x, float y)
			{
				return (x % y + y) % y;
			}
		}

		public static void NestedFoldout(ImGui gui, int current, ref int total)
		{
			//IL_0030: 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)
			//IL_00c9: 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_00a1: 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)
			ReadOnlySpan<char> readOnlySpan = ((current == 0) ? "Nested Foldout".AsSpan() : Format("Nested Foldout ".AsSpan(), current, "0".AsSpan()));
			if (!ImFoldout.BeginFoldout(gui, readOnlySpan, default(ImSize), false))
			{
				return;
			}
			ImLayoutUtility.BeginIndent(gui);
			if (current < total)
			{
				NestedFoldout(gui, current + 1, ref total);
			}
			else if (current == total)
			{
				if (total == 8)
				{
					ImText.Text(gui, "Let's just stop here".AsSpan(), false, (ImTextOverflow)0);
					if (ImButton.Button(gui, "Reset".AsSpan(), default(ImSize), (ImButtonFlag)0))
					{
						total = 0;
					}
				}
				else if (ImButton.Button(gui, "Add one more".AsSpan(), default(ImSize), (ImButtonFlag)0))
				{
					total++;
				}
			}
			ImLayoutUtility.EndIndent(gui);
			ImFoldout.EndFoldout(gui);
		}

		private static ReadOnlySpan<char> Format(ReadOnlySpan<char> prefix, float value, ReadOnlySpan<char> format = default(ReadOnlySpan<char>))
		{
			Span<char> destination = new Span<char>(formatBuffer);
			prefix.CopyTo(destination);
			int length = prefix.Length;
			value.TryFormat(destination.Slice(length, destination.Length - length), out var charsWritten, format);
			return destination.Slice(0, prefix.Length + charsWritten);
		}
	}
}
namespace WKLib.Core.UI
{
	internal class OverlayState : MonoBehaviour
	{
		public static List<PopupSettings> Popups = new List<PopupSettings>();

		private Dictionary<GraphicRaycaster, bool> _originalState = new Dictionary<GraphicRaycaster, bool>();

		private CL_GameManager gameManager = null;

		private GraphicRaycaster mainGraphicRaycaster = null;

		private bool isOpen = false;

		public bool IsOpen
		{
			get
			{
				return isOpen;
			}
			set
			{
				if ((Object)(object)gameManager == (Object)null)
				{
					GameObject obj = GameObject.Find("GameManager");
					gameManager = ((obj != null) ? obj.GetComponent<CL_GameManager>() : null);
				}
				bool flag = (Object)(object)gameManager != (Object)null && gameManager.loading;
				bool flag2 = (Object)(object)gameManager != (Object)null && gameManager.reviving;
				if (!flag && !flag2)
				{
					if (isOpen == value)
					{
						return;
					}
				}
				else
				{
					value = false;
				}
				isOpen = value;
				bool flag3 = (Object)(object)gameManager != (Object)null && gameManager.isPaused;
				bool inUse = OS_Manager.inUse;
				bool flag4 = (Object)(object)gameManager != (Object)null && Object.op_Implicit((Object)(object)gameManager.pauseMenu);
				bool flag5 = (Object)(object)gameManager != (Object)null && gameManager.canPause;
				if (isOpen)
				{
					_originalState.Clear();
					if (flag4)
					{
						if (flag3)
						{
							return;
						}
						if (!inUse && flag5 && !flag && !flag2)
						{
							CL_GameManager obj2 = gameManager;
							if (obj2 != null)
							{
								obj2.Pause();
							}
							return;
						}
						isOpen = false;
						PopupSettings popupSettings = new PopupSettings();
						if (inUse)
						{
							popupSettings.PopupText = "Cannot open overlay in terminal.";
						}
						else if (!flag5)
						{
							popupSettings.PopupText = "Cannot open because game cannot be paused.";
						}
						else if (flag)
						{
							popupSettings.PopupText = "Cannot open overlay because the game is loading.";
						}
						else if (flag2)
						{
							popupSettings.PopupText = "Cannot open overlay because the player is reviving.";
						}
						popupSettings.TimeTillClose = Time.realtimeSinceStartup + popupSettings.PopupTime;
						Popups.Add(popupSettings);
					}
					else
					{
						if (!((Object)(object)mainGraphicRaycaster != (Object)null))
						{
							return;
						}
						GraphicRaycaster[] array = Object.FindObjectsOfType<GraphicRaycaster>();
						GraphicRaycaster[] array2 = array;
						foreach (GraphicRaycaster val in array2)
						{
							if (!((Object)(object)val == (Object)null))
							{
								_originalState[val] = ((UIBehaviour)val).IsActive();
								((Behaviour)val).enabled = false;
							}
						}
						((Behaviour)mainGraphicRaycaster).enabled = true;
					}
					return;
				}
				if (flag4)
				{
					if (flag3 && !inUse && flag5 && !flag && !flag2)
					{
						CL_GameManager obj3 = gameManager;
						if (obj3 != null)
						{
							obj3.UnPause();
						}
					}
					return;
				}
				foreach (KeyValuePair<GraphicRaycaster, bool> item in _originalState)
				{
					if (!((Object)(object)item.Key == (Object)null))
					{
						((Behaviour)item.Key).enabled = true;
					}
				}
			}
		}

		private void OnEnable()
		{
			mainGraphicRaycaster = ((Component)this).gameObject.GetComponent<GraphicRaycaster>();
		}

		public void Draw(ImGui gui)
		{
			foreach (PopupSettings popup in Popups)
			{
				if (Time.realtimeSinceStartup < popup.TimeTillClose)
				{
					QuickPopupWindow.Draw(gui, popup.PopupText);
				}
			}
		}
	}
	[DefaultExecutionOrder(-999)]
	internal class RootPanel : MonoSingleton<RootPanel>
	{
		public ImGui gui = null;

		public ImuiPanel ImuiPanel = null;

		public ThemeController ThemeController = null;

		public OverlayState OverlayState = null;

		private bool isDemoOpen = false;

		public bool IsOpen
		{
			get
			{
				return OverlayState.IsOpen;
			}
			set
			{
				OverlayState.IsOpen = value;
			}
		}

		public override void OnEnable()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			base.OnEnable();
			SceneManager.sceneLoaded -= OnSceneChange;
			SceneManager.sceneLoaded += OnSceneChange;
			((Object)ImuiPanel.Canvas).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)ImuiPanel.Canvas);
			ImuiUnityGUIBackend component = ((Component)((Component)this).transform).GetComponent<ImuiUnityGUIBackend>();
			if (gui == null)
			{
				gui = new ImGui((IImuiRenderer)(object)component, (IImuiInput)(object)component);
			}
			OverlayState = ((Component)this).gameObject.GetComponent<OverlayState>();
			if ((Object)(object)OverlayState == (Object)null)
			{
				OverlayState = ((Component)this).gameObject.AddComponent<OverlayState>();
			}
			ThemeController = ((Component)this).gameObject.GetComponent<ThemeController>();
			if ((Object)(object)ThemeController == (Object)null)
			{
				ThemeController = ((Component)this).gameObject.AddComponent<ThemeController>();
			}
			ThemeController.SetTheme(gui);
			ModListWindow.Initialize();
			void OnSceneChange(Scene scene, LoadSceneMode loadSceneMode)
			{
				if (ConfigManager.AutoCloseOverlay.Value)
				{
					IsOpen = false;
				}
			}
		}

		private void Update()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ThemeController.DetectChanges(gui);
			gui.BeginFrame();
			if (InputUtility.GetKeyDown(ConfigManager.OverlayKey.Value))
			{
				IsOpen = !IsOpen;
			}
			HandleAPIInput();
			OverlayState.Draw(gui);
			if (IsOpen)
			{
				DrawRootMenuBar();
			}
			ChangeLogWindow.Draw(gui, IsOpen);
			if (ConfigManager.EnableDemoWindow.Value)
			{
				DemoWindow.Draw(gui, ref isDemoOpen);
			}
			ModListWindow.Draw(gui, IsOpen);
			DrawAPIWindows();
			if (InputUtility.GetKeyDown((KeyCode)13))
			{
				gui.ResetActiveControl();
			}
			gui.EndFrame();
			gui.Render();
		}

		private void DrawRootMenuBar()
		{
			ImMenuBar.BeginMenuBar(gui);
			if (ImMenu.BeginMenu(gui, "General".AsSpan()))
			{
				ImMenu.Menu(gui, "Open mod list".AsSpan(), ref ModListWindow.isOpen);
				if (ConfigManager.EnableDemoWindow.Value)
				{
					ImMenu.Menu(gui, "Open demo menu".AsSpan(), ref isDemoOpen);
				}
				ImSeparator.Separator(gui);
				ImMenu.Menu(gui, "Open changelog".AsSpan(), ref ChangeLogWindow.isOpen);
				ImSeparator.Separator(gui);
				if (ImMenu.Menu(gui, "Close menu".AsSpan()))
				{
					IsOpen = false;
				}
				ImMenu.EndMenu(gui);
			}
			if (ImMenu.BeginMenu(gui, "Windows".AsSpan()))
			{
				if (ImMenu.Menu(gui, "Close all windows".AsSpan()))
				{
					ModListWindow.isOpen = false;
					ModListWindow.CloseConfigWindows();
					CloseAPIWindows();
				}
				ImMenu.EndMenu(gui);
			}
			ImMenuBar.EndMenuBar(gui);
		}

		private void DrawAPIWindows()
		{
			foreach (WKLibAPI internalAPI in WKLibAPI.internalAPIs)
			{
				if (internalAPI == null)
				{
					continue;
				}
				foreach (WKLibWindow window in internalAPI.Windows)
				{
					window?.Draw(gui, IsOpen);
				}
			}
		}

		private void HandleAPIInput()
		{
			foreach (WKLibAPI internalAPI in WKLibAPI.internalAPIs)
			{
				if (internalAPI == null)
				{
					continue;
				}
				foreach (WKLibWindow window in internalAPI.Windows)
				{
					window?.HandleInput(gui);
				}
			}
		}

		private void CloseAPIWindows()
		{
			foreach (WKLibAPI internalAPI in WKLibAPI.internalAPIs)
			{
				if (internalAPI == null)
				{
					continue;
				}
				foreach (WKLibWindow window in internalAPI.Windows)
				{
					if (window != null)
					{
						window.isOpen = false;
					}
				}
			}
		}
	}
	internal class ThemeController : MonoBehaviour
	{
		public ImTheme BaseTheme = SetBaseTheme(ImThemeBuiltin.Dark());

		private bool changesDetected = false;

		public static ImTheme SetBaseTheme(ImTheme theme)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			theme.Background = new Color(0f, 0f, 0f, 1f);
			theme.Foreground = new Color(1f, 1f, 1f, 1f);
			theme.Accent = ConfigManager.AccentColor.Value;
			theme.Control = new Color(0.15f, 0.15f, 0.15f, 1f);
			theme.Contrast = (ConfigManager.HighContrast.Value ? 1f : 0f);
			theme.BorderContrast = 1f;
			theme.TextSize = 16f;
			theme.BorderRadius = 1f;
			theme.ReadOnlyColorMultiplier = 0.25f;
			return theme;
		}

		public void RegisterChanges()
		{
			//IL_0036: 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)
			changesDetected = true;
			BaseTheme.Contrast = (ConfigManager.HighContrast.Value ? 1f : 0f);
			BaseTheme.Accent = ConfigManager.AccentColor.Value;
		}

		public void DetectChanges(ImGui gui)
		{
			if (changesDetected)
			{
				changesDetected = false;
				SetTheme(gui);
			}
		}

		public void DrawAppearanceEditor(ImGui gui)
		{
			//IL_001b: 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_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_0074: 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_008c: 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)
			bool value = ConfigManager.HighContrast.Value;
			if (ImCheckbox.Checkbox(gui, ref value, "High contrast".AsSpan(), default(ImSize)))
			{
				ConfigManager.HighContrast.Value = value;
				BaseTheme.Contrast = (ConfigManager.HighContrast.Value ? 1f : 0f);
				SetTheme(gui);
			}
			Color value2 = ConfigManager.AccentColor.Value;
			if (ImColorEdit.ColorEdit(gui, ref value2, default(ImSize)))
			{
				ConfigManager.AccentColor.Value = value2;
				BaseTheme.Accent = ConfigManager.AccentColor.Value;
				SetTheme(gui);
			}
		}

		public static bool DrawThemeEditor(ImGui gui, ref ImTheme theme)
		{
			//IL_0035: 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_0075: 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_00b5: 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_00f5: 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_0135: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			ImSeparator.Separator(gui, "Colors".AsSpan());
			using (new UIUtility.LabeledScope(gui, "Foreground".AsSpan()))
			{
				flag |= ImColorEdit.ColorEdit(gui, ref theme.Foreground, default(ImSize));
			}
			using (new UIUtility.LabeledScope(gui, "Background".AsSpan()))
			{
				flag |= ImColorEdit.ColorEdit(gui, ref theme.Background, default(ImSize));
			}
			using (new UIUtility.LabeledScope(gui, "Accent".AsSpan()))
			{
				flag |= ImColorEdit.ColorEdit(gui, ref theme.Accent, default(ImSize));
			}
			using (new UIUtility.LabeledScope(gui, "Control".AsSpan()))
			{
				flag |= ImColorEdit.ColorEdit(gui, ref theme.Control, default(ImSize));
			}
			using (new UIUtility.LabeledScope(gui, "Contrast".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.Contrast, default(ImSize), default(ReadOnlySpan<char>), 0.1f, -1f, 1f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "BorderContrast".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.BorderContrast, default(ImSize), default(ReadOnlySpan<char>), 0.1f, -1f, 2f, (ImNumericEditFlag)2);
			}
			ImSeparator.Separator(gui, "Values".AsSpan());
			using (new UIUtility.LabeledScope(gui, "TextSize".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.TextSize, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 4f, 128f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "Spacing".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.Spacing, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 32f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "InnerSpacing".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.InnerSpacing, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 32f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "Indent".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.Indent, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 128f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "ExtraRowHeight".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.ExtraRowHeight, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 128f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "ScrollBarSize".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.ScrollBarSize, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 2f, 128f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "WindowBorderRadius".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.WindowBorderRadius, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 32f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "WindowBorderThickness".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.WindowBorderThickness, default(ImSize), default(ReadOnlySpan<char>), 0.5f, 0f, 8f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "BorderRadius".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.BorderRadius, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 16f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "BorderThickness".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.BorderThickness, default(ImSize), default(ReadOnlySpan<char>), 0.5f, 0f, 8f, (ImNumericEditFlag)2);
			}
			using (new UIUtility.LabeledScope(gui, "ReadOnlyColorMultiplier".AsSpan()))
			{
				flag |= ImNumericEdit.NumericEdit(gui, ref theme.ReadOnlyColorMultiplier, default(ImSize), default(ReadOnlySpan<char>), 0.1f, 0f, 8f, (ImNumericEditFlag)2);
			}
			return flag;
		}

		public void SetTheme(ImGui gui)
		{
			gui.SetTheme(ref BaseTheme);
		}
	}
}
namespace WKLib.Core.UI.Windows
{
	internal class ChangeLogWindow
	{
		public static bool isOpen;

		public static void Draw(ImGui gui, bool isRootPanelOpen)
		{
			//IL_0023: 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_005f: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01f5: 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)
			if (isRootPanelOpen && ImWindow.BeginWindow(gui, "WKLib changelog", ref isOpen, new ImSize(500f, 400f), (ImWindowFlag)0))
			{
				ImSeparator.Separator(gui, "Versions".AsSpan());
				if (ImTree.BeginTreeNode(gui, "Version 0.3.0".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Rework Input system to work with more keys".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "- Remove old config system and adapted BepInEx config system".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "- Remove config window, now found in Mod List".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				if (ImTree.BeginTreeNode(gui, "Version 0.2.3".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Change config system default saving folder location, dont use WKLib as the default".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "+ Fix configs not saving as jsons".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				if (ImTree.BeginTreeNode(gui, "Version 0.2.2".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Fix plugin object being deleted".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "+ Fix error on scene loaded".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				if (ImTree.BeginTreeNode(gui, "Version 0.2.1".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Change config system saving and loading".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				if (ImTree.BeginTreeNode(gui, "Version 0.2.0".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Added ChangeLog window".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "+ Updated AssetService".AsSpan(), false, (ImTextOverflow)0);
					ImText.Text(gui, "+ Added Overlay button on main menu and pause menu".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				if (ImTree.BeginTreeNode(gui, "Version 0.1.0".AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					ImText.Text(gui, "+ Reworked UI and Config API".AsSpan(), false, (ImTextOverflow)0);
					ImTree.EndTreeNode(gui);
				}
				ImWindow.EndWindow(gui);
			}
		}
	}
	internal static class ModListWindow
	{
		public static bool isOpen = true;

		private static PluginContainer[] pluginContainers = Array.Empty<PluginContainer>();

		private static string searchString = "";

		public static void Initialize()
		{
			List<PluginContainer> pluginSettings = PluginConfigSearcher.GetPluginSettings();
			foreach (PluginContainer item in pluginSettings)
			{
				item.PluginName = PrettifyName(item.PluginInfo.Metadata.Name);
			}
			pluginContainers = pluginSettings.OrderBy<PluginContainer, string>((PluginContainer x) => x.PluginName, StringComparer.OrdinalIgnoreCase).ToArray();
			static string PrettifyName(string input)
			{
				input = Regex.Replace(input, "([a-z])([A-Z])", "$1 $2");
				input = Regex.Replace(input, "([A-Z])([A-Z][a-z])", "$1 $2");
				input = Regex.Replace(input, "\\s+", " ");
				input = Regex.Replace(input, "([A-Z]\\.)\\s([A-Z]\\.)", "$1$2");
				return input.Trim();
			}
		}

		public static void Draw(ImGui gui, bool open)
		{
			//IL_0023: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			if (!open || !ImWindow.BeginWindow(gui, "Mod list", ref isOpen, new ImSize(250f, 500f), (ImWindowFlag)0))
			{
				return;
			}
			ImLayoutUtility.BeginVertical(gui, 0f, 0f);
			ImSeparator.Separator(gui, "Mods".AsSpan());
			ReadOnlySpan<char> readOnlySpan = "Search for mod".AsSpan();
			ImTextEdit.TextEdit(gui, ref searchString, default(ImSize), (bool?)null, 0, (ImTouchKeyboardType)0, readOnlySpan);
			ImLayoutUtility.AddSpacing(gui);
			for (int i = 0; i < pluginContainers.Length; i++)
			{
				ref PluginContainer reference = ref pluginContainers[i];
				if (reference == null || reference.PluginInfo == null)
				{
					continue;
				}
				WKLibAPI aPIReference = reference.APIReference;
				if (aPIReference == null || (aPIReference != null && aPIReference.ModTab == null))
				{
					string name = reference.PluginInfo.Metadata.Name;
					if (!Utility.IsNullOrWhiteSpace(name) && (!(searchString.Trim() != string.Empty) || name.Contains(searchString, StringComparison.OrdinalIgnoreCase)))
					{
						gui.PushId(reference.PluginInfo.Metadata.GUID.AsSpan());
						if (ImButton.Button(gui, name.AsSpan(), default(ImSize), (ImButtonFlag)0))
						{
							reference.IsWindowOpen = !reference.IsWindowOpen;
						}
						gui.PopId();
					}
				}
				else if (aPIReference.ModTab != null && (!(searchString.Trim() != string.Empty) || aPIReference.ModTab.DisplayName.Contains(searchString, StringComparison.OrdinalIgnoreCase)) && ImTree.BeginTreeNode(gui, aPIReference.ModTab.DisplayName.AsSpan(), default(ImSize), (ImTreeNodeFlags)0))
				{
					aPIReference.ModTab.DrawSubMenu(gui);
					ImTree.EndTreeNode(gui);
				}
			}
			ImLayoutUtility.EndVertical(gui);
			ImWindow.EndWindow(gui);
			DrawConfigWindows(gui);
		}

		public static void CloseConfigWindows()
		{
			for (int i = 0; i < pluginContainers.Length; i++)
			{
				ref PluginContainer reference = ref pluginContainers[i];
				if (reference != null)
				{
					reference.IsWindowOpen = false;
				}
			}
		}

		private static void DrawConfigWindows(ImGui gui)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < pluginContainers.Length; i++)
			{
				ref PluginContainer reference = ref pluginContainers[i];
				if (reference == null || reference.PluginInfo == null || !reference.IsWindowOpen)
				{
					continue;
				}
				string name = reference.PluginInfo.Metadata.Name;
				if (Utility.IsNullOrWhiteSpace(name) || !ImWindow.BeginWindow(gui, name + " " + reference.PluginInfo.Metadata.Version, ref reference.IsWindowOpen, new ImSize(500f, 500f), (ImWindowFlag)0))
				{
					continue;
				}
				PluginContainer.ConfigEntrySection[] configSection = reference.ConfigSection;
				foreach (PluginContainer.ConfigEntrySection configEntrySection in configSection)
				{
					if (!Utility.IsNullOrWhiteSpace(configEntrySection.Section))
					{
						ImLayoutUtility.AddSpacing(gui);
						ImSeparator.Separator(gui, configEntrySection.Section.AsSpan());
					}
					ConfigEntryBase[] configEntries = configEntrySection.ConfigEntries;
					foreach (ConfigEntryBase configEntry in configEntries)
					{
						UIUtility.DrawConfigEntry(gui, configEntry);
					}
				}
				ImWindow.EndWindow(gui);
			}
		}

		public static void HandleInput(ImGui gui, bool open)
		{
		}
	}
	internal static class QuickPopupWindow
	{
		public static void Draw(ImGui gui, string text)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!(text.Trim() == string.Empty))
			{
				Vector2 val = ImText.MeasureTextSize(gui, text.AsSpan());
				ImWindow.BeginWindow(gui, "Popup", new ImSize(val.x * 1.5f, ImLayoutUtility.GetRowHeight(gui) * 5f), (ImWindowFlag)0);
				ImText.Text(gui, text.AsSpan(), false, (ImTextOverflow)0);
				ImWindow.EndWindow(gui);
			}
		}
	}
}
namespace WKLib.Core.Reflection
{
	internal class ReflectionUtility
	{
		private static readonly SortedDictionary<string, Type> AllTypes = new SortedDictionary<string, Type>(StringComparer.OrdinalIgnoreCase);

		internal static void Initialize()
		{
			SetupTypeCache();
		}

		internal static Type GetTypeByName(string fullName)
		{
			AllTypes.TryGetValue(fullName, out var value);
			if (value == null)
			{
				return Type.GetType(fullName);
			}
			return value;
		}

		private static void SetupTypeCache()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly asm in assemblies)
			{
				CacheTypes(asm);
			}
		}

		private static void CacheTypes(Assembly asm)
		{
			Type[] array = null;
			try
			{
				array = asm.GetTypes();
			}
			catch
			{
				return;
			}
			if (array != null)
			{
				Type[] array2 = array;
				foreach (Type type in array2)
				{
					AllTypes[type.FullName] = type;
				}
			}
		}
	}
}
namespace WKLib.Core.Patches
{
	[PatchOnEntry]
	[HarmonyPatch]
	internal static class CL_GameManagerPatch
	{
		[HarmonyPatch(typeof(CL_GameManager), "UnPause")]
		[HarmonyPostfix]
		private static void CL_GameManager_UnPause(CL_GameManager __instance)
		{
			if (!((Object)(object)MonoSingleton<RootPanel>.Instance == (Object)null) && ConfigManager.AutoCloseOverlay.Value && MonoSingleton<RootPanel>.Instance.IsOpen && !__instance.isPaused)
			{
				MonoSingleton<RootPanel>.Instance.IsOpen = false;
			}
		}
	}
	[PatchOnEntry]
	[HarmonyPatch]
	internal static class InputManagerPatch
	{
		[HarmonyPatch(typeof(InputManager), "Start")]
		[HarmonyPostfix]
		private static void InputManager_Start(InputManager __instance)
		{
			if (!((Object)(object)MonoSingleton<RootPanel>.Instance != (Object)null))
			{
				ImuiPanel val = ImuiBepInExAPI.CreateImuiPanel();
				((Component)val.Backend).gameObject.SetActive(false);
				RootPanel rootPanel = ((Component)val.Backend).gameObject.AddComponent<RootPanel>();
				rootPanel.ImuiPanel = val;
				((Component)val.Backend).gameObject.SetActive(true);
			}
		}
	}
}
namespace WKLib.Core.Config
{
	public static class ConfigManager
	{
		public static ConfigEntry<KeyCode> OverlayKey;

		public static ConfigEntry<bool> AutoCloseOverlay;

		public static ConfigEntry<bool> EnableDemoWindow;

		public static ConfigEntry<bool> HighContrast;

		public static ConfigEntry<Color> AccentColor;

		public static void CreateEntries(ConfigFile Config)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			OverlayKey = Config.Bind<KeyCode>("General", "Overlay Key", (KeyCode)287, "Keybind for opening and closing the overlay menu");
			AutoCloseOverlay = Config.Bind<bool>("General", "Auto Close Overlay", true, "Automatically close overlay on scene change");
			EnableDemoWindow = Config.Bind<bool>("General", "Enable Demo Window", false, "Enable demo window, used to showcase the WKLib UI");
			HighContrast = Config.Bind<bool>("Theme", "High Contrast", false, "Apply high contrast to the UI");
			AccentColor = Config.Bind<Color>("Theme", "Accent color", new Color(0.05f, 0.45f, 0.75f, 1f), "Change accent color of the UI");
			HighContrast.SettingChanged += delegate
			{
				MonoSingleton<RootPanel>.Instance?.ThemeController?.RegisterChanges();
			};
			AccentColor.SettingChanged += delegate
			{
				MonoSingleton<RootPanel>.Instance?.ThemeController?.RegisterChanges();
			};
		}
	}
	internal static class PluginConfigSearcher
	{
		public static BaseUnityPlugin[] FindPlugins()
		{
			return (from x in Chainloader.PluginInfos.Values
				select x.Instance into plugin
				where (Object)(object)plugin != (Object)null
				select plugin).Union(Object.FindObjectsOfType(typeof(BaseUnityPlugin)).Cast<BaseUnityPlugin>()).ToArray();
		}

		public static List<PluginContainer> GetPluginSettings()
		{
			List<PluginContainer> list = new List<PluginContainer>();
			BaseUnityPlugin[] array = FindPlugins();
			foreach (BaseUnityPlugin val in array)
			{
				string GUID = val.Info.Metadata.GUID;
				WKLibAPI wKLibAPI = WKLibAPI.internalAPIs.Find((WKLibAPI api) => string.Equals(api.GUID, GUID, StringComparison.Ordinal));
				Type type = ((object)val).GetType();
				if (type.GetCustomAttributes(typeof(BrowsableAttribute), inherit: false).Cast<BrowsableAttribute>().Any((BrowsableAttribute x) => !x.Browsable) && wKLibAPI == null)
				{
					continue;
				}
				PluginContainer pluginContainer = new PluginContainer
				{
					PluginName = val.Info.Metadata.Name,
					PluginInfo = val.Info,
					APIReference = wKLibAPI
				};
				if (wKLibAPI == null || (wKLibAPI != null && wKLibAPI.ModTab == null))
				{
					Dictionary<string, List<ConfigEntryBase>> dictionary = new Dictionary<string, List<ConfigEntryBase>>();
					foreach (ConfigEntryBase item in ((IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)val.Config).Select((KeyValuePair<ConfigDefinition, ConfigEntryBase> configEntry) => configEntry.Value))
					{
						ConfigDescription description = item.Description;
						object[] array2 = ((description != null) ? description.Tags : null);
						if (array2 == null || !array2.Contains("Hidden"))
						{
							string section2 = item.Definition.Section;
							if (!dictionary.TryGetValue(section2, out var value))
							{
								value = (dictionary[section2] = new List<ConfigEntryBase>());
							}
							value.Add(item);
						}
					}
					pluginContainer.ConfigSection = dictionary.Select((KeyValuePair<string, List<ConfigEntryBase>> section) => new PluginContainer.ConfigEntrySection
					{
						Section = section.Key,
						ConfigEntries = section.Value.ToArray()
					}).ToArray();
					if (pluginContainer.ConfigSection.Length == 0)
					{
						continue;
					}
				}
				list.Add(pluginContainer);
			}
			return list;
		}
	}
	public class PluginContainer
	{
		public class ConfigEntrySection
		{
			public string Section = "";

			public ConfigEntryBase[] ConfigEntries = Array.Empty<ConfigEntryBase>();
		}

		public string PluginName = "";

		public PluginInfo PluginInfo = null;

		public ConfigEntrySection[] ConfigSection = Array.Empty<ConfigEntrySection>();

		public bool IsWindowOpen = false;

		public WKLibAPI APIReference = null;
	}
}
namespace WKLib.Core.Classes
{
	public enum AudioMixerType
	{
		Music,
		Sfx,
		UI
	}
	internal class AudioManager : MonoSingleton<AudioManager>
	{
		private Queue<AudioSource> _audioSourcePool = new Queue<AudioSource>();

		private List<AudioSource> _playingSources = new List<AudioSource>();

		public static void CreateAudioManager()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)MonoSingleton<AudioManager>.Instance))
			{
				MonoSingleton<AudioManager>.Instance = new GameObject("AudioManager").AddComponent<AudioManager>();
			}
		}

		public AudioSource PlaySound(AudioClip clip, Vector3 position, Transform parent = null, float volume = 1f, float pitch = 1f, bool loop = false, float spatial = 1f, float reverbMix = 1f, bool bypassEffects = false, float minDistance = 0f, float? maxDistance = null, float? dopplerLevel = null, float? spread = null, AudioRolloffMode? rolloffMode = null, AnimationCurve customRolloffCurve = null, AudioMixerType mixerType = AudioMixerType.Sfx, string sourceType = "")
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: 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)
			if (!Object.op_Implicit((Object)(object)clip))
			{
				return null;
			}
			if (_audioSourcePool.Count == 0)
			{
				CreateAudioSource();
			}
			AudioSource val = _audioSourcePool.Dequeue();
			val.clip = clip;
			((Component)val).transform.position = position;
			if (Object.op_Implicit((Object)(object)parent))
			{
				((Component)val).transform.SetParent(parent, true);
			}
			val.volume = volume;
			val.pitch = pitch;
			val.loop = loop;
			val.spatialBlend = spatial;
			val.reverbZoneMix = reverbMix;
			val.bypassEffects = bypassEffects;
			val.minDistance = minDistance;
			if (!string.IsNullOrEmpty(sourceType) && AudioManager.sourceTypeDict.TryGetValue(sourceType, out var value))
			{
				AudioSource audioSourcePrefab = value.audioSourcePrefab;
				val.dopplerLevel = dopplerLevel ?? audioSourcePrefab.dopplerLevel;
				val.spread = spread ?? audioSourcePrefab.spread;
				val.maxDistance = maxDistance ?? audioSourcePrefab.maxDistance;
				if (!rolloffMode.HasValue)
				{
					AnimationCurve customCurve = audioSourcePrefab.GetCustomCurve((AudioSourceCurveType)0);
					val.rolloffMode = (AudioRolloffMode)2;
					val.SetCustomCurve((AudioSourceCurveType)0, customRolloffCurve ?? customCurve);
				}
			}
			else
			{
				AudioSource defaultAudio = AudioManager.defaultAudio;
				val.dopplerLevel = dopplerLevel ?? defaultAudio.dopplerLevel;
				val.spread = spread ?? defaultAudio.spread;
				val.maxDistance = maxDistance ?? defaultAudio.maxDistance;
				if (!rolloffMode.HasValue)
				{
					AnimationCurve customCurve2 = defaultAudio.GetCustomCurve((AudioSourceCurveType)0);
					val.rolloffMode = (AudioRolloffMode)2;
					val.SetCustomCurve((AudioSourceCurveType)0, customRolloffCurve ?? customCurve2);
				}
			}
			val.rolloffMode = (AudioRolloffMode)(((??)rolloffMode) ?? val.rolloffMode);
			AudioSource val2 = val;
			if (1 == 0)
			{
			}
			AudioMixerGroup outputAudioMixerGroup = (AudioMixerGroup)(mixerType switch
			{
				AudioMixerType.Music => AudioManager.instance.soundtrackMixer, 
				AudioMixerType.Sfx => AudioManager.instance.gameMixer, 
				AudioMixerType.UI => AudioManager.instance.UIMixer, 
				_ => val.outputAudioMixerGroup, 
			});
			if (1 == 0)
			{
			}
			val2.outputAudioMixerGroup = outputAudioMixerGroup;
			((Component)val).gameObject.SetActive(true);
			_playingSources.Add(val);
			val.Play();
			return val;
		}

		private void CreateAudioSource()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			AudioSource val = new GameObject("AudioSource").AddComponent<AudioSource>();
			((Component)val).transform.SetParent(((Component)this).transform);
			val.playOnAwake = false;
			_audioSourcePool.Enqueue(val);
		}

		private void SendBackToPool(AudioSource source)
		{
			_audioSourcePool.Enqueue(source);
			((Component)source).transform.SetParent(((Component)this).transform);
			((Component)source).gameObject.SetActive(false);
		}

		private void Update()
		{
			for (int num = _playingSources.Count - 1; num >= 0; num--)
			{
				AudioSource val = _playingSources[num];
				if (!Object.op_Implicit((Object)(object)val))
				{
					_playingSources.RemoveAt(num);
				}
				else if (!val.isPlaying)
				{
					_playingSources.RemoveAt(num);
					SendBackToPool(val);
				}
			}
		}
	}
	[DefaultExecutionOrder(-200)]
	internal abstract class MonoSingleton : MonoBehaviour
	{
	}
	internal abstract class MonoSingleton<T> : MonoSingleton where T : MonoSingleton<T>
	{
		private static T instance;

		public static T Instance
		{
			get
			{
				return instance;
			}
			set
			{
				instance = value;
			}
		}

		public virtual void Awake()
		{
			if (Object.op_Implicit((Object)(object)Instance) && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				Instance = (T)this;
			}
		}

		public virtual void OnEnable()
		{
			Instance = (T)this;
		}
	}
}
namespace WKLib.Core.Attributes
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	internal sealed class PatchOnEntryAttribute : Attribute
	{
	}
}
namespace WKLib.API
{
	public class WKLibAPI
	{
		internal static List<WKLibAPI> internalAPIs = new List<WKLibAPI>();

		public string DisplayName { get; internal set; } = string.Empty;


		public string GUID { get; internal set; } = string.Empty;


		public List<WKLibWindow> Windows { get; internal set; } = new List<WKLibWindow>();


		public ModTab ModTab { get; internal set; } = null;


		public AssetService AssetService { get; internal set; } = null;


		private WKLibAPI(string displayName, string guid, string defaultConfigFileName)
		{
			DisplayName = displayName;
			GUID = guid;
			AssetService = new AssetService(this);
		}

		public static WKLibAPI Create(string displayName, string guid)
		{
			return Create_Internal(displayName, guid);
		}

		public static WKLibAPI Create(string displayName, string guid, string defaultConfigFileName)
		{
			return Create_Internal(displayName, guid, defaultConfigFileName);
		}

		private static WKLibAPI Create_Internal(string displayName, string guid, string defaultConfigFileName = "DefaultConfig")
		{
			foreach (WKLibAPI internalAPI in internalAPIs)
			{
				if (string.Equals(guid, internalAPI.GUID))
				{
					throw new Exception(displayName + " collides with " + internalAPI.DisplayName + ", they both have the same guid, " + guid);
				}
			}
			WKLibAPI wKLibAPI = new WKLibAPI(displayName, guid, defaultConfigFileName);
			internalAPIs.Add(wKLibAPI);
			internalAPIs.Sort((WKLibAPI a, WKLibAPI b) => string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase));
			return wKLibAPI;
		}

		public void AddWindow(WKLibWindow window)
		{
			if (!Windows.Contains(window))
			{
				Windows.Add(window);
			}
		}

		public void AddToModList(ModTab modTab)
		{
			if (ModTab != null)
			{
				throw new Exception("Mod tab already exists, cant add new one");
			}
			ModTab = modTab;
		}

		public void Destroy()
		{
			if (internalAPIs.Contains(this))
			{
				internalAPIs.Remove(this);
			}
		}
	}
}
namespace WKLib.API.UI
{
	public abstract class ModTab
	{
		public abstract string DisplayName { get; }

		public abstract void DrawSubMenu(ImGui gui);
	}
	public class PopupSettings
	{
		public string PopupText = "";

		public float PopupTime = 2.5f;

		public float TimeTillClose = -1f;

		public PopupSettings()
		{
		}

		public PopupSettings(string text, float seconds = 2.5f)
		{
			PopupText = text;
			PopupTime = seconds;
			TimeTillClose = Time.realtimeSinceStartup + PopupTime;
		}
	}
	public static class UIUtility
	{
		public struct LabeledScope : IDisposable
		{
			private ImGui gui;

			public LabeledScope(ImGui gui, ReadOnlySpan<char> label, float firstRectSize = 0.4f)
			{
				//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_003f: Unknown result type (might be due to invalid IL or missing references)
				this.gui = gui;
				gui.PushId(label);
				ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
				ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
				ImRect val = ImLayoutUtility.AddLayoutRect(gui, ImLayoutUtility.GetLayoutWidth(gui) * firstRectSize, ImLayoutUtility.GetRowHeight(gui));
				ImText.Text(gui, label, val, false, (ImTextOverflow)1);
				ImLayoutUtility.BeginVertical(gui, 0f, 0f);
			}

			public void Dispose()
			{
				ImLayoutUtility.EndVertical(gui);
				ImLayoutUtility.EndHorizontal(gui);
				gui.PopId();
			}
		}

		public static bool Keybind(this ImGui gui, string label, ref KeyCode keyCode)
		{
			//IL_0043: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			bool result = false;
			uint controlId = gui.GetControlId(label.AsSpan());
			gui.PushId(controlId);
			ImLayoutUtility.AddSpacingIfLayoutFrameNotEmpty(gui);
			ImLayoutUtility.BeginHorizontal(gui, 0f, 0f);
			ImRect val = ImLayoutUtility.AddLayoutRect(gui, ImLayoutUtility.GetLayoutWidth(gui) * 0.8f, ImLayoutUtility.GetRowHeight(gui));
			ImText.Text(gui, label.AsSpan(), val, false, (ImTextOverflow)1);
			ImLayoutUtility.BeginVertical(gui, 0f, 0f);
			if (gui.GetActiveControl() == controlId)
			{
				ImButton.Button(gui, "...".AsSpan(), default(ImSize), (ImButtonFlag)0);
				if (SetToPressedKey(gui, ref keyCode))
				{
					result = true;
					gui.ResetActiveControl();
				}
			}
			else if (ImButton.Button(gui, ((object)(KeyCode)(ref keyCode)).ToString().AsSpan(), default(ImSize), (ImButtonFlag)0))
			{
				gui.SetActiveControl(controlId, (ImControlFlag)0);
			}
			ImLayoutUtility.EndVertical(gui);
			ImLayoutUtility.EndHorizontal(gui);
			gui.PopId();
			return result;
			static bool SetToPressedKey(ImGui gui, ref KeyCode keyCode)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Invalid comparison between Unknown and I4
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Invalid comparison between Unknown and I4
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected I4, but got Unknown
				KeyCode? firstActiveKey = InputUtility.GetFirstActiveKey();
				if (!firstActiveKey.HasValue)
				{
					return false;
				}
				if ((int)firstActiveKey.GetValueOrDefault() == 323 || (int)firstActiveKey.GetValueOrDefault() == 324)
				{
					return true;
				}
				if ((int)firstActiveKey.GetValueOrDefault() == 27)
				{
					keyCode = (KeyCode)0;
					return true;
				}
				keyCode = (KeyCode)(int)firstActiveKey.Value;
				return true;
			}
		}

		public static void DrawConfigEntry(ImGui gui, ConfigEntryBase configEntry)
		{
			//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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b39: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0670: Unknown result type (might be due to invalid IL or missing references)
			//IL_0771: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Unknown result type (might be due to invalid IL or missing references)
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08de: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0873: Unknown result type (might be due to invalid IL or missing references)
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_090a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0910: Unknown result type (might be due to invalid IL or missing references)
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_0993: Unknown result type (might be due to invalid IL or missing references)
			//IL_0998: Unknown result type (might be due to invalid IL or missing references)
			//IL_099f: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0925: Unknown result type (might be due to invalid IL or missing references)
			//IL_092c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0933: Unknown result type (might be due to invalid IL or missing references)
			//IL_093a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a11: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a16: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a28: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a88: Unknown result type (might be due to invalid IL or missing references)
			string key = configEntry.Definition.Key;
			string description = configEntry.Description.Description;
			description = InsertLineBreaks(description, 40);
			object boxedValue = configEntry.BoxedValue;
			Type settingType = configEntry.SettingType;
			float availableWidth = gui.Layout.GetAvailableWidth();
			float rowHeight = ImLayoutUtility.GetRowHeight(gui);
			Vector2 nextPosition = gui.Layout.GetNextPosition(rowHeight);
			ImRect val = default(ImRect);
			((ImRect)(ref val))..ctor(nextPosition.x, nextPosition.y, availableWidth, rowHeight);
			uint nextControlId = gui.GetNextControlId();
			gui.RegisterGroup(nextControlId, val);
			if (settingType == typeof(bool))
			{
				bool flag = (bool)boxedValue;
				if (ImCheckbox.Checkbox(gui, ref flag, key.AsSpan(), default(ImSize)))
				{
					configEntry.BoxedValue = flag;
				}
			}
			else if (settingType == typeof(byte))
			{
				byte b = (byte)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref b, default(ImSize), default(ReadOnlySpan<char>), (byte)1, (byte)0, byte.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = b;
					}
				}
			}
			else if (settingType == typeof(sbyte))
			{
				int num = (sbyte)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num, default(ImSize), default(ReadOnlySpan<char>), 1, -128, 127, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = (sbyte)num;
					}
				}
			}
			else if (settingType == typeof(short))
			{
				short num2 = (short)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num2, default(ImSize), default(ReadOnlySpan<char>), (short)1, short.MinValue, short.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = num2;
					}
				}
			}
			else if (settingType == typeof(ushort))
			{
				int num3 = (ushort)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num3, default(ImSize), default(ReadOnlySpan<char>), 1, 0, 65535, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = (ushort)num3;
					}
				}
			}
			else if (settingType == typeof(int))
			{
				int num4 = (int)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num4, default(ImSize), default(ReadOnlySpan<char>), 1, int.MinValue, int.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = num4;
					}
				}
			}
			else if (settingType == typeof(uint))
			{
				long num5 = (uint)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num5, default(ImSize), default(ReadOnlySpan<char>), 1L, 0L, 4294967295L, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = (uint)num5;
					}
				}
			}
			else if (settingType == typeof(long))
			{
				long num6 = (long)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num6, default(ImSize), default(ReadOnlySpan<char>), 1L, long.MinValue, long.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = num6;
					}
				}
			}
			else if (settingType == typeof(ulong))
			{
				long num7 = (long)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num7, default(ImSize), default(ReadOnlySpan<char>), 1L, 0L, long.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = (ulong)num7;
					}
				}
			}
			else if (settingType == typeof(float))
			{
				float num8 = (float)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num8, default(ImSize), default(ReadOnlySpan<char>), 0.1f, float.MinValue, float.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = num8;
					}
				}
			}
			else if (settingType == typeof(double))
			{
				double num9 = (double)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num9, default(ImSize), default(ReadOnlySpan<char>), 0.1, double.MinValue, double.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = num9;
					}
				}
			}
			else if (settingType == typeof(decimal))
			{
				double num10 = Convert.ToDouble((decimal)boxedValue);
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImNumericEdit.NumericEdit(gui, ref num10, default(ImSize), default(ReadOnlySpan<char>), 0.1, double.MinValue, double.MaxValue, (ImNumericEditFlag)2))
					{
						configEntry.BoxedValue = (decimal)num10;
					}
				}
			}
			else if (settingType == typeof(string))
			{
				string boxedValue2 = ((string)boxedValue) ?? "";
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImTextEdit.TextEdit(gui, ref boxedValue2, default(ImSize), (bool?)null, 0, (ImTouchKeyboardType)0, default(ReadOnlySpan<char>)))
					{
						configEntry.BoxedValue = boxedValue2;
					}
				}
			}
			else if (settingType == typeof(Vector2))
			{
				Vector2 val2 = (Vector2)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImVector.Vector(gui, ref val2, default(ImSize)))
					{
						configEntry.BoxedValue = val2;
					}
				}
			}
			else if (settingType == typeof(Vector3))
			{
				Vector3 val3 = (Vector3)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImVector.Vector(gui, ref val3, default(ImSize)))
					{
						configEntry.BoxedValue = val3;
					}
				}
			}
			else if (settingType == typeof(Vector4))
			{
				Vector4 val4 = (Vector4)boxedValue;
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImVector.Vector(gui, ref val4, default(ImSize)))
					{
						configEntry.BoxedValue = val4;
					}
				}
			}
			else if (settingType == typeof(Quaternion))
			{
				Quaternion val5 = (Quaternion)boxedValue;
				Vector4 val6 = default(Vector4);
				((Vector4)(ref val6))..ctor(val5.x, val5.y, val5.z, val5.w);
				using (new LabeledScope(gui, key.AsSpan()))
				{
					if (ImVector.Vector(gui, ref val6, default(ImSize)))
					{
						configEntry.BoxedValue = (object)new Quaternion(val6.x, val6.y, val6.z, val6.w);
					}
				}
			}
			else if (settingType == typeof(Color))
			{
				using (new LabeledScope(gui, key.AsSpan()))
				{
					Color val7 = (Color)configEntry.BoxedValue;
					if (ImColorEdit.ColorEdit(gui, ref val7, default(ImSize)))
					{
						configEntry.BoxedValue = val7;
					}
				}
			}
			else
			{
				if (settingType == typeof(KeyboardShortcut))
				{
					return;
				}
				if (settingType == typeof(KeyCode))
				{
					KeyCode keyCode = (KeyCode)configEntry.BoxedValue;
					if (gui.Keybind(key, ref keyCode))
					{
						configEntry.BoxedValue = keyCode;
					}
				}
				else if (settingType.IsEnum)
				{
					string[] names = Enum.GetNames(settingType);
					int num11 = Array.IndexOf<string>(names, boxedValue.ToString());
					using (new LabeledScope(gui, key.AsSpan()))
					{
						if (ImDropdown.Dropdown(gui, ref num11, (ReadOnlySpan<string>)names, default(ImSize), (ImDropdownPreviewType)0, default(ReadOnlySpan<char>)))
						{
							object boxedValue3 = Enum.Parse(settingType, names[num11]);
							configEntry.BoxedValue = boxedValue3;
						}
					}
				}
				else
				{
					ImText.Text(gui, (key + ": Unsupported type (" + settingType.Name + ")").AsSpan(), false, (ImTextOverflow)0);
				}
			}
			if (!Utility.IsNullOrWhiteSpace(description) && gui.IsGroupHovered(nextControlId))
			{
				ImTooltip.Tooltip(gui, description.AsSpan(), gui.Input.MousePosition + gui.Style.Tooltip.OffsetPixels / gui.Canvas.ScreenScale);
			}
			static string InsertLineBreaks(string text, int maxLineLength)
			{
				if (string.IsNullOrWhiteSpace(text) || maxLineLength <= 0)
				{
					return text;
				}
				string[] array = text.Split(' ');
				StringBuilder stringBuilder = new StringBuilder();
				int num12 = 0;
				string[] array2 = array;
				foreach (string text2 in array2)
				{
					if (num12 + text2.Length + 1 > maxLineLength)
					{
						stringBuilder.AppendLine();
						num12 = 0;
					}
					else if (num12 > 0)
					{
						stringBuilder.Append(' ');
						num12++;
					}
					stringBuilder.Append(text2);
					num12 += text2.Length;
				}
				return stringBuilder.ToString();
			}
		}

		public static void ShowPopupForTime(string text, float seconds = 2.5f)
		{
			OverlayState.Popups.Add(new PopupSettings(text, seconds));
		}
	}
	public abstract class WKLibWindow
	{
		public bool isOpen = false;

		public abstract void Draw(ImGui gui, bool isRootPanelOpen);

		public abstract void HandleInput(ImGui gui);
	}
}
namespace WKLib.API.Input
{
	public static class InputUtility
	{
		private enum KeyCodeDeviceType
		{
			None,
			Keyboard,
			Mouse,
			Gamepad
		}

		private static Type? t_Keyboard;

		private static Type? t_Mouse;

		private static Type? t_Gamepad;

		private static Type? t_Key;

		private static PropertyInfo? p_btnIsPressed;

		private static PropertyInfo? p_btnWasPressed;

		private static PropertyInfo? p_btnWasReleased;

		private static PropertyInfo? p_kbCurrent;

		private static PropertyInfo? p_kbIndexer;

		private static PropertyInfo? p_mouseCurrent;

		private static PropertyInfo? p_leftButton;

		private static PropertyInfo? p_rightButton;

		private static PropertyInfo? p_middleButton;

		private static PropertyInfo? p_forwardButton;

		private static PropertyInfo? p_backButton;

		private static PropertyInfo? p_gamepadCurrent;

		private static PropertyInfo? p_buttonWest;

		private static PropertyInfo? p_buttonNorth;

		private static PropertyInfo? p_buttonSouth;

		private static PropertyInfo? p_buttonEast;

		private static PropertyInfo? p_startButton;

		private static PropertyInfo? p_selectButton;

		private static PropertyInfo? p_leftStickButton;

		private static PropertyInfo? p_rightStickButton;

		private static PropertyInfo? p_dpad;

		private static PropertyInfo? p_dpadUp;

		private static PropertyInfo? p_dpadDown;

		private static PropertyInfo? p_dpadLeft;

		private static PropertyInfo? p_dpadRight;

		private static PropertyInfo? p_leftShoulder;

		private static PropertyInfo? p_rightShoulder;

		private static PropertyInfo? p_leftStick;

		private static PropertyInfo? p_rightStick;

		private static PropertyInfo? p_leftTrigger;

		private static PropertyInfo? p_rightTrigger;

		private static MethodInfo? m_ReadV2Control;

		private static PropertyInfo? p_position;

		private static PropertyInfo? p_scrollDelta;

		internal static bool Initialized = false;

		private static Dictionary<KeyCode, object?> KeyCodeToKeyboardKeyCache = new Dictionary<KeyCode, object>();

		private static readonly Dictionary<string, string> keycodeToKeyFixes = new Dictionary<string, string>
		{
			{ "Control", "Ctrl" },
			{ "Return", "Enter" },
			{ "Alpha", "Digit" },
			{ "Keypad", "Numpad" },
			{ "Numlock", "NumLock" },
			{ "Print", "PrintScreen" },
			{ "BackQuote", "Backquote" }
		};

		private static Type TKeyboard => t_Keyboard ?? (t_Keyboard = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Keyboard"));

		private static Type TMouse => t_Mouse ?? (t_Mouse = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Mouse"));

		private static Type TGamepad => t_Gamepad ?? (t_Gamepad = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Gamepad"));

		private static Type TKey => t_Key ?? (t_Key = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Key"));

		private static object? CurrentKeyboard => p_kbCurrent?.GetValue(null, null);

		private static object? CurrentMouse => p_mouseCurrent?.GetValue(null, null);

		private static object? LeftMouseButton => p_leftButton?.GetValue(CurrentMouse, null);

		private static object? RightMouseButton => p_rightButton?.GetValue(CurrentMouse, null);

		private static object? MiddleMouseButton => p_middleButton?.GetValue(CurrentMouse, null);

		private static object? ForwardMouseButton => p_forwardButton?.GetValue(CurrentMouse, null);

		private static object? BackMouseButton => p_backButton?.GetValue(CurrentMouse, null);

		private static object? CurrentGamepad => p_gamepadCurrent?.GetValue(null, null);

		private static object? ButtonGamepadWest => p_buttonWest?.GetValue(CurrentGamepad, null);

		private static object? ButtonGamepadNorth => p_buttonNorth?.GetValue(CurrentGamepad, null);

		private static object? ButtonGamepadSouth => p_buttonSouth?.GetValue(CurrentGamepad, null);

		private static object? ButtonGamepadEast => p_buttonEast?.GetValue(CurrentGamepad, null);

		private static object? StartButton => p_startButton?.GetValue(CurrentGamepad, null);

		private static object? SelectButton => p_selectButton?.GetValue(CurrentGamepad, null);

		private static object? LeftStickButton => p_leftStickButton?.GetValue(CurrentGamepad, null);

		private static object? RightStickButton => p_rightStickButton?.GetValue(CurrentGamepad, null);

		private static object? Dpad => p_dpad?.GetValue(CurrentGamepad, null);

		private static object? DpadUp => p_dpadUp?.GetValue(Dpad, null);

		private static object? DpadDown => p_dpadDown?.GetValue(Dpad, null);

		private static object? DpadLeft => p_dpadLeft?.GetValue(Dpad, null);

		private static object? DpadRight => p_dpadRight?.GetValue(Dpad, null);

		private static object? LeftShoulder => p_leftShoulder?.GetValue(CurrentGamepad, null);

		private static object? RightShoulder => p_rightShoulder?.GetValue(CurrentGamepad, null);

		private static object? LeftStick => p_leftStick?.GetValue(CurrentGamepad, null);

		private static object? RightStick => p_rightStick?.GetValue(CurrentGamepad, null);

		private static object? LeftTrigger => p_leftTrigger?.GetValue(CurrentGamepad, null);

		private static object? RightTrigger => p_rightTrigger?.GetValue(CurrentGamepad, null);

		private static object? MousePositionInfo => p_position?.GetValue(CurrentMouse, null);

		private static object? MouseScrollInfo => p_scrollDelta?.GetValue(CurrentMouse, null);

		internal static void Initialize()
		{
			if (!Initialized)
			{
				p_kbCurrent = TKeyboard.GetProperty("current");
				p_kbIndexer = TKeyboard.GetProperty("Item", new Type[1] { TKey });
				Type typeByName = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.ButtonControl");
				p_btnIsPressed = typeByName.GetProperty("isPressed");
				p_btnWasPressed = typeByName.GetProperty("wasPressedThisFrame");
				p_btnWasReleased = typeByName.GetProperty("wasReleasedThisFrame");
				p_mouseCurrent = TMouse.GetProperty("current");
				p_leftButton = TMouse.GetProperty("leftButton");
				p_rightButton = TMouse.GetProperty("rightButton");
				p_middleButton = TMouse.GetProperty("middleButton");
				p_backButton = TMouse.GetProperty("backButton");
				p_forwardButton = TMouse.GetProperty("forwardButton");
				p_scrollDelta = TMouse.GetProperty("scroll");
				p_position = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Pointer").GetProperty("position");
				p_gamepadCurrent = TGamepad.GetProperty("current");
				p_buttonWest = TGamepad.GetProperty("buttonWest");
				p_buttonNorth = TGamepad.GetProperty("buttonNorth");
				p_buttonSouth = TGamepad.GetProperty("buttonSouth");
				p_buttonEast = TGamepad.GetProperty("buttonEast");
				p_startButton = TGamepad.GetProperty("startButton");
				p_selectButton = TGamepad.GetProperty("selectButton");
				p_leftStickButton = TGamepad.GetProperty("leftStickButton");
				p_rightStickButton = TGamepad.GetProperty("rightStickButton");
				p_dpad = TGamepad.GetProperty("dpad");
				Type typeByName2 = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.Controls.DpadControl");
				p_dpadUp = typeByName2.GetProperty("up");
				p_dpadDown = typeByName2.GetProperty("down");
				p_dpadLeft = typeByName2.GetProperty("left");
				p_dpadRight = typeByName2.GetProperty("right");
				p_leftShoulder = TGamepad.GetProperty("leftShoulder");
				p_rightShoulder = TGamepad.GetProperty("rightShoulder");
				p_leftStick = TGamepad.GetProperty("leftStick");
				p_rightStick = TGamepad.GetProperty("rightStick");
				p_leftTrigger = TGamepad.GetProperty("leftTrigger");
				p_rightTrigger = TGamepad.GetProperty("rightTrigger");
				m_ReadV2Control = ReflectionUtility.GetTypeByName("UnityEngine.InputSystem.InputControl`1").MakeGenericType(typeof(Vector2)).GetMethod("ReadValue");
				Initialized = true;
			}
		}

		private static bool IsJoystickKeyCode(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			return (int)key >= 330 && (int)key <= 349;
		}

		private static bool IsMouseKeyCode(KeyCode key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			return (int)key >= 323 && (int)key <= 329;
		}

		private static object? KeyCodeToKeyEnum(KeyCode key)
		{
			string text = ((object)(KeyCode)(ref key)).ToString();
			foreach (KeyValuePair<string, string> keycodeToKeyFix in keycodeToKeyFixes)
			{
				if (text.Contains(keycodeToKeyFix.Key))
				{
					text = text.Replace(keycodeToKeyFix.Key, keycodeToKeyFix.Value);
					break;
				}
			}
			try
			{
				return Enum.Parse(TKey, text);
			}
			catch
			{
				return null;
			}
		}

		private static object? KeyCodeToKeyboardControl(KeyCode key)
		{
			//IL_0019: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentKeyboard == null)
			{
				return null;
			}
			if (KeyCodeToKeyboardKeyCache.TryGetValue(key, out object value))
			{
				return value;
			}
			object obj = null;
			if ((object)p_kbIndexer != null && CurrentKeyboard != null)
			{
				object obj2 = KeyCodeToKeyEnum(key);
				if (obj2 != null)
				{
					try
					{
						obj = p_kbIndexer.GetValue(CurrentKeyboard, new object[1] { obj2 });
					}
					catch
					{
						obj = null;
					}
				}
			}
			KeyCodeToKeyboardKeyCache[key] = obj;
			return obj;
		}

		private static object? KeyCodeToMouseControl(KeyCode key)
		{
			//IL_0015: 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_0035: Expected I4, but got Unknown
			if (CurrentMouse == null)
			{
				return null;
			}
			if (1 == 0)
			{
			}
			object result = (key - 323) switch
			{
				0 => LeftMouseButton, 
				1 => RightMouseButton, 
				2 => MiddleMouseButton, 
				3 => BackMouseButton, 
				4 => ForwardMouseButton, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static object? KeyCodeToGamepadControl(KeyCode key)
		{
			//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)
			//IL_0064: Expected I4, but got Unknown
			if (CurrentGamepad == null)
			{
				return null;
			}
			if (1 == 0)
			{
			}
			object result = (key - 330) switch
			{
				0 => ButtonGamepadSouth, 
				1 => ButtonGamepadEast, 
				2 => ButtonGamepadWest, 
				3 => ButtonGamepadNorth, 
				4 => LeftShoulder, 
				5 => RightShoulder, 
				6 => LeftTrigger, 
				7 => RightTrigger, 
				8 => SelectButton, 
				9 => StartButton, 
				10 => LeftStickButton, 
				11 => RightStickButton, 
				12 => DpadUp, 
				13 => DpadDown, 
				14 => DpadLeft, 
				15 => DpadRight, 
				_ => null, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static KeyCodeDeviceType GetDeviceType(KeyCode key)
		{
			//IL_0001: 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 (IsMouseKeyCode(key))
			{
				return KeyCodeDeviceType.Mouse;
			}
			if (IsJoystickKeyCode(key))
			{
				return KeyCodeDeviceType.Gamepad;
			}
			return KeyCodeDeviceType.Keyboard;
		}

		private static object? KeyCodeToControl(KeyCode key)
		{
			//IL_0003: 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_0022: 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)
			object result = null;
			switch (GetDeviceType(key))
			{
			case KeyCodeDeviceType.Mouse:
				result = KeyCodeToMouseControl(key);
				break;
			case KeyCodeDeviceType.Gamepad:
				result = KeyCodeToGamepadControl(key);
				break;
			case KeyCodeDeviceType.Keyboard:
				result = KeyCodeToKeyboardControl(key);
				break;
			}
			return result;
		}

		private static bool TryGetControlState(object? control, PropertyInfo? stateProperty, out bool state)
		{
			state = false;
			if (control == null || (object)stateProperty == null)
			{
				return false;
			}
			try
			{
				object value = stateProperty.GetValue(control, null);
				if (value is bool)
				{
					bool flag = (bool)value;
					if (true)
					{
						state = flag;
						return true;
					}
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		public static bool GetKeyDown(KeyCode key)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!Initialized || (object)p_btnWasPressed == null)
			{
				return false;
			}
			object control = KeyCodeToControl(key);
			bool state;
			return TryGetControlState(control, p_btnWasPressed, out state) && state;
		}

		public static bool GetKey(KeyCode key)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!Initialized || (object)p_btnIsPressed == null)
			{
				return false;
			}
			object control = KeyCodeToControl(key);
			bool state;
			return TryGetControlState(control, p_btnIsPressed, out state) && state;
		}

		public static bool GetKeyUp(KeyCode key)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!Initialized || (object)p_btnWasReleased == null)
			{
				return false;
			}
			object control = KeyCodeToControl(key);
			bool state;
			return TryGetControlState(control, p_btnWasReleased, out state) && state;
		}

		public static KeyCode? GetFirstActiveKey()
		{
			//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_003f: 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)
			if (!Initialized)
			{
				return null;
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				object control = KeyCodeToControl(value);
				if (TryGetControlState(control, p_btnIsPressed, out var state) && state)
				{
					return value;
				}
			}
			return null;
		}
	}
}
namespace WKLib.API.Gamemodes
{
	public class GamemodeBuilder
	{
		private List<M_Region> _regions = new List<M_Region>();

		private string _modeName = "Custom Gamemode";

		private string _introText = "ASCEND";

		private bool _isEndless;

		private bool _hasPerks;

		private bool _hasRevives;

		private Sprite _capsuleSprite;

		private Sprite _screenArtSprite;

		private List<SpawnItem> _spawnItems;

		private GameType _gameType;

		public GamemodeBuilder WithRegions(List<M_Region> regions)
		{
			_regions = regions ?? new List<M_Region>();
			return this;
		}

		public GamemodeBuilder WithName(string modeName)
		{
			_modeName = modeName;
			return this;
		}

		public GamemodeBuilder WithIntroText(string introText)
		{
			_introText = introText;
			return this;
		}

		public GamemodeBuilder IsEndless(bool isEndless)
		{
			_isEndless = isEndless;
			return this;
		}

		public GamemodeBuilder HasPerks(bool hasPerks)
		{
			_hasPerks = hasPerks;
			return this;
		}

		public GamemodeBuilder HasRevives(bool hasRevives)
		{
			_hasRevives = hasRevives;
			return this;
		}

		public GamemodeBuilder WithCapsuleSprite(Sprite sprite)
		{
			_capsuleSprite = sprite;
			return this;
		}

		public GamemodeBuilder WithScreenArt(Sprite sprite)
		{
			_screenArtSprite = sprite;
			return this;
		}

		public GamemodeBuilder WithStartItems(List<SpawnItem> spawnItems)
		{
			_spawnItems = spawnItems;
			return this;
		}

		public GamemodeBuilder WithGameType(string gameType)
		{
			//IL_0050: 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_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)
			//IL_0058: 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_0060: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			string text = gameType.ToLower();
			if (1 == 0)
			{
			}
			GameType gameType2 = (GameType)(text switch
			{
				"endless" => 3, 
				"standard" => 0, 
				"playlist" => 1, 
				"playlist-shuffle" => 2, 
				"single" => 4, 
				_ => _gameType, 
			});
			if (1 == 0)
			{
			}
			_gameType = gameType2;
			return this;
		}

		public M_Gamemode Build()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Invalid comparison between Unknown and I4
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Expected O, but got Unknown
			M_Gamemode gm = ScriptableObject.CreateInstance<M_Gamemode>();
			gm.allowAchievements = false;
			gm.allowCheatedScores = false;
			gm.allowCheats = true;
			gm.allowLeaderboardScoring = true;
			gm.steamLeaderboardName = "";
			gm.allowHeightAchievements = false;
			gm.baseGamemode = true;
			gm.modeType = (GameType)((!_isEndless) ? 1 : 3);
			gm.capsuleName = _modeName;
			gm.gamemodeName = _modeName;
			gm.introText = _introText;
			gm.isEndless = _isEndless;
			gm.hasPerks = _hasPerks;
			gm.hasRevives = _hasRevives;
			gm.gamemodeScene = "Game-Main";
			gm.roachBankID = "custom-" + _modeName;
			gm.gamemodePanel = ((IEnumerable<UI_GamemodeScreen_Panel>)Resources.FindObjectsOfTypeAll<UI_GamemodeScreen_Panel>()).FirstOrDefault((Func<UI_GamemodeScreen_Panel, bool>)((UI_GamemodeScreen_Panel x) => ((Object)x).name == "Gamemode_Panel_Base"));
			gm.loseScreen = ((IEnumerable<UI_ScoreScreen>)Resources.FindObjectsOfTypeAll<UI_ScoreScreen>()).FirstOrDefault((Func<UI_ScoreScreen, bool>)((UI_ScoreScreen x) => ((Object)x).name == "ScorePanel_Standard_Death"));
			gm.winScreen = ((IEnumerable<UI_ScoreScreen>)Resources.FindObjectsOfTypeAll<UI_ScoreScreen>()).FirstOrDefault((Func<UI_ScoreScreen, bool>)((UI_ScoreScreen x) => ((Object)x).name == "ScorePanel_Standard_Win"));
			gm.modeTags = new List<string>(1) { "" };
			gm.unlockAchievement = "";
			GamemodeModule_Standard gamemodeModule = new GamemodeModule_Standard
			{
				winScoreMultiplier = 1f
			};
			gm.gamemodeModule = (GamemodeModule)(object)gamemodeModule;
			int numLevelsToLoad = 0;
			_regions.ForEach(delegate(M_Region reg)
			{
				reg.subregionGroups.ForEach(delegate(SubregionGroup subRegGroup)
				{
					subRegGroup.subregions.ForEach(delegate(M_Subregion subReg)
					{
						numLevelsToLoad += subReg.levelReferences.Count;
					});
				});
			});
			WKLog.Debug($"[Gamemode Builder] Will load {numLevelsToLoad} levels for {_modeName}");
			int num = numLevelsToLoad;
			int num2 = num;
			if (num2 <= 1)
			{
				if (num2 == 1)
				{
					gm.modeType = (GameType)4;
					gm.playlistLevelAssets = new List<LevelAssetHolder>(1) { _regions[0].subregionGroups[0].subregions[0].levelReferences[0] };
					WKLog.Debug("[Gamemode Builder] Loading one singular level");
				}
			}
			else if ((int)_gameType == 4)
			{
				gm.modeType = (GameType)1;
				_regions.ForEach(delegate(M_Region reg)
				{
					reg.subregionGroups.ForEach(delegate(SubregionGroup subRegGroup)
					{
						subRegGroup.subregions.ForEach(delegate(M_Subregion subReg)
						{
							gm.playlistLevelAssets.AddRange(subReg.levelReferences);
						});
					});
				});
			}
			else
			{
				gm.modeType = _gameType;
				List<LevelAssetHolder> list = new List<LevelAssetHolder>();
				int num3 = 0;
				foreach (LevelAssetHolder item2 in from region in _regions
					from subRegionGroup in region.subregionGroups
					from subRegion in subRegionGroup.subregions
					from level in subRegion.levelReferences
					select level)
				{
					try
					{
						list.Add(item2);
						num3++;
					}
					catch (Exception ex)
					{
						WKLog.Error("[Gamemode Builder] Failed to load: " + ex.Message);
					}
				}
				WKLog.Debug($"[Gamemode Builder] Loaded {num3}/{numLevelsToLoad} levels");
				_regions.ForEach(delegate(M_Region reg)
				{
					reg.subregionGroups.ForEach(delegate(SubregionGroup subRegGroup)
					{
						subRegGroup.subregions.ForEach(delegate(M_Subregion subReg)
						{
							gm.playlistLevelAssets.AddRange(subReg.levelReferences);
						});
					});
				});
			}
			gm.levelsToGenerate = numLevelsToLoad;
			((Object)gm).name = _modeName;
			if (_capsuleSprite != null)
			{
				gm.capsuleArt = _capsuleSprite;
			}
			if (_screenArtSprite != null)
			{
				gm.screenArt = _screenArtSprite;
			}
			gm.regions = _regions;
			GameObject val = ((IEnumerable<GameObject>)Resources.FindObjectsOfTypeAll<GameObject>()).FirstOrDefault((Func<GameObject, bool>)((GameObject go) => ((Object)go).name == "World_Root"));
			gm.gamemodeObjects = ((val != null) ? new List<GameObject>(1) { val } : new List<GameObject>());
			SpawnItem item = new SpawnItem
			{
				itemid = "Item_Hammer"
			};
			gm.startItems = _spawnItems ?? new List<SpawnItem>(1) { item };
			return gm;
		}
	}
	public class RegionBuilder
	{
		private string _name = "New Region";

		private List<M_Subregion> _subregions = new List<M_Subregion>();

		private bool _hasStartingLevel = true;

		public RegionBuilder WithName(string regionName)
		{
			_name = regionName;
			return this;
		}

		public RegionBuilder WithSubregions(List<M_Subregion> subregions)
		{
			_subregions = subregions ?? new List<M_Subregion>();
			return this;
		}

		[Obsolete("Game Handles this automatically, Let the game decide")]
		public RegionBuilder WithStartingLevel(bool hasStartingLevel)
		{
			_hasStartingLevel = hasStartingLevel;
			return this;
		}

		public M_Region Build()
		{
			//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_0060: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			M_Region val = ScriptableObject.CreateInstance<M_Region>();
			val.regionName = _name;
			((Object)val).name = _name;
			List<SubregionGroup> list = new List<SubregionGroup>();
			foreach (M_Subregion subregion in _subregions)
			{
				list.Add(new SubregionGroup
				{
					subregions = new List<M_Subregion>(1) { subregion }
				});
			}
			val.subregionGroups = list;
			if (_subregions.Count > 1 && _subregions[0].levelReferences.Count > 1)
			{
				List<TransitionLevels> list2 = new List<TransitionLevels>(1);
				TransitionLevels val2 = new TransitionLevels
				{
					fromRegion = _name
				};
				List<M_Level> list3 = new List<M_Level>(1);
				List<LevelAssetHolder> levelReferences = _subregions[0].levelReferences;
				list3.Add(levelReferences[levelReferences.Count - 1].level);
				val2.levels = list3;
				list2.Add(val2);
				val.transitionLevels = list2;
				_subregions[0].levelReferences.RemoveAt(_subregions[0].levelReferences.Count - 1);
			}
			val.regionHeight = _subregions.Sum((M_Subregion sr) => sr.subregionHeight);
			M_Level val3 = ((IEnumerable<LevelAssetHolder>)CL_AssetManager.GetFullCombinedAssetDatabase().levelAssets).FirstOrDefault((Func<LevelAssetHolder, bool>)((LevelAssetHolder pref) => pref.level.levelName == "M1_Intro_01"))?.level;
			if (val3 != null && _hasStartingLevel)
			{
				val.startLevels = new List<M_Level>(1) { val3 };
			}
			val.regionOrder = (RegionOrder)1;
			val.introText = _name;
			val.sessionEventLists = _subregions.SelectMany((M_Subregion sr) => sr.sessionEventLists).ToList();
			return val;
		}
	}
	public class SubRegionBuilder
	{
		private string _name = "New Subregion";

		private List<LevelAssetHolder> _levelAssets = new List<LevelAssetHolder>();

		public SubRegionBuilder WithName(string subregionName)
		{
			_name = subregionName;
			return this;
		}

		public SubRegionBuilder WithLevels(List<M_Level> levels)
		{
			_levelAssets = levels.Select((M_Level l) => LevelAssetHolder.GetNewHolderFromLevel(l)).ToList();
			return this;
		}

		public M_Subregion Build()
		{
			M_Subregion val = ScriptableObject.CreateInstance<M_Subregion>();
			val.subregionName = _name;
			((Object)val).name = _name;
			val.levelReferences = _levelAssets;
			val.subregionHeight = _levelAssets.Sum((LevelAssetHolder lv) => lv.level.GetHeight());
			val.sessionEventLists = _levelAssets.SelectMany((LevelAssetHolder lv) => lv.level.sessionEventLists).ToList();
			return val;
		}
	}
}
namespace WKLib.API.Common
{
	public struct WKVersion : IComparable<WKVersion>
	{
		public int Major;

		public int Minor;

		public string Suffix;

		public WKVersion(string version)
		{
			Match match = Regex.Match(version, "(\\d+)\\.(\\d+)([a-z]?)");
			if (match.Success)
			{
				Major = int.Parse(match.Groups[1].Value);
				Minor = int.Parse(match.Groups[2].Value);
				Suffix = (string.IsNullOrWhiteSpace(match.Groups[3].Value) ? "a" : match.Groups[3].Value);
			}
			else
			{
				Major = (Minor = 0);
				Suffix = "a";
			}
		}

		public int CompareTo(WKVersion other)
		{
			if (Major != other.Major)
			{
				return Major.CompareTo(other.Major);
			}
			if (Minor != other.Minor)
			{
				return Minor.CompareTo(other.Minor);
			}
			return string.Compare(Suffix, other.Suffix, StringComparison.Ordinal);
		}

		public static bool operator >=(WKVersion a, WKVersion b)
		{
			return a.CompareTo(b) >= 0;
		}

		public static bool operator <=(WKVersion a, WKVersion b)
		{
			return a.CompareTo(b) <= 0;
		}

		public static bool operator >(WKVersion a, WKVersion b)
		{
			return a.CompareTo(b) > 0;
		}

		public static bool operator <(WKVersion a, WKVersion b)
		{
			return a.CompareTo(b) < 0;
		}
	}
}
namespace WKLib.API.Audio
{
	public static class AudioUtility
	{
		public static AudioSource PlaySound(AudioClip clip, Vector3 position, Transform parent = null, float volume = 1f, float pitch = 1f, bool loop = false, float spatial = 1f, float reverbMix = 1f, bool bypassEffects = false, float minDistance = 0f, float? maxDistance = null, float? dopplerLevel = null, float? spread = null, AudioRolloffMode? rolloffMode = null, AnimationCurve customRolloffCurve = null, AudioMixerType mixerType = AudioMixerType.Sfx, string sourceType = "")
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)MonoSingleton<AudioManager>.Instance))
			{
				AudioManager.CreateAudioManager();
			}
			return MonoSingleton<AudioManager>.Instance.PlaySound(clip, position, parent, volume, pitch, loop, spatial, reverbMix, bypassEffects, minDistance, maxDistance, dopplerLevel, spread, rolloffMode, customRolloffCurve, mixerType, sourceType);
		}
	}
}
namespace WKLib.API.Assets
{
	public class AssetService
	{
		private readonly WKLibAPI _wkLibAPI;

		public readonly string AssemblyFolder;

		private readonly Dictionary<string, AssetBundle> _bundleCache = new Dictionary<string, AssetBundle>();

		private readonly Dictionary<string, Dictionary<string, M_Level>> _loadedLevelsCache = new Dictionary<string, Dictionary<string, M_Level>>();

		private readonly Dictionary<string, M_Gamemode> _gamemodeCache = new Dictionary<string, M_Gamemode>();

		private readonly CancellationTokenSource _sQuitCts = new CancellationTokenSource();

		public AssetService(WKLibAPI API)
		{
			_wkLibAPI = API ?? throw new ArgumentNullException("API");
			if (!Chainloader.PluginInfos.TryGetValue(API.GUID, out var value))
			{
				throw new Exception("WKLibAPI GUID Mistmatch with PluginInfo, " + API.DisplayName + ", " + API.GUID);
			}
			string location = value.Location;
			AssemblyFolder = Path.GetDirectoryName(location) ?? string.Empty;
			Application.quitting += delegate
			{
				WKLog.Debug("[AssetService] Quitting...");
				_sQuitCts.Cancel();
			};
		}

		public async Task<AssetBundle> LoadBundleRelativeAsync(string relativePath, IProgress<float> progress = null)
		{
			progress?.Report(0f);
			if (string.IsNullOrEmpty(relativePath))
			{
				WKLog.Error("[AssetService] Path is null or empty.");
				progress?.Report(1f);
				return null;
			}
			string cacheKey = _wkLibAPI.DisplayName + ":" + Path.GetFileNameWithoutExtension(relativePath);
			if (_bundleCache.TryGetValue(cacheKey, out var cached) && cached != null)
			{
				WKLog.Debug("[AssetService] Returning cached bundle: " + cacheKey);
				progress?.Report(1f);
				return cached;
			}
			string fullPath = Path.Combine(AssemblyFolder, relativePath);
			if (!File.Exists(fullPath))
			{
				WKLog.Error("[AssetService] Bundle not found at " + fullPath);
				progress?.Report(1f);
				return null;
			}
			AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(fullPath);
			if (request == null)
			{
				WKLog.Error("[AssetService] Failed to load bundle: " + fullPath + " (request)");
				progress?.Report(1f);
				return null;
			}
			try
			{
				while (!((AsyncOperation)request).isDone)
				{
					_sQuitCts.Token.ThrowIfCancellationRequested();
					progress?.Report(((AsyncOperation)request).progress * 1.1f);
					await Task.Yield();
				}
			}
			catch (OperationCanceledException)
			{
				WKLog.Debug("[AssetService] Asset Bundle Load cancelled");
				return null;
			}
			AssetBundle bundle = request.assetBundle;
			if (bundle == null)
			{
				WKLog.Error("[AssetService] Failed to load bundle at " + fullPath + " (bundle)");
				progress?.Report(1f);
				return null;
			}
			_bundleCache[cacheKey] = bundle;
			WKLog.Debug("[AssetService] Loaded & cached bundle: " + cacheKey);
			progress?.Report(1f);
			return bundle;
		}

		public void UnloadBundleRelative(string relativePath, bool unloadAllLoadedObjects = false)
		{
			string text = _wkLibAPI.DisplayName + ":" + relativePath;
			if (_bundleCache.TryGetValue(text, out var value) && value != null)
			{
				try
				{
					value.Unload(unloadAllLoadedObjects);
				}
				catch
				{
					WKLog.Error("[AssetService] Failed to unload bundle: " + text);
					return;
				}
				WKLog.Debug("[AssetService] Unloaded bundle: " + text);
				_bundleCache.Remove(text);
			}
		}

		public void UnloadAllBundles(bool unloadAllLoadedObjects = false)
		{
			List<string> list = _bundleCache.Keys.Where((string k) => k.StartsWith(_wkLibAPI.DisplayName + ":")).ToList();
			foreach (string item in list)
			{
				if (_bundleCache[item] != null)
				{
					try
					{
						_bundleCache[item].Unload(unloadAllLoadedObjects);
					}
					catch
					{
						WKLog.Error("[AssetService] Failed to unload bundle: " + item);
						continue;
					}
					WKLog.Debug("[AssetService] Unloaded bundle: " + item);
				}
				_bundleCache.Remove(item);
			}
		}

		public async Task<Dictionary<string, M_Level>> LoadAllLevelsFromBundle(AssetBundle bundle, IProgress<float> progress = null)
		{
			Dictionary<string, M_Level> foundLevels = new Dictionary<string, M_Level>();
			if (bundle == null)
			{
				WKLog.Error("[AssetService] LoadAllLevelsFromBundle called with null bundle.");
				progress?.Report(1f);
				return foundLevels;
			}
			string cacheKey = _wkLibAPI.DisplayName + ":" + ((Object)bundle).name;
			if (_loadedLevelsCache.ContainsKey(cacheKey))
			{
				WKLog.Debug("[AssetService] Returning Cached loaded levels for bundle: " + cacheKey);
				progress?.Report(1f);
				return _loadedLevelsCache.GetValueOrDefault(cacheKey);
			}
			AssetBundleRequest request = bundle.LoadAllAssetsAsync<GameObject>();
			try
			{
				while (!((AsyncOperation)request).isDone)
				{
					_sQuitCts.Token.ThrowIfCancellationRequested();
					progress?.Report(((AsyncOperation)request).progress * 0.5f);
					await Task.Yield();
				}
			}
			catch (OperationCanceledException)
			{
				WKLog.Debug("[AssetService] LoadAllLevelsFromBundle canceled.");
				return null;
			}
			WKAssetDatabase currentDatabase = CL_AssetManager.GetDatabase(_wkLibAPI.DisplayName);
			if ((Object)(object)currentDatabase == (Object)null)
			{
				WKLog.Info("[AssetService] Creating new asset database for " + _wkLibAPI.DisplayName);
				currentDatabase = new WKAssetDatabase();
				CL_AssetManager.AddNewDatabase(_wkLibAPI.DisplayName, currentDatabase);
			}
			List<GameObject> allGOs = request.allAssets.Cast<GameObject>().ToList();
			int total = allGOs.Count;
			M_Level level = default(M_Level);
			for (int i = 0; i < total; i += 20)
			{
				for (int j = i; j < i + 20 && j < total; j++)
				{
					GameObject go = allGOs[j];
					if (go.TryGetComponent<M_Level>(ref level))
					{
						bool alreadyExists = false;
						foreach (LevelAssetHolder levelAsset in currentDatabase.levelAssets)
						{
							if (levelAsset == null || !(levelAsset.id == level.levelName))
							{
								continue;
							}
							alreadyExists = true;
							break;
						}
						if (!alreadyExists)
						{
							currentDatabase.levelAssets.Add(LevelAssetHolder.GetNewHolderFromLevel(level));
						}
						WKLog.Debug("[AssetService] Found level: " + ((Object)level).name);
						if (!foundLevels.TryAdd(((Object)level).name, level))
						{
							WKLog.Debug("[AssetService] Duplicate prefab.name '" + ((Object)level).name + "' found; skipping the duplicate.");
						}
					}
					level = null;
				}
				progress?.Report(0.5f + (float)i / (float)total * 0.5f);
				await Task.Yield();
			}
			_loadedLevelsCache[cacheKey] = foundLevels;
			progress?.Report(1f);
			return foundLevels;
		}

		public List<M_Level> FindLevelsByName(string nameContains)
		{
			return (from levelAsset in CL_AssetManager.GetFullCombinedAssetDatabase().levelAssets
				select levelAsset.level into level
				where level != null
				where ((Object)level).name.Contains(nameContains)
				select level).ToList();
		}

		public async Task<M_Gamemode> LoadGameModeFromBundle(AssetBundle bundle, string assetName, IProgress<float> progress = null)
		{
			if (bundle == null)
			{
				WKLog.Error("[AssetService] Bundle is null; cannot load gamemode.");
				progress?.Report(1f);
				return null;
			}
			string cacheKey = _wkLibAPI.DisplayName + ":" + assetName;
			if (_gamemodeCache.TryGetValue(cacheKey, out var cachedGamemode))
			{
				WKLog.Debug("[AssetService] Returning cached gamemode: '" + cacheKey + "'");
				progress?.Report(1f);
				return cachedGamemode;
			}
			AssetBundleRequest request = bundle.LoadAssetAsync<ScriptableObject>(assetName);
			while (!((AsyncOperation)request).isDone)
			{
				progress?.Report(((AsyncOperation)request).progress);
				await Task.Yield();
			}
			Object asset = request.asset;
			M_Gamemode gamemode = (M_Gamemode)(object)((asset is M_Gamemode) ? asset : null);
			if (gamemode == null)
			{
				WKLog.Error("[AssetService] Gamemode '" + assetName + "' not found in bundle " + ((Object)bundle).name);
				progress?.Report(1f);
				return null;
			}
			if (string.IsNullOrEmpty(gamemode.unlockAchievement))
			{
				gamemode.unlockAchievement = "ACH_TUTORIAL";
			}
			gamemode.gamemodePanel = ((IEnumerable<UI_GamemodeScreen_Panel>)Resources.FindObjectsOfTypeAll<UI_GamemodeScreen_Panel>()).FirstOrDefault((Func<UI_GamemodeScreen_Panel, bool>)((UI_GamemodeScreen_Panel x) => ((Object)x).name == "Gamemode_Panel_Base"));
			gamemode.loseScreen = ((IEnumerable<UI_ScoreScreen>)Resources.FindObjectsOfTypeAll<UI_ScoreScreen>()).FirstOrDefault((Func<UI_ScoreScreen, bool>)((UI_ScoreScreen x) => ((Object)x).name == "ScorePanel_Standard_Death"));
			gamemode.winScreen = ((IEnumerable<UI_ScoreScreen>)Resources.FindObjectsOfTypeAll<UI_ScoreScreen>()).FirstOrDefault((Func<UI_ScoreScreen, bool>)((UI_ScoreScreen x) => ((Object)x).name == "ScorePanel_Standard_Win"));
			_gamemodeCache[cacheKey] = gamemode;
			progress?.Report(1f);
			WKLog.Debug("[AssetService] Loaded and cached gamemode: '" + assetName + "'");
			return gamemode;
		}

		public Sprite LoadPngAsSpriteRelative(string relativePngPath)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0085: 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 = Path.Combine(AssemblyFolder, relativePngPath);
			if (!File.Exists(text))
			{
				WKLog.Error("[AssetService] PNG not found at: " + text);
				return null;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array))
			{
				WKLog.Error("[AssetService] Failed to load image: " + relativePngPath);
				return null;
			}
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			((Object)val2).name = Path.GetFileNameWithoutExtension(relativePngPath);
			return val2;
		}

		public Sprite LoadPngAsSprite(string pngFileName)
		{
			//IL_002e: 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)
			Texture2D val = LoadPngTexture(pngFileName);
			if (val == null)
			{
				return null;
			}
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			((Object)val2).name = pngFileName.Split(".png")[0];
			return val2;
		}

		private Texture2D LoadPngTexture(string pngFileName)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			string text = Path.Combine(AssemblyFolder, "Assets", pngFileName);
			if (!File.Exists(text))
			{
				WKLog.Error("[AssetService] PNG not found at: " + text);
				return null;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (ImageConversion.LoadImage(val, array))
			{
				return val;
			}
			WKLog.Error("[AssetService] Failed to decode PNG: " + text);
			return null;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}