using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Assets.Scripts.Actors;
using Assets.Scripts.Actors.Enemies;
using Assets.Scripts.Actors.Player;
using Assets.Scripts.Inventory__Items__Pickups;
using Assets.Scripts.Inventory__Items__Pickups.AbilitiesPassive;
using Assets.Scripts.Inventory__Items__Pickups.Interactables;
using Assets.Scripts.Inventory__Items__Pickups.Items;
using Assets.Scripts.Inventory__Items__Pickups.Items.ItemImplementations;
using Assets.Scripts.Inventory__Items__Pickups.Stats;
using Assets.Scripts.Inventory__Items__Pickups.Upgrades;
using Assets.Scripts.Inventory__Items__Pickups.Weapons;
using Assets.Scripts.Managers;
using Assets.Scripts.Menu.Shop;
using Assets.Scripts.Saves___Serialization.Progression.Achievements;
using Assets.Scripts.Settings___Saves.SaveFiles;
using Assets.Scripts.Settings___Saves.SaveFiles.ConfigSaves;
using Assets.Scripts.UI.HUD;
using Assets.Scripts.UI.InGame.Rewards;
using Assets.Scripts._Data;
using Assets.Scripts._Data.Tomes;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Inventory__Items__Pickups;
using Inventory__Items__Pickups.Xp_and_Levels;
using Microsoft.CodeAnalysis;
using RizzottoMegamod.Features;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RizzottoMegamod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RizzottoMegamod")]
[assembly: AssemblyTitle("RizzottoMegamod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RizzottoMegamod
{
	public static class Diagnostics
	{
		private static readonly List<string> _report = new List<string>();

		private static readonly List<string> _errors = new List<string>();

		public static void Begin(string version)
		{
			_report.Clear();
			_errors.Clear();
			Line("Rizzotto Megamod " + version);
			Line($"Started at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
			Line(new string('-', 60));
		}

		public static bool TryApply(ModFeature feature, Harmony harmony)
		{
			try
			{
				feature.ApplyPatches(harmony);
				Line($"  [ PASS ] {feature.DisplayName,-25} (id: {feature.Id})");
				return true;
			}
			catch (Exception ex)
			{
				Line($"  [ FAIL ] {feature.DisplayName,-25} (id: {feature.Id})");
				Line("           -> " + ex.GetType().Name + ": " + ex.Message);
				_errors.Add($"{feature.Id}: {ex}");
				for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
				{
					Line("           caused by " + innerException.GetType().Name + ": " + innerException.Message);
				}
				return false;
			}
		}

		public static bool VerifyType(string typeName)
		{
			try
			{
				if (Type.GetType(typeName + ", Assembly-CSharp", throwOnError: false) != null)
				{
					return true;
				}
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					if (assemblies[i].GetType(typeName, throwOnError: false) != null)
					{
						return true;
					}
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		public static void Line(string s)
		{
			Plugin.Log.LogInfo((object)s);
			_report.Add(s);
		}

		public static void Warn(string s)
		{
			Plugin.Log.LogWarning((object)s);
			_report.Add("[WARN] " + s);
		}

		public static void Error(string s, Exception ex = null)
		{
			Plugin.Log.LogError((object)s);
			_report.Add("[ERROR] " + s);
			if (ex != null)
			{
				_report.Add("        " + ex);
				_errors.Add(s + ": " + ex);
			}
		}

		public static void Finish(int enabled, int total)
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			Line(new string('-', 60));
			Line($"Result: {enabled}/{total} features enabled, {_errors.Count} error(s)");
			if (_errors.Count > 0)
			{
				Line("");
				Line("ERRORS:");
				for (int i = 0; i < _errors.Count; i++)
				{
					Line($"  ({i + 1}) {_errors[i]}");
				}
			}
			bool flag = default(bool);
			try
			{
				string text = Path.Combine(Paths.BepInExRootPath, "Megamod_Status.log");
				File.WriteAllLines(text, _report);
				ManualLogSource log = Plugin.Log;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Diagnostics] status written to ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				}
				log.LogInfo(val);
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(43, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[Diagnostics] could not write status file: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				log2.LogWarning(val2);
			}
		}

		public static bool TryApplyLeaderboardBlocker(Harmony harmony)
		{
			try
			{
				LeaderboardBlocker.Init(harmony);
				Line("  [ PASS ] LeaderboardBlocker          (always-on safety)");
				return true;
			}
			catch (Exception ex)
			{
				Line("  [ FAIL ] LeaderboardBlocker          (always-on safety)");
				Line("           -> " + ex.GetType().Name + ": " + ex.Message);
				_errors.Add("LeaderboardBlocker: " + ex);
				return false;
			}
		}
	}
	public static class EnumLists
	{
		public static readonly string[] Tomes = new string[27]
		{
			"Agility", "Armor", "Attraction", "Balance", "Blood", "Bounce", "Chaos", "Cooldown", "Cursed", "Damage",
			"Duration", "Evasion", "Gambler", "Golden", "Health", "Hoarder", "Knockback", "Luck", "Precision", "ProjectileSpeed",
			"Quantity", "Regeneration", "Shield", "Silver", "Size", "Thorns", "Xp"
		};

		public static readonly HashSet<string> HiddenTomes = new HashSet<string> { "Balance", "Bounce", "Gambler", "Hoarder" };

		public static readonly string[] Characters = new string[21]
		{
			"Fox", "Calcium", "SirOofie", "Cl4nk", "Megachad", "Ogre", "Robinette", "Athena", "Birdo", "Bush",
			"Bandit", "Monke", "Noelle", "TonyMcZoom", "Amog", "Spaceman", "Ninja", "Vlad", "Dicehead", "SirChadwell",
			"Roberto"
		};

		public static readonly string[] Items = new string[88]
		{
			"Key", "Beer", "SpikyShield", "Bonker", "SlipperyRing", "CowardsCloak", "GymSauce", "Battery", "PhantomShroud", "ForbiddenJuice",
			"DemonBlade", "GrandmasSecretTonic", "GiantFork", "MoldyCheese", "GoldenSneakers", "SpicyMeatball", "Chonkplate", "LightningOrb", "IceCube", "DemonicBlood",
			"DemonicSoul", "BeefyRing", "Dragonfire", "GoldenGlove", "GoldenShield", "ZaWarudo", "OverpoweredLamp", "Feathers", "Ghost", "SluttyCannon",
			"TurboSocks", "ShatteredWisdom", "EchoShard", "SuckyMagnet", "Backpack", "Clover", "Campfire", "Rollerblades", "Skuleg", "EagleClaw",
			"Scarf", "Anvil", "Oats", "CursedDoll", "EnergyCore", "ElectricPlug", "BobDead", "SoulHarvester", "Mirror", "JoesDagger",
			"WeebHeadset", "SpeedBoi", "Gasmask", "ToxicBarrel", "HolyBook", "BrassKnuckles", "IdleJuice", "Kevin", "Borgar", "Medkit",
			"GamerGoggles", "UnstableTransfusion", "BloodyCleaver", "CreditCardRed", "CreditCardGreen", "BossBuster", "LeechingCrystal", "TacticalGlasses", "Cactus", "CageKey",
			"IceCrystal", "TimeBracelet", "GloveLightning", "GlovePoison", "GloveBlood", "GloveCurse", "GlovePower", "Wrench", "Beacon", "GoldenRing",
			"QuinsMask", "CryptKey", "OldMask", "Snek", "Pot", "BobsLantern", "Pumpkin", "WizardsHat"
		};

		public static readonly string[][] ItemAliases = new string[7][]
		{
			new string[2] { "burger", "Borgar" },
			new string[2] { "hamburger", "Borgar" },
			new string[2] { "hourglass", "ZaWarudo" },
			new string[2] { "op lamp", "OverpoweredLamp" },
			new string[2] { "big bonk", "Bonker" },
			new string[2] { "slurp gloves", "GloveBlood" },
			new string[2] { "thunder mitts", "GloveLightning" }
		};

		public static readonly string[] EStats = new string[25]
		{
			"DamageMultiplier", "AttackSpeed", "CritChance", "CritDamage", "ProjectileSpeedMultiplier", "Projectiles", "SizeMultiplier", "KnockbackMultiplier", "DurationMultiplier", "Thorns",
			"MaxHealth", "HealthRegen", "Armor", "Shield", "Evasion", "Lifesteal", "MoveSpeedMultiplier", "PickupRange", "Luck", "GoldIncreaseMultiplier",
			"XpIncreaseMultiplier", "Difficulty", "PowerupChance", "PowerupBoostMultiplier", "ExtraJumps"
		};

		public static readonly string[] Hotkeys = new string[73]
		{
			"F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
			"F11", "F12", "Insert", "Home", "PageUp", "PageDown", "End", "Delete", "Keypad0", "Keypad1",
			"Keypad2", "Keypad3", "Keypad4", "Keypad5", "Keypad6", "Keypad7", "Keypad8", "Keypad9", "KeypadPlus", "KeypadMinus",
			"KeypadDivide", "KeypadMultiply", "KeypadEnter", "Tab", "CapsLock", "Backspace", "Return", "Q", "W", "E",
			"R", "T", "Y", "U", "I", "O", "P", "A", "S", "D",
			"F", "G", "H", "J", "K", "L", "Z", "X", "C", "V",
			"B", "N", "M", "Alpha0", "Alpha1", "Alpha2", "Alpha3", "Alpha4", "Alpha5", "Alpha6",
			"Alpha7", "Alpha8", "Alpha9"
		};
	}
	public static class LeaderboardBlocker
	{
		public static void Init(Harmony harmony)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			harmony.PatchAll(typeof(LeaderboardUploadPatches));
			VerifyPatched("QueueLeaderboardUpload");
			VerifyPatched("UploadLeaderboardScore");
			try
			{
				ClassInjector.RegisterTypeInIl2Cpp<LeaderboardToggleBlocker>();
				GameObject val = new GameObject("Megamod_LeaderboardToggleBlocker")
				{
					hideFlags = (HideFlags)61
				};
				val.AddComponent<LeaderboardToggleBlocker>();
				Object.DontDestroyOnLoad((Object)val);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[LeaderboardBlocker] toggle-blocker spawn failed: " + ex.Message));
			}
			Plugin.Log.LogInfo((object)"LeaderboardBlocker active — leaderboard uploads are suppressed.");
		}

		private static void VerifyPatched(string methodName)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(SteamLeaderboardsManagerNew), methodName, (Type[])null, (Type[])null);
			bool flag = default(bool);
			if (methodInfo == null)
			{
				ManualLogSource log = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(100, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[LeaderboardBlocker] target '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(methodName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' not found — UPLOAD MAY NOT BE BLOCKED. Game version may have changed.");
				}
				log.LogError(val);
				return;
			}
			Patches patchInfo = Harmony.GetPatchInfo((MethodBase)methodInfo);
			if (patchInfo == null || patchInfo.Prefixes.Count == 0)
			{
				ManualLogSource log2 = Plugin.Log;
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(77, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[LeaderboardBlocker] prefix did not attach to '");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(methodName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' — UPLOAD MAY NOT BE BLOCKED.");
				}
				log2.LogError(val);
				return;
			}
			ManualLogSource log3 = Plugin.Log;
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(64, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[LeaderboardBlocker] verified prefix on ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(methodName);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" (");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(patchInfo.Prefixes.Count);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" prefix(es) attached).");
			}
			log3.LogInfo(val2);
		}
	}
	public class LeaderboardToggleBlocker : MonoBehaviour
	{
		private float _toastTimer;

		private GUIStyle _toastBox;

		private GUIStyle _toastText;

		private bool _stylesReady;

		private int _scanCounter;

		public LeaderboardToggleBlocker(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Update()
		{
			try
			{
				SaveManager instance = SaveManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					ConfigSaveFile config = instance.config;
					obj = ((config != null) ? config.cfGameSettings : null);
				}
				CFGameSettings val = (CFGameSettings)obj;
				if (val != null && val.upload_score_to_leaderboard != 0)
				{
					val.upload_score_to_leaderboard = 0;
					_toastTimer = 4f;
				}
				if (_toastTimer > 0f)
				{
					_toastTimer -= Time.unscaledDeltaTime;
				}
				if ((_scanCounter++ & 7) == 0)
				{
					ForceVisualToggleOff();
				}
			}
			catch
			{
			}
		}

		private void ForceVisualToggleOff()
		{
			try
			{
				Il2CppArrayBase<BetterSetting> val = Object.FindObjectsOfType<BetterSetting>();
				for (int i = 0; i < val.Length; i++)
				{
					BetterSetting val2 = val[i];
					if (!((Object)(object)val2 == (Object)null) && IsLeaderboardRow(val2) && !val2.IsDisabled())
					{
						val2.Disable("Can't Enable with Megamod");
					}
				}
			}
			catch
			{
			}
		}

		private static bool IsLeaderboardRow(BetterSetting row)
		{
			try
			{
				TextMeshProUGUI settingName = row.settingName;
				if ((Object)(object)settingName != (Object)null && (((TMP_Text)settingName).text ?? "").ToLowerInvariant().Contains("upload"))
				{
					return true;
				}
			}
			catch
			{
			}
			Transform val = ((Component)row).transform;
			for (int i = 0; i < 6; i++)
			{
				if (!((Object)(object)val != (Object)null))
				{
					break;
				}
				string text = (((Object)val).name ?? "").ToLowerInvariant();
				if (text.Contains("upload_score") || text.Contains("uploadscore") || text.Contains("upload "))
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private void OnGUI()
		{
			//IL_0053: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!(_toastTimer <= 0f))
			{
				EnsureStyles();
				float num = ((float)Screen.width - 460f) / 2f;
				float num2 = 60f;
				int depth = GUI.depth;
				GUI.depth = -2000;
				float num3 = Mathf.Min(1f, _toastTimer / 0.8f);
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, num3);
				GUI.Box(new Rect(num, num2, 460f, 56f), GUIContent.none, _toastBox);
				GUI.Label(new Rect(num, num2, 460f, 56f), "Can't Enable with Megamod", _toastText);
				GUI.color = color;
				GUI.depth = depth;
			}
		}

		private void EnsureStyles()
		{
			//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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0075: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			if (!_stylesReady || _toastBox == null || _toastBox.normal == null || (Object)(object)_toastBox.normal.background == (Object)null)
			{
				_stylesReady = true;
				GUIStyle val = new GUIStyle();
				val.normal.background = MakeTex(new Color(0.12f, 0.05f, 0.05f, 1f));
				_toastBox = val;
				GUIStyle val2 = new GUIStyle
				{
					fontSize = 18,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
				val2.normal.textColor = new Color(1f, 0.6f, 0.6f);
				_toastText = val2;
			}
		}

		private static Texture2D MakeTex(Color c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0025: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, c);
			val.Apply();
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)val);
			return val;
		}
	}
	public static class LeaderboardUploadPatches
	{
		[HarmonyPatch(typeof(SteamLeaderboardsManagerNew), "QueueLeaderboardUpload")]
		[HarmonyPrefix]
		private static bool QueueUpload_Prefix()
		{
			return false;
		}

		[HarmonyPatch(typeof(SteamLeaderboardsManagerNew), "UploadLeaderboardScore")]
		[HarmonyPrefix]
		private static bool UploadScore_Prefix()
		{
			return false;
		}
	}
	public class MegaMenu : MonoBehaviour
	{
		private sealed class HotkeyRow
		{
			public string Item = "Anvil";

			public int Amount = 5;

			public string Key = "F9";

			public string Search = "Anvil";
		}

		public static ConfigEntry<KeyCode> ToggleKey;

		private static MegaMenu _instance;

		private bool _open;

		private Vector2 _scroll;

		private string _itemSearch = "";

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

		private readonly List<HotkeyRow> _hotkeyRows = new List<HotkeyRow>();

		private bool _hotkeyRowsLoaded;

		private string _assignTarget = "";

		private int _amountEditTarget = -1;

		private string _amountEditBuffer = "";

		private string _configIntId = "";

		private string _configIntBuffer = "";

		private ConfigEntry<int> _configIntEntry;

		private int _configIntMin = 1;

		private int _configIntMax = int.MaxValue;

		private string _configFloatId = "";

		private string _configFloatBuffer = "";

		private ConfigEntry<float> _configFloatEntry;

		private float _configFloatMin;

		private float _configFloatMax = 1f;

		private float _savedTimeScale = 1f;

		private CursorLockMode _savedCursorLock;

		private bool _savedCursorVisible = true;

		private readonly List<GraphicRaycaster> _suppressedRaycasters = new List<GraphicRaycaster>();

		private GUIStyle _box;

		private GUIStyle _header;

		private GUIStyle _label;

		private GUIStyle _dim;

		private GUIStyle _btn;

		private GUIStyle _accent;

		private GUIStyle _danger;

		private GUIStyle _textfield;

		private GUIStyle _backdrop;

		private bool _stylesReady;

		private const float WIN_W = 720f;

		private const float WIN_H = 820f;

		private const float PAD = 14f;

		private const float ROW_H = 28f;

		private const float ROW_GAP = 4f;

		private const float HEADER_H = 60f;

		private const float FOOTER_H = 50f;

		private const float MENU_CARD_H = 90f;

		private const float SLIDER_LABEL_W = 240f;

		private const int HK_MAX_MATCHES = 8;

		private const int HK_MATCH_COLS = 4;

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)_instance != (Object)null)
				{
					return _instance._open;
				}
				return false;
			}
		}

		public MegaMenu(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Awake()
		{
			_instance = this;
		}

		public static void BindConfig(ConfigFile cfg)
		{
			ToggleKey = cfg.Bind<KeyCode>("Menu", "ToggleKey", (KeyCode)282, "Key that opens / closes the in-game megamod menu.");
		}

		private void Update()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(_assignTarget))
			{
				KeyCode val = ScanFirstKey();
				if ((int)val != 0)
				{
					ApplyAssignedKey(val);
					_assignTarget = "";
				}
				return;
			}
			if (Input.GetKeyDown(ToggleKey.Value))
			{
				Toggle();
			}
			if (_open && Input.GetKeyDown((KeyCode)27))
			{
				Toggle();
			}
			if (!_open || !string.IsNullOrEmpty(_assignTarget))
			{
				return;
			}
			string inputString = Input.inputString;
			if (inputString.Length <= 0)
			{
				return;
			}
			bool flag = _amountEditTarget >= 0 && _amountEditTarget < _hotkeyRows.Count;
			bool flag2 = _configIntId.Length > 0 && _configIntEntry != null;
			bool flag3 = _configFloatId.Length > 0 && _configFloatEntry != null;
			for (int i = 0; i < inputString.Length; i++)
			{
				char c = inputString[i];
				if (flag)
				{
					switch (c)
					{
					case '\b':
						if (_amountEditBuffer.Length > 0)
						{
							_amountEditBuffer = _amountEditBuffer.Substring(0, _amountEditBuffer.Length - 1);
						}
						break;
					case '\n':
					case '\r':
						CommitAmountEdit();
						flag = false;
						break;
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						if (_amountEditBuffer.Length < 6)
						{
							_amountEditBuffer += c;
						}
						break;
					}
					continue;
				}
				if (flag2)
				{
					switch (c)
					{
					case '\b':
						if (_configIntBuffer.Length > 0)
						{
							_configIntBuffer = _configIntBuffer.Substring(0, _configIntBuffer.Length - 1);
						}
						break;
					case '\n':
					case '\r':
						CommitConfigIntEdit();
						flag2 = false;
						break;
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						if (_configIntBuffer.Length < 6)
						{
							_configIntBuffer += c;
						}
						break;
					}
					continue;
				}
				if (flag3)
				{
					switch (c)
					{
					case '\b':
						if (_configFloatBuffer.Length > 0)
						{
							_configFloatBuffer = _configFloatBuffer.Substring(0, _configFloatBuffer.Length - 1);
						}
						continue;
					case '\n':
					case '\r':
						CommitConfigFloatEdit();
						flag3 = false;
						continue;
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						if (_configFloatBuffer.Length < 8)
						{
							_configFloatBuffer += c;
							continue;
						}
						break;
					}
					if (c == '.' && !_configFloatBuffer.Contains('.') && _configFloatBuffer.Length < 7)
					{
						if (_configFloatBuffer.Length == 0)
						{
							_configFloatBuffer = "0";
						}
						_configFloatBuffer += c;
					}
					continue;
				}
				switch (c)
				{
				case '\b':
					if (_itemSearch.Length > 0)
					{
						_itemSearch = _itemSearch.Substring(0, _itemSearch.Length - 1);
					}
					break;
				case ' ':
				case '!':
				case '"':
				case '#':
				case '$':
				case '%':
				case '&':
				case '\'':
				case '(':
				case ')':
				case '*':
				case '+':
				case ',':
				case '-':
				case '.':
				case '/':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case ':':
				case ';':
				case '<':
				case '=':
				case '>':
				case '?':
				case '@':
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
				case '[':
				case '\\':
				case ']':
				case '^':
				case '_':
				case '`':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
				case '{':
				case '|':
				case '}':
				case '~':
					_itemSearch += c;
					break;
				}
			}
		}

		private void CommitAmountEdit()
		{
			if (_amountEditTarget < 0 || _amountEditTarget >= _hotkeyRows.Count)
			{
				_amountEditTarget = -1;
				_amountEditBuffer = "";
				return;
			}
			if (_amountEditBuffer.Length > 0 && int.TryParse(_amountEditBuffer, out var result) && result >= 1)
			{
				_hotkeyRows[_amountEditTarget].Amount = result;
				FlushHotkeyRowsToConfig();
			}
			_amountEditTarget = -1;
			_amountEditBuffer = "";
		}

		private void CommitConfigIntEdit()
		{
			if (_configIntEntry != null && _configIntBuffer.Length > 0 && int.TryParse(_configIntBuffer, out var result))
			{
				_configIntEntry.Value = Mathf.Clamp(result, _configIntMin, _configIntMax);
			}
			_configIntId = "";
			_configIntBuffer = "";
			_configIntEntry = null;
		}

		private void CommitConfigFloatEdit()
		{
			if (_configFloatEntry != null && _configFloatBuffer.Length > 0 && float.TryParse(_configFloatBuffer, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				_configFloatEntry.Value = Mathf.Clamp(result, _configFloatMin, _configFloatMax);
			}
			_configFloatId = "";
			_configFloatBuffer = "";
			_configFloatEntry = null;
		}

		private void CommitAnyIntEdit()
		{
			if (_amountEditTarget >= 0)
			{
				CommitAmountEdit();
			}
			if (_configIntId.Length > 0)
			{
				CommitConfigIntEdit();
			}
			if (_configFloatId.Length > 0)
			{
				CommitConfigFloatEdit();
			}
		}

		private void Toggle()
		{
			//IL_0075: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			_open = !_open;
			if (_open)
			{
				_savedTimeScale = Time.timeScale;
				_savedCursorLock = Cursor.lockState;
				_savedCursorVisible = Cursor.visible;
				Time.timeScale = 0f;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				SuppressGuiRaycasters();
				if (!_hotkeyRowsLoaded)
				{
					LoadHotkeyRows();
				}
			}
			else
			{
				CommitAnyIntEdit();
				Time.timeScale = _savedTimeScale;
				Cursor.lockState = _savedCursorLock;
				Cursor.visible = _savedCursorVisible;
				RestoreGuiRaycasters();
				_assignTarget = "";
			}
		}

		private void SuppressGuiRaycasters()
		{
			try
			{
				Il2CppArrayBase<GraphicRaycaster> val = Object.FindObjectsOfType<GraphicRaycaster>();
				for (int i = 0; i < val.Length; i++)
				{
					GraphicRaycaster val2 = val[i];
					if ((Object)(object)val2 != (Object)null && ((Behaviour)val2).enabled)
					{
						_suppressedRaycasters.Add(val2);
						((Behaviour)val2).enabled = false;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[MegaMenu] could not suppress GraphicRaycasters: " + ex.Message));
			}
		}

		private void RestoreGuiRaycasters()
		{
			for (int i = 0; i < _suppressedRaycasters.Count; i++)
			{
				GraphicRaycaster val = _suppressedRaycasters[i];
				if ((Object)(object)val != (Object)null)
				{
					try
					{
						((Behaviour)val).enabled = true;
					}
					catch
					{
					}
				}
			}
			_suppressedRaycasters.Clear();
		}

		private static KeyCode ScanFirstKey()
		{
			//IL_0016: 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)
			string[] hotkeys = EnumLists.Hotkeys;
			for (int i = 0; i < hotkeys.Length; i++)
			{
				if (Enum.TryParse<KeyCode>(hotkeys[i], out KeyCode result) && Input.GetKeyDown(result))
				{
					return result;
				}
			}
			return (KeyCode)0;
		}

		private void ApplyAssignedKey(KeyCode k)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (_assignTarget == "menu")
			{
				ToggleKey.Value = k;
			}
			else if (_assignTarget.StartsWith("hotkey:") && int.TryParse(_assignTarget.Substring(7), out result) && result >= 0 && result < _hotkeyRows.Count)
			{
				_hotkeyRows[result].Key = ((object)(KeyCode)(ref k)).ToString();
				FlushHotkeyRowsToConfig();
			}
		}

		private void OnGUI()
		{
			if (!_open)
			{
				return;
			}
			try
			{
				Draw();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[MegaMenu] OnGUI: " + ex));
			}
		}

		private void Draw()
		{
			//IL_006c: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: 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_0203: Unknown result type (might be due to invalid IL or missing references)
			EnsureStyles();
			float num = Mathf.Min(720f, (float)(Screen.width - 80));
			float num2 = Mathf.Min(820f, (float)(Screen.height - 80));
			float num3 = ((float)Screen.width - num) / 2f;
			float num4 = ((float)Screen.height - num2) / 2f;
			GUI.depth = -1000;
			GUI.Box(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), GUIContent.none, _backdrop);
			GUI.Box(new Rect(num3, num4, num, num2), GUIContent.none, _box);
			GUI.Label(new Rect(num3 + 14f, num4 + 8f, num - 28f, 32f), "Rizzotto Megamod", _header);
			GUI.Label(new Rect(num3 + 14f, num4 + 38f, num - 28f, 18f), "Leaderboard submission is permanently disabled while this mod is installed.", _danger);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num3 + 14f, num4 + 60f + 6f, num - 28f, num2 - 60f - 50f - 12f);
			float num5 = ((Rect)(ref val)).width - 20f;
			float num6 = MeasureContentHeight(num5);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(0f, 0f, num5, num6);
			_scroll = GUI.BeginScrollView(val, _scroll, val2);
			DrawContent(((Rect)(ref val2)).width);
			GUI.EndScrollView();
			float num7 = num4 + num2 - 50f + 8f;
			string text = ((!string.IsNullOrEmpty(_assignTarget)) ? "Press any key to bind..." : "Changes apply and save automatically.");
			GUIStyle val3 = ((!string.IsNullOrEmpty(_assignTarget)) ? _danger : _dim);
			GUI.Label(new Rect(num3 + 14f, num7, num - 140f, 30f), text, val3);
			if (GUI.Button(new Rect(num3 + num - 110f, num7, 100f, 30f), "Close", _accent))
			{
				Toggle();
			}
		}

		private float MeasureContentHeight(float canvasW)
		{
			float num = 94f;
			ModFeature[] features = Plugin.Features;
			if (features == null)
			{
				return num + 28f;
			}
			for (int i = 0; i < features.Length; i++)
			{
				num += FeatureCardHeight(features[i], canvasW);
				num += 4f;
			}
			return num + 20f;
		}

		private float MeasureDescriptionHeight(string description, float innerW)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (_dim == null || string.IsNullOrEmpty(description))
			{
				return 28f;
			}
			try
			{
				return _dim.CalcHeight(new GUIContent(description), innerW);
			}
			catch
			{
				return 28f;
			}
		}

		private float FeatureCardHeight(ModFeature f, float canvasW)
		{
			float num = 40f;
			if (!_expanded.TryGetValue(f.Id, out var value) || !value)
			{
				return num + 4f;
			}
			float num2 = MeasureDescriptionHeight(f.Description, canvasW - 20f);
			num += num2 + 6f;
			switch (f.Id)
			{
			case "BurgerStat":
				num += 92f;
				break;
			case "BaldForest":
				num += 32f;
				break;
			case "PumpkinStacker":
				num += 32f;
				break;
			case "EliteSlayer":
				num += SliderRowHeight("Boost multiplier (1.0 = Rizzo's video):") + 4f + 280f + 8f;
				break;
			case "ItemUpgrader":
				num += SliderRowHeight("Upgrade chance multiplier (1.0 = original):") + 4f;
				break;
			case "PotLuck":
				num += SliderRowHeight("Pot luck multiplier (1.0 = original 0.5%-8% curve):") + 4f;
				break;
			case "UnlimitedBanish":
				num += 64f;
				break;
			case "TomeUncap":
				num += 288f;
				break;
			case "MultiPassive":
				num += 232f;
				break;
			case "BossStatDoubler":
				num += 64f;
				break;
			case "BossPassiveLottery":
				num += 64f;
				break;
			case "ItemHotkeys":
				num += 32f;
				if (_itemSearch.Length > 0)
				{
					num += 66f;
				}
				if (_hotkeyRows.Count > 0)
				{
					num += 20f;
				}
				num += (float)_hotkeyRows.Count * 30f + 8f;
				break;
			}
			return num + 8f;
		}

		private void DrawContent(float canvasW)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			DrawCard(0f, num, canvasW, 90f);
			GUI.Label(new Rect(8f, num + 8f, canvasW - 16f, 32f), "Menu Hotkey", _header);
			GUI.Label(new Rect(8f, num + 48f, 220f, 28f), "Open/close the menu with:", _label);
			Rect rect = new Rect(232f, num + 48f, 140f, 28f);
			KeyCode value = ToggleKey.Value;
			DrawAssignKeyButton(rect, "menu", ((object)(KeyCode)(ref value)).ToString());
			num += 94f;
			ModFeature[] features = Plugin.Features;
			if (features == null)
			{
				GUI.Label(new Rect(0f, num, canvasW, 28f), "(features not initialised — Plugin.Load() may have failed)", _danger);
				return;
			}
			for (int i = 0; i < features.Length; i++)
			{
				float num2 = FeatureCardHeight(features[i], canvasW);
				try
				{
					DrawFeatureCard(0f, num, canvasW, num2, features[i]);
				}
				catch (Exception ex)
				{
					GUI.Label(new Rect(8f, num + 4f, canvasW - 16f, 28f), "[error rendering " + features[i].Id + "]: " + ex.Message, _danger);
					Plugin.Log.LogError((object)("[MegaMenu] feature " + features[i].Id + ": " + ex));
				}
				num += num2 + 4f;
			}
		}

		private void DrawCard(float x, float y, float w, float h)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			GUI.Box(new Rect(x, y, w, h), GUIContent.none, _box);
		}

		private void DrawFeatureCard(float x, float y, float w, float h, ModFeature f)
		{
			//IL_002e: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			DrawCard(x, y, w, h);
			if (f.Enabled == null)
			{
				GUI.Label(new Rect(x + 8f, y + 4f, w - 16f, 28f), "[" + f.Id + "] config not bound", _danger);
				return;
			}
			if (!_expanded.ContainsKey(f.Id))
			{
				_expanded[f.Id] = false;
			}
			float num = y + 6f;
			string text = (f.Enabled.Value ? "[ON]" : "[OFF]");
			GUIStyle val = (f.Enabled.Value ? _accent : _btn);
			if (GUI.Button(new Rect(x + 8f, num, 64f, 28f), text, val))
			{
				f.Enabled.Value = !f.Enabled.Value;
				if (f.Enabled.Value)
				{
					_expanded[f.Id] = true;
				}
			}
			if (GUI.Button(new Rect(x + 78f, num, w - 78f - 88f, 28f), "  " + f.DisplayName, _btn))
			{
				_expanded[f.Id] = !_expanded[f.Id];
			}
			bool flag = _expanded[f.Id];
			if (GUI.Button(new Rect(x + w - 86f, num, 78f, 28f), flag ? "Hide" : "Show", _btn))
			{
				_expanded[f.Id] = !flag;
			}
			if (!flag)
			{
				return;
			}
			float num2 = y + 28f + 12f;
			float num3 = MeasureDescriptionHeight(f.Description, w - 20f);
			GUI.Label(new Rect(x + 10f, num2, w - 20f, num3), f.Description, _dim);
			float num4 = num2 + num3 + 6f;
			string id = f.Id;
			if (id == null)
			{
				return;
			}
			switch (id.Length)
			{
			case 10:
				switch (id[1])
				{
				case 'u':
					if (id == "BurgerStat" && f is BurgerStatFeature burgerStatFeature && burgerStatFeature.ChancePerStack != null)
					{
						GUI.Label(new Rect(x + 10f, num4, w - 20f, 56f), "Vanilla: 2% chance + 1% per extra Borgar stacked. This mod is linear — each Borgar adds the slider value to the total chance.", _dim);
						DrawTypeableFloatRow(x + 10f, num4 + 56f + 4f, w - 20f, "Chance per Borgar (0.0 - 1.0):", "burger_chance", burgerStatFeature.ChancePerStack, 0f, 1f);
					}
					break;
				case 'a':
					if (id == "BaldForest" && f is BaldForestFeature baldForestFeature && baldForestFeature.ExtraShrines != null)
					{
						DrawTypeableIntRow(x + 10f, num4, w - 20f, "Extra bald heads per Forest stage:", "baldforest_extra", baldForestFeature.ExtraShrines, 0, 20);
					}
					break;
				}
				break;
			case 11:
				switch (id[0])
				{
				case 'E':
					if (id == "EliteSlayer" && f is EliteSlayerFeature eliteSlayerFeature && eliteSlayerFeature.BoostMultiplier != null && eliteSlayerFeature.AllowedStatList != null)
					{
						DrawSliderRow(x + 10f, num4, w - 20f, "Boost multiplier (1.0 = Rizzo's video):", eliteSlayerFeature.BoostMultiplier, 0.1f, 2f, 0.1f);
						float num5 = SliderRowHeight("Boost multiplier (1.0 = Rizzo's video):");
						DrawCheckList(x + 10f, num4 + num5 + 4f, w - 20f, "Allowed stats:", EnumLists.EStats, eliteSlayerFeature.AllowedStatList);
					}
					break;
				case 'I':
					if (id == "ItemHotkeys" && f is ItemHotkeysFeature itemHotkeysFeature && itemHotkeysFeature.Bindings != null)
					{
						DrawHotkeyEditor(x + 10f, num4, w - 20f, itemHotkeysFeature.Bindings);
					}
					break;
				}
				break;
			case 12:
				switch (id[0])
				{
				case 'I':
					if (id == "ItemUpgrader" && f is ItemUpgraderFeature itemUpgraderFeature && itemUpgraderFeature.ChanceMultiplier != null)
					{
						DrawSliderRow(x + 10f, num4, w - 20f, "Upgrade chance multiplier (1.0 = original):", itemUpgraderFeature.ChanceMultiplier, 0.1f, 2f, 0.1f);
					}
					break;
				case 'M':
					if (id == "MultiPassive" && f is MultiPassiveFeature multiPassiveFeature && multiPassiveFeature.ActivePassives != null)
					{
						DrawCheckList(x + 10f, num4, w - 20f, "Characters whose passives to grant:", EnumLists.Characters, multiPassiveFeature.ActivePassives);
					}
					break;
				}
				break;
			case 15:
				switch (id[0])
				{
				case 'U':
					if (id == "UnlimitedBanish" && f is UnlimitedBanishFeature unlimitedBanishFeature && unlimitedBanishFeature.Infinite != null && unlimitedBanishFeature.BanishCount != null)
					{
						DrawBoolRow(x + 10f, num4, w - 20f, "Infinite (∞ banishes per stage)", unlimitedBanishFeature.Infinite);
						bool flag2 = !unlimitedBanishFeature.Infinite.Value;
						DrawTypeableIntRow(x + 10f, num4 + 28f + 4f, w - 20f, "Banishes per stage:", "banish_count", unlimitedBanishFeature.BanishCount, 1, 999, !flag2);
					}
					break;
				case 'B':
					if (id == "BossStatDoubler" && f is BossStatDoublerFeature bossStatDoublerFeature && bossStatDoublerFeature.OnlyMajorBosses != null && bossStatDoublerFeature.ShowPopup != null)
					{
						DrawBoolRow(x + 10f, num4, w - 20f, "Only major bosses (stage bosses + final)", bossStatDoublerFeature.OnlyMajorBosses);
						DrawBoolRow(x + 10f, num4 + 28f + 4f, w - 20f, "Show Balance Shrine picker on each kill (manual pick)", bossStatDoublerFeature.ShowPopup);
					}
					break;
				}
				break;
			case 14:
				if (id == "PumpkinStacker" && f is PumpkinStackerFeature pumpkinStackerFeature && pumpkinStackerFeature.StartingPumpkins != null)
				{
					DrawTypeableIntRow(x + 10f, num4, w - 20f, "Starting Pumpkins:", "pumpkin_start", pumpkinStackerFeature.StartingPumpkins, 0, 100);
				}
				break;
			case 7:
				if (id == "PotLuck" && f is PotLuckFeature potLuckFeature && potLuckFeature.LuckMultiplier != null)
				{
					DrawSliderRow(x + 10f, num4, w - 20f, "Pot luck multiplier (1.0 = original 0.5%-8% curve):", potLuckFeature.LuckMultiplier, 0.1f, 2f, 0.1f);
				}
				break;
			case 18:
				if (id == "BossPassiveLottery" && f is BossPassiveLotteryFeature bossPassiveLotteryFeature && bossPassiveLotteryFeature.OnlyMajorBosses != null && bossPassiveLotteryFeature.ExcludeOwnPassive != null)
				{
					DrawBoolRow(x + 10f, num4, w - 20f, "Only major bosses (stage bosses + final)", bossPassiveLotteryFeature.OnlyMajorBosses);
					DrawBoolRow(x + 10f, num4 + 28f + 4f, w - 20f, "Skip your own character's passive", bossPassiveLotteryFeature.ExcludeOwnPassive);
				}
				break;
			case 9:
				if (id == "TomeUncap" && f is TomeUncapFeature tomeUncapFeature && tomeUncapFeature.UncappedTomes != null)
				{
					DrawCheckList(x + 10f, num4, w - 20f, "Tomes to uncap:", EnumLists.Tomes, tomeUncapFeature.UncappedTomes, EnumLists.HiddenTomes);
				}
				break;
			case 8:
			case 13:
			case 16:
			case 17:
				break;
			}
		}

		private void DrawBoolRow(float x, float y, float w, string label, ConfigEntry<bool> entry)
		{
			//IL_003a: 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)
			string text = (entry.Value ? "[ON]" : "[OFF]");
			GUIStyle val = (entry.Value ? _accent : _btn);
			if (GUI.Button(new Rect(x, y, 64f, 28f), text, val))
			{
				entry.Value = !entry.Value;
			}
			GUI.Label(new Rect(x + 72f, y, w - 80f, 28f), label, _label);
		}

		private void DrawFloatRow(float x, float y, float w, string label, ConfigEntry<float> entry)
		{
			//IL_000e: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(x, y, w - 200f, 28f), label, _label);
			GUI.Label(new Rect(x + w - 196f, y, 80f, 28f), entry.Value.ToString("0.00", CultureInfo.InvariantCulture), _label);
			if (GUI.Button(new Rect(x + w - 110f, y, 32f, 28f), "−", _btn))
			{
				entry.Value = Mathf.Max(0f, entry.Value - 0.01f);
			}
			if (GUI.Button(new Rect(x + w - 74f, y, 32f, 28f), "+", _btn))
			{
				entry.Value += 0.01f;
			}
			if (GUI.Button(new Rect(x + w - 38f, y, 36f, 28f), "++", _btn))
			{
				entry.Value += 0.1f;
			}
		}

		private float SliderRowHeight(string label)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (_label == null || string.IsNullOrEmpty(label))
			{
				return 28f;
			}
			try
			{
				return Mathf.Max(28f, _label.CalcHeight(new GUIContent(label), 240f));
			}
			catch
			{
				return 28f;
			}
		}

		private void DrawSliderRow(float x, float y, float w, string label, ConfigEntry<float> entry, float min, float max, float step)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			float num = w - 240f - 60f - 8f;
			if (num < 60f)
			{
				num = 60f;
			}
			float num2 = SliderRowHeight(label);
			GUI.Label(new Rect(x, y, 240f, num2), label, _label);
			float num3 = GUI.HorizontalSlider(new Rect(x + 240f, y + (num2 - 12f) / 2f, num, 12f), entry.Value, min, max);
			num3 = Mathf.Round(num3 / step) * step;
			num3 = Mathf.Clamp(num3, min, max);
			if (Mathf.Abs(num3 - entry.Value) > step / 4f)
			{
				entry.Value = num3;
			}
			GUI.Label(new Rect(x + 240f + num + 4f, y, 60f, num2), num3.ToString("0.0", CultureInfo.InvariantCulture) + "x", _label);
		}

		private void DrawTypeableIntRow(float x, float y, float w, string label, string id, ConfigEntry<int> entry, int min, int max, bool disabled = false)
		{
			//IL_000e: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(x, y, w - 200f, 28f), label, disabled ? _dim : _label);
			bool flag = _configIntId == id && !disabled;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x + w - 196f, y, 80f, 28f);
			GUI.Box(val, GUIContent.none, _textfield);
			string text = ((!flag) ? entry.Value.ToString() : ((_configIntBuffer.Length == 0) ? "|" : (_configIntBuffer + "|")));
			GUI.Label(new Rect(((Rect)(ref val)).x + 6f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 12f, ((Rect)(ref val)).height), text, disabled ? _dim : _label);
			if (!disabled && GUI.Button(val, GUIContent.none, GUIStyle.none))
			{
				if (flag)
				{
					CommitConfigIntEdit();
				}
				else
				{
					CommitAnyIntEdit();
					_configIntId = id;
					_configIntBuffer = "";
					_configIntEntry = entry;
					_configIntMin = min;
					_configIntMax = max;
				}
			}
			if (disabled)
			{
				GUI.Label(new Rect(x + w - 110f, y, 32f, 28f), "−", _dim);
				GUI.Label(new Rect(x + w - 74f, y, 32f, 28f), "+", _dim);
				GUI.Label(new Rect(x + w - 38f, y, 36f, 28f), "++", _dim);
				return;
			}
			if (GUI.Button(new Rect(x + w - 110f, y, 32f, 28f), "−", _btn) && entry.Value > min)
			{
				CommitAnyIntEdit();
				entry.Value -= 1;
			}
			if (GUI.Button(new Rect(x + w - 74f, y, 32f, 28f), "+", _btn) && entry.Value < max)
			{
				CommitAnyIntEdit();
				entry.Value += 1;
			}
			if (GUI.Button(new Rect(x + w - 38f, y, 36f, 28f), "++", _btn) && entry.Value < max)
			{
				CommitAnyIntEdit();
				entry.Value = Mathf.Min(max, entry.Value + 10);
			}
		}

		private void DrawTypeableFloatRow(float x, float y, float w, string label, string id, ConfigEntry<float> entry, float min, float max, float stepSmall = 0.01f, float stepLarge = 0.1f, string format = "0.00")
		{
			//IL_000e: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(x, y, w - 200f, 28f), label, _label);
			bool flag = _configFloatId == id;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x + w - 196f, y, 80f, 28f);
			GUI.Box(val, GUIContent.none, _textfield);
			string text = ((!flag) ? entry.Value.ToString(format, CultureInfo.InvariantCulture) : ((_configFloatBuffer.Length == 0) ? "|" : (_configFloatBuffer + "|")));
			GUI.Label(new Rect(((Rect)(ref val)).x + 6f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 12f, ((Rect)(ref val)).height), text, _label);
			if (GUI.Button(val, GUIContent.none, GUIStyle.none))
			{
				if (flag)
				{
					CommitConfigFloatEdit();
				}
				else
				{
					CommitAnyIntEdit();
					_configFloatId = id;
					_configFloatBuffer = "";
					_configFloatEntry = entry;
					_configFloatMin = min;
					_configFloatMax = max;
				}
			}
			if (GUI.Button(new Rect(x + w - 110f, y, 32f, 28f), "−", _btn) && entry.Value > min)
			{
				CommitAnyIntEdit();
				entry.Value = Mathf.Max(min, entry.Value - stepSmall);
			}
			if (GUI.Button(new Rect(x + w - 74f, y, 32f, 28f), "+", _btn) && entry.Value < max)
			{
				CommitAnyIntEdit();
				entry.Value = Mathf.Min(max, entry.Value + stepSmall);
			}
			if (GUI.Button(new Rect(x + w - 38f, y, 36f, 28f), "++", _btn) && entry.Value < max)
			{
				CommitAnyIntEdit();
				entry.Value = Mathf.Min(max, entry.Value + stepLarge);
			}
		}

		private void DrawIntRow(float x, float y, float w, string label, ConfigEntry<int> entry)
		{
			//IL_000e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(x, y, w - 200f, 28f), label, _label);
			GUI.Label(new Rect(x + w - 196f, y, 80f, 28f), entry.Value.ToString(), _label);
			if (GUI.Button(new Rect(x + w - 110f, y, 32f, 28f), "−", _btn) && entry.Value > 0)
			{
				entry.Value -= 1;
			}
			if (GUI.Button(new Rect(x + w - 74f, y, 32f, 28f), "+", _btn))
			{
				entry.Value += 1;
			}
			if (GUI.Button(new Rect(x + w - 38f, y, 36f, 28f), "++", _btn))
			{
				entry.Value += 10;
			}
		}

		private void DrawCheckList(float x, float y, float w, string label, string[] options, ConfigEntry<string> csv, HashSet<string> hidden = null)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(new Rect(x, y, w, 28f), label, _label);
			string obj = csv.Value ?? "";
			HashSet<string> hashSet = new HashSet<string>();
			string[] array = obj.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					hashSet.Add(text);
				}
			}
			float num = (w - 16f) / 3f;
			bool flag = false;
			int num2 = 0;
			foreach (string text2 in options)
			{
				if (hidden != null && hidden.Contains(text2))
				{
					continue;
				}
				int num3 = num2 / 3;
				int num4 = num2 % 3;
				num2++;
				float num5 = x + (float)num4 * num;
				float num6 = y + 28f + 4f + (float)num3 * 30f;
				bool flag2 = hashSet.Contains(text2);
				string text3 = (flag2 ? "[X] " : "[ ] ") + text2;
				GUIStyle val = (flag2 ? _accent : _btn);
				if (GUI.Button(new Rect(num5, num6, num - 6f, 28f), text3, val))
				{
					if (flag2)
					{
						hashSet.Remove(text2);
					}
					else
					{
						hashSet.Add(text2);
					}
					flag = true;
				}
			}
			if (!flag)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int k = 0; k < options.Length; k++)
			{
				if (hashSet.Contains(options[k]))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append(options[k]);
				}
			}
			csv.Value = stringBuilder.ToString();
		}

		private void DrawAssignKeyButton(Rect rect, string targetId, string currentKey)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _assignTarget == targetId;
			string text = (flag ? "Press a key..." : currentKey);
			GUIStyle val = (flag ? _accent : _btn);
			if (GUI.Button(rect, text, val))
			{
				if (!flag)
				{
					CommitAnyIntEdit();
				}
				_assignTarget = (flag ? "" : targetId);
			}
		}

		private void LoadHotkeyRows()
		{
			_hotkeyRows.Clear();
			ItemHotkeysFeature itemHotkeysFeature = null;
			ModFeature[] features = Plugin.Features;
			if (features != null)
			{
				for (int i = 0; i < features.Length; i++)
				{
					if (features[i].Id == "ItemHotkeys")
					{
						itemHotkeysFeature = (ItemHotkeysFeature)features[i];
						break;
					}
				}
			}
			if (itemHotkeysFeature == null || itemHotkeysFeature.Bindings == null)
			{
				_hotkeyRowsLoaded = true;
				return;
			}
			string[] array = (itemHotkeysFeature.Bindings.Value ?? "").Split(';');
			for (int j = 0; j < array.Length; j++)
			{
				string text = array[j].Trim();
				if (text.Length != 0)
				{
					string[] array2 = text.Split(':');
					if (array2.Length == 3 && int.TryParse(array2[1].Trim(), out var result))
					{
						string text2 = array2[0].Trim();
						_hotkeyRows.Add(new HotkeyRow
						{
							Item = text2,
							Amount = result,
							Key = array2[2].Trim(),
							Search = text2
						});
					}
				}
			}
			_hotkeyRowsLoaded = true;
		}

		private void DrawHotkeyEditor(float x, float y, float w, ConfigEntry<string> entry)
		{
			//IL_001c: 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_00c6: 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_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f2: Unknown result type (might be due to invalid IL or missing references)
			if (!_hotkeyRowsLoaded)
			{
				LoadHotkeyRows();
			}
			float num = y;
			GUI.Label(new Rect(x, num, 64f, 28f), "Search:", _label);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x + 68f, num, w - 68f - 90f, 28f);
			GUI.Box(val, GUIContent.none, _textfield);
			bool num2 = _itemSearch.Length > 0;
			string text = (num2 ? (_itemSearch + "|") : "(type to filter items — Backspace to delete)");
			GUIStyle val2 = (num2 ? _label : _dim);
			GUI.Label(new Rect(((Rect)(ref val)).x + 6f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 12f, ((Rect)(ref val)).height), text, val2);
			if (num2 && GUI.Button(new Rect(x + w - 84f, num, 80f, 28f), "Clear", _btn))
			{
				_itemSearch = "";
			}
			num += 32f;
			if (_itemSearch.Length > 0)
			{
				int num3 = 0;
				float num4 = w / 4f;
				for (int i = 0; i < EnumLists.Items.Length; i++)
				{
					if (num3 >= 8)
					{
						break;
					}
					if (Matches(EnumLists.Items[i], _itemSearch))
					{
						int num5 = num3 % 4;
						int num6 = num3 / 4;
						float num7 = x + (float)num5 * num4;
						float num8 = num + (float)num6 * 30f;
						if (GUI.Button(new Rect(num7, num8, num4 - 4f, 28f), EnumLists.Items[i], _btn))
						{
							_hotkeyRows.Add(new HotkeyRow
							{
								Item = EnumLists.Items[i],
								Amount = 1,
								Key = "F9",
								Search = EnumLists.Items[i]
							});
							FlushHotkeyRowsToConfig();
							_itemSearch = "";
						}
						num3++;
					}
				}
				if (num3 == 0)
				{
					GUI.Label(new Rect(x, num, w, 28f), "(no items match \"" + _itemSearch + "\")", _dim);
					num += 32f;
				}
				else
				{
					int num9 = (num3 + 4 - 1) / 4;
					num += (float)num9 * 30f + 6f;
				}
			}
			if (_hotkeyRows.Count > 0)
			{
				GUI.Label(new Rect(x, num, 220f, 18f), "Item", _dim);
				GUI.Label(new Rect(x + 230f, num, 130f, 18f), "Amount", _dim);
				GUI.Label(new Rect(x + 370f, num, 130f, 18f), "Hotkey", _dim);
				num += 20f;
			}
			Rect val3 = default(Rect);
			for (int j = 0; j < _hotkeyRows.Count; j++)
			{
				HotkeyRow hotkeyRow = _hotkeyRows[j];
				GUI.Label(new Rect(x, num, 220f, 28f), hotkeyRow.Item, _label);
				bool flag = _amountEditTarget == j;
				((Rect)(ref val3))..ctor(x + 230f, num, 56f, 28f);
				GUI.Box(val3, GUIContent.none, _textfield);
				string text2 = ((!flag) ? hotkeyRow.Amount.ToString() : ((_amountEditBuffer.Length == 0) ? "|" : (_amountEditBuffer + "|")));
				GUI.Label(new Rect(((Rect)(ref val3)).x + 6f, ((Rect)(ref val3)).y, ((Rect)(ref val3)).width - 12f, ((Rect)(ref val3)).height), text2, _label);
				if (GUI.Button(val3, GUIContent.none, GUIStyle.none))
				{
					if (flag)
					{
						CommitAmountEdit();
					}
					else
					{
						if (_amountEditTarget >= 0)
						{
							CommitAmountEdit();
						}
						_amountEditTarget = j;
						_amountEditBuffer = "";
					}
				}
				if (GUI.Button(new Rect(x + 290f, num, 28f, 28f), "−", _btn) && hotkeyRow.Amount > 1)
				{
					if (_amountEditTarget >= 0)
					{
						CommitAmountEdit();
					}
					hotkeyRow.Amount--;
					FlushHotkeyRowsToConfig();
				}
				if (GUI.Button(new Rect(x + 322f, num, 28f, 28f), "+", _btn))
				{
					if (_amountEditTarget >= 0)
					{
						CommitAmountEdit();
					}
					hotkeyRow.Amount++;
					FlushHotkeyRowsToConfig();
				}
				DrawAssignKeyButton(new Rect(x + 370f, num, 110f, 28f), "hotkey:" + j, hotkeyRow.Key);
				if (GUI.Button(new Rect(x + 488f, num, 30f, 28f), "X", _btn))
				{
					if (_amountEditTarget == j)
					{
						_amountEditTarget = -1;
						_amountEditBuffer = "";
					}
					else if (_amountEditTarget > j)
					{
						_amountEditTarget--;
					}
					_hotkeyRows.RemoveAt(j);
					FlushHotkeyRowsToConfig();
					break;
				}
				num += 30f;
			}
		}

		private static bool Matches(string itemName, string query)
		{
			if (string.IsNullOrEmpty(query))
			{
				return true;
			}
			string value = query.ToLowerInvariant();
			if (itemName.ToLowerInvariant().Contains(value))
			{
				return true;
			}
			string[][] itemAliases = EnumLists.ItemAliases;
			foreach (string[] array in itemAliases)
			{
				if (array.Length == 2 && !(array[1] != itemName) && array[0].ToLowerInvariant().Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsExactItem(string s)
		{
			for (int i = 0; i < EnumLists.Items.Length; i++)
			{
				if (EnumLists.Items[i] == s)
				{
					return true;
				}
			}
			return false;
		}

		private void FlushHotkeyRowsToConfig()
		{
			ItemHotkeysFeature itemHotkeysFeature = null;
			ModFeature[] features = Plugin.Features;
			if (features != null)
			{
				for (int i = 0; i < features.Length; i++)
				{
					if (features[i].Id == "ItemHotkeys")
					{
						itemHotkeysFeature = (ItemHotkeysFeature)features[i];
						break;
					}
				}
			}
			if (itemHotkeysFeature == null || itemHotkeysFeature.Bindings == null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int j = 0; j < _hotkeyRows.Count; j++)
			{
				HotkeyRow hotkeyRow = _hotkeyRows[j];
				if (!string.IsNullOrEmpty(hotkeyRow.Item) && hotkeyRow.Amount >= 1 && !string.IsNullOrEmpty(hotkeyRow.Key))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(';');
					}
					stringBuilder.Append(hotkeyRow.Item).Append(':').Append(hotkeyRow.Amount)
						.Append(':')
						.Append(hotkeyRow.Key);
				}
			}
			string text = stringBuilder.ToString();
			if (text != itemHotkeysFeature.Bindings.Value)
			{
				itemHotkeysFeature.Bindings.Value = text;
			}
		}

		private static Texture2D SolidTex(Color c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0025: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, c);
			val.Apply();
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)val);
			return val;
		}

		private static RectOffset NewRectOffset(int l, int r, int t, int b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new RectOffset
			{
				left = l,
				right = r,
				top = t,
				bottom = b
			};
		}

		private void EnsureStyles()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: 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_02cb: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			if (!_stylesReady || _box == null || _box.normal == null || (Object)(object)_box.normal.background == (Object)null || _accent == null || _accent.normal == null || (Object)(object)_accent.normal.background == (Object)null || _backdrop == null || _backdrop.normal == null || (Object)(object)_backdrop.normal.background == (Object)null)
			{
				_stylesReady = true;
				GUIStyle val = new GUIStyle();
				val.normal.background = SolidTex(new Color(0f, 0f, 0f, 0.6f));
				_backdrop = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.box);
				val2.normal.background = SolidTex(new Color(0.1f, 0.11f, 0.14f, 1f));
				val2.padding = NewRectOffset(10, 10, 8, 8);
				_box = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 22,
					fontStyle = (FontStyle)1
				};
				val3.normal.textColor = new Color(1f, 0.6f, 0.2f);
				_header = val3;
				GUIStyle val4 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 14
				};
				val4.normal.textColor = new Color(0.92f, 0.92f, 0.95f);
				val4.wordWrap = true;
				val4.richText = true;
				val4.alignment = (TextAnchor)3;
				_label = val4;
				GUIStyle val5 = new GUIStyle(_label);
				val5.normal.textColor = new Color(0.6f, 0.62f, 0.68f);
				_dim = val5;
				_btn = new GUIStyle(GUI.skin.button)
				{
					fontSize = 13,
					padding = NewRectOffset(8, 8, 4, 4),
					alignment = (TextAnchor)4
				};
				GUIStyle val6 = new GUIStyle(_btn)
				{
					fontStyle = (FontStyle)1
				};
				val6.normal.background = SolidTex(new Color(1f, 0.6f, 0.2f));
				val6.normal.textColor = Color.black;
				val6.hover.background = SolidTex(new Color(1f, 0.7f, 0.3f));
				val6.hover.textColor = Color.black;
				val6.active.background = SolidTex(new Color(0.9f, 0.55f, 0.18f));
				val6.active.textColor = Color.black;
				_accent = val6;
				GUIStyle val7 = new GUIStyle(_label);
				val7.normal.textColor = new Color(0.9f, 0.35f, 0.35f);
				val7.fontSize = 11;
				_danger = val7;
				GUIStyle val8 = new GUIStyle(GUI.skin.textField)
				{
					fontSize = 14
				};
				val8.normal.textColor = new Color(0.95f, 0.95f, 0.97f);
				val8.padding = NewRectOffset(6, 6, 4, 4);
				val8.alignment = (TextAnchor)3;
				_textfield = val8;
			}
		}
	}
	public abstract class ModFeature
	{
		public ConfigEntry<bool> Enabled { get; private set; }

		public abstract string Id { get; }

		public abstract string DisplayName { get; }

		public abstract string Description { get; }

		public virtual bool BlocksLeaderboard => false;

		public virtual void BindConfig(ConfigFile cfg)
		{
			Enabled = cfg.Bind<bool>(Id, "Enabled", false, Description);
		}

		public abstract void ApplyPatches(Harmony harmony);
	}
	[BepInPlugin("com.rizzotto.megamod", "Rizzotto Megamod", "0.5.3")]
	public class Plugin : BasePlugin
	{
		public const string GUID = "com.rizzotto.megamod";

		public const string VERSION = "0.5.3";

		internal static ManualLogSource Log;

		internal static ConfigFile Cfg;

		internal static ModFeature[] Features;

		public static bool IsEnabled<T>() where T : ModFeature
		{
			if (Features == null)
			{
				return false;
			}
			for (int i = 0; i < Features.Length; i++)
			{
				if (Features[i] is T val)
				{
					if (val.Enabled != null)
					{
						return val.Enabled.Value;
					}
					return false;
				}
			}
			return false;
		}

		public override void Load()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BasePlugin)this).Log;
			Cfg = ((BasePlugin)this).Config;
			Diagnostics.Begin("0.5.3");
			Harmony harmony = new Harmony("com.rizzotto.megamod");
			Diagnostics.TryApplyLeaderboardBlocker(harmony);
			RewiredInputBlocker.Init(harmony);
			Features = new ModFeature[16]
			{
				new LevelUncapFeature(),
				new AllWeaponsFeature(),
				new BurgerStatFeature(),
				new BaldForestFeature(),
				new TomeUncapFeature(),
				new MultiPassiveFeature(),
				new EliteSlayerFeature(),
				new EscalatingDifficultyFeature(),
				new ItemHotkeysFeature(),
				new ItemUpgraderFeature(),
				new OneShotFeature(),
				new PotLuckFeature(),
				new PumpkinStackerFeature(),
				new UnlimitedBanishFeature(),
				new BossStatDoublerFeature(),
				new BossPassiveLotteryFeature()
			};
			ModFeature[] features = Features;
			foreach (ModFeature modFeature in features)
			{
				try
				{
					modFeature.BindConfig(Cfg);
				}
				catch (Exception ex)
				{
					Diagnostics.Error("BindConfig failed for " + modFeature.Id, ex);
				}
			}
			Diagnostics.Line("");
			Diagnostics.Line("Feature load (patches always register; each checks its own Enabled at runtime):");
			int num = 0;
			features = Features;
			for (int i = 0; i < features.Length; i++)
			{
				if (Diagnostics.TryApply(features[i], harmony))
				{
					num++;
				}
			}
			Diagnostics.Finish(num, Features.Length);
			bool flag = default(bool);
			try
			{
				MegaMenu.BindConfig(Cfg);
				ClassInjector.RegisterTypeInIl2Cpp<MegaMenu>();
				GameObject val = new GameObject("Megamod_MegaMenu")
				{
					hideFlags = (HideFlags)61
				};
				val.AddComponent<MegaMenu>();
				Object.DontDestroyOnLoad((Object)val);
				ManualLogSource log = Log;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Press [");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<KeyCode>(MegaMenu.ToggleKey.Value);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("] in-game to open the megamod menu.");
				}
				log.LogInfo(val2);
			}
			catch (Exception ex2)
			{
				ManualLogSource log2 = Log;
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Failed to spawn MegaMenu: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<Exception>(ex2);
				}
				log2.LogError(val3);
			}
			Log.LogInfo((object)"Leaderboard submission is permanently disabled while this mod is installed.");
		}
	}
	public static class RewiredInputBlocker
	{
		public static void Init(Harmony harmony)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			try
			{
				Type type = AccessTools.TypeByName("Rewired.Player");
				if (type == null)
				{
					Plugin.Log.LogWarning((object)"[RewiredBlocker] Rewired.Player not found; keyboard leak fix disabled");
					return;
				}
				int num = 0;
				num += PatchAll(harmony, type, "GetButton", typeof(bool));
				num += PatchAll(harmony, type, "GetButtonDown", typeof(bool));
				num += PatchAll(harmony, type, "GetButtonUp", typeof(bool));
				num += PatchAll(harmony, type, "GetAxis", typeof(float));
				num += PatchAll(harmony, type, "GetAxisRaw", typeof(float));
				num += PatchAll(harmony, type, "GetNegativeButton", typeof(bool));
				num += PatchAll(harmony, type, "GetNegativeButtonDown", typeof(bool));
				num += PatchAll(harmony, type, "GetNegativeButtonUp", typeof(bool));
				ManualLogSource log = Plugin.Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(56, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[RewiredBlocker] patched ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" Rewired.Player input method(s)");
				}
				log.LogInfo(val);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[RewiredBlocker] init failed: " + ex));
			}
		}

		private static int PatchAll(Harmony harmony, Type type, string methodName, Type returnType)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			int num = 0;
			try
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name != methodName || methodInfo.ReturnType != returnType || methodInfo.IsGenericMethodDefinition)
					{
						continue;
					}
					MethodInfo methodInfo2;
					if (returnType == typeof(bool))
					{
						methodInfo2 = AccessTools.Method(typeof(RewiredInputBlocker), "BoolPrefix", (Type[])null, (Type[])null);
					}
					else
					{
						if (!(returnType == typeof(float)))
						{
							continue;
						}
						methodInfo2 = AccessTools.Method(typeof(RewiredInputBlocker), "FloatPrefix", (Type[])null, (Type[])null);
					}
					try
					{
						harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						num++;
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("[RewiredBlocker] failed " + type.Name + "." + methodName + ": " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[RewiredBlocker] reflect " + methodName + ": " + ex2.Message));
			}
			return num;
		}

		private static bool BoolPrefix(ref bool __result)
		{
			if (!MegaMenu.IsOpen)
			{
				return true;
			}
			__result = false;
			return false;
		}

		private static bool FloatPrefix(ref float __result)
		{
			if (!MegaMenu.IsOpen)
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
}
namespace RizzottoMegamod.Features
{
	public sealed class AllWeaponsFeature : ModFeature
	{
		private static class Patches
		{
			private static IntPtr _expandedForPicker;

			[HarmonyPatch(typeof(InventoryUtility), "GetNumMaxWeaponSlots")]
			[HarmonyPostfix]
			private static void GetNumMaxWeaponSlots_Postfix(ref int __result)
			{
				if (Plugin.IsEnabled<AllWeaponsFeature>())
				{
					GameManager instance = GameManager.Instance;
					if ((Object)(object)((instance != null) ? instance.player : null) != (Object)null)
					{
						__result = 31;
					}
				}
			}

			[HarmonyPatch(typeof(InventoryUtility), "GetNumAvailableWeaponSlots")]
			[HarmonyPostfix]
			private static void GetNumAvailableWeaponSlots_Postfix(ref int __result)
			{
				if (Plugin.IsEnabled<AllWeaponsFeature>())
				{
					GameManager instance = GameManager.Instance;
					if ((Object)(object)((instance != null) ? instance.player : null) != (Object)null)
					{
						__result = 31;
					}
				}
			}

			[HarmonyPatch(typeof(InventoryHud), "Refresh")]
			[HarmonyPrefix]
			private static void InventoryHudRefresh_Prefix(InventoryHud __instance)
			{
				if (!Plugin.IsEnabled<AllWeaponsFeature>())
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				if ((Object)(object)((instance != null) ? instance.player : null) == (Object)null)
				{
					return;
				}
				int numAvailableWeaponSlots = InventoryUtility.GetNumAvailableWeaponSlots();
				int count = __instance.weaponContainers.Count;
				if (count >= numAvailableWeaponSlots)
				{
					return;
				}
				for (int i = count; i < numAvailableWeaponSlots; i++)
				{
					InventoryItemPrefabUI component = Object.Instantiate<GameObject>(__instance.itemContainerPrefab, __instance.weaponParent).GetComponent<InventoryItemPrefabUI>();
					if ((Object)(object)component != (Object)null)
					{
						__instance.weaponContainers.Add(component);
					}
				}
			}

			[HarmonyPatch(typeof(UpgradeInventoryUI), "Refresh")]
			[HarmonyPrefix]
			private static void UpgradeInventoryUIRefresh_Prefix(UpgradeInventoryUI __instance)
			{
				if (!Plugin.IsEnabled<AllWeaponsFeature>())
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				if ((Object)(object)((instance != null) ? instance.player : null) == (Object)null)
				{
					return;
				}
				int numAvailableWeaponSlots = InventoryUtility.GetNumAvailableWeaponSlots();
				int count = __instance.weaponContainers.Count;
				if (count >= numAvailableWeaponSlots)
				{
					return;
				}
				for (int i = count; i < numAvailableWeaponSlots; i++)
				{
					InventoryItemPrefabUI component = Object.Instantiate<GameObject>(__instance.itemContainerPrefab, __instance.weaponParent).GetComponent<InventoryItemPrefabUI>();
					if ((Object)(object)component != (Object)null)
					{
						__instance.weaponContainers.Add(component);
					}
				}
			}

			[HarmonyPatch(typeof(UpgradePicker), "ShuffleUpgrades")]
			[HarmonyPrefix]
			private static void ShuffleUpgrades_Prefix(UpgradePicker __instance, EEncounter encounterType)
			{
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Expected O, but got Unknown
				//IL_0008: 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_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.IsEnabled<AllWeaponsFeature>() || (int)encounterType != 0 || ((Il2CppObjectBase)__instance).Pointer == _expandedForPicker || __instance.buttons == null || ((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons).Length < 3)
				{
					return;
				}
				try
				{
					GameObject gameObject = ((Component)((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons)[0]).gameObject;
					Transform parent = gameObject.transform.parent;
					if (((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons).Length < 4)
					{
						GameObject obj = Object.Instantiate<GameObject>(gameObject, parent);
						((Object)obj).name = "UpgradeButton_Modded";
						UpgradeButton component = obj.GetComponent<UpgradeButton>();
						if ((Object)(object)component == (Object)null)
						{
							return;
						}
						component.upgradePicker = __instance;
						Il2CppReferenceArray<UpgradeButton> val = new Il2CppReferenceArray<UpgradeButton>((long)(((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons).Length + 1));
						for (int i = 0; i < ((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons).Length; i++)
						{
							((Il2CppArrayBase<UpgradeButton>)(object)val)[i] = ((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons)[i];
						}
						((Il2CppArrayBase<UpgradeButton>)(object)val)[((Il2CppArrayBase<UpgradeButton>)(object)__instance.buttons).Length] = component;
						__instance.buttons = val;
					}
					RectTransform component2 = gameObject.GetComponent<RectTransform>();
					float num;
					if (!((Object)(object)component2 != (Object)null))
					{
						num = 150f;
					}
					else
					{
						Rect rect = component2.rect;
						num = ((Rect)(ref rect)).height;
					}
					float num2 = num + 10f;
					Transform val2 = parent;
					while ((Object)(object)val2 != (Object)null)
					{
						string name = ((Object)val2).name;
						if (name == "Content" || name == "W_Offers")
						{
							RectTransform component3 = ((Component)val2).GetComponent<RectTransform>();
							if ((Object)(object)component3 != (Object)null)
							{
								Vector2 sizeDelta = component3.sizeDelta;
								component3.sizeDelta = new Vector2(sizeDelta.x, sizeDelta.y + num2);
							}
						}
						val2 = val2.parent;
					}
					_expandedForPicker = ((Il2CppObjectBase)__instance).Pointer;
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(35, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("[AllWeapons] expand picker failed: ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
					}
					log.LogError(val3);
				}
			}

			[HarmonyPatch(typeof(InventoryUtility), "GetRandomUpgrades")]
			[HarmonyPostfix]
			private static void GetRandomUpgrades_Postfix(List<IUpgradable> __result)
			{
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Invalid comparison between Unknown and I4
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Invalid comparison between Unknown and I4
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Invalid comparison between Unknown and I4
				//IL_0139: 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_0226: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_026d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.IsEnabled<AllWeaponsFeature>() || __result == null || __result.Count == 0)
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				MyPlayer val = ((instance != null) ? instance.player : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				AlwaysManager instance2 = AlwaysManager.Instance;
				DataManager val2 = ((instance2 != null) ? instance2.dataManager : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				WeaponInventory weaponInventory = val.inventory.weaponInventory;
				TomeInventory tomeInventory = val.inventory.tomeInventory;
				int num = 0;
				int num2 = 0;
				for (int i = 0; i < __result.Count; i++)
				{
					IUpgradable obj = __result[i];
					if ((Object)(object)((obj != null) ? ((Il2CppObjectBase)obj).TryCast<WeaponData>() : null) != (Object)null)
					{
						num++;
						continue;
					}
					IUpgradable obj2 = __result[i];
					if ((Object)(object)((obj2 != null) ? ((Il2CppObjectBase)obj2).TryCast<TomeData>() : null) != (Object)null)
					{
						num2++;
					}
				}
				HashSet<UnlockableBase> banishedUpgradables = RunUnlockables.banishedUpgradables;
				List<WeaponData> list = new List<WeaponData>();
				List<WeaponData> allWeapons = val2.GetAllWeapons();
				bool flag = weaponInventory.GetNumWeapons() < InventoryUtility.GetNumAvailableWeaponSlots();
				for (int j = 0; j < allWeapons.Count; j++)
				{
					WeaponData val3 = allWeapons[j];
					if ((int)val3.eWeapon == 8 || (int)val3.eWeapon == 17 || ((int)val3.eWeapon != 20 && !((Il2CppObjectBase)val3).Cast<UnlockableBase>().isEnabled) || !(weaponInventory.weapons.ContainsKey(val3.eWeapon) || flag))
					{
						continue;
					}
					bool flag2 = false;
					for (int k = 0; k < __result.Count; k++)
					{
						IUpgradable obj3 = __result[k];
						WeaponData val4 = ((obj3 != null) ? ((Il2CppObjectBase)obj3).TryCast<WeaponData>() : null);
						if ((Object)(object)val4 != (Object)null && val4.eWeapon == val3.eWeapon)
						{
							flag2 = true;
							break;
						}
					}
					if (!flag2)
					{
						list.Add(val3);
					}
				}
				List<TomeData> list2 = new List<TomeData>();
				List<TomeData> allTomes = val2.GetAllTomes();
				bool flag3 = InventoryUtility.GetNumAvailableTomeSlots() > tomeInventory.tomeLevels.Count;
				for (int l = 0; l < allTomes.Count; l++)
				{
					TomeData val5 = allTomes[l];
					if ((banishedUpgradables != null && banishedUpgradables.Contains(((Il2CppObjectBase)val5).Cast<UnlockableBase>())) || !((Il2CppObjectBase)val5).Cast<UnlockableBase>().isEnabled)
					{
						continue;
					}
					if (tomeInventory.HasTome(val5.eTome))
					{
						int tomeLevel = tomeInventory.GetTomeLevel(val5.eTome);
						int maxLevel = val5.GetMaxLevel();
						if (tomeLevel >= maxLevel)
						{
							continue;
						}
					}
					else if (!flag3)
					{
						continue;
					}
					bool flag4 = false;
					for (int m = 0; m < __result.Count; m++)
					{
						IUpgradable obj4 = __result[m];
						TomeData val6 = ((obj4 != null) ? ((Il2CppObjectBase)obj4).TryCast<TomeData>() : null);
						if ((Object)(object)val6 != (Object)null && val6.eTome == val5.eTome)
						{
							flag4 = true;
							break;
						}
					}
					if (!flag4)
					{
						list2.Add(val5);
					}
				}
				while (__result.Count < 4)
				{
					if (num2 < 2 && list2.Count > 0)
					{
						int index = Random.Range(0, list2.Count);
						__result.Add(((Il2CppObjectBase)list2[index]).Cast<IUpgradable>());
						list2.RemoveAt(index);
						num2++;
						continue;
					}
					if (num < 2 && list.Count > 0)
					{
						int index2 = Random.Range(0, list.Count);
						__result.Add(((Il2CppObjectBase)list[index2]).Cast<IUpgradable>());
						list.RemoveAt(index2);
						num++;
						continue;
					}
					if (list2.Count > 0)
					{
						int index3 = Random.Range(0, list2.Count);
						__result.Add(((Il2CppObjectBase)list2[index3]).Cast<IUpgradable>());
						list2.RemoveAt(index3);
						num2++;
						continue;
					}
					if (list.Count <= 0)
					{
						break;
					}
					int index4 = Random.Range(0, list.Count);
					__result.Add(((Il2CppObjectBase)list[index4]).Cast<IUpgradable>());
					list.RemoveAt(index4);
					num++;
				}
				num = 0;
				num2 = 0;
				for (int n = 0; n < __result.Count; n++)
				{
					IUpgradable obj5 = __result[n];
					if ((Object)(object)((obj5 != null) ? ((Il2CppObjectBase)obj5).TryCast<WeaponData>() : null) != (Object)null)
					{
						num++;
						continue;
					}
					IUpgradable obj6 = __result[n];
					if ((Object)(object)((obj6 != null) ? ((Il2CppObjectBase)obj6).TryCast<TomeData>() : null) != (Object)null)
					{
						num2++;
					}
				}
				while (num > 2 && num2 < 2 && list2.Count > 0)
				{
					for (int num3 = __result.Count - 1; num3 >= 0; num3--)
					{
						IUpgradable obj7 = __result[num3];
						if ((Object)(object)((obj7 != null) ? ((Il2CppObjectBase)obj7).TryCast<WeaponData>() : null) != (Object)null)
						{
							int index5 = Random.Range(0, list2.Count);
							__result[num3] = ((Il2CppObjectBase)list2[index5]).Cast<IUpgradable>();
							list2.RemoveAt(index5);
							num--;
							num2++;
							break;
						}
					}
				}
				while (num2 > 2 && num < 2 && list.Count > 0)
				{
					for (int num4 = __result.Count - 1; num4 >= 0; num4--)
					{
						IUpgradable obj8 = __result[num4];
						if ((Object)(object)((obj8 != null) ? ((Il2CppObjectBase)obj8).TryCast<TomeData>() : null) != (Object)null)
						{
							int index6 = Random.Range(0, list.Count);
							__result[num4] = ((Il2CppObjectBase)list[index6]).Cast<IUpgradable>();
							list.RemoveAt(index6);
							num2--;
							num++;
							break;
						}
					}
				}
			}
		}

		public override string Id => "AllWeapons";

		public override string DisplayName => "All Weapons";

		public override string Description => "Expands the inventory HUD to fit all 31 weapons, gives 4 upgrade choices (2 weapons + 2 tomes), and unlocks all weapon slots from the start.";

		public override bool BlocksLeaderboard => true;

		public override void ApplyPatches(Harmony harmony)
		{
			harmony.PatchAll(typeof(Patches));
		}
	}
	public sealed class BaldForestFeature : ModFeature
	{
		private static class Patches
		{
			private static GameObject _balancePrefab = null;

			private static readonly HashSet<IntPtr> OurShrines = new HashSet<IntPtr>();

			private static InteractableShrineBalance _lastInteracted = null;

			private static int _interactCount;

			private static MyPlayer _lastPlayer = null;

			private static readonly Dictionary<int, EStat> ForcedStats = new Dictionary<int, EStat>
			{
				{
					1,
					(EStat)0
				},
				{
					4,
					(EStat)32
				}
			};

			[HarmonyPatch(typeof(SpawnInteractables), "SpawnShrines")]
			[HarmonyPrefix]
			private static void SpawnShrines_Prefix()
			{
				if (!Plugin.IsEnabled<BaldForestFeature>())
				{
					return;
				}
				OurShrines.Clear();
				if ((Object)(object)_balancePrefab != (Object)null)
				{
					return;
				}
				AlwaysManager instance = AlwaysManager.Instance;
				DataManager val = ((instance != null) ? instance.dataManager : null);
				if (((val != null) ? val.maps : null) == null)
				{
					return;
				}
				for (int i = 0; i < val.maps.Count; i++)
				{
					MapData val2 = val.maps[i];
					if (((val2 != null) ? val2.shrines : null) == null)
					{
						continue;
					}
					for (int j = 0; j < ((Il2CppArrayBase<GameObject>)(object)val2.shrines).Length; j++)
					{
						GameObject val3 = ((Il2CppArrayBase<GameObject>)(object)val2.shrines)[j];
						if ((Object)(object)val3 != (Object)null && (Object)(object)val3.GetComponent(Il2CppType.From(typeof(InteractableShrineBalance))) != (Object)null)
						{
							_balancePrefab = val3;
							return;
						}
					}
				}
			}

			[HarmonyPatch(typeof(SpawnInteractables), "SpawnShrines")]
			[HarmonyPostfix]
			private static void SpawnShrines_Postfix()
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Invalid comparison between Unknown and I4
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0221: Unknown result type (might be due to invalid IL or missing references)
				//IL_0242: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: 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)
				if (!Plugin.IsEnabled<BaldForestFeature>())
				{
					return;
				}
				MapData currentMap = MapController.currentMap;
				if ((Object)(object)currentMap == (Object)null || (int)currentMap.eMap != 1 || (Object)(object)_balancePrefab == (Object)null)
				{
					return;
				}
				Il2CppArrayBase<BaseInteractable> val = Object.FindObjectsOfType<BaseInteractable>();
				List<Vector3> list = new List<Vector3>();
				Transform val2 = null;
				for (int i = 0; i < val.Length; i++)
				{
					BaseInteractable val3 = val[i];
					string text = ((Object)val3).name ?? "";
					bool flag = text.Contains("Shady") || text.Contains("shady");
					if (text.Contains("Shrine") || text.Contains("shrine") || text.Contains("Moai") || text.Contains("moai") || text.Contains("Charge") || text.Contains("charge"))
					{
						list.Add(((Component)val3).transform.position);
						if ((Object)(object)val2 == (Object)null)
						{
							val2 = ((Component)val3).transform.parent;
						}
					}
					else if (flag)
					{
						list.Add(((Component)val3).transform.position);
					}
				}
				if (list.Count == 0)
				{
					return;
				}
				int num = Mathf.Clamp((_instance?.ExtraShrines?.Value).GetValueOrDefault(5), 0, 20);
				if (num == 0)
				{
					return;
				}
				int count = list.Count;
				int num2 = ((count <= num) ? 1 : (count / num));
				RaycastHit val7 = default(RaycastHit);
				for (int j = 0; j < num; j++)
				{
					int index = j * num2 % count;
					Vector3 val4 = list[index];
					float num3 = Random.Range(0f, 360f) * ((float)Math.PI / 180f);
					float num4 = Random.Range(15f, 30f);
					Vector3 val5 = val4 + new Vector3(Mathf.Cos(num3) * num4, 0f, Mathf.Sin(num3) * num4);
					Vector3 val6 = val5;
					if (Physics.Raycast(new Vector3(val5.x, val5.y + 50f, val5.z), Vector3.down, ref val7, 100f))
					{
						val6 = ((RaycastHit)(ref val7)).point;
					}
					GameObject val8 = Object.Instantiate<GameObject>(_balancePrefab, val6, _balancePrefab.transform.rotation);
					if ((Object)(object)val2 != (Object)null)
					{
						val8.transform.SetParent(val2);
					}
					InteractableShrineBalance component = val8.GetComponent<InteractableShrineBalance>();
					if ((Object)(object)component != (Object)null)
					{
						OurShrines.Add(((Il2CppObjectBase)component).Pointer);
					}
				}
			}

			[HarmonyPatch(typeof(InteractableShrineBalance), "Interact")]
			[HarmonyPrefix]
			private static void Interact_Prefix(InteractableShrineBalance __instance)
			{
				if (!Plugin.IsEnabled<BaldForestFeature>())
				{
					return;
				}
				_lastInteracted = __instance;
				if (!OurShrines.Contains(((Il2CppObjectBase)__instance).Pointer))
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				MyPlayer val = ((instance != null) ? instance.player : null);
				if ((Object)(object)val != (Object)(object)_lastPlayer)
				{
					_lastPlayer = val;
					if (MapController.GetStageIndex() == 0)
					{
						_interactCount = 0;
					}
				}
				_interactCount++;
			}

			[HarmonyPatch(typeof(EncounterUtility), "GetBalanceShrineOffers")]
			[HarmonyPostfix]
			private static void GetBalanceOffers_Postfix(List<EncounterOffer> __result)
			{
				//IL_0062: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Expected O, but got Unknown
				//IL_00b4: 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_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Expected O, but got Unknown
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				if (!Plugin.IsEnabled<BaldForestFeature>() || __result == null || __result.Count == 0)
				{
					return;
				}
				InteractableShrineBalance lastInteracted = _lastInteracted;
				if ((Object)(object)lastInteracted == (Object)null || !OurShrines.Contains(((Il2CppObjectBase)lastInteracted).Pointer) || !ForcedStats.TryGetValue(_interactCount, out var value))
				{
					return;
				}
				EncounterOffer val = __result[0];
				if (((val != null) ? val.effects : null) == null)
				{
					return;
				}
				EStat stat = value;
				for (int i = 0; i < ((Il2CppArrayBase<EffectStat>)(object)val.effects).Length; i++)
				{
					EffectStat val2 = ((Il2CppArrayBase<