using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace WhiteKnuckleTrainer
{
	internal sealed class EspOverlay : MonoBehaviour
	{
		private readonly List<Item_Object> _targets = new List<Item_Object>();

		private float _nextRefresh;

		private GUIStyle? _style;

		private void Update()
		{
			if (!(Time.unscaledTime < _nextRefresh))
			{
				_nextRefresh = Time.unscaledTime + 1f;
				_targets.Clear();
				_targets.AddRange(from item in Object.FindObjectsOfType<Item_Object>()
					where (Object)(object)item != (Object)null && item.itemData != null
					select item);
			}
		}

		private void OnGUI()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0081: 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: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			WhiteKnuckleTrainerPlugin instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance == null || !instance.Features.EspEnabled || NativePauseMenuPatch.IsOpen)
			{
				return;
			}
			ENT_Player player = ENT_Player.GetPlayer();
			Camera main = Camera.main;
			if ((Object)(object)player == (Object)null || (Object)(object)main == (Object)null)
			{
				return;
			}
			if (_style == null)
			{
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontSize = 12,
					fontStyle = (FontStyle)1
				};
				val.normal.textColor = Color.white;
				_style = val;
			}
			TrainerFeatures features = instance.Features;
			int num = 0;
			RaycastHit val2 = default(RaycastHit);
			foreach (Item_Object item in from target in _targets
				where (Object)(object)target != (Object)null
				orderby Vector3.SqrMagnitude(((Component)target).transform.position - ((Component)player).transform.position)
				select target)
			{
				if (num >= features.EspMaximumLabels)
				{
					break;
				}
				Vector3 position = ((Component)item).transform.position;
				float num2 = Vector3.Distance(((Component)player).transform.position, position);
				if (!(num2 > features.EspMaximumDistance) && (!features.EspOcclusionCheck || !Physics.Linecast(((Component)main).transform.position, position, ref val2) || !((Object)(object)((RaycastHit)(ref val2)).transform != (Object)(object)((Component)item).transform) || ((RaycastHit)(ref val2)).transform.IsChildOf(((Component)item).transform)))
				{
					Vector3 val3 = main.WorldToScreenPoint(position);
					bool flag = val3.z > 0f && val3.x >= 0f && val3.x <= (float)Screen.width && val3.y >= 0f && val3.y <= (float)Screen.height;
					if ((!features.EspOnlyOnScreen || flag) && flag)
					{
						string text = (string.IsNullOrWhiteSpace(item.itemData.itemName) ? ((Object)item).name : item.itemData.itemName);
						GUI.Label(new Rect(val3.x - 90f, (float)Screen.height - val3.y - 15f, 180f, 30f), "[" + text + "]\n" + num2.ToString("0") + " m", _style);
						num++;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(CL_GameManager), "Pause")]
	internal static class NativePauseMenuPatch
	{
		private const string ModMenuButtonName = "WhiteKnuckleTrainer_ModMenu";

		private const string ModMenuGapName = "WhiteKnuckleTrainer_ModMenuGap";

		private const string GeneratedPrefix = "WhiteKnuckleTrainer_Generated_";

		private const int PageSize = 6;

		private static bool _reportedMissingTemplate;

		private static Transform? _layout;

		private static Transform? _settingsTemplate;

		private static readonly List<(GameObject Object, bool WasActive)> OriginalEntries = new List<(GameObject, bool)>();

		private static readonly List<GameObject> GeneratedEntries = new List<GameObject>();

		internal static bool IsOpen { get; private set; }

		private static void Postfix(CL_GameManager __instance)
		{
			try
			{
				EnsureInjected(__instance);
			}
			catch (Exception arg)
			{
				WhiteKnuckleTrainerPlugin.Instance?.LogNativeError($"[Trainer] Native pause-menu injection failed: {arg}");
			}
		}

		internal static void ResetSceneState()
		{
			Close();
			_reportedMissingTemplate = false;
			_layout = null;
			_settingsTemplate = null;
		}

		internal static bool TryOpen(CL_GameManager gameManager)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			WhiteKnuckleTrainerPlugin instance = WhiteKnuckleTrainerPlugin.Instance;
			if ((Object)(object)instance == (Object)null || !EnsureInjected(gameManager) || (Object)(object)_layout == (Object)null || (Object)(object)_settingsTemplate == (Object)null)
			{
				return false;
			}
			if (IsOpen)
			{
				return true;
			}
			OriginalEntries.Clear();
			foreach (Transform item in _layout)
			{
				Transform val = item;
				OriginalEntries.Add((((Component)val).gameObject, ((Component)val).gameObject.activeSelf));
				((Component)val).gameObject.SetActive(false);
			}
			IsOpen = true;
			ShowHome(instance);
			instance.LogNativeInfo("[Trainer] Native trainer menu opened.");
			return true;
		}

		internal static void Close()
		{
			if (!IsOpen)
			{
				return;
			}
			ClearGeneratedEntries();
			foreach (var (val, active) in OriginalEntries)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetActive(active);
				}
			}
			OriginalEntries.Clear();
			IsOpen = false;
			RebuildLayout();
			WhiteKnuckleTrainerPlugin.Instance?.LogNativeInfo("[Trainer] Returned to the native pause menu.");
		}

		private static bool EnsureInjected(CL_GameManager gameManager)
		{
			WhiteKnuckleTrainerPlugin instance = WhiteKnuckleTrainerPlugin.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)gameManager.pauseMenu == (Object)null)
			{
				return false;
			}
			Transform val = FindPauseLayout(gameManager.pauseMenu.transform);
			if ((Object)(object)val == (Object)null)
			{
				ReportMissingTemplate(instance, "Pause Layout");
				return false;
			}
			_layout = val;
			_settingsTemplate = val.Find("Settings");
			Transform val2 = val.Find("Gap.01");
			if ((Object)(object)_settingsTemplate == (Object)null || (Object)(object)val2 == (Object)null)
			{
				ReportMissingTemplate(instance, "Settings button or Gap.01 layout entry");
				return false;
			}
			if ((Object)(object)val.Find("WhiteKnuckleTrainer_ModMenu") != (Object)null)
			{
				return true;
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)val2).gameObject, val);
			((Object)obj).name = "WhiteKnuckleTrainer_ModMenuGap";
			obj.SetActive(true);
			obj.transform.SetSiblingIndex(val.childCount - 1);
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)_settingsTemplate).gameObject, val);
			((Object)obj2).name = "WhiteKnuckleTrainer_ModMenu";
			obj2.SetActive(true);
			obj2.transform.SetSiblingIndex(val.childCount - 1);
			ConfigureNativeButton(obj2, "MOD MENU", delegate
			{
				TryOpen(gameManager);
			}, enabled: true);
			RebuildLayout();
			instance.LogNativeInfo("[Trainer] Native MOD MENU button injected successfully.");
			return true;
		}

		private static void ShowHome(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("WHITE KNUCKLE TRAINER", null, enabled: false);
			if (CommandConsole.hasCheated)
			{
				AddButton("CHEAT MODE ACTIVE — LEADERBOARDS DISABLED", null, enabled: false);
			}
			AddButton("PLAYER", delegate
			{
				ShowPlayer(plugin);
			});
			AddButton("MOVEMENT", delegate
			{
				ShowMovement(plugin);
			});
			AddButton("ITEMS", delegate
			{
				ShowItemCategories(plugin, 0);
			});
			AddButton("PERKS", delegate
			{
				ShowPerks(plugin, 0);
			});
			AddButton("ESP / ITEM RADAR", delegate
			{
				ShowEsp(plugin);
			});
			AddButton("COSMETICS", delegate
			{
				ShowCosmetics(plugin);
			});
			AddButton("TOOLS", delegate
			{
				ShowTools(plugin);
			});
			AddButton("BACK TO PAUSE MENU", Close);
			FinishPage();
		}

		private static void ShowPlayer(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("PLAYER", null, enabled: false);
			AddButton("GOD MODE: " + OnOff(plugin.Features.GodMode), delegate
			{
				plugin.Features.ToggleGodMode();
				ShowPlayer(plugin);
			});
			AddButton("NO FALL DAMAGE: " + OnOff(plugin.Features.NoFallDamage), delegate
			{
				plugin.Features.ToggleNoFallDamage();
				ShowPlayer(plugin);
			});
			AddButton("INFINITE STAMINA: " + OnOff(plugin.InfiniteStamina), delegate
			{
				plugin.ToggleInfiniteStamina();
				ShowPlayer(plugin);
			});
			AddButton("INFINITE AMMO / PITONS: " + OnOff(plugin.InfiniteAmmoAndThrowables), delegate
			{
				plugin.ToggleInfiniteAmmoAndThrowables();
				ShowPlayer(plugin);
			});
			AddButton("NO ENCUMBRANCE: " + OnOff(plugin.Features.NoEncumbrance), delegate
			{
				plugin.Features.ToggleNoEncumbrance();
				ShowPlayer(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowHome(plugin);
			});
			FinishPage();
		}

		private static void ShowMovement(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("MOVEMENT", null, enabled: false);
			AddButton("INFINITE JUMPS: " + OnOff(plugin.InfiniteJumps), delegate
			{
				plugin.ToggleInfiniteJumps();
				ShowMovement(plugin);
			});
			AddButton("MULTI-JUMP COUNT: " + plugin.Features.MultiJumpCount, delegate
			{
				ShowMultiJump(plugin);
			});
			AddButton("MOVEMENT SPEED: " + plugin.Features.MovementMultiplier.ToString("0.00") + "x", delegate
			{
				ShowMovementTuning(plugin);
			});
			AddButton("JUMP HEIGHT: " + plugin.Features.JumpHeightMultiplier.ToString("0.00") + "x", delegate
			{
				ShowMovementTuning(plugin);
			});
			AddButton("GRAVITY: " + plugin.Features.GravityMultiplier.ToString("0.00") + "x", delegate
			{
				ShowMovementTuning(plugin);
			});
			AddButton("TIME SCALE: " + plugin.Features.TimeScaleMultiplier.ToString("0.00") + "x", delegate
			{
				ShowTime(plugin);
			});
			AddButton("MODE CONTROLS", delegate
			{
				ShowMovementModes(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowHome(plugin);
			});
			FinishPage();
		}

		private static void ShowMultiJump(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("MULTI-JUMP COUNT: " + plugin.Features.MultiJumpCount, null, enabled: false);
			AddButton("DECREASE", delegate
			{
				plugin.Features.AdjustMultiJump(-1);
				ShowMultiJump(plugin);
			});
			AddButton("INCREASE", delegate
			{
				plugin.Features.AdjustMultiJump(1);
				ShowMultiJump(plugin);
			});
			AddButton("1 = VANILLA AIR JUMP ALLOWANCE", null, enabled: false);
			AddButton("INFINITE JUMPS OVERRIDES THIS VALUE", null, enabled: false);
			AddButton("BACK", delegate
			{
				ShowMovement(plugin);
			});
			FinishPage();
		}

		private static void ShowMovementTuning(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("MOVEMENT SPEED: " + plugin.Features.MovementMultiplier.ToString("0.00") + "x", delegate
			{
				plugin.Features.AdjustMovement(0.25f);
				ShowMovementTuning(plugin);
			});
			AddButton("JUMP HEIGHT: " + plugin.Features.JumpHeightMultiplier.ToString("0.00") + "x", delegate
			{
				plugin.Features.AdjustJumpHeight(0.25f);
				ShowMovementTuning(plugin);
			});
			AddButton("GRAVITY: " + plugin.Features.GravityMultiplier.ToString("0.00") + "x", delegate
			{
				plugin.Features.AdjustGravity(-0.25f);
				ShowMovementTuning(plugin);
			});
			AddButton("RESET MOVEMENT SPEED", delegate
			{
				plugin.Features.AdjustMovement(1f - plugin.Features.MovementMultiplier);
				ShowMovementTuning(plugin);
			});
			AddButton("RESET JUMP HEIGHT", delegate
			{
				plugin.Features.AdjustJumpHeight(1f - plugin.Features.JumpHeightMultiplier);
				ShowMovementTuning(plugin);
			});
			AddButton("RESET GRAVITY", delegate
			{
				plugin.Features.AdjustGravity(1f - plugin.Features.GravityMultiplier);
				ShowMovementTuning(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowMovement(plugin);
			});
			FinishPage();
		}

		private static void ShowTime(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("TIME SCALE: " + plugin.Features.TimeScaleMultiplier.ToString("0.00") + "x", null, enabled: false);
			AddButton("SLOWER", delegate
			{
				plugin.Features.AdjustTimeScale(-0.1f);
				ShowTime(plugin);
			});
			AddButton("FASTER", delegate
			{
				plugin.Features.AdjustTimeScale(0.1f);
				ShowTime(plugin);
			});
			AddButton("RESET TO 1.00x", delegate
			{
				plugin.Features.AdjustTimeScale(1f - plugin.Features.TimeScaleMultiplier);
				ShowTime(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowMovement(plugin);
			});
			FinishPage();
		}

		private static void ShowMovementModes(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("FLY MODE: " + OnOff(plugin.Features.Fly), delegate
			{
				plugin.Features.ToggleFly();
				ShowMovementModes(plugin);
			});
			AddButton("NOCLIP: " + OnOff(plugin.Features.Noclip), delegate
			{
				plugin.Features.ToggleNoclip();
				ShowMovementModes(plugin);
			});
			AddButton("CLIMB ANYWHERE: " + OnOff(plugin.Features.ClimbAnywhere), delegate
			{
				plugin.Features.ToggleClimbAnywhere();
				ShowMovementModes(plugin);
			});
			AddButton("FLY: JUMP ASCENDS, CROUCH DESCENDS", null, enabled: false);
			AddButton("BACK", delegate
			{
				ShowMovement(plugin);
			});
			FinishPage();
		}

		private static void ShowItemCategories(WhiteKnuckleTrainerPlugin plugin, int page)
		{
			ShowPagedButtons(new List<string> { "Consumables", "Tools & weapons", "Miscellaneous", "Artifacts", "Trinkets", "Cheats / unused", "All discovered" }, page, (string category) => "SPAWN — " + category.ToUpperInvariant(), delegate(string category)
			{
				ShowItems(plugin, category, 0);
			}, delegate(int previous)
			{
				ShowItemCategories(plugin, previous);
			}, delegate
			{
				ShowHome(plugin);
			});
		}

		private static void ShowItems(WhiteKnuckleTrainerPlugin plugin, string category, int page)
		{
			List<WhiteKnuckleTrainerPlugin.ItemEntry> list = (from item in plugin.GetItemsForNativeMenu().Where(WhiteKnuckleTrainerPlugin.ShouldListNativeItem)
				where category == "All discovered" || item.Category == category
				orderby item.DisplayName
				select item).ToList();
			if (list.Count == 0)
			{
				BeginPage();
				AddButton("NO ITEMS AVAILABLE YET", null, enabled: false);
				AddButton("ENTER A RUN, THEN OPEN THIS MENU", null, enabled: false);
				AddButton("BACK", delegate
				{
					ShowItemCategories(plugin, 0);
				});
				FinishPage();
				return;
			}
			ShowPagedButtons(list, page, (WhiteKnuckleTrainerPlugin.ItemEntry item) => "SPAWN: " + item.DisplayName.ToUpperInvariant(), delegate(WhiteKnuckleTrainerPlugin.ItemEntry item)
			{
				plugin.Spawn(item);
				ShowItems(plugin, category, page);
			}, delegate(int previous)
			{
				ShowItems(plugin, category, previous);
			}, delegate
			{
				ShowItemCategories(plugin, 0);
			});
		}

		private static void ShowCosmetics(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("COSMETICS", null, enabled: false);
			AddButton("HANDS", delegate
			{
				ShowCosmeticList(plugin, hands: true, 0);
			});
			AddButton("HAMMERS", delegate
			{
				ShowCosmeticList(plugin, hands: false, 0);
			});
			AddButton("BACK", delegate
			{
				ShowHome(plugin);
			});
			FinishPage();
		}

		private static void ShowPerks(WhiteKnuckleTrainerPlugin plugin, int page)
		{
			List<Perk> list = plugin.GetPerksForNativeMenu().ToList();
			if (list.Count == 0)
			{
				BeginPage();
				AddButton("NO PERKS AVAILABLE YET", null, enabled: false);
				AddButton("ENTER A RUN, THEN OPEN THIS MENU", null, enabled: false);
				AddButton("BACK", delegate
				{
					ShowHome(plugin);
				});
				FinishPage();
				return;
			}
			ShowPagedButtons(list, page, (Perk perk) => (plugin.IsPerkActive(perk) ? "REMOVE: " : "ADD: ") + PerkLabel(perk).ToUpperInvariant(), delegate(Perk perk)
			{
				if (plugin.IsPerkActive(perk))
				{
					plugin.RemovePerkFromNativeMenu(perk);
				}
				else
				{
					plugin.AddPerkFromNativeMenu(perk);
				}
				ShowPerks(plugin, page);
			}, delegate(int previous)
			{
				ShowPerks(plugin, previous);
			}, delegate
			{
				ShowHome(plugin);
			});
		}

		private static void ShowTools(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("TOOLS", null, enabled: false);
			AddButton("EXPORT DIAGNOSTICS", delegate
			{
				TrainerTools.ExportDiagnostics(plugin);
			});
			AddButton("EXPORT LEVEL DATA", delegate
			{
				TrainerTools.ExportLevelData(plugin);
			});
			AddButton("EXPORTS: BEPINEX/CONFIG/WHITEKNUCKLETRAINER", null, enabled: false);
			AddButton("LEVEL EXPORT ENABLES NATIVE CHEAT MODE", null, enabled: false);
			AddButton("BACK", delegate
			{
				ShowHome(plugin);
			});
			FinishPage();
		}

		private static void ShowEsp(WhiteKnuckleTrainerPlugin plugin)
		{
			TrainerFeatures features = plugin.Features;
			BeginPage();
			AddButton("ESP / ITEM RADAR", null, enabled: false);
			AddButton("ENABLE ESP: " + OnOff(features.EspEnabled), delegate
			{
				features.ToggleEsp();
				ShowEsp(plugin);
			});
			AddButton("MAX DISTANCE: " + features.EspMaximumDistance.ToString("0") + "m", delegate
			{
				ShowEspDistance(plugin);
			});
			AddButton("MAX LABELS: " + features.EspMaximumLabels, delegate
			{
				ShowEspLabels(plugin);
			});
			AddButton("ONLY ON SCREEN: " + OnOff(features.EspOnlyOnScreen), delegate
			{
				features.ToggleEspOnlyOnScreen();
				ShowEsp(plugin);
			});
			AddButton("OCCLUSION CHECK: " + OnOff(features.EspOcclusionCheck), delegate
			{
				features.ToggleEspOcclusionCheck();
				ShowEsp(plugin);
			});
			AddButton("NEAREST DISCOVERED ITEMS — 1s REFRESH", null, enabled: false);
			AddButton("BACK", delegate
			{
				ShowHome(plugin);
			});
			FinishPage();
		}

		private static void ShowEspDistance(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("MAX ESP DISTANCE: " + plugin.Features.EspMaximumDistance.ToString("0") + "m", null, enabled: false);
			AddButton("DECREASE BY 15m", delegate
			{
				plugin.Features.AdjustEspDistance(-15f);
				ShowEspDistance(plugin);
			});
			AddButton("INCREASE BY 15m", delegate
			{
				plugin.Features.AdjustEspDistance(15f);
				ShowEspDistance(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowEsp(plugin);
			});
			FinishPage();
		}

		private static void ShowEspLabels(WhiteKnuckleTrainerPlugin plugin)
		{
			BeginPage();
			AddButton("MAX ESP LABELS: " + plugin.Features.EspMaximumLabels, null, enabled: false);
			AddButton("DECREASE", delegate
			{
				plugin.Features.AdjustEspLabels(-3);
				ShowEspLabels(plugin);
			});
			AddButton("INCREASE", delegate
			{
				plugin.Features.AdjustEspLabels(3);
				ShowEspLabels(plugin);
			});
			AddButton("BACK", delegate
			{
				ShowEsp(plugin);
			});
			FinishPage();
		}

		private static void ShowCosmeticList(WhiteKnuckleTrainerPlugin plugin, bool hands, int page)
		{
			List<Cosmetic_Base> list = (hands ? plugin.GetHandCosmeticsForNativeMenu() : plugin.GetHammerCosmeticsForNativeMenu()).OrderBy(WhiteKnuckleTrainerPlugin.GetNativeCosmeticName).ToList();
			if (list.Count == 0)
			{
				BeginPage();
				AddButton("NO " + (hands ? "HAND" : "HAMMER") + " COSMETICS FOUND", null, enabled: false);
				AddButton("BACK", delegate
				{
					ShowCosmetics(plugin);
				});
				FinishPage();
				return;
			}
			ShowPagedButtons(list, page, (Cosmetic_Base cosmetic) => "EQUIP: " + WhiteKnuckleTrainerPlugin.GetNativeCosmeticName(cosmetic).ToUpperInvariant(), delegate(Cosmetic_Base cosmetic)
			{
				plugin.EquipCosmeticFromNativeMenu(cosmetic, hands);
				plugin.LogNativeInfo("[Trainer] Equipped cosmetic: " + WhiteKnuckleTrainerPlugin.GetNativeCosmeticName(cosmetic));
				ShowCosmeticList(plugin, hands, page);
			}, delegate(int previous)
			{
				ShowCosmeticList(plugin, hands, previous);
			}, delegate
			{
				ShowCosmetics(plugin);
			});
		}

		private static void ShowPagedButtons<T>(IReadOnlyList<T> entries, int requestedPage, Func<T, string> label, Action<T> selected, Action<int> showPage, Action back)
		{
			int num = Mathf.Max(1, Mathf.CeilToInt((float)entries.Count / 6f));
			int page = Mathf.Clamp(requestedPage, 0, num - 1);
			int num2 = page * 6;
			int num3 = Mathf.Min(num2 + 6, entries.Count);
			BeginPage();
			for (int i = num2; i < num3; i++)
			{
				T entry = entries[i];
				AddButton(label(entry), delegate
				{
					selected(entry);
				});
			}
			if (page > 0)
			{
				AddButton("PREVIOUS PAGE (" + page + "/" + num + ")", delegate
				{
					showPage(page - 1);
				});
			}
			if (page + 1 < num)
			{
				AddButton("NEXT PAGE (" + (page + 2) + "/" + num + ")", delegate
				{
					showPage(page + 1);
				});
			}
			AddButton("BACK", back);
			FinishPage();
		}

		private static void BeginPage()
		{
			ClearGeneratedEntries();
		}

		private static void FinishPage()
		{
			ConfigureGeneratedNavigation();
			RebuildLayout();
		}

		private static void AddButton(string label, Action? action, bool enabled = true)
		{
			if (!((Object)(object)_layout == (Object)null) && !((Object)(object)_settingsTemplate == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)_settingsTemplate).gameObject, _layout);
				((Object)val).name = "WhiteKnuckleTrainer_Generated_" + GeneratedEntries.Count;
				val.SetActive(true);
				ConfigureNativeButton(val, label, action, enabled);
				GeneratedEntries.Add(val);
			}
		}

		private static void ConfigureNativeButton(GameObject buttonObject, string label, Action? action, bool enabled)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			UI_MenuButton component = buttonObject.GetComponent<UI_MenuButton>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Button component2 = buttonObject.GetComponent<Button>();
			TMP_Text componentInChildren = buttonObject.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)component2 == (Object)null || (Object)(object)componentInChildren == (Object)null)
			{
				throw new InvalidOperationException("The verified Settings template no longer contains a Button and TMP label.");
			}
			componentInChildren.text = label;
			bool flag = label.Length > 24;
			LayoutElement val = buttonObject.GetComponent<LayoutElement>();
			if ((Object)(object)val == (Object)null)
			{
				val = buttonObject.AddComponent<LayoutElement>();
			}
			val.minHeight = (flag ? 72f : 0f);
			val.preferredHeight = (flag ? 72f : (-1f));
			componentInChildren.enableWordWrapping = flag;
			componentInChildren.overflowMode = (TextOverflowModes)((!flag) ? 1 : 3);
			componentInChildren.enableAutoSizing = true;
			componentInChildren.fontSizeMin = (flag ? 15f : 18f);
			componentInChildren.fontSizeMax = (flag ? 24f : 32f);
			((UnityEventBase)component2.onClick).RemoveAllListeners();
			((Selectable)component2).interactable = enabled && action != null;
			if (enabled && action != null)
			{
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					action();
				});
			}
		}

		private static void ConfigureGeneratedNavigation()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			List<Button> list = (from entry in GeneratedEntries
				where (Object)(object)entry != (Object)null && entry.activeInHierarchy
				select entry.GetComponent<Button>() into button
				where (Object)(object)button != (Object)null && ((Selectable)button).interactable
				select button).Cast<Button>().ToList();
			for (int num = 0; num < list.Count; num++)
			{
				Navigation navigation = ((Selectable)list[num]).navigation;
				((Navigation)(ref navigation)).mode = (Mode)4;
				((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)((num > 0) ? list[num - 1] : list[num]);
				((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)((num + 1 < list.Count) ? list[num + 1] : list[num]);
				((Selectable)list[num]).navigation = navigation;
			}
			if (list.Count > 0)
			{
				((Selectable)list[0]).Select();
			}
		}

		private static void ClearGeneratedEntries()
		{
			foreach (GameObject generatedEntry in GeneratedEntries)
			{
				if ((Object)(object)generatedEntry != (Object)null)
				{
					generatedEntry.SetActive(false);
					Object.Destroy((Object)(object)generatedEntry);
				}
			}
			GeneratedEntries.Clear();
		}

		private static void RebuildLayout()
		{
			Transform? layout = _layout;
			RectTransform val = (RectTransform)(object)((layout is RectTransform) ? layout : null);
			if (val != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val);
			}
		}

		private static Transform? FindPauseLayout(Transform pauseMenu)
		{
			Transform[] componentsInChildren = ((Component)pauseMenu).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "Pause Layout")
				{
					return val;
				}
			}
			return null;
		}

		private static void ReportMissingTemplate(WhiteKnuckleTrainerPlugin plugin, string missing)
		{
			if (!_reportedMissingTemplate)
			{
				_reportedMissingTemplate = true;
				plugin.LogNativeWarning("[Trainer] Pause menu discovered, but native template was not found: " + missing + ".");
			}
		}

		private static string OnOff(bool enabled)
		{
			if (!enabled)
			{
				return "OFF";
			}
			return "ON";
		}

		private static string PerkLabel(Perk perk)
		{
			if (!string.IsNullOrWhiteSpace(perk.title))
			{
				return perk.title;
			}
			return perk.id;
		}
	}
	[HarmonyPatch(typeof(CL_GameManager), "UnPause")]
	internal static class NativePauseMenuUnpausePatch
	{
		private static void Postfix()
		{
			NativePauseMenuPatch.Close();
		}
	}
	internal sealed class TrainerFeatures
	{
		private readonly struct PlayerDefaults
		{
			internal readonly bool Initialized;

			internal readonly float Speed;

			internal readonly float SprintSpeed;

			internal readonly float CrouchSpeed;

			internal readonly float SwimSpeed;

			internal readonly float JumpHeight;

			internal readonly float Gravity;

			internal readonly int ExtraJumps;

			internal PlayerDefaults(ENT_Player player)
			{
				Initialized = true;
				Speed = player.speed;
				SprintSpeed = player.sprintSpeed;
				CrouchSpeed = player.crouchSpeed;
				SwimSpeed = player.swimSpeed;
				JumpHeight = player.jumpHeight;
				Gravity = player.gravity;
				ExtraJumps = player.extraJumps;
			}
		}

		private readonly WhiteKnuckleTrainerPlugin _plugin;

		private ENT_Player? _player;

		private PlayerDefaults _defaults;

		internal bool GodMode { get; private set; }

		internal bool NoFallDamage { get; private set; }

		internal bool NoEncumbrance { get; private set; }

		internal bool Fly { get; private set; }

		internal bool Noclip { get; private set; }

		internal bool ClimbAnywhere { get; private set; }

		internal bool EspEnabled { get; private set; }

		internal bool EspOnlyOnScreen { get; private set; } = true;

		internal bool EspOcclusionCheck { get; private set; }

		internal float EspMaximumDistance { get; private set; } = 75f;

		internal int EspMaximumLabels { get; private set; } = 15;

		internal int MultiJumpCount { get; private set; } = 1;

		internal float MovementMultiplier { get; private set; } = 1f;

		internal float JumpHeightMultiplier { get; private set; } = 1f;

		internal float GravityMultiplier { get; private set; } = 1f;

		internal float TimeScaleMultiplier { get; private set; } = 1f;

		internal TrainerFeatures(WhiteKnuckleTrainerPlugin plugin)
		{
			_plugin = plugin;
		}

		internal void ResetScene()
		{
			_player = null;
			_defaults = default(PlayerDefaults);
		}

		internal void Update(ENT_Player player)
		{
			if ((Object)(object)_player != (Object)(object)player)
			{
				RestorePreviousPlayer();
				_player = player;
				_defaults = new PlayerDefaults(player);
				ApplyNativeToggles(player);
			}
			if (!HasActiveGameplayModification() || _plugin.EnsureNativeCheatMode())
			{
				ApplyPlayerValues(player);
			}
		}

		internal void ToggleGodMode()
		{
			GodMode = ToggleGameplay(GodMode);
			ApplyNativeTogglesIfReady();
		}

		internal void ToggleNoFallDamage()
		{
			NoFallDamage = ToggleGameplay(NoFallDamage);
		}

		internal void ToggleNoEncumbrance()
		{
			NoEncumbrance = ToggleGameplay(NoEncumbrance);
		}

		internal void ToggleFly()
		{
			Fly = ToggleGameplay(Fly);
			ApplyNativeTogglesIfReady();
		}

		internal void ToggleNoclip()
		{
			Noclip = ToggleGameplay(Noclip);
			ApplyNativeTogglesIfReady();
		}

		internal void ToggleClimbAnywhere()
		{
			ClimbAnywhere = ToggleGameplay(ClimbAnywhere);
			ApplyNativeTogglesIfReady();
		}

		internal void ToggleEsp()
		{
			EspEnabled = ToggleGameplay(EspEnabled);
		}

		internal void ToggleEspOnlyOnScreen()
		{
			EspOnlyOnScreen = !EspOnlyOnScreen;
		}

		internal void ToggleEspOcclusionCheck()
		{
			EspOcclusionCheck = !EspOcclusionCheck;
		}

		internal void AdjustEspDistance(float delta)
		{
			float espMaximumDistance = Mathf.Clamp(EspMaximumDistance + delta, 15f, 200f);
			if (_plugin.EnsureNativeCheatMode())
			{
				EspMaximumDistance = espMaximumDistance;
			}
		}

		internal void AdjustEspLabels(int delta)
		{
			int espMaximumLabels = Mathf.Clamp(EspMaximumLabels + delta, 3, 30);
			if (_plugin.EnsureNativeCheatMode())
			{
				EspMaximumLabels = espMaximumLabels;
			}
		}

		internal void AdjustMultiJump(int delta)
		{
			SetMultiJump(Mathf.Clamp(MultiJumpCount + delta, 1, 20));
		}

		internal void AdjustMovement(float delta)
		{
			SetMovement(Mathf.Clamp(MovementMultiplier + delta, 0.5f, 3f));
		}

		internal void AdjustJumpHeight(float delta)
		{
			SetJumpHeight(Mathf.Clamp(JumpHeightMultiplier + delta, 0.5f, 3f));
		}

		internal void AdjustGravity(float delta)
		{
			SetGravity(Mathf.Clamp(GravityMultiplier + delta, 0.25f, 2f));
		}

		internal void AdjustTimeScale(float delta)
		{
			SetTimeScale(Mathf.Clamp(TimeScaleMultiplier + delta, 0.1f, 1f));
		}

		private void SetMultiJump(int value)
		{
			if (value <= 1 || _plugin.EnsureNativeCheatMode())
			{
				MultiJumpCount = value;
			}
		}

		private void SetMovement(float value)
		{
			if (Mathf.Approximately(value, 1f) || _plugin.EnsureNativeCheatMode())
			{
				MovementMultiplier = value;
			}
		}

		private void SetJumpHeight(float value)
		{
			if (Mathf.Approximately(value, 1f) || _plugin.EnsureNativeCheatMode())
			{
				JumpHeightMultiplier = value;
			}
		}

		private void SetGravity(float value)
		{
			if (Mathf.Approximately(value, 1f) || _plugin.EnsureNativeCheatMode())
			{
				GravityMultiplier = value;
			}
		}

		private void SetTimeScale(float value)
		{
			if (Mathf.Approximately(value, 1f) || _plugin.EnsureNativeCheatMode())
			{
				TimeScaleMultiplier = value;
				CL_GameManager.SetTimescaleMult(TimeScaleMultiplier);
			}
		}

		private bool ToggleGameplay(bool current)
		{
			bool flag = !current;
			if (flag && !_plugin.EnsureNativeCheatMode())
			{
				return current;
			}
			return flag;
		}

		private void ApplyNativeTogglesIfReady()
		{
			if ((Object)(object)_player != (Object)null)
			{
				ApplyNativeToggles(_player);
			}
		}

		private void ApplyPlayerValues(ENT_Player player)
		{
			if (_defaults.Initialized)
			{
				player.speed = _defaults.Speed * MovementMultiplier;
				player.sprintSpeed = _defaults.SprintSpeed * MovementMultiplier;
				player.crouchSpeed = _defaults.CrouchSpeed * MovementMultiplier;
				player.swimSpeed = _defaults.SwimSpeed * MovementMultiplier;
				player.jumpHeight = _defaults.JumpHeight * JumpHeightMultiplier;
				player.gravity = _defaults.Gravity * GravityMultiplier;
				player.extraJumps = MultiJumpCount - 1;
			}
			CL_GameManager.SetTimescaleMult(TimeScaleMultiplier);
		}

		private void ApplyNativeToggles(ENT_Player player)
		{
			player.GodMode(new string[1] { GodMode.ToString() });
			player.FlyCommand(new string[1] { Fly.ToString() });
			player.Noclip(new string[1] { Noclip.ToString() });
			player.ClimbAnywhereCommand(new string[1] { ClimbAnywhere.ToString() });
			CL_GameManager.SetTimescaleMult(TimeScaleMultiplier);
		}

		private bool HasActiveGameplayModification()
		{
			if (!GodMode && !NoFallDamage && !NoEncumbrance && !Fly && !Noclip && !ClimbAnywhere && !EspEnabled && MultiJumpCount <= 1 && Mathf.Approximately(MovementMultiplier, 1f) && Mathf.Approximately(JumpHeightMultiplier, 1f) && Mathf.Approximately(GravityMultiplier, 1f))
			{
				return !Mathf.Approximately(TimeScaleMultiplier, 1f);
			}
			return true;
		}

		private void RestorePreviousPlayer()
		{
			if (!((Object)(object)_player == (Object)null) && _defaults.Initialized)
			{
				_player.speed = _defaults.Speed;
				_player.sprintSpeed = _defaults.SprintSpeed;
				_player.crouchSpeed = _defaults.CrouchSpeed;
				_player.swimSpeed = _defaults.SwimSpeed;
				_player.jumpHeight = _defaults.JumpHeight;
				_player.gravity = _defaults.Gravity;
				_player.extraJumps = _defaults.ExtraJumps;
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "GetEncumberance")]
	internal static class NoEncumbrancePatch
	{
		private static bool Prefix(ref float __result)
		{
			WhiteKnuckleTrainerPlugin? instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance == null || !instance.Features.NoEncumbrance)
			{
				return true;
			}
			__result = 1f;
			return false;
		}
	}
	[HarmonyPatch(typeof(ENT_Player), "Damage")]
	internal static class NoFallDamagePatch
	{
		private static bool Prefix(DamageInfo info)
		{
			WhiteKnuckleTrainerPlugin? instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance != null && instance.Features.NoFallDamage)
			{
				return !string.Equals(info.type, "falling", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ENT_Player), "Kill")]
	internal static class NoFallDeathPatch
	{
		private static bool Prefix(string type)
		{
			WhiteKnuckleTrainerPlugin? instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance != null && instance.Features.NoFallDamage)
			{
				return !string.Equals(type, "falling", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}
	}
	internal static class TrainerTools
	{
		[Serializable]
		private sealed class LevelDump
		{
			public string scene = "";

			public Vector3 playerPosition;

			public List<LevelItem> items = new List<LevelItem>();
		}

		[Serializable]
		private sealed class LevelItem
		{
			public string name = "";

			public string prefabId = "";

			public string category = "";

			public Vector3 position;
		}

		private static string ExportDirectory => Path.Combine(Paths.ConfigPath, "WhiteKnuckleTrainer");

		internal static string ExportDiagnostics(WhiteKnuckleTrainerPlugin plugin)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Directory.CreateDirectory(ExportDirectory);
			TrainerFeatures features = plugin.Features;
			string text = Path.Combine(ExportDirectory, "diagnostics.txt");
			string[] obj = new string[23]
			{
				"White Knuckle Trainer diagnostics",
				"Version: 1.0.0",
				"BepInEx assembly: " + typeof(BaseUnityPlugin).Assembly.GetName().Version,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			Scene activeScene = SceneManager.GetActiveScene();
			obj[3] = "Scene: " + ((Scene)(ref activeScene)).name;
			obj[4] = "Native cheat mode: " + CommandConsole.hasCheated;
			obj[5] = "God mode: " + features.GodMode;
			obj[6] = "No fall damage: " + features.NoFallDamage;
			obj[7] = "No encumbrance: " + features.NoEncumbrance;
			obj[8] = "Infinite jumps: " + plugin.InfiniteJumps;
			obj[9] = "Infinite stamina: " + plugin.InfiniteStamina;
			obj[10] = "Infinite ammo: " + plugin.InfiniteAmmoAndThrowables;
			obj[11] = "Multi-jump count: " + features.MultiJumpCount;
			obj[12] = "Movement multiplier: " + features.MovementMultiplier.ToString("0.00");
			obj[13] = "Jump-height multiplier: " + features.JumpHeightMultiplier.ToString("0.00");
			obj[14] = "Gravity multiplier: " + features.GravityMultiplier.ToString("0.00");
			obj[15] = "Time scale: " + features.TimeScaleMultiplier.ToString("0.00");
			obj[16] = "Fly: " + features.Fly;
			obj[17] = "Noclip: " + features.Noclip;
			obj[18] = "Climb anywhere: " + features.ClimbAnywhere;
			obj[19] = "Spawnable items discovered: " + plugin.GetItemsForNativeMenu().Count;
			obj[20] = "Perks discovered: " + plugin.GetPerksForNativeMenu().Count;
			obj[21] = "Hand cosmetics: " + plugin.GetHandCosmeticsForNativeMenu().Count;
			obj[22] = "Hammer cosmetics: " + plugin.GetHammerCosmeticsForNativeMenu().Count;
			string[] contents = obj;
			File.WriteAllLines(text, contents);
			plugin.LogNativeInfo("[Trainer] Diagnostics exported: " + text);
			return text;
		}

		internal static string? ExportLevelData(WhiteKnuckleTrainerPlugin plugin)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!plugin.EnsureNativeCheatMode())
			{
				return null;
			}
			Directory.CreateDirectory(ExportDirectory);
			ENT_Player player = ENT_Player.GetPlayer();
			LevelDump levelDump = new LevelDump();
			Scene activeScene = SceneManager.GetActiveScene();
			levelDump.scene = ((Scene)(ref activeScene)).name;
			levelDump.playerPosition = (((Object)(object)player == (Object)null) ? Vector3.zero : ((Component)player).transform.position);
			levelDump.items = (from item in Object.FindObjectsOfType<Item_Object>()
				where (Object)(object)item != (Object)null && item.itemData != null
				select new LevelItem
				{
					name = item.itemData.itemName,
					prefabId = item.itemData.prefabName,
					category = WhiteKnuckleTrainerPlugin.Categorize(item.itemData.itemName, item.itemData.prefabName),
					position = ((Component)item).transform.position
				}).ToList();
			LevelDump levelDump2 = levelDump;
			string text = Path.Combine(ExportDirectory, "level-" + DateTime.Now.ToString("yyyyMMdd-HHmmss") + ".json");
			File.WriteAllText(text, JsonUtility.ToJson((object)levelDump2, true));
			plugin.LogNativeInfo("[Trainer] Metadata-only level export written: " + text);
			return text;
		}
	}
	[BepInPlugin("drake.whiteknuckle.trainer", "White Knuckle Trainer", "1.0.0")]
	public sealed class WhiteKnuckleTrainerPlugin : BaseUnityPlugin
	{
		internal sealed class ItemEntry
		{
			public string DisplayName { get; }

			public string PrefabId { get; }

			public string Category { get; }

			public Sprite? Icon { get; }

			public ItemEntry(string displayName, string prefabId, string category, Sprite? icon)
			{
				DisplayName = displayName;
				PrefabId = prefabId;
				Category = category;
				Icon = icon;
			}
		}

		public const string PluginGuid = "drake.whiteknuckle.trainer";

		public const string PluginName = "White Knuckle Trainer";

		public const string PluginVersion = "1.0.0";

		private readonly List<ItemEntry> _items = new List<ItemEntry>();

		private readonly List<Cosmetic_Base> _handCosmetics = new List<Cosmetic_Base>();

		private readonly List<Cosmetic_Base> _hammerCosmetics = new List<Cosmetic_Base>();

		private readonly Dictionary<Cosmetic_Base, Sprite?> _cosmeticPreviewCache = new Dictionary<Cosmetic_Base, Sprite>();

		private Vector2 _scroll;

		private Vector2 _handCosmeticScroll;

		private Vector2 _hammerCosmeticScroll;

		private Rect _windowRect = new Rect(25f, 60f, 900f, 650f);

		private string _category = "Consumables";

		private string _search = string.Empty;

		private bool _menuOpen;

		private bool _pausedByTrainer;

		private bool _cursorStateCaptured;

		private CursorLockMode _savedCursorLockState;

		private bool _savedCursorVisible;

		private bool _lastInfiniteAmmo;

		private bool _itemsScanned;

		private string _mainTab = "Trainer";

		private string _cosmeticTab = "Hands";

		private bool _cosmeticsCached;

		private string? _cosmeticDiscoveryError;

		private GUIStyle? _windowStyle;

		private GUIStyle? _buttonStyle;

		private GUIStyle? _labelStyle;

		private GUIStyle? _textFieldStyle;

		private GUIStyle? _toggleStyle;

		private GUIStyle? _cosmeticCardStyle;

		private GUIStyle? _cosmeticNameStyle;

		private GUIStyle? _sectionHeaderStyle;

		private GUIStyle? _closeButtonStyle;

		private Texture2D? _opaqueBackground;

		private Texture2D? _checkboxOff;

		private Texture2D? _checkboxOn;

		private Texture2D? _buttonNormalTexture;

		private Texture2D? _buttonHoverTexture;

		private Texture2D? _buttonSelectedTexture;

		private GUIStyle? _buttonTextStyle;

		private static readonly string[] Categories = new string[7] { "Consumables", "Tools & weapons", "Miscellaneous", "Artifacts", "Trinkets", "Cheats / unused", "All discovered" };

		internal static WhiteKnuckleTrainerPlugin? Instance { get; private set; }

		internal TrainerFeatures Features { get; private set; }

		internal bool InfiniteJumps { get; private set; }

		internal bool InfiniteStamina { get; private set; }

		internal bool InfiniteAmmoAndThrowables { get; private set; }

		internal void LogNativeInfo(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}

		internal void LogNativeWarning(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)message);
		}

		internal void LogNativeError(string message)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)message);
		}

		internal void ToggleInfiniteJumps()
		{
			if (InfiniteJumps || EnsureNativeCheatMode())
			{
				InfiniteJumps = !InfiniteJumps;
			}
		}

		internal void ToggleInfiniteStamina()
		{
			if (InfiniteStamina || EnsureNativeCheatMode())
			{
				InfiniteStamina = !InfiniteStamina;
			}
		}

		internal void ToggleInfiniteAmmoAndThrowables()
		{
			if (InfiniteAmmoAndThrowables || EnsureNativeCheatMode())
			{
				InfiniteAmmoAndThrowables = !InfiniteAmmoAndThrowables;
			}
		}

		internal IReadOnlyList<ItemEntry> GetItemsForNativeMenu()
		{
			if (!_itemsScanned)
			{
				ScanInstalledItems();
			}
			return _items;
		}

		internal IReadOnlyList<Perk> GetPerksForNativeMenu()
		{
			try
			{
				return (from perk in CL_AssetManager.GetFullCombinedAssetDatabase().perkAssets
					where (Object)(object)perk != (Object)null && !string.IsNullOrWhiteSpace(perk.id)
					orderby (!string.IsNullOrWhiteSpace(perk.title)) ? perk.title : perk.id
					select perk).ToList();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Perk database is not ready: " + ex.Message));
				return Array.Empty<Perk>();
			}
		}

		internal bool AddPerkFromNativeMenu(Perk perk)
		{
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player == (Object)null || !EnsureNativeCheatMode())
			{
				return false;
			}
			if (player.HasPerk(perk.id) && !perk.canStack)
			{
				return false;
			}
			player.AddPerk(perk, 1, true);
			return true;
		}

		internal bool RemovePerkFromNativeMenu(Perk perk)
		{
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player == (Object)null || !EnsureNativeCheatMode() || !player.HasPerk(perk.id))
			{
				return false;
			}
			player.RemovePerk(perk.id, false);
			return true;
		}

		internal bool IsPerkActive(Perk perk)
		{
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player != (Object)null)
			{
				return player.HasPerk(perk.id);
			}
			return false;
		}

		internal IReadOnlyList<Cosmetic_Base> GetHandCosmeticsForNativeMenu()
		{
			EnsureCosmeticCache();
			return _handCosmetics;
		}

		internal IReadOnlyList<Cosmetic_Base> GetHammerCosmeticsForNativeMenu()
		{
			EnsureCosmeticCache();
			return _hammerCosmetics;
		}

		internal void EquipCosmeticFromNativeMenu(Cosmetic_Base cosmetic, bool hands)
		{
			if (hands)
			{
				Cosmetic_HandItem val = (Cosmetic_HandItem)(object)((cosmetic is Cosmetic_HandItem) ? cosmetic : null);
				if (val != null)
				{
					EquipHandCosmetic(val);
					return;
				}
			}
			if (!hands)
			{
				EquipHammerCosmetic(cosmetic);
			}
		}

		internal static string GetNativeCosmeticName(Cosmetic_Base cosmetic)
		{
			return GetDisplayName(cosmetic);
		}

		internal static bool ShouldListNativeItem(ItemEntry item)
		{
			if (!(item.Category != "Consumables"))
			{
				return IsUsefulConsumable(item);
			}
			return true;
		}

		private void Awake()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			Features = new TrainerFeatures(this);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Component)this).gameObject.AddComponent<EspOverlay>();
			new Harmony("drake.whiteknuckle.trainer").PatchAll();
			SceneManager.sceneLoaded += OnSceneLoaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"White Knuckle Trainer 1.0.0 loaded. Press Shift + Insert to open the menu.");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			NativePauseMenuPatch.Close();
			SetGameInfiniteAmmo(enabled: false);
			Instance = null;
		}

		private void OnSceneLoaded(Scene _, LoadSceneMode __)
		{
			NativePauseMenuPatch.ResetSceneState();
			Features.ResetScene();
			_itemsScanned = false;
			_items.Clear();
			_cosmeticsCached = false;
			_handCosmetics.Clear();
			_hammerCosmetics.Clear();
			_cosmeticPreviewCache.Clear();
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)277) && (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303)))
			{
				ToggleNativeTrainerMenu();
			}
			if (NativePauseMenuPatch.IsOpen && Input.GetKeyDown((KeyCode)27))
			{
				NativePauseMenuPatch.Close();
			}
			if (_menuOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (InfiniteJumps || InfiniteStamina || InfiniteAmmoAndThrowables)
			{
				EnsureNativeCheatMode();
			}
			if (InfiniteStamina)
			{
				Hand[] hands = player.hands;
				foreach (Hand obj in hands)
				{
					obj.SetGripStrength(obj.GetGripStrengthMax());
				}
			}
			if (InfiniteJumps)
			{
				SetJumpCounters(player, 99, 99);
			}
			Features.Update(player);
			if (_lastInfiniteAmmo != InfiniteAmmoAndThrowables)
			{
				SetGameInfiniteAmmo(InfiniteAmmoAndThrowables);
				_lastInfiniteAmmo = InfiniteAmmoAndThrowables;
			}
			if (!_itemsScanned)
			{
				ScanInstalledItems();
			}
		}

		private void OnGUI()
		{
		}

		private void DrawWindow(int _)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (GUI.Button(new Rect(((Rect)(ref _windowRect)).width - 27f, 2f, 23f, 18f), "X"))
			{
				SetMenuOpen(open: false);
				return;
			}
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Space(12f);
			DrawHeaderTabs();
			if (_mainTab == "Cosmetic editor")
			{
				DrawCosmeticEditor();
			}
			else
			{
				DrawTrainerTab();
			}
			GUILayout.EndVertical();
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref _windowRect)).width - 32f, 22f));
		}

		private void DrawHeaderTabs()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (DrawButton("TRAINER", 180f, 30f, _mainTab == "Trainer"))
			{
				_mainTab = "Trainer";
			}
			if (DrawButton("COSMETIC EDITOR", 210f, 30f, _mainTab == "Cosmetic editor"))
			{
				_mainTab = "Cosmetic editor";
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.Space(8f);
		}

		private void DrawTrainerTab()
		{
			GUILayout.Label("TRAINER OPTIONS", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			DrawTrainerOptions();
			GUILayout.Space(8f);
			GUILayout.Label("ITEM SPAWNER", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			DrawItemSpawner();
		}

		private void DrawTrainerOptions()
		{
			InfiniteJumps = DrawCheckbox("Infinite Jumps", InfiniteJumps);
			InfiniteStamina = DrawCheckbox("Infinite Stamina", InfiniteStamina);
			InfiniteAmmoAndThrowables = DrawCheckbox("Infinite Ammo / Throwables / Pitons", InfiniteAmmoAndThrowables);
		}

		private void DrawItemSpawner()
		{
			GUILayout.Label("Spawn items directly into the inventory", _labelStyle, Array.Empty<GUILayoutOption>());
			DrawItemCategoryFilters();
			DrawItemSearch();
			DrawItemResults();
		}

		private void DrawItemCategoryFilters()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			string[] categories = Categories;
			foreach (string text in categories)
			{
				if (DrawButton(text.ToUpperInvariant(), 0f, 27f, _category == text))
				{
					_category = text;
				}
			}
			GUILayout.EndHorizontal();
		}

		private void DrawItemSearch()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Search", _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(48f) });
			_search = GUILayout.TextField(_search, _textFieldStyle, Array.Empty<GUILayoutOption>());
			if (DrawButton("CLEAR", 65f, 25f))
			{
				_search = string.Empty;
			}
			GUILayout.EndHorizontal();
		}

		private void DrawItemResults()
		{
			//IL_00b9: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (!_itemsScanned)
			{
				GUILayout.Label("Waiting for a gameplay scene so the game's item database is available...", _labelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				IEnumerable<ItemEntry> source = _items.Where((ItemEntry item) => _category == "All discovered" || item.Category == _category);
				if (_category == "Consumables")
				{
					source = source.Where(IsUsefulConsumable);
				}
				if (!string.IsNullOrWhiteSpace(_search))
				{
					source = source.Where((ItemEntry item) => item.DisplayName.IndexOf(_search, StringComparison.OrdinalIgnoreCase) >= 0 || item.PrefabId.IndexOf(_search, StringComparison.OrdinalIgnoreCase) >= 0);
				}
				bool flag = _category == "Consumables" || _category == "All discovered";
				if (flag)
				{
					_scroll = GUILayout.BeginScrollView(_scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(440f) });
				}
				foreach (ItemEntry item in source.OrderBy((ItemEntry item) => item.DisplayName))
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					DrawItemPreview(item);
					GUILayout.Label(item.DisplayName, _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(250f) });
					GUILayout.Label(item.PrefabId, _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) });
					if (DrawButton("SPAWN", 90f, 25f))
					{
						Spawn(item);
					}
					GUILayout.EndHorizontal();
				}
				if (flag)
				{
					GUILayout.EndScrollView();
				}
			}
			GUILayout.Label("Shift + Insert or X closes this menu. The list is read from this installed game's runtime database.", _labelStyle, Array.Empty<GUILayoutOption>());
		}

		private bool DrawCheckbox(string label, bool value)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Rect rect = GUILayoutUtility.GetRect(24f, 24f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(24f),
				GUILayout.Height(24f)
			});
			GUI.DrawTexture(rect, (Texture)(object)(value ? _checkboxOn : _checkboxOff));
			if (value)
			{
				GUI.Label(rect, "✓", _buttonStyle);
			}
			Rect rect2 = GUILayoutUtility.GetRect(420f, 24f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(24f)
			});
			GUI.Label(rect2, label, _labelStyle);
			if ((int)Event.current.type == 0 && (((Rect)(ref rect)).Contains(Event.current.mousePosition) || ((Rect)(ref rect2)).Contains(Event.current.mousePosition)))
			{
				Event.current.Use();
				value = !value;
			}
			GUILayout.EndHorizontal();
			return value;
		}

		private bool DrawButton(string label, float width, float height, bool selected = false)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			Rect val = ((width > 0f) ? GUILayoutUtility.GetRect(width, height, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(width),
				GUILayout.Height(height)
			}) : GUILayoutUtility.GetRect(0f, height, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(height)
			}));
			bool flag = ((Rect)(ref val)).Contains(Event.current.mousePosition);
			DrawOutlinedPanel(val, selected ? new Color(0.48f, 0.51f, 0.55f, 1f) : (flag ? new Color(0.4f, 0.43f, 0.47f, 1f) : new Color(0.3f, 0.32f, 0.35f, 1f)));
			GUI.Label(val, label, _buttonTextStyle);
			return GUI.Button(val, GUIContent.none, GUIStyle.none);
		}

		private static void DrawOutlinedPanel(Rect rect, Color fill)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = fill;
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, 1f), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).yMax - 1f, ((Rect)(ref rect)).width, 1f), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, 1f, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - 1f, ((Rect)(ref rect)).y, 1f, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
		}

		private void DrawCosmeticEditor()
		{
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Label("COSMETIC EDITOR", _sectionHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (DrawButton("HANDS", 150f, 30f, _cosmeticTab == "Hands"))
			{
				_cosmeticTab = "Hands";
			}
			if (DrawButton("HAMMERS", 150f, 30f, _cosmeticTab == "Hammers"))
			{
				_cosmeticTab = "Hammers";
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			EnsureCosmeticCache();
			if (_cosmeticDiscoveryError != null)
			{
				GUILayout.Label("Cosmetic discovery failed. Check the BepInEx log.", _labelStyle, Array.Empty<GUILayoutOption>());
				return;
			}
			List<Cosmetic_Base> list = ((_cosmeticTab == "Hands") ? _handCosmetics : _hammerCosmetics);
			if (list.Count == 0)
			{
				GUILayout.Label((_cosmeticTab == "Hands") ? "No hand cosmetics were discovered." : "No hammer cosmetics were discovered.", _labelStyle, Array.Empty<GUILayoutOption>());
				return;
			}
			Vector2 val = ((_cosmeticTab == "Hands") ? _handCosmeticScroll : _hammerCosmeticScroll);
			val = GUILayout.BeginScrollView(val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(500f) });
			foreach (Cosmetic_Base item in list.OrderBy(GetDisplayName))
			{
				DrawCosmeticRow(item, _cosmeticTab == "Hands");
			}
			GUILayout.EndScrollView();
			if (_cosmeticTab == "Hands")
			{
				_handCosmeticScroll = val;
			}
			else
			{
				_hammerCosmeticScroll = val;
			}
			GUILayout.Label("Hands apply immediately. Hammer cosmetics apply when a hammer is equipped again.", _labelStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawCosmeticRow(Cosmetic_Base cosmetic, bool hands)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(_cosmeticCardStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(54f) });
			Rect rect = GUILayoutUtility.GetRect(44f, 44f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(44f),
				GUILayout.Height(44f)
			});
			DrawCosmeticPreview(rect, cosmetic);
			if (DrawButton(GetDisplayName(cosmetic), 0f, 44f))
			{
				if (hands)
				{
					Cosmetic_HandItem val = (Cosmetic_HandItem)(object)((cosmetic is Cosmetic_HandItem) ? cosmetic : null);
					if (val != null)
					{
						EquipHandCosmetic(val);
						goto IL_008a;
					}
				}
				EquipHammerCosmetic(cosmetic);
			}
			goto IL_008a;
			IL_008a:
			GUILayout.EndHorizontal();
		}

		private void DrawCosmeticPreview(Rect destination, Cosmetic_Base cosmetic)
		{
			//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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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)
			if (!_cosmeticPreviewCache.TryGetValue(cosmetic, out Sprite value))
			{
				value = cosmetic.GetInfoSprite() ?? cosmetic.cosmeticInfo.cardForeground ?? cosmetic.cosmeticInfo.cardBackground;
				if ((Object)(object)value == (Object)null)
				{
					Cosmetic_HandItem val = (Cosmetic_HandItem)(object)((cosmetic is Cosmetic_HandItem) ? cosmetic : null);
					if (val != null && val.cosmeticData?.swapSprites != null)
					{
						value = val.cosmeticData.swapSprites.SelectMany(delegate(SwapSprite swap)
						{
							IEnumerable<Sprite> replacementSprites = swap.replacementSprites;
							return replacementSprites ?? Enumerable.Empty<Sprite>();
						}).FirstOrDefault();
					}
				}
				_cosmeticPreviewCache[cosmetic] = value;
				if ((Object)(object)value == (Object)null)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("[Trainer] Failed to load icon for cosmetic: " + GetDisplayName(cosmetic)));
				}
			}
			if ((Object)(object)value == (Object)null)
			{
				GUI.DrawTexture(destination, (Texture)(object)_opaqueBackground);
				return;
			}
			Rect rect = value.rect;
			Texture texture = (Texture)(object)value.texture;
			GUI.DrawTextureWithTexCoords(destination, texture, new Rect(((Rect)(ref rect)).x / (float)texture.width, ((Rect)(ref rect)).y / (float)texture.height, ((Rect)(ref rect)).width / (float)texture.width, ((Rect)(ref rect)).height / (float)texture.height));
		}

		private void EnsureCosmeticCache()
		{
			if (_cosmeticsCached)
			{
				return;
			}
			try
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Trainer] Discovering hand and hammer cosmetics...");
				foreach (Cosmetic_Base allLoadedCosmetic in CL_CosmeticManager.GetAllLoadedCosmetics())
				{
					if (allLoadedCosmetic?.cosmeticInfo != null)
					{
						if (IsHammerCosmetic(allLoadedCosmetic) && !GetDisplayName(allLoadedCosmetic).Replace(" ", string.Empty).EndsWith("handitem", StringComparison.OrdinalIgnoreCase))
						{
							_hammerCosmetics.Add(allLoadedCosmetic);
						}
						else if (allLoadedCosmetic is Cosmetic_HandItem && !IsHammerCosmetic(allLoadedCosmetic))
						{
							_handCosmetics.Add(allLoadedCosmetic);
						}
					}
				}
				foreach (Cosmetic_Base handCosmetic in _handCosmetics)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[Trainer] Hand cosmetic discovered: " + GetDisplayName(handCosmetic)));
				}
				foreach (Cosmetic_Base hammerCosmetic in _hammerCosmetics)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[Trainer] Hammer cosmetic discovered: " + GetDisplayName(hammerCosmetic)));
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Trainer] {_handCosmetics.Count} hand cosmetics and {_hammerCosmetics.Count} hammer cosmetics discovered.");
				_cosmeticsCached = true;
			}
			catch (Exception ex)
			{
				_cosmeticDiscoveryError = ex.Message;
				((BaseUnityPlugin)this).Logger.LogError((object)$"[Trainer] Cosmetic discovery failed: {ex}");
			}
		}

		private static string GetDisplayName(Cosmetic_Base cosmetic)
		{
			string cosmeticName = cosmetic.cosmeticInfo.cosmeticName;
			if (!string.IsNullOrWhiteSpace(cosmeticName) && !string.Equals(cosmeticName, "default", StringComparison.OrdinalIgnoreCase) && !string.Equals(cosmeticName, "template", StringComparison.OrdinalIgnoreCase))
			{
				return cosmeticName;
			}
			string[] source = (cosmetic.cosmeticInfo.id ?? "Unnamed cosmetic").Replace("_", " ").Replace("-", " ").Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			return string.Join(" ", from word in source
				where !string.Equals(word, "item", StringComparison.OrdinalIgnoreCase)
				select char.ToUpperInvariant(word[0]) + word.Substring(1));
		}

		private static bool IsHammerCosmetic(Cosmetic_Base cosmetic)
		{
			if (string.Equals(cosmetic.cosmeticInfo.tag, "hammer", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string text = cosmetic.cosmeticInfo.id ?? string.Empty;
			Cosmetic_Item val = (Cosmetic_Item)(object)((cosmetic is Cosmetic_Item) ? cosmetic : null);
			if (val != null && val.cosmeticData != null)
			{
				text = text + " " + val.cosmeticData.itemName;
			}
			if (text.IndexOf("hammer", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("wrench", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("mallet", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("crowbar", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void EquipHandCosmetic(Cosmetic_HandItem cosmetic)
		{
			CosmeticSaveData cosmeticSaveData = SettingsManager.settings.cosmeticSaveData;
			cosmeticSaveData.ActivateHandCosmetic(cosmetic, 0, true);
			cosmeticSaveData.ActivateHandCosmetic(cosmetic, 1, true);
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player != (Object)null)
			{
				Hand[] hands = player.hands;
				foreach (Hand obj in hands)
				{
					obj.RemoveAllCosmetics();
					obj.currentCosmetics.Add(cosmetic);
				}
			}
			SettingsManager.instance.SaveSettings();
		}

		private static void EquipHammerCosmetic(Cosmetic_Base cosmetic)
		{
			SettingsManager.settings.cosmeticSaveData.ActivateCosmetic(cosmetic, true);
			SettingsManager.instance.SaveSettings();
		}

		private void EnsureTheme()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			//IL_0184: 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_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Expected O, but got Unknown
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Expected O, but got Unknown
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			if (_windowStyle == null)
			{
				_opaqueBackground = MakeTexture(new Color(0.005f, 0.006f, 0.008f, 1f));
				_buttonNormalTexture = MakeBorderTexture(new Color(0.22f, 0.24f, 0.27f, 1f), Color.white);
				_buttonHoverTexture = MakeBorderTexture(new Color(0.34f, 0.37f, 0.41f, 1f), Color.white);
				_buttonSelectedTexture = MakeBorderTexture(new Color(0.45f, 0.48f, 0.52f, 1f), Color.white);
				GUIStyle val = new GUIStyle
				{
					alignment = (TextAnchor)4,
					fontSize = 13,
					fontStyle = (FontStyle)1
				};
				val.normal.textColor = Color.white;
				_buttonTextStyle = val;
				_checkboxOff = MakeBorderTexture(new Color(0.02f, 0.025f, 0.03f, 1f), Color.white);
				_checkboxOn = MakeBorderTexture(new Color(0.18f, 0.3f, 0.22f, 1f), Color.white);
				_windowStyle = CreateStyle(new Color(0.035f, 0.04f, 0.05f, 0.98f), Color.white, (TextAnchor)1, 14);
				_windowStyle.padding = new RectOffset(12, 12, 28, 10);
				_buttonStyle = CreateStyle(new Color(0.1f, 0.12f, 0.15f, 1f), Color.white, (TextAnchor)4, 13);
				_buttonStyle.hover.background = MakeBorderTexture(new Color(0.18f, 0.21f, 0.25f, 1f), Color.white);
				_buttonStyle.active.background = MakeBorderTexture(new Color(0.25f, 0.29f, 0.34f, 1f), Color.white);
				_buttonStyle.onNormal.background = MakeBorderTexture(new Color(0.24f, 0.3f, 0.36f, 1f), Color.white);
				_buttonStyle.onHover.background = MakeBorderTexture(new Color(0.32f, 0.39f, 0.46f, 1f), Color.white);
				_labelStyle = CreateStyle(Color.clear, Color.white, (TextAnchor)3, 13);
				_textFieldStyle = CreateStyle(new Color(0.015f, 0.018f, 0.022f, 1f), Color.white, (TextAnchor)3, 13);
				_textFieldStyle.padding = new RectOffset(7, 7, 4, 4);
				_toggleStyle = CreateStyle(Color.clear, Color.white, (TextAnchor)3, 13);
				_toggleStyle.normal.background = MakeTexture(new Color(0.08f, 0.09f, 0.11f, 1f));
				_toggleStyle.onNormal.background = MakeTexture(new Color(0.22f, 0.31f, 0.39f, 1f));
				_toggleStyle.padding = new RectOffset(22, 6, 3, 3);
				_sectionHeaderStyle = CreateStyle(new Color(0.025f, 0.03f, 0.04f, 1f), Color.white, (TextAnchor)3, 16);
				_sectionHeaderStyle.fontStyle = (FontStyle)1;
				_sectionHeaderStyle.padding = new RectOffset(10, 10, 6, 6);
				_closeButtonStyle = CreateStyle(new Color(0.12f, 0.03f, 0.03f, 1f), Color.white, (TextAnchor)4, 13);
				_closeButtonStyle.fontStyle = (FontStyle)1;
				_cosmeticCardStyle = CreateStyle(new Color(0.06f, 0.07f, 0.085f, 1f), Color.white, (TextAnchor)3, 13);
				_cosmeticCardStyle.padding = new RectOffset(4, 4, 4, 4);
				_cosmeticNameStyle = CreateStyle(new Color(0.09f, 0.11f, 0.13f, 1f), Color.white, (TextAnchor)3, 14);
				_cosmeticNameStyle.padding = new RectOffset(10, 8, 3, 3);
				_cosmeticNameStyle.hover.background = MakeBorderTexture(new Color(0.19f, 0.23f, 0.27f, 1f), Color.white);
			}
		}

		private static GUIStyle CreateStyle(Color background, Color text, TextAnchor alignment, int fontSize)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0054: Expected O, but got Unknown
			GUIStyle val = new GUIStyle
			{
				alignment = alignment,
				fontSize = fontSize
			};
			val.normal.textColor = text;
			val.normal.background = MakeBorderTexture(background, Color.white);
			val.border = new RectOffset(1, 1, 1, 1);
			val.margin = new RectOffset(2, 2, 2, 2);
			return val;
		}

		private static Texture2D MakeTexture(Color color)
		{
			//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_0017: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, color);
			val.Apply();
			return val;
		}

		private static Texture2D MakeBorderTexture(Color interior, Color border)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(4, 4);
			for (int i = 0; i < 4; i++)
			{
				for (int j = 0; j < 4; j++)
				{
					val.SetPixel(j, i, (j == 0 || i == 0 || j == 3 || i == 3) ? border : interior);
				}
			}
			val.Apply();
			return val;
		}

		private void ScanInstalledItems()
		{
			try
			{
				List<GameObject> itemPrefabs = CL_AssetManager.GetFullCombinedAssetDatabase().itemPrefabs;
				if (itemPrefabs == null || itemPrefabs.Count == 0)
				{
					return;
				}
				_items.Clear();
				foreach (GameObject item in itemPrefabs)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					Item_Object component = item.GetComponent<Item_Object>();
					if (component?.itemData != null)
					{
						string text = component.itemData.prefabName;
						if (string.IsNullOrWhiteSpace(text))
						{
							text = ((Object)item).name;
						}
						string text2 = (string.IsNullOrWhiteSpace(component.itemData.itemName) ? ((Object)item).name : component.itemData.itemName);
						_items.Add(new ItemEntry(text2, text, Categorize(text2, text), component.itemData.normalSprite));
						((BaseUnityPlugin)this).Logger.LogInfo((object)("Item database: " + text2 + " => " + text));
					}
				}
				_itemsScanned = true;
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Read {_items.Count} item prefabs from the current White Knuckle database.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)("Item database is not ready: " + ex.Message));
			}
		}

		internal void Spawn(ItemEntry entry)
		{
			Item_Object itemObjectPrefab = CL_AssetManager.GetItemObjectPrefab(entry.PrefabId, "");
			if ((Object)(object)itemObjectPrefab == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Spawn failed: " + entry.PrefabId + " is not in the current item database."));
				return;
			}
			if (!EnsureNativeCheatMode())
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Spawn cancelled because White Knuckle cheat mode is not ready.");
				return;
			}
			Inventory.instance.AddItemToInventoryCenter(itemObjectPrefab.itemData.GetClone((Item)null, false));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Added " + entry.DisplayName + " (" + entry.PrefabId + ") to the inventory."));
		}

		private void SetMenuOpen(bool open)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (_menuOpen == open)
			{
				return;
			}
			_menuOpen = open;
			if (open)
			{
				_savedCursorLockState = Cursor.lockState;
				_savedCursorVisible = Cursor.visible;
				_cursorStateCaptured = true;
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if ((Object)(object)CL_GameManager.gMan != (Object)null)
				{
					CL_GameManager.gMan.Pause();
					_pausedByTrainer = true;
				}
			}
			else if (_cursorStateCaptured)
			{
				Cursor.lockState = _savedCursorLockState;
				Cursor.visible = _savedCursorVisible;
				_cursorStateCaptured = false;
				if (_pausedByTrainer && (Object)(object)CL_GameManager.gMan != (Object)null)
				{
					CL_GameManager.gMan.UnPause();
					_pausedByTrainer = false;
				}
			}
		}

		private void ToggleNativeTrainerMenu()
		{
			CL_GameManager gMan = CL_GameManager.gMan;
			if ((Object)(object)gMan == (Object)null)
			{
				return;
			}
			if (NativePauseMenuPatch.IsOpen)
			{
				NativePauseMenuPatch.Close();
				return;
			}
			if (!gMan.isPaused)
			{
				gMan.Pause();
			}
			NativePauseMenuPatch.TryOpen(gMan);
		}

		internal bool EnsureNativeCheatMode()
		{
			if (CommandConsole.hasCheated)
			{
				return true;
			}
			if ((Object)(object)CommandConsole.instance == (Object)null)
			{
				return false;
			}
			CommandConsole.instance.ExecuteCommand("cheats true", false);
			if (CommandConsole.hasCheated)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Trainer] Enabled White Knuckle cheats for the active trainer run.");
			}
			return CommandConsole.hasCheated;
		}

		internal static string Categorize(string displayName, string prefabId)
		{
			string value = (displayName + " " + prefabId).ToLowerInvariant();
			if (Contains(value, "banhammer", "fruit", "rope"))
			{
				return "Cheats / unused";
			}
			if (Contains(value, "glove", "remote", "spear", "timepiece", "translocator", "rapier", "blink", "cleaver", "rho", "barnacle", "p-beans", "p_beans", "p beans"))
			{
				return "Artifacts";
			}
			if (Contains(value, "beta", "buddy", "carabiner", "chalk", "climbing shoes", "employee id", "gold nugget", "head lamp", "helmet", "mass damper", "moon rocks", "yearning photo"))
			{
				return "Trinkets";
			}
			if (Contains(value, "hammer", "cryo", "flare gun", "handgun", "flashlight", "wrench", "scanner", "auto piton", "brick", "piton", "rebar"))
			{
				return "Tools & weapons";
			}
			if (Contains(value, "gold roach", "platinum roach", "ruby roach", "flare", "ammo", "floppy", "fuel cell"))
			{
				return "Miscellaneous";
			}
			if (Contains(value, "bean", "food bar", "grub", "inject", "inocul", "roach", "milk", "pill", "wine", "cocoa", "cookie", "meat", "candy cauldron"))
			{
				return "Consumables";
			}
			return "Uncategorized";
		}

		private static bool Contains(string value, params string[] words)
		{
			return words.Any(value.Contains);
		}

		private static bool IsUsefulConsumable(ItemEntry item)
		{
			string text = item.PrefabId.ToLowerInvariant();
			if (!text.Contains("_empty") && !text.Contains("_eaten"))
			{
				return !text.Contains("_navmesh");
			}
			return false;
		}

		private static void DrawItemPreview(ItemEntry item)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(24f, 24f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(24f),
				GUILayout.Height(24f)
			});
			if (!((Object)(object)item.Icon == (Object)null))
			{
				Rect rect2 = item.Icon.rect;
				Texture texture = (Texture)(object)item.Icon.texture;
				GUI.DrawTextureWithTexCoords(rect, texture, new Rect(((Rect)(ref rect2)).x / (float)texture.width, ((Rect)(ref rect2)).y / (float)texture.height, ((Rect)(ref rect2)).width / (float)texture.width, ((Rect)(ref rect2)).height / (float)texture.height));
			}
		}

		private static void SetJumpCounters(ENT_Player player, int normal, int temporary)
		{
			Traverse obj = Traverse.Create((object)player);
			obj.Field("extraJumpsRemaining").SetValue((object)normal);
			obj.Field("temporaryExtraJumpsRemaining").SetValue((object)temporary);
		}

		private static void SetGameInfiniteAmmo(bool enabled)
		{
			ENT_Player player = ENT_Player.GetPlayer();
			if ((Object)(object)player != (Object)null)
			{
				player.InfiniteAmmoCommand(new string[1] { enabled.ToString() });
			}
		}
	}
	[HarmonyPatch(typeof(ENT_Player), "Jump")]
	internal static class InfiniteJumpPatch
	{
		private static void Prefix(ENT_Player __instance)
		{
			WhiteKnuckleTrainerPlugin? instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance != null && instance.InfiniteJumps)
			{
				Traverse obj = Traverse.Create((object)__instance);
				obj.Field("extraJumpsRemaining").SetValue((object)99);
				obj.Field("temporaryExtraJumpsRemaining").SetValue((object)99);
			}
		}
	}
	[HarmonyPatch(typeof(HandItem), "RemoveItem")]
	internal static class InfiniteThrowablePatch
	{
		private static bool Prefix(HandItem __instance)
		{
			WhiteKnuckleTrainerPlugin? instance = WhiteKnuckleTrainerPlugin.Instance;
			if (instance == null || !instance.InfiniteAmmoAndThrowables)
			{
				return true;
			}
			__instance.item.SetUsed(false);
			__instance.used = false;
			return false;
		}
	}
}