using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Photon.Pun;
using Photon.Realtime;
using REPOLib.Extensions;
using REPOLib.Modules;
using RepoAdminMenu.Patches;
using RepoAdminMenu.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("RepoAdminMenu")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("proferabg")]
[assembly: AssemblyProduct("RepoAdminMenu")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3ae48784-5268-4c13-9676-09db1348e95e")]
[assembly: AssemblyFileVersion("1.0.10.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.10.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 RepoAdminMenu
{
	internal class Configuration
	{
		public static ConfigEntry<bool> EnableCommands { get; private set; }

		public static ConfigEntry<bool> EnableHotkey { get; private set; }

		public static ConfigEntry<KeyCode> MenuHotkey { get; private set; }

		public static ConfigEntry<int> MaxUpgradeLevel { get; private set; }

		public static ConfigEntry<bool> ResetSettingsOnLobbyCreation { get; private set; }

		public static ConfigEntry<bool> CloseMenuOnSpawning { get; private set; }

		public static void Init(ConfigFile config)
		{
			EnableCommands = config.Bind<bool>("General", "EnableCommands", true, "Enables RepoAdminMenu commands");
			EnableHotkey = config.Bind<bool>("General", "EnableHotkey", true, "Enables RepoAdminMenu menu");
			MenuHotkey = config.Bind<KeyCode>("General", "MenuHotkey", (KeyCode)289, "Key to open or close the menu");
			MaxUpgradeLevel = config.Bind<int>("General", "MaxUpgrade", 25, "Changes the slider max value for player upgrades");
			ResetSettingsOnLobbyCreation = config.Bind<bool>("General", "ResetSettingsOnLobbyCreation", true, "Should menu settings and player toggles reset on new lobby creation");
			CloseMenuOnSpawning = config.Bind<bool>("General", "CloseMenuOnSpawning", true, "Should the menu close when spawning an enemy");
		}
	}
	internal class Menu
	{
		private static string selectedPlayerId;

		private static REPOPopupPage currentMenu;

		private static string currentMenuStr = "";

		private static Dictionary<string, Action> menus = new Dictionary<string, Action>();

		private static MethodInfo removeAllPagesMethod = AccessTools.Method(typeof(MenuManager), "PageCloseAll", (Type[])null, (Type[])null);

		private static Dictionary<string, Action<string, REPOPopupPage>> menuPreCallbacks = new Dictionary<string, Action<string, REPOPopupPage>>();

		private static Dictionary<string, Action<string, REPOPopupPage>> menuPostCallbacks = new Dictionary<string, Action<string, REPOPopupPage>>();

		public static void Init()
		{
			registerMenu("playerList", openPlayerListMenu);
			registerMenu("player", openPlayerMenu);
			registerMenu("playerUpgrade", openPlayerUpgrades);
			registerMenu("spawn", openSpawnMenu);
			registerMenu("spawnItem", openSpawnItemsMenu);
			registerMenu("spawnEnemy", openSpawnEnemyMenu);
			registerMenu("spawnValuable", openSpawnValuablesMenu);
			registerMenu("spawnValuableTiny", openSpawnValuablesTinyMenu);
			registerMenu("spawnValuableSmall", openSpawnValuablesSmallMenu);
			registerMenu("spawnValuableMedium", openSpawnValuablesMediumMenu);
			registerMenu("spawnValuableBig", openSpawnValuablesBigMenu);
			registerMenu("spawnValuableWide", openSpawnValuablesWideMenu);
			registerMenu("spawnValuableTall", openSpawnValuablesTallMenu);
			registerMenu("spawnValuableVeryTall", openSpawnValuablesVeryTallMenu);
			registerMenu("map", openMapMenu);
			registerMenu("levelSelector", openLevelSelectorMenu);
			registerMenu("settings", openSettingsMenu);
			registerMenu("credits", openCreditsMenu);
			registerMenu("mainmenu", openMainMenu);
		}

		public static void registerMenu(string name, Action openAction)
		{
			menus.Add(name, openAction);
		}

		public static void addMenuPreCallback(string mod_name, Action<string, REPOPopupPage> action)
		{
			menuPreCallbacks.Add(mod_name, action);
		}

		public static void removeMenuPreCallback(string mod_name)
		{
			menuPreCallbacks.Remove(mod_name);
		}

		public static void addMenuPostCallback(string mod_name, Action<string, REPOPopupPage> action)
		{
			menuPostCallbacks.Add(mod_name, action);
		}

		public static void removeMenuPostCallback(string mod_name)
		{
			menuPostCallbacks.Remove(mod_name);
		}

		public static void toggleMenu()
		{
			if (menus.Count < 1)
			{
				Init();
			}
			if (SemiFunc.MenuLevel())
			{
				RepoAdminMenu.mls.LogInfo((object)"Repo Admin Menu can only be opened while in-game!");
				return;
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				RepoAdminMenu.mls.LogInfo((object)"Repo Admin Menu can only be opened in single player or as host in multiplayer!");
				return;
			}
			if ((Object)(object)currentMenu != (Object)null && ((Behaviour)currentMenu).isActiveAndEnabled)
			{
				closePage(currentMenu);
				return;
			}
			RepoAdminMenu.mls.LogInfo((object)"Opening menu");
			menus.GetValueOrDefault(currentMenuStr, openMainMenu)();
		}

		public static void closePage(REPOPopupPage page)
		{
			RepoAdminMenu.mls.LogInfo((object)("Closing: " + ((Object)page.menuPage).name));
			removeAllPagesMethod.Invoke(MenuManager.instance, new object[0]);
			page.ClosePage(true);
			MenuManager.instance.PageRemove(page.menuPage);
			if ((Object)(object)currentMenu == (Object)(object)page)
			{
				currentMenu = null;
			}
		}

		public static void navigate(REPOPopupPage page, string menu)
		{
			closePage(page);
			menus.GetValueOrDefault(menu, delegate
			{
				RepoAdminMenu.mls.LogError((object)("Menu not found: " + menu));
			})();
		}

		public static void openPage(REPOPopupPage page, string name)
		{
			((MonoBehaviour)MenuManager.instance).StartCoroutine(openPageInternal(page, name));
		}

		private static IEnumerator openPageInternal(REPOPopupPage page, string name)
		{
			yield return (object)new WaitForSeconds(0.05f);
			foreach (KeyValuePair<string, Action<string, REPOPopupPage>> menuPostCallback in menuPostCallbacks)
			{
				RepoAdminMenu.mls.LogInfo((object)("Running post-callback for '" + menuPostCallback.Key + "' on menu '" + name + "'"));
				menuPostCallback.Value(name, page);
			}
			RepoAdminMenu.mls.LogInfo((object)("Opening: " + ((Object)page.menuPage).name));
			removeAllPagesMethod.Invoke(MenuManager.instance, new object[0]);
			page.OpenPage(false);
			currentMenu = page;
			currentMenuStr = name;
		}

		public static REPOPopupPage createMenu(string title, string currentMenu, string parentMenu)
		{
			REPOPopupPage val = MenuAPI.CreateREPOPopupPage(title, (PresetSide)0, false, true, 0f);
			foreach (KeyValuePair<string, Action<string, REPOPopupPage>> menuPreCallback in menuPreCallbacks)
			{
				RepoAdminMenu.mls.LogInfo((object)("Running pre-callback for '" + menuPreCallback.Key + "' on menu '" + currentMenu + "'"));
				menuPreCallback.Value(currentMenu, val);
			}
			addBackButton(val, parentMenu);
			return val;
		}

		public static REPOPopupPage createMainMenu(string title)
		{
			REPOPopupPage val = MenuAPI.CreateREPOPopupPage(title, (PresetSide)0, false, true, 0f);
			foreach (KeyValuePair<string, Action<string, REPOPopupPage>> menuPreCallback in menuPreCallbacks)
			{
				RepoAdminMenu.mls.LogInfo((object)("Running pre-callback for '" + menuPreCallback.Key + "' on menu 'mainmenu'"));
				menuPreCallback.Value("mainmenu", val);
			}
			addCloseButton(val);
			return val;
		}

		public static void addButton(REPOPopupPage parent, string text, Action action)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOButton(text, action, scrollView, default(Vector2))).rectTransform), 0f, 0f);
		}

		public static void addBackButton(REPOPopupPage parent, string parentMenu)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			parent.AddElement((BuilderDelegate)delegate(Transform transform)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				MenuAPI.CreateREPOButton("← Back", (Action)delegate
				{
					closePage(parent);
					menus.GetValueOrDefault(parentMenu, delegate
					{
						RepoAdminMenu.mls.LogError((object)("Menu not found: " + parentMenu));
					})();
				}, transform, new Vector2(250f, 20f));
			});
		}

		public static void addCloseButton(REPOPopupPage parent)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			parent.AddElement((BuilderDelegate)delegate(Transform transform)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				MenuAPI.CreateREPOButton("Close", (Action)delegate
				{
					closePage(parent);
				}, transform, new Vector2(270f, 20f));
			});
		}

		public static void addToggle(REPOPopupPage parent, string text, Action<bool> action, bool defaultValue, string[] buttonText = null)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOToggle(text, action, scrollView, Vector2.zero, (buttonText == null || buttonText.Length < 2) ? "Off" : buttonText[0], (buttonText == null || buttonText.Length < 2) ? "On" : buttonText[1], !defaultValue)).rectTransform), 0f, 0f);
		}

		public static void addLabel(REPOPopupPage parent, string text)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOLabel(text, scrollView, default(Vector2))).rectTransform), 0f, 0f);
		}

		public static void addIntSlider(REPOPopupPage parent, string text, string description, Action<int> action, int min, int max, int defaultValue)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOSlider(text, description, action, scrollView, Vector2.zero, min, max, defaultValue, "", "", (BarBehavior)0)).rectTransform), 0f, 0f);
		}

		public static void addFloatSlider(REPOPopupPage parent, string text, string description, Action<float> action, float min, float max, int precision, float defaultValue)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOSlider(text, description, action, scrollView, Vector2.zero, min, max, precision, defaultValue, "", "", (BarBehavior)0)).rectTransform), 0f, 0f);
		}

		public static void addStringSlider(REPOPopupPage parent, string text, string description, Action<string> action, string[] options, string defaultValue)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)((Transform scrollView) => ((REPOElement)MenuAPI.CreateREPOSlider(text, description, action, scrollView, options, defaultValue, Vector2.zero, "", "", (BarBehavior)0)).rectTransform), 0f, 0f);
		}

		public static void openMainMenu()
		{
			REPOPopupPage mainMenu = createMainMenu("R.E.P.O. Admin Menu");
			addButton(mainMenu, "Players", delegate
			{
				navigate(mainMenu, "playerList");
			});
			addButton(mainMenu, "Spawn", delegate
			{
				navigate(mainMenu, "spawn");
			});
			addButton(mainMenu, "Map", delegate
			{
				navigate(mainMenu, "map");
			});
			addButton(mainMenu, "Settings", delegate
			{
				navigate(mainMenu, "settings");
			});
			addButton(mainMenu, "Credits", delegate
			{
				navigate(mainMenu, "credits");
			});
			addButton(mainMenu, "Report a Bug", delegate
			{
				Application.OpenURL("https://github.com/proferabg/RepoAdminMenu/issues");
			});
			openPage(mainMenu, "mainmenu");
		}

		private static void openPlayerListMenu()
		{
			REPOPopupPage playersMenu = createMenu("R.A.M. - Players", "playerList", "mainmenu");
			foreach (PlayerAvatar player in SemiFunc.PlayerGetAll())
			{
				addButton(playersMenu, SemiFunc.PlayerGetName(player), delegate
				{
					selectedPlayerId = SemiFunc.PlayerGetSteamID(player);
					navigate(playersMenu, "player");
				});
			}
			openPage(playersMenu, "playerList");
		}

		private static void openPlayerMenu()
		{
			if (selectedPlayerId == null || (Object)(object)SemiFunc.PlayerGetFromSteamID(selectedPlayerId) == (Object)null)
			{
				RepoAdminMenu.mls.LogInfo((object)"No player selected");
				openPlayerListMenu();
				return;
			}
			PlayerAvatar avatar = SemiFunc.PlayerGetFromSteamID(selectedPlayerId);
			REPOPopupPage playerMenu = createMenu("R.A.M. - " + SemiFunc.PlayerGetName(avatar), "player", "playerList");
			addToggle(playerMenu, "God Mode", delegate(bool b)
			{
				Settings.toggle(Settings.instance.godModePlayers, avatar.steamID, b);
			}, Settings.isGod(avatar));
			addToggle(playerMenu, "No Death", delegate(bool b)
			{
				Settings.toggle(Settings.instance.noDeathPlayers, avatar.steamID, b);
			}, Settings.isNoDeath(avatar));
			addToggle(playerMenu, "No Target", delegate(bool b)
			{
				Settings.toggle(Settings.instance.noTargetPlayers, avatar.steamID, b);
			}, Settings.isNoTarget(avatar));
			addToggle(playerMenu, "No Tumble", delegate(bool b)
			{
				Settings.toggle(Settings.instance.noTumblePlayers, avatar.steamID, b);
			}, Settings.isNoTumble(avatar));
			addToggle(playerMenu, "Infinite Stamina", delegate(bool b)
			{
				Settings.toggle(Settings.instance.infiniteStaminaPlayers, avatar.steamID, b);
			}, Settings.isInfiniteStamina(avatar));
			addToggle(playerMenu, "Force Tumble", delegate(bool b)
			{
				Settings.toggleDictLong(Settings.instance.forcedTumble, avatar.steamID, b);
			}, Settings.isForceTumble(avatar));
			addButton(playerMenu, "Upgrades", delegate
			{
				navigate(playerMenu, "playerUpgrade");
			});
			addButton(playerMenu, "Heal", delegate
			{
				PlayerUtil.healPlayer(avatar);
			});
			addButton(playerMenu, "Kill", delegate
			{
				PlayerUtil.killPlayer(avatar);
			});
			addButton(playerMenu, "Revive", delegate
			{
				PlayerUtil.revivePlayer(avatar);
			});
			addButton(playerMenu, "Teleport To", delegate
			{
				PlayerUtil.teleportTo(avatar);
			});
			addButton(playerMenu, "Summon", delegate
			{
				PlayerUtil.summon(avatar);
			});
			addButton(playerMenu, "Give Crown", delegate
			{
				PlayerUtil.giveCrown(avatar);
			});
			addButton(playerMenu, "Kick Player", delegate
			{
				closePage(playerMenu);
				openConfirmMenu("player", "Kick: " + SemiFunc.PlayerGetName(avatar), new Dictionary<string, Action>
				{
					{
						"Yes",
						delegate
						{
							PlayerUtil.KickPlayer(avatar);
						}
					},
					{ "No", null }
				});
			});
			openPage(playerMenu, "player");
		}

		private static void openPlayerUpgrades()
		{
			if (selectedPlayerId == null || (Object)(object)SemiFunc.PlayerGetFromSteamID(selectedPlayerId) == (Object)null)
			{
				RepoAdminMenu.mls.LogInfo((object)"No player selected");
				openPlayerListMenu();
				return;
			}
			PlayerAvatar avatar = SemiFunc.PlayerGetFromSteamID(selectedPlayerId);
			REPOPopupPage obj = createMenu("R.A.M. - " + SemiFunc.PlayerGetName(avatar) + " - Upgrades", "playerUpgrade", "player");
			addIntSlider(obj, "Health", "", delegate(int v)
			{
				PlayerUtil.upgradeHealth(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("health", avatar));
			addIntSlider(obj, "Jump", "", delegate(int v)
			{
				PlayerUtil.upgradeJump(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("jump", avatar));
			addIntSlider(obj, "Launch", "", delegate(int v)
			{
				PlayerUtil.upgradeLaunch(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("launch", avatar));
			addIntSlider(obj, "Map Player Count", "", delegate(int v)
			{
				PlayerUtil.upgradeMapPlayerCount(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("playercount", avatar));
			addIntSlider(obj, "Range", "", delegate(int v)
			{
				PlayerUtil.upgradeRange(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("range", avatar));
			addIntSlider(obj, "Speed", "", delegate(int v)
			{
				PlayerUtil.upgradeSpeed(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("speed", avatar));
			addIntSlider(obj, "Stamina", "", delegate(int v)
			{
				PlayerUtil.upgradeStamina(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("stamina", avatar));
			addIntSlider(obj, "Strength", "", delegate(int v)
			{
				PlayerUtil.upgradeStrength(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("strength", avatar));
			addIntSlider(obj, "Throw", "", delegate(int v)
			{
				PlayerUtil.upgradeThrow(avatar, v);
			}, 0, Configuration.MaxUpgradeLevel.Value, PlayerUtil.getUpgradeLevel("throw", avatar));
			openPage(obj, "playerUpgrade");
		}

		private static void openSpawnMenu()
		{
			REPOPopupPage spawnerMenu = createMenu("R.A.M. - Spawn", "spawn", "mainmenu");
			addButton(spawnerMenu, "Items", delegate
			{
				navigate(spawnerMenu, "spawnItem");
			});
			addButton(spawnerMenu, "Valuables", delegate
			{
				navigate(spawnerMenu, "spawnValuable");
			});
			addButton(spawnerMenu, "Enemies", delegate
			{
				navigate(spawnerMenu, "spawnEnemy");
			});
			openPage(spawnerMenu, "spawn");
		}

		private static void openSpawnItemsMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Spawn - Items", "spawnItem", "spawn");
			foreach (KeyValuePair<string, Item> entry in ItemUtil.getItems())
			{
				addButton(val, entry.Key, delegate
				{
					ItemUtil.spawnItem(entry.Value);
				});
			}
			openPage(val, "spawnItem");
		}

		private static void openSpawnValuablesMenu()
		{
			REPOPopupPage valuablesMenu = createMenu("R.A.M. - Spawn - Valuables", "spawnValuable", "spawn");
			addButton(valuablesMenu, "Tiny", delegate
			{
				navigate(valuablesMenu, "spawnValuableTiny");
			});
			addButton(valuablesMenu, "Small", delegate
			{
				navigate(valuablesMenu, "spawnValuableSmall");
			});
			addButton(valuablesMenu, "Medium", delegate
			{
				navigate(valuablesMenu, "spawnValuableMedium");
			});
			addButton(valuablesMenu, "Big", delegate
			{
				navigate(valuablesMenu, "spawnValuableBig");
			});
			addButton(valuablesMenu, "Wide", delegate
			{
				navigate(valuablesMenu, "spawnValuableWide");
			});
			addButton(valuablesMenu, "Tall", delegate
			{
				navigate(valuablesMenu, "spawnValuableTall");
			});
			addButton(valuablesMenu, "Very Tall", delegate
			{
				navigate(valuablesMenu, "spawnValuableVeryTall");
			});
			openPage(valuablesMenu, "spawnValuable");
		}

		private static void openSpawnValuablesTinyMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Tiny Valuables", "spawnValuableTiny", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getTinyValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableTiny");
		}

		private static void openSpawnValuablesSmallMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Small Valuables", "spawnValuableSmall", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getSmallValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableSmall");
		}

		private static void openSpawnValuablesMediumMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Medium Valuables", "spawnValuableMedium", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getMediumValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableMedium");
		}

		private static void openSpawnValuablesBigMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Big Valuables", "spawnValuableBig", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getBigValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableBig");
		}

		private static void openSpawnValuablesWideMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Wide Valuables", "spawnValuableWide", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getWideValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableWide");
		}

		private static void openSpawnValuablesTallMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Tall Valuables", "spawnValuableTall", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getTallValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableTall");
		}

		private static void openSpawnValuablesVeryTallMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Very Tall Valuables", "spawnValuableVeryTall", "spawnValuable");
			foreach (KeyValuePair<string, GameObject> entry in ValuableUtil.getVeryTallValuables())
			{
				addButton(val, entry.Key, delegate
				{
					ValuableUtil.spawnValuable(entry.Value);
				});
			}
			openPage(val, "spawnValuableVeryTall");
		}

		private static void openSpawnEnemyMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Spawn - Enemies", "spawnEnemy", "spawn");
			foreach (string enemy in EnemyUtil.getEnemies().Keys)
			{
				addButton(val, enemy, delegate
				{
					EnemyUtil.spawnEnemy(enemy);
				});
			}
			foreach (string enemy2 in EnemyUtil.getModEnemies().Keys)
			{
				addButton(val, "(Mod) " + enemy2, delegate
				{
					EnemyUtil.spawnEnemy(enemy2);
				});
			}
			openPage(val, "spawnEnemy");
		}

		private static void openMapMenu()
		{
			REPOPopupPage mapMenu = createMenu("R.A.M. - Map Settings", "map", "mainmenu");
			foreach (KeyValuePair<string, Level> entry in MapUtil.getMaps())
			{
				addToggle(mapMenu, entry.Key, delegate(bool b)
				{
					MapUtil.setMapEnabled(entry.Value, b);
				}, MapUtil.isMapEnabled(entry.Value));
			}
			addIntSlider(mapMenu, "Current Level", "", delegate(int v)
			{
				RunManager.instance.levelsCompleted = v;
			}, 1, 500, RunManager.instance.levelsCompleted);
			addIntSlider(mapMenu, "Money", "", delegate(int v)
			{
				PunManager.instance.SetRunStatSet("currency", v);
			}, 0, 9999, StatsManager.instance.runStats["currency"]);
			addButton(mapMenu, "Map Selector", delegate
			{
				navigate(mapMenu, "levelSelector");
			});
			addButton(mapMenu, "Discover Extraction Point", ExtractionPointUtil.discoverNext);
			addButton(mapMenu, "Complete Extraction Point", ExtractionPointUtil.complete);
			openPage(mapMenu, "map");
		}

		private static void openLevelSelectorMenu()
		{
			REPOPopupPage val = createMenu("R.A.M. - Map Selector", "levelSelector", "map");
			foreach (KeyValuePair<string, Level> entry in MapUtil.getMaps())
			{
				addButton(val, entry.Key, delegate
				{
					MapUtil.changeLevel(entry.Value);
				});
			}
			addButton(val, "Arena", delegate
			{
				MapUtil.changeLevel(RunManager.instance.levelArena);
			});
			addButton(val, "Lobby", delegate
			{
				MapUtil.changeLevel(RunManager.instance.levelLobby);
			});
			addButton(val, "Shop", delegate
			{
				MapUtil.changeLevel(RunManager.instance.levelShop);
			});
			openPage(val, "levelSelector");
		}

		private static void openSettingsMenu()
		{
			REPOPopupPage obj = createMenu("R.A.M. - Settings", "settings", "mainmenu");
			addToggle(obj, "Infinite Money", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.infiniteMoney, !b);
				Settings.UpdateClients();
			}, Settings.instance.infiniteMoney);
			addToggle(obj, "No Break", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.noBreak, !b);
			}, Settings.instance.noBreak);
			addToggle(obj, "No Battery/Ammo Drain", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.noBatteryDrain, !b);
			}, Settings.instance.noBatteryDrain);
			addToggle(obj, "No Traps", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.noTraps, !b);
			}, Settings.instance.noTraps);
			addToggle(obj, "Weak Enemies", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.weakEnemies, !b);
			}, Settings.instance.weakEnemies);
			addToggle(obj, "Deaf Enemies", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.deafEnemies, !b);
			}, Settings.instance.deafEnemies);
			addToggle(obj, "Blind Enemies", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.blindEnemies, !b);
			}, Settings.instance.blindEnemies);
			addToggle(obj, "Boom Hammer", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.boomhammer, !b);
			}, Settings.instance.boomhammer);
			addToggle(obj, "Friendly Duck", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.friendlyDuck, !b);
			}, Settings.instance.friendlyDuck);
			addToggle(obj, "Upgrade In Shop", delegate(bool b)
			{
				Settings.UpdateOption(ref Settings.instance.useShopUpgrades, !b);
			}, Settings.instance.useShopUpgrades);
			openPage(obj, "settings");
		}

		private static void openCreditsMenu()
		{
			REPOPopupPage obj = createMenu("R.A.M. - Credits", "credits", "mainmenu");
			addLabel(obj, "Repo Admin Menu by");
			addLabel(obj, "  proferabg  ");
			addLabel(obj, "");
			addLabel(obj, "Special thanks to:");
			addLabel(obj, " - REPOrium_Team");
			addLabel(obj, " - nickklmao");
			addLabel(obj, " - Godji");
			addLabel(obj, " - Zehs");
			addLabel(obj, "");
			addLabel(obj, "Repo Admin Menu © 2025");
			openPage(obj, "credits");
		}

		private static void openConfirmMenu(string currentMenu, string message, Dictionary<string, Action> options)
		{
			REPOPopupPage confirmMenu = createMenu("R.A.M. - Confirm", "confirm", "player");
			confirmMenu.closeMenuOnEscape = false;
			addLabel(confirmMenu, message);
			addLabel(confirmMenu, "");
			foreach (KeyValuePair<string, Action> option in options)
			{
				addButton(confirmMenu, option.Key, delegate
				{
					if (option.Value != null)
					{
						option.Value();
					}
					navigate(confirmMenu, currentMenu);
				});
			}
			openPage(confirmMenu, "confirm");
		}

		public static string getSelectedPlayer()
		{
			return selectedPlayerId;
		}
	}
	[HarmonyPatch(typeof(ChatManager))]
	internal class ChatManagerPatch
	{
		[HarmonyPatch("MessageSend")]
		[HarmonyPrefix]
		private static bool MessageSend_Prefix(ChatManager __instance, ref string ___chatMessage)
		{
			if (!Configuration.EnableCommands.Value || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return true;
			}
			if (___chatMessage.Replace("<b>|</b>", string.Empty).ToLower().Split(' ')[0] == "!menu")
			{
				Menu.toggleMenu();
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("proferabg.REPO.RepoAdminMenu", "Repo Admin Menu", "1.0.10")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class RepoAdminMenu : BaseUnityPlugin
	{
		private const string mod_guid = "proferabg.REPO.RepoAdminMenu";

		private const string mod_name = "Repo Admin Menu";

		private const string mod_version = "1.0.10";

		private static RepoAdminMenu _plugin;

		public static Harmony harmony = new Harmony("proferabg.REPO.RepoAdminMenu");

		public static ManualLogSource mls;

		public void Awake()
		{
			if ((Object)(object)_plugin == (Object)null)
			{
				_plugin = this;
			}
			mls = Logger.CreateLogSource("Repo Admin Menu");
			Configuration.Init(((BaseUnityPlugin)this).Config);
			Settings.Init();
			harmony.PatchAll();
			mls.LogInfo((object)"R.A.M. (1.0.10) has been allocated!");
		}
	}
	internal class Settings
	{
		internal static Settings instance;

		public bool infiniteMoney;

		public bool noBreak;

		public bool noBatteryDrain;

		public bool noTraps;

		public bool weakEnemies;

		public bool deafEnemies;

		public bool blindEnemies;

		public bool boomhammer;

		public bool friendlyDuck;

		public bool useShopUpgrades;

		public List<string> godModePlayers = new List<string>();

		public List<string> noDeathPlayers = new List<string>();

		public List<string> infiniteStaminaPlayers = new List<string>();

		public List<string> noTargetPlayers = new List<string>();

		public List<string> noTumblePlayers = new List<string>();

		public Dictionary<string, long> forcedTumble = new Dictionary<string, long>();

		public Settings()
		{
			instance = this;
		}

		public static void Init()
		{
			if (instance == null)
			{
				new Settings();
			}
		}

		public static void toggle(List<string> list, string steamId, bool value)
		{
			if (value)
			{
				list.Remove(steamId);
			}
			else
			{
				list.Add(steamId);
			}
			UpdateClients();
		}

		public static void toggleDictLong(Dictionary<string, long> list, string steamId, bool value)
		{
			if (value)
			{
				list.Remove(steamId);
			}
			else
			{
				list.Add(steamId, 0L);
			}
			UpdateClients();
		}

		public static bool isGod(PlayerAvatar avatar)
		{
			return instance.godModePlayers.Contains(SemiFunc.PlayerGetSteamID(avatar));
		}

		public static bool isNoDeath(PlayerAvatar avatar)
		{
			return instance.noDeathPlayers.Contains(SemiFunc.PlayerGetSteamID(avatar));
		}

		public static bool isInfiniteStamina(PlayerAvatar avatar)
		{
			return instance.infiniteStaminaPlayers.Contains(SemiFunc.PlayerGetSteamID(avatar));
		}

		public static bool isNoTarget(PlayerAvatar avatar)
		{
			return instance.noTargetPlayers.Contains(SemiFunc.PlayerGetSteamID(avatar));
		}

		public static bool isNoTumble(PlayerAvatar avatar)
		{
			return instance.noTumblePlayers.Contains(SemiFunc.PlayerGetSteamID(avatar));
		}

		public static bool isForceTumble(PlayerAvatar avatar)
		{
			return instance.forcedTumble.ContainsKey(SemiFunc.PlayerGetSteamID(avatar));
		}

		internal static long getLastForceTumble(PlayerAvatar avatar)
		{
			return instance.forcedTumble.GetValueOrDefault(SemiFunc.PlayerGetSteamID(avatar), 0L);
		}

		internal static long setLastForceTumble(PlayerAvatar avatar, long lastTumble)
		{
			return instance.forcedTumble[SemiFunc.PlayerGetSteamID(avatar)] = lastTumble;
		}

		public static void UpdateOption(ref bool option, bool value)
		{
			option = value;
			UpdateClients();
		}

		public static void UpdateClients()
		{
			if (SemiFunc.IsMasterClient())
			{
				RepoAdminMenu.mls.LogInfo((object)"Sending Settings Sync");
				NetworkUtil.SendCommandString("SettingsSync", instance.toJson(), (ReceiverGroup)0);
			}
		}

		public string toJson()
		{
			return JsonConvert.SerializeObject((object)this);
		}

		public static void loadFromJson(string json)
		{
			instance = JsonConvert.DeserializeObject<Settings>(json);
		}

		internal void log()
		{
			RepoAdminMenu.mls.LogInfo((object)("\n\n\n" + instance.toJson() + "\n\n\n"));
			RepoAdminMenu.mls.LogInfo((object)("Current Settings:\n  infiniteMoney - " + instance.infiniteMoney + "\n  noBreak - " + instance.noBreak + "\n  noBatteryDrain - " + instance.noBatteryDrain + "\n  noTraps - " + instance.noTraps + "\n  weakEnemies - " + instance.weakEnemies + "\n  deafEnemies - " + instance.deafEnemies + "\n  blindEnemies - " + instance.blindEnemies + "\n  boomhammer - " + instance.boomhammer + "\n  friendlyDuck - " + instance.friendlyDuck + "\n  useShopUpgrades - " + instance.useShopUpgrades + "\n  godMode: - " + string.Join(",", instance.godModePlayers.Select((string player) => SemiFunc.PlayerGetName(SemiFunc.PlayerGetFromSteamID(player)))) + "\n  noDeathPlayers: - " + string.Join(",", instance.noDeathPlayers.Select((string player) => SemiFunc.PlayerGetName(SemiFunc.PlayerGetFromSteamID(player)))) + "\n  infiniteStaminaPlayers: - " + string.Join(",", instance.infiniteStaminaPlayers.Select((string player) => SemiFunc.PlayerGetName(SemiFunc.PlayerGetFromSteamID(player)))) + "\n  noTargetPlayers: - " + string.Join(",", instance.noTargetPlayers.Select((string player) => SemiFunc.PlayerGetName(SemiFunc.PlayerGetFromSteamID(player)))) + "\n  noTumblePlayers: - " + string.Join(",", instance.noTumblePlayers.Select((string player) => SemiFunc.PlayerGetName(SemiFunc.PlayerGetFromSteamID(player)))) + "\n"));
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "RepoAdminMenu";

		public const string PLUGIN_NAME = "RepoAdminMenu";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace RepoAdminMenu.Utils
{
	internal class EnemyUtil
	{
		private static SortedDictionary<string, EnemySetup> enemySetups = new SortedDictionary<string, EnemySetup>();

		private static SortedDictionary<string, EnemySetup> modEnemySetups = new SortedDictionary<string, EnemySetup>();

		public static void Init()
		{
			enemySetups.Clear();
			modEnemySetups.Clear();
			List<EnemySetup> list = new List<EnemySetup>();
			list.AddRange(EnemyDirector.instance.enemiesDifficulty1);
			list.AddRange(EnemyDirector.instance.enemiesDifficulty2);
			list.AddRange(EnemyDirector.instance.enemiesDifficulty3);
			foreach (EnemySetup item in list)
			{
				if (!((Object)item).name.StartsWith("Enemy Group"))
				{
					string text = ((Object)item).name.Replace("Enemy - ", string.Empty);
					switch (text)
					{
					case "Ceiling Eye":
						addEnemySetupSafe("Peeper", item);
						break;
					case "Thin Man":
						addEnemySetupSafe("Shadow Child", item);
						break;
					case "Gnome":
						addEnemySetupSafe("Gnome", item);
						break;
					case "Duck":
						addEnemySetupSafe("Apex Predator", item);
						break;
					case "Slow Mouth":
						addEnemySetupSafe("Spewer", item);
						break;
					case "Valuable Thrower":
						addEnemySetupSafe("Rugrat", item);
						break;
					case "Animal":
						addEnemySetupSafe("Animal", item);
						break;
					case "Upscream":
						addEnemySetupSafe("Upscream", item);
						break;
					case "Hidden":
						addEnemySetupSafe("Hidden", item);
						break;
					case "Tumbler":
						addEnemySetupSafe("Chef", item);
						break;
					case "Bowtie":
						addEnemySetupSafe("Bowtie", item);
						break;
					case "Floater":
						addEnemySetupSafe("Mentalist", item);
						break;
					case "Bang":
						addEnemySetupSafe("Bang", item);
						break;
					case "Head":
						addEnemySetupSafe("Headman", item);
						break;
					case "Robe":
						addEnemySetupSafe("Robe", item);
						break;
					case "Hunter":
						addEnemySetupSafe("Huntsman", item);
						break;
					case "Runner":
						addEnemySetupSafe("Reaper", item);
						break;
					case "Beamer":
						addEnemySetupSafe("Clown", item);
						break;
					case "Slow Walker":
						addEnemySetupSafe("Trudge", item);
						break;
					default:
						addModEnemySetupSafe(text, item);
						break;
					}
				}
			}
		}

		internal static void addEnemySetupSafe(string name, EnemySetup setup)
		{
			if (!enemySetups.ContainsKey(name))
			{
				enemySetups.Add(name, setup);
			}
		}

		internal static void addModEnemySetupSafe(string name, EnemySetup setup)
		{
			if (!modEnemySetups.ContainsKey(name))
			{
				modEnemySetups.Add(name, setup);
			}
		}

		public static SortedDictionary<string, EnemySetup> getEnemies()
		{
			return enemySetups;
		}

		public static SortedDictionary<string, EnemySetup> getModEnemies()
		{
			return modEnemySetups;
		}

		private static EnemySetup getEnemySetup(string name)
		{
			EnemySetup valueOrDefault = enemySetups.GetValueOrDefault(name, null);
			if ((Object)(object)valueOrDefault == (Object)null)
			{
				valueOrDefault = modEnemySetups.GetValueOrDefault(name, null);
			}
			return valueOrDefault;
		}

		public static void spawnEnemy(string enemy)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			if (EnemyParentPatch.spawning)
			{
				MissionUI.instance.MissionText("Already spawning enemy '" + enemy + "'!", Color.red, Color.red, 3f);
				return;
			}
			EnemySetup enemySetup = getEnemySetup(enemy);
			if ((Object)(object)enemySetup != (Object)null)
			{
				Vector3 position = ((Component)PlayerAvatar.instance).transform.position;
				((MonoBehaviour)EnemyDirector.instance).StartCoroutine(SpawnEnemy(enemySetup, position));
				if (Configuration.CloseMenuOnSpawning.Value)
				{
					Menu.toggleMenu();
				}
				MissionUI.instance.MissionText("Spawning '" + enemy + "'. Run...!", Color.red, Color.red, 3f);
			}
			else
			{
				MissionUI.instance.MissionText("Could not find enemy named '" + enemy + "'", Color.red, Color.red, 3f);
			}
		}

		private static IEnumerator SpawnEnemy(EnemySetup enemySetup, Vector3 position)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			yield return (object)new WaitForSeconds(3f);
			if (SemiFunc.IsMultiplayer())
			{
				Enemies.SpawnEnemy(enemySetup, position, Quaternion.identity, false);
				yield break;
			}
			EnemyParentPatch.spawning = true;
			LevelGenerator.Instance.EnemiesSpawned = -1;
			GameObject val = Object.Instantiate<GameObject>(enemySetup.spawnObjects[0], position, Quaternion.identity);
			EnemyParent component = val.GetComponent<EnemyParent>();
			if (!((Object)(object)component != (Object)null))
			{
				yield break;
			}
			component.SetupDone = true;
			val.GetComponentInChildren<Enemy>().EnemyTeleported(position);
			EnemyDirector.instance.FirstSpawnPointAdd(component);
			EnemyDirector.instance.enemiesSpawned.Add(component);
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				component.Enemy.PlayerAdded(item.photonView.ViewID);
			}
		}
	}
	internal class ExtractionPointUtil
	{
		public static void discoverNext()
		{
			if (RoundDirector.instance.extractionPointActive)
			{
				return;
			}
			foreach (GameObject extractionPoint in RoundDirector.instance.extractionPointList)
			{
				ExtractionPoint component = extractionPoint.GetComponent<ExtractionPoint>();
				if ((Object)(object)component != (Object)null && component.StateIs((State)1))
				{
					component.OnClick();
				}
			}
		}

		public static void complete()
		{
			if (RoundDirector.instance.extractionPointActive)
			{
				RoundDirector.instance.extractionPointCurrent.isCompletedRightAway = true;
				RoundDirector.instance.extractionPointCurrent.StateSet((State)6);
			}
		}
	}
	internal class ItemUtil
	{
		private static SortedDictionary<string, Item> items = new SortedDictionary<string, Item>();

		public static void Init()
		{
			items.Clear();
			foreach (Item item in StatsManagerExtensions.GetItems(StatsManager.instance))
			{
				string key = ((Object)item).name.Replace("Item ", string.Empty);
				if (!items.ContainsKey(key))
				{
					items.Add(key, item);
				}
			}
		}

		public static SortedDictionary<string, Item> getItems()
		{
			return items;
		}

		public static void spawnItem(Item item)
		{
			//IL_000a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0064: 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)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)PlayerAvatar.instance).transform.position + new Vector3(0f, 1f, 0f) + ((Component)PlayerAvatar.instance).transform.forward * 1f;
			GameObject val2 = ((!SemiFunc.IsMultiplayer()) ? Object.Instantiate<GameObject>(item.prefab, val, Quaternion.identity) : Items.SpawnItem(item, val, Quaternion.identity));
			ItemBattery componentInParent = val2.GetComponentInParent<ItemBattery>();
			if (Object.op_Implicit((Object)(object)componentInParent) && componentInParent.batteryLifeInt < 6)
			{
				componentInParent.SetBatteryLife(100);
			}
		}
	}
	internal class MapUtil
	{
		private static SortedDictionary<string, Level> maps = new SortedDictionary<string, Level>();

		private static Dictionary<Level, bool> mapToggles = new Dictionary<Level, bool>();

		private static Level nextLevel = null;

		public static void Init()
		{
			if (maps.Count > 0)
			{
				return;
			}
			foreach (Level level in RunManager.instance.levels)
			{
				maps.Add(((Object)level).name.Replace("Level - ", string.Empty), level);
				mapToggles.Add(level, value: true);
			}
		}

		public static SortedDictionary<string, Level> getMaps()
		{
			return maps;
		}

		public static Dictionary<Level, bool> getMapToggles()
		{
			return mapToggles;
		}

		public static void setMapEnabled(Level level, bool enabled)
		{
			if (mapToggles.ContainsKey(level))
			{
				mapToggles[level] = enabled;
			}
		}

		public static bool isMapEnabled(Level level)
		{
			return mapToggles.GetValueOrDefault(level, defaultValue: false);
		}

		public static int getEnabledCount()
		{
			int num = 0;
			foreach (bool value in mapToggles.Values)
			{
				if (value)
				{
					num++;
				}
			}
			return num;
		}

		public static void changeLevel(Level level)
		{
			nextLevel = level;
			RunManager.instance.ChangeLevel(true, false, (ChangeLevelType)1);
		}

		public static Level getNextLevel()
		{
			return nextLevel;
		}

		public static void clearNextLevel()
		{
			nextLevel = null;
		}

		public static void resetLevels()
		{
			foreach (KeyValuePair<Level, bool> mapToggle in mapToggles)
			{
				if (!isMapEnabled(mapToggle.Key))
				{
					if (RunManager.instance.levels.Contains(mapToggle.Key))
					{
						RunManager.instance.levels.Remove(mapToggle.Key);
					}
				}
				else if (!RunManager.instance.levels.Contains(mapToggle.Key))
				{
					RunManager.instance.levels.Add(mapToggle.Key);
				}
			}
		}
	}
	internal class NetworkUtil : IOnEventCallback
	{
		internal bool registered;

		internal string clientRandomString = string.Empty;

		private static Random random = new Random();

		internal const byte RAMEventCode = 180;

		internal static NetworkUtil instance { get; private set; } = null;


		public NetworkUtil()
		{
			instance = this;
			if (!registered)
			{
				RepoAdminMenu.mls.LogInfo((object)"Registering network event callbacks");
				PhotonNetwork.AddCallbackTarget((object)this);
				registered = true;
			}
		}

		public static void Init()
		{
			if (instance == null)
			{
				new NetworkUtil();
			}
		}

		private static string randomString(int length)
		{
			return new string((from s in Enumerable.Repeat("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%", length)
				select s[random.Next(s.Length)]).ToArray());
		}

		internal static void SendCommandSteamIDString(string command, string steamId, string value, ReceiverGroup receiverGroup)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			PhotonNetwork.RaiseEvent((byte)180, (object)new object[3] { command, steamId, value }, new RaiseEventOptions
			{
				Receivers = receiverGroup
			}, SendOptions.SendReliable);
		}

		internal static void SendCommandString(string command, string value, ReceiverGroup receiverGroup)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			PhotonNetwork.RaiseEvent((byte)180, (object)new object[2] { command, value }, new RaiseEventOptions
			{
				Receivers = receiverGroup
			}, SendOptions.SendReliable);
		}

		internal static void SendCommand(string command, ReceiverGroup receiverGroup)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			PhotonNetwork.RaiseEvent((byte)180, (object)new object[1] { command }, new RaiseEventOptions
			{
				Receivers = receiverGroup
			}, SendOptions.SendReliable);
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code != 180)
			{
				return;
			}
			RepoAdminMenu.mls.LogInfo((object)"Received RAM Network Event!");
			object[] array = (object[])photonEvent.CustomData;
			if (array.Length == 1)
			{
				string text = array[0].ToString();
				if (text == "NeedSettings")
				{
					Settings.UpdateClients();
				}
				else
				{
					RepoAdminMenu.mls.LogWarning((object)("Unknown command(" + array.Length + "): " + text));
				}
			}
			else if (array.Length == 2)
			{
				string text2 = array[0].ToString();
				string json = array[1].ToString();
				if (text2 == "SettingsSync")
				{
					if (!SemiFunc.IsMasterClient())
					{
						RepoAdminMenu.mls.LogInfo((object)"Syncing settings with Master Client");
						Settings.loadFromJson(json);
					}
				}
				else
				{
					RepoAdminMenu.mls.LogWarning((object)("Unknown command(" + array.Length + "): " + text2));
				}
			}
			else if (array.Length == 3)
			{
				string text3 = array[0].ToString();
				string text4 = array[1].ToString();
				PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(text4);
				if ((Object)(object)val == (Object)null)
				{
					RepoAdminMenu.mls.LogWarning((object)("Invalid player: " + text4));
				}
				else if (!(text3 == "KickPlayer"))
				{
					if (text3 == "KickPlayerAck")
					{
						if (SemiFunc.IsMasterClient())
						{
							RepoAdminMenu.mls.LogInfo((object)("Sending kick acknowledge: " + SemiFunc.PlayerGetName(val)));
							SendCommandSteamIDString("KickPlayer", text4, array[2].ToString(), (ReceiverGroup)0);
						}
					}
					else
					{
						RepoAdminMenu.mls.LogWarning((object)("Unknown command(" + array.Length + "): " + text3));
					}
				}
				else if (!SemiFunc.IsMasterClient() && PlayerAvatar.instance.steamID.Equals(text4))
				{
					RepoAdminMenu.mls.LogInfo((object)"Received kick request");
					string text5 = array[2].ToString();
					if (text5.Length != 16)
					{
						RepoAdminMenu.mls.LogInfo((object)"Sending secret to master client to confirm kick");
						clientRandomString = randomString(16);
						SendCommandSteamIDString("KickPlayerAck", text4, clientRandomString, (ReceiverGroup)2);
					}
					else if (text5.Equals(clientRandomString))
					{
						RepoAdminMenu.mls.LogInfo((object)"I was kicked :(");
						NetworkManager.instance.LeavePhotonRoom();
						clientRandomString = "";
					}
				}
			}
			else
			{
				RepoAdminMenu.mls.LogWarning((object)("Received event with incorrect argument count: " + array.Length));
			}
		}
	}
	internal class PlayerUtil
	{
		private static FieldInfo maxHealthField = AccessTools.Field(typeof(PlayerHealth), "maxHealth");

		private static FieldInfo healthField = AccessTools.Field(typeof(PlayerHealth), "health");

		public static void killPlayer(PlayerAvatar avatar)
		{
			avatar.PlayerDeath(-1);
			RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " Killed!"));
		}

		public static void revivePlayer(PlayerAvatar avatar)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerAvatar), "deadSet");
			if (fieldInfo != null && (bool)fieldInfo.GetValue(avatar) && (Object)(object)avatar.playerDeathHead != (Object)null)
			{
				PlayerDeathHead playerDeathHead = avatar.playerDeathHead;
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerDeathHead), "inExtractionPoint");
				if (fieldInfo2 != null)
				{
					fieldInfo2.SetValue(playerDeathHead, true);
					avatar.Revive(false);
					fieldInfo2.SetValue(playerDeathHead, false);
					RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " Revived!"));
				}
				else
				{
					RepoAdminMenu.mls.LogError((object)"Failed to grab field 'PlayerDeathHead->inExtractionPoint'!");
				}
			}
			else
			{
				RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " is not dead. Cannot be revived!"));
			}
		}

		public static void healPlayer(PlayerAvatar avatar)
		{
			PlayerHealth playerHealth = avatar.playerHealth;
			if (maxHealthField != null && healthField != null)
			{
				avatar.playerHealth.HealOther((int)maxHealthField.GetValue(playerHealth), true);
				RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " Healed!"));
			}
			else
			{
				RepoAdminMenu.mls.LogError((object)"Failed to grab field 'PlayerHealth->maxHealth' or 'PlayerHealth->health'!");
			}
		}

		public static void upgradeHealth(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeHealth[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerHealthRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerHealthRPC", (RpcTarget)0, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeHealth[text]
				});
			}
		}

		public static void upgradeJump(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeExtraJump[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerExtraJumpRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerExtraJumpRPC", (RpcTarget)0, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeExtraJump[text]
				});
			}
		}

		public static void upgradeLaunch(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeLaunch[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerTumbleLaunchRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerTumbleLaunchRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeLaunch[text]
				});
			}
		}

		public static void upgradeMapPlayerCount(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeMapPlayerCount[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradeMapPlayerCountRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradeMapPlayerCountRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeMapPlayerCount[text]
				});
			}
		}

		public static void upgradeRange(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeRange[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerGrabRangeRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerGrabRangeRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeRange[text]
				});
			}
		}

		public static void upgradeSpeed(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeSpeed[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerSprintSpeedRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerSprintSpeedRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeSpeed[text]
				});
			}
		}

		public static void upgradeStamina(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeStamina[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerEnergyRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerEnergyRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeStamina[text]
				});
			}
		}

		public static void upgradeStrength(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeStrength[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerGrabStrengthRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerGrabStrengthRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeStrength[text]
				});
			}
		}

		public static void upgradeThrow(PlayerAvatar avatar, int level)
		{
			string text = SemiFunc.PlayerGetSteamID(avatar);
			StatsManager.instance.playerUpgradeThrow[text] = level;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpgradePlayerThrowStrengthRPC(text, level);
			}
			if (SemiFunc.IsMasterClient())
			{
				PunManager.instance.photonView.RPC("UpgradePlayerThrowStrengthRPC", (RpcTarget)1, new object[2]
				{
					text,
					StatsManager.instance.playerUpgradeThrow[text]
				});
			}
		}

		public static int getUpgradeLevel(string type, PlayerAvatar avatar)
		{
			StatsManager instance = StatsManager.instance;
			string key = SemiFunc.PlayerGetSteamID(avatar);
			if (type.Equals("health") && instance.playerUpgradeHealth.ContainsKey(key))
			{
				return instance.playerUpgradeHealth[key];
			}
			if (type.Equals("jump") && instance.playerUpgradeExtraJump.ContainsKey(key))
			{
				return instance.playerUpgradeExtraJump[key];
			}
			if (type.Equals("launch") && instance.playerUpgradeLaunch.ContainsKey(key))
			{
				return instance.playerUpgradeLaunch[key];
			}
			if (type.Equals("playercount") && instance.playerUpgradeMapPlayerCount.ContainsKey(key))
			{
				return instance.playerUpgradeMapPlayerCount[key];
			}
			if (type.Equals("range") && instance.playerUpgradeRange.ContainsKey(key))
			{
				return instance.playerUpgradeRange[key];
			}
			if (type.Equals("speed") && instance.playerUpgradeSpeed.ContainsKey(key))
			{
				return instance.playerUpgradeSpeed[key];
			}
			if (type.Equals("stamina") && instance.playerUpgradeStamina.ContainsKey(key))
			{
				return instance.playerUpgradeStamina[key];
			}
			if (type.Equals("strength") && instance.playerUpgradeStrength.ContainsKey(key))
			{
				return instance.playerUpgradeStrength[key];
			}
			if (type.Equals("throw") && instance.playerUpgradeThrow.ContainsKey(key))
			{
				return instance.playerUpgradeThrow[key];
			}
			return 0;
		}

		public static void giveCrown(PlayerAvatar avatar)
		{
			SessionManager.instance.crownedPlayerSteamID = SemiFunc.PlayerGetSteamID(avatar);
			SessionManager.instance.CrownPlayer();
		}

		public static void teleportTo(PlayerAvatar avatar)
		{
			teleport(PlayerAvatar.instance, avatar);
		}

		public static void summon(PlayerAvatar avatar)
		{
			teleport(avatar, PlayerAvatar.instance);
		}

		private static void teleport(PlayerAvatar from, PlayerAvatar to)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_004b: 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_0055: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)to).transform.position;
			Quaternion rotation = ((Component)to).transform.rotation;
			if (to.deadSet)
			{
				position = ((Component)to.playerDeathHead.physGrabObject).transform.position;
				rotation = ((Component)to.playerDeathHead.physGrabObject).transform.rotation;
			}
			if (!SemiFunc.IsMultiplayer())
			{
				from.Spawn(position, rotation);
			}
			else if ((Object)(object)from.photonView != (Object)null)
			{
				if (from.deadSet)
				{
					from.playerDeathHead.physGrabObject.Teleport(position, rotation);
					return;
				}
				from.photonView.RPC("SpawnRPC", (RpcTarget)0, new object[2] { position, rotation });
			}
		}

		public static void KickPlayer(PlayerAvatar avatar)
		{
			if (!((Object)(object)avatar == (Object)(object)PlayerAvatar.instance))
			{
				RepoAdminMenu.mls.LogInfo((object)("Sending kick to: " + SemiFunc.PlayerGetName(avatar)));
				NetworkUtil.SendCommandSteamIDString("KickPlayer", avatar.steamID, "", (ReceiverGroup)0);
			}
		}
	}
	internal class ValuableUtil
	{
		private static SortedDictionary<string, GameObject> tinyValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> smallValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> mediumValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> bigValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> wideValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> tallValuables = new SortedDictionary<string, GameObject>();

		private static SortedDictionary<string, GameObject> veryTallValuables = new SortedDictionary<string, GameObject>();

		public static void Init()
		{
			tinyValuables.Clear();
			smallValuables.Clear();
			mediumValuables.Clear();
			bigValuables.Clear();
			wideValuables.Clear();
			tallValuables.Clear();
			veryTallValuables.Clear();
			foreach (LevelValuables valuablePreset in RunManager.instance.levelCurrent.ValuablePresets)
			{
				foreach (GameObject item in valuablePreset.tiny)
				{
					string key = ((Object)item).name.Replace("Valuable ", string.Empty);
					if (!tinyValuables.ContainsKey(key))
					{
						tinyValuables.Add(key, item);
					}
				}
				foreach (GameObject item2 in valuablePreset.small)
				{
					string key2 = ((Object)item2).name.Replace("Valuable ", string.Empty);
					if (!smallValuables.ContainsKey(key2))
					{
						smallValuables.Add(key2, item2);
					}
				}
				foreach (GameObject item3 in valuablePreset.medium)
				{
					string key3 = ((Object)item3).name.Replace("Valuable ", string.Empty);
					if (!mediumValuables.ContainsKey(key3))
					{
						mediumValuables.Add(key3, item3);
					}
				}
				foreach (GameObject item4 in valuablePreset.big)
				{
					string key4 = ((Object)item4).name.Replace("Valuable ", string.Empty);
					if (!bigValuables.ContainsKey(key4))
					{
						bigValuables.Add(key4, item4);
					}
				}
				foreach (GameObject item5 in valuablePreset.wide)
				{
					string key5 = ((Object)item5).name.Replace("Valuable ", string.Empty);
					if (!wideValuables.ContainsKey(key5))
					{
						wideValuables.Add(key5, item5);
					}
				}
				foreach (GameObject item6 in valuablePreset.tall)
				{
					string key6 = ((Object)item6).name.Replace("Valuable ", string.Empty);
					if (!tallValuables.ContainsKey(key6))
					{
						tallValuables.Add(key6, item6);
					}
				}
				foreach (GameObject item7 in valuablePreset.veryTall)
				{
					string key7 = ((Object)item7).name.Replace("Valuable ", string.Empty);
					if (!veryTallValuables.ContainsKey(key7))
					{
						veryTallValuables.Add(key7, item7);
					}
				}
			}
		}

		public static SortedDictionary<string, GameObject> getTinyValuables()
		{
			return tinyValuables;
		}

		public static SortedDictionary<string, GameObject> getSmallValuables()
		{
			return smallValuables;
		}

		public static SortedDictionary<string, GameObject> getMediumValuables()
		{
			return mediumValuables;
		}

		public static SortedDictionary<string, GameObject> getBigValuables()
		{
			return bigValuables;
		}

		public static SortedDictionary<string, GameObject> getWideValuables()
		{
			return wideValuables;
		}

		public static SortedDictionary<string, GameObject> getTallValuables()
		{
			return tallValuables;
		}

		public static SortedDictionary<string, GameObject> getVeryTallValuables()
		{
			return veryTallValuables;
		}

		public static void spawnValuable(GameObject valuable)
		{
			//IL_000a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0092: 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_007f: 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)
			Vector3 val = ((Component)PlayerAvatar.instance).transform.position + new Vector3(0f, 1f, 0f) + ((Component)PlayerAvatar.instance).transform.forward * 1f;
			if (SemiFunc.IsMultiplayer())
			{
				ValuableObject val2 = default(ValuableObject);
				if (!valuable.TryGetComponent<ValuableObject>(ref val2))
				{
					ItemInfoExtraUI.instance.ItemInfoText("Could not spawn valuable '" + ((Object)valuable).name + "'", Color.red);
				}
				else
				{
					Valuables.SpawnValuable(val2, val, Quaternion.identity);
				}
			}
			else
			{
				Object.Instantiate<GameObject>(valuable.gameObject, val, Quaternion.identity);
			}
		}
	}
}
namespace RepoAdminMenu.Patches
{
	[HarmonyPatch(typeof(EnemyDirector))]
	internal class EnemyDirectorPatch
	{
		[HarmonyPatch("SetInvestigate")]
		[HarmonyPrefix]
		private static bool SetInvestigate_Prefix(EnemyDirector __instance)
		{
			return !Settings.instance.deafEnemies;
		}
	}
	[HarmonyPatch(typeof(EnemyHealth))]
	internal class EnemyHealthPatch
	{
		[HarmonyPatch("Hurt")]
		[HarmonyPrefix]
		private static void Hurt_Prefix(ref int _damage, int ___healthCurrent)
		{
			if (Settings.instance.weakEnemies)
			{
				_damage = ___healthCurrent;
				if (___healthCurrent < 1)
				{
					_damage = 100;
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyParent))]
	internal class EnemyParentPatch
	{
		public static bool spawning;

		[HarmonyPatch("Despawn")]
		[HarmonyPrefix]
		private static bool Despawn_Prefix(float ___SpawnedTimeMin, float ___SpawnedTimeMax, ref float ___SpawnedTimer)
		{
			if (spawning)
			{
				spawning = false;
				___SpawnedTimer = Random.Range(___SpawnedTimeMin, ___SpawnedTimeMax);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyVision))]
	internal class EnemyVisionPatch
	{
		[HarmonyPatch("VisionTrigger")]
		[HarmonyPrefix]
		private static bool VisionTrigger_Prefix(int playerID, PlayerAvatar player, EnemyVision __instance)
		{
			if (Settings.instance.blindEnemies || Settings.isNoTarget(player))
			{
				__instance.VisionTriggered[playerID] = false;
				__instance.VisionsTriggered[playerID] = 0;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ExtractionPoint))]
	internal class ExtractionPointPatch
	{
		private static int previousMoney = -1;

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(ExtractionPoint __instance, bool ___isShop)
		{
			if (!___isShop)
			{
				return;
			}
			if (Settings.instance.infiniteMoney)
			{
				if (previousMoney < 0)
				{
					previousMoney = StatsManager.instance.runStats["currency"];
				}
				StatsManager.instance.runStats["currency"] = 9999;
			}
			else
			{
				if (previousMoney >= 0)
				{
					StatsManager.instance.runStats["currency"] = previousMoney;
				}
				previousMoney = -1;
			}
		}
	}
	[HarmonyPatch(typeof(ItemBattery))]
	internal class ItemBatteryPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_Postfix(ItemBattery __instance, ref int ___batteryLifeInt)
		{
			if (Settings.instance.noBatteryDrain)
			{
				__instance.batteryLife = 100f;
				___batteryLifeInt = 6;
			}
		}
	}
	[HarmonyPatch(typeof(ItemMeleeInflatableHammer))]
	internal class ItemMeleeInflatableHammerPatch
	{
		[HarmonyPatch("OnHit")]
		[HarmonyPrefix]
		private static bool OnHit_Prefix(ItemMeleeInflatableHammer __instance, PhotonView ___photonView)
		{
			if (Settings.instance.boomhammer)
			{
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					__instance.ExplosionRPC();
					return false;
				}
				if (SemiFunc.IsMasterClient())
				{
					___photonView.RPC("ExplosionRPC", (RpcTarget)1, new object[0]);
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ItemUpgrade))]
	internal class ItemUpgradePatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(ItemToggle ___itemToggle)
		{
			if (Settings.instance.useShopUpgrades)
			{
				((Behaviour)___itemToggle).enabled = true;
			}
		}
	}
	[HarmonyPatch(typeof(NetworkConnect))]
	internal class NetworkConnectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix()
		{
			NetworkUtil.Init();
		}

		[HarmonyPatch("OnCreatedRoom")]
		[HarmonyPostfix]
		private static void OnCreatedRoom_Postfix()
		{
			if (Configuration.ResetSettingsOnLobbyCreation.Value)
			{
				RepoAdminMenu.mls.LogInfo((object)"Resetting settings");
				Settings.instance = new Settings();
			}
		}

		[HarmonyPatch("OnJoinedRoom")]
		[HarmonyPostfix]
		private static void OnJoinedRoom_Postfix()
		{
			NetworkUtil.instance.clientRandomString = string.Empty;
			NetworkUtil.SendCommand("NeedSettings", (ReceiverGroup)2);
		}
	}
	[HarmonyPatch]
	internal class NoTargetPatches
	{
		[HarmonyPatch(typeof(Enemy), "Update")]
		[HarmonyPrefix]
		private static void Enemy_Update_Prefix(ref PlayerAvatar ___TargetPlayerAvatar)
		{
			if ((Object)(object)___TargetPlayerAvatar != (Object)null && Settings.isNoTarget(___TargetPlayerAvatar))
			{
				___TargetPlayerAvatar = null;
			}
		}

		[HarmonyPatch(typeof(EnemyAnimal), "Update")]
		[HarmonyPrefix]
		private static void EnemyAnimal_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyBangDirector), "Update")]
		[HarmonyPrefix]
		private static void EnemyBangDirector_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyBeamer), "Update")]
		[HarmonyPrefix]
		private static void EnemyBeamer_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyBowtie), "Update")]
		[HarmonyPrefix]
		private static void EnemyBowtie_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyCeilingEye), "Update")]
		[HarmonyPrefix]
		private static void EnemyCeilingEye_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyDuck), "Update")]
		[HarmonyPrefix]
		private static void EnemyDuck_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyDuck), "OnGrabbed")]
		[HarmonyPrefix]
		private static bool EnemyDuck_OnGrabbed_Prefix(EnemyDuck __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.instance.friendlyDuck)
			{
				__instance.currentState = (State)2;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyDuck), "UpdateState")]
		[HarmonyPrefix]
		private static void EnemyDuck_UpdateState_Prefix(ref State _state)
		{
			if (Settings.instance.friendlyDuck && (int)_state == 11)
			{
				_state = (State)2;
			}
		}

		[HarmonyPatch(typeof(EnemyFloater), "Update")]
		[HarmonyPrefix]
		private static void EnemyFloater_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyGnomeDirector), "Update")]
		[HarmonyPrefix]
		private static void EnemyGnomeDirector_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyHidden), "Update")]
		[HarmonyPrefix]
		private static void EnemyHidden_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyRobe), "Update")]
		[HarmonyPrefix]
		private static void EnemyRobe_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyRunner), "Update")]
		[HarmonyPrefix]
		private static void EnemyRunner_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemySlowMouth), "Update")]
		[HarmonyPrefix]
		private static void EnemySlowMouth_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemySlowWalker), "Update")]
		[HarmonyPrefix]
		private static void EnemySlowWalker_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "Update")]
		[HarmonyPrefix]
		private static void EnemyThinMan_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}

		[HarmonyPatch(typeof(EnemyTumbler), "Update")]
		[HarmonyPrefix]
		private static void EnemyTumbler_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyUpscream), "Update")]
		[HarmonyPrefix]
		private static void EnemyUpscream_Update_Prefix(ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
			}
		}

		[HarmonyPatch(typeof(EnemyValuableThrower), "Update")]
		[HarmonyPrefix]
		private static void EnemyValuableThrower_Update_Prefix(ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector))]
	internal class PhysGrabObjectImpactDetectorPatch
	{
		[HarmonyPatch("Break")]
		[HarmonyPrefix]
		private static bool Break_Prefix(bool ___isEnemy)
		{
			return !Settings.instance.noBreak || ___isEnemy;
		}
	}
	[HarmonyPatch(typeof(PlayerController))]
	internal class PlayerControllerPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(PlayerController __instance, PlayerAvatar ___playerAvatarScript)
		{
			if ((Object)(object)___playerAvatarScript != (Object)null)
			{
				if (Settings.isInfiniteStamina(___playerAvatarScript))
				{
					__instance.EnergyCurrent = __instance.EnergyStart;
				}
				__instance.DebugNoTumble = Settings.isNoTumble(___playerAvatarScript);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHealth))]
	internal class PlayerHealthPatch
	{
		[HarmonyPatch("Hurt")]
		[HarmonyPrefix]
		private static bool Hurt_Prefix(ref int damage, PlayerAvatar ___playerAvatar, int ___health)
		{
			if (Settings.isGod(___playerAvatar))
			{
				return false;
			}
			if (Settings.isNoDeath(___playerAvatar))
			{
				damage = Math.Min(damage, ___health - 1);
				if (damage == 0)
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerTumble))]
	internal class PlayerTumblePatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(PlayerTumble __instance, PlayerAvatar ___playerAvatar)
		{
			if ((Object)(object)__instance != (Object)null && (Object)(object)___playerAvatar != (Object)null && Settings.isForceTumble(___playerAvatar) && SemiFunc.IsMasterClient())
			{
				long num = DateTime.Now.Ticks / 10000;
				if (Settings.getLastForceTumble(___playerAvatar) < num - 500)
				{
					__instance.TumbleRequest(true, false);
					Settings.setLastForceTumble(___playerAvatar, num);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	internal class PunManagerPatch
	{
		[HarmonyPatch("UpdateHealthRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateHealthRightAway(ref string playerName)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(playerName);
			if ((Object)(object)val == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				val.playerHealth.maxHealth = 100 + StatsManager.instance.playerUpgradeHealth[playerName] * 20;
				val.playerHealth.Heal(val.playerHealth.maxHealth - val.playerHealth.health, false);
			}
			return false;
		}

		[HarmonyPatch("UpdateEnergyRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateEnergyRightAway(ref string _steamID)
		{
			if ((Object)(object)SemiFunc.PlayerAvatarGetFromSteamID(_steamID) == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				PlayerController.instance.EnergyStart = 40f + (float)StatsManager.instance.playerUpgradeStamina[_steamID] * 10f;
				PlayerController.instance.EnergyCurrent = PlayerController.instance.EnergyStart;
			}
			return false;
		}

		[HarmonyPatch("UpdateExtraJumpRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateExtraJumpRightAway(ref string _steamID)
		{
			if ((Object)(object)SemiFunc.PlayerAvatarGetFromSteamID(_steamID) == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				PlayerController.instance.JumpExtra = StatsManager.instance.playerUpgradeExtraJump[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateMapPlayerCountRightAway")]
		[HarmonyPrefix]
		private static bool UpdateMapPlayerCountRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if ((Object)(object)val == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				val.upgradeMapPlayerCount = StatsManager.instance.playerUpgradeMapPlayerCount[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateTumbleLaunchRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateTumbleLaunchRightAway(ref string _steamID)
		{
			SemiFunc.PlayerAvatarGetFromSteamID(_steamID).tumble.tumbleLaunch = StatsManager.instance.playerUpgradeLaunch[_steamID];
			return false;
		}

		[HarmonyPatch("UpdateSprintSpeedRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateSprintSpeedRightAway(ref string _steamID)
		{
			if ((Object)(object)SemiFunc.PlayerAvatarGetFromSteamID(_steamID) == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				PlayerController.instance.SprintSpeed = StatsManager.instance.playerUpgradeSpeed[_steamID];
				PlayerController.instance.SprintSpeedUpgrades = StatsManager.instance.playerUpgradeSpeed[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateGrabStrengthRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateGrabStrengthRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.physGrabber.grabStrength = 1f + (float)StatsManager.instance.playerUpgradeStrength[_steamID] * 0.2f;
			}
			return false;
		}

		[HarmonyPatch("UpdateThrowStrengthRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateThrowStrengthRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.physGrabber.throwStrength = (float)StatsManager.instance.playerUpgradeThrow[_steamID] * 0.3f;
			}
			return false;
		}

		[HarmonyPatch("UpdateGrabRangeRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateGrabRangeRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.physGrabber.grabRange = 4f + (float)StatsManager.instance.playerUpgradeRange[_steamID] * 1f;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	internal class RunManagerPatch
	{
		private static bool lastKeyState;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_Postfix(RunManager __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Configuration.EnableHotkey.Value)
			{
				bool key = Input.GetKey(Configuration.MenuHotkey.Value);
				if (!lastKeyState && key)
				{
					Menu.toggleMenu();
					lastKeyState = key;
				}
				else if (lastKeyState && !key)
				{
					lastKeyState = key;
				}
			}
		}

		[HarmonyPatch("ChangeLevel")]
		[HarmonyPostfix]
		private static void ChangeLevel_Postfix()
		{
			ItemUtil.Init();
			ValuableUtil.Init();
			EnemyUtil.Init();
			MapUtil.Init();
		}

		[HarmonyPatch("SetRunLevel")]
		[HarmonyPrefix]
		private static bool SetRunLevel_Prefix(RunManager __instance, ref Level ___previousRunLevel, ref Level ___levelCurrent)
		{
			MapUtil.resetLevels();
			if (__instance.levels.Count == 0)
			{
				MapUtil.setMapEnabled(MapUtil.getMaps().First().Value, enabled: true);
				MapUtil.resetLevels();
			}
			if (MapUtil.getEnabledCount() == 1 || (Object)(object)MapUtil.getNextLevel() != (Object)null)
			{
				___previousRunLevel = null;
			}
			if ((Object)(object)MapUtil.getNextLevel() != (Object)null)
			{
				___levelCurrent = MapUtil.getNextLevel();
				MapUtil.clearNextLevel();
				return false;
			}
			return true;
		}
	}
	internal class TestingCode
	{
	}
	[HarmonyPatch(typeof(Trap))]
	internal class TrapPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(ref bool ___trapStart, ref bool ___trapActive)
		{
			if (Settings.instance.noTraps)
			{
				___trapActive = false;
				___trapStart = false;
			}
		}
	}
}