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 System.Text.RegularExpressions;
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.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: AssemblyMetadata("RepositoryUrl", "https://github.com/proferabg/RepoAdminMenu")]
[assembly: ComVisible(false)]
[assembly: Guid("3ae48784-5268-4c13-9676-09db1348e95e")]
[assembly: AssemblyFileVersion("1.0.15.0")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.15.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
	{
		[CompilerGenerated]
		private sealed class <openPageInternal>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string name;

			public REPOPopupPage page;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <openPageInternal>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					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;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		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));
		}

		[IteratorStateMachine(typeof(<openPageInternal>d__17))]
		private static IEnumerator openPageInternal(REPOPopupPage page, string name)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <openPageInternal>d__17(0)
			{
				page = page,
				name = 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/new?template=bug_report.md");
				Application.OpenURL("file://" + Application.persistentDataPath + "/Player.log");
			});
			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 Player", delegate
			{
				PlayerUtil.teleportTo(avatar);
			});
			addButton(playerMenu, "Summon", delegate
			{
				PlayerUtil.summon(avatar);
			});
			addButton(playerMenu, "Return To Truck", delegate
			{
				PlayerUtil.returnToTruck(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 }
				});
			});
			addButton(playerMenu, "Ban Player", delegate
			{
				closePage(playerMenu);
				openConfirmMenu("player", "Ban: " + SemiFunc.PlayerGetName(avatar), new Dictionary<string, Action>
				{
					{
						"Yes",
						delegate
						{
							PlayerUtil.BanPlayer(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 val = createMenu("R.A.M. - " + SemiFunc.PlayerGetName(avatar) + " - Upgrades", "playerUpgrade", "player");
			foreach (KeyValuePair<string, UpgradeUtil.GameUpgrade> upgradePair2 in UpgradeUtil.GetGameUpgrades())
			{
				addIntSlider(val, upgradePair2.Value.GetName(), "", delegate(int v)
				{
					upgradePair2.Value.Upgrade(avatar, v);
				}, 0, Configuration.MaxUpgradeLevel.Value, upgradePair2.Value.GetPlayerLevel(avatar));
			}
			foreach (KeyValuePair<string, PlayerUpgrade> upgradePair in UpgradeUtil.GetModUpgrades())
			{
				addIntSlider(val, "(Mod) " + upgradePair.Key, "", delegate(int v)
				{
					UpgradeUtil.UpgradeLevel(upgradePair.Value, avatar, v);
				}, 0, Configuration.MaxUpgradeLevel.Value, upgradePair.Value.GetLevel(avatar));
			}
			openPage(val, "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, PrefabRef> 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, PrefabRef> 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, PrefabRef> 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, PrefabRef> 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, PrefabRef> 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, PrefabRef> 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, PrefabRef> 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.15")]
	[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.15";

		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.15) 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
	{
		[CompilerGenerated]
		private sealed class <SpawnEnemy>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnemySetup enemySetup;

			public Vector3 position;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SpawnEnemy>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//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_00b1: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (SemiFunc.IsMultiplayer())
					{
						Enemies.SpawnEnemy(enemySetup, position, Quaternion.identity, false);
					}
					else
					{
						EnemyParentPatch.spawning = true;
						LevelGenerator.Instance.EnemiesSpawned = -1;
						GameObject val = Object.Instantiate<GameObject>(enemySetup.spawnObjects[0].Prefab, position, Quaternion.identity);
						EnemyParent component = val.GetComponent<EnemyParent>();
						if ((Object)(object)component != (Object)null)
						{
							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);
							}
						}
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Dictionary<string, string> enemyDictionary = new Dictionary<string, string>
		{
			{ "Animal", "Animal" },
			{ "Bang", "Bang" },
			{ "Beamer", "Clown" },
			{ "Birthday Boy", "Birthday Boy" },
			{ "Bomb Thrower", "Cleanup Crew" },
			{ "Bowtie", "Bowtie" },
			{ "Ceiling Eye", "Peeper" },
			{ "Duck", "Apex Predator" },
			{ "Elsa", "Elsa" },
			{ "Floater", "Mentalist" },
			{ "Gnome", "Gnome" },
			{ "Head", "Headman" },
			{ "Head Grabber", "Headgrab" },
			{ "Heart Hugger", "Heart Hugger" },
			{ "Hidden", "Hidden" },
			{ "Hunter", "Huntsman" },
			{ "Oogly", "Oogly" },
			{ "Robe", "Robe" },
			{ "Runner", "Reaper" },
			{ "Shadow", "Loom" },
			{ "Slow Mouth", "Spewer" },
			{ "Slow Walker", "Trudge" },
			{ "Spinny", "Gambit" },
			{ "Thin Man", "Shadow Child" },
			{ "Tick", "Tick" },
			{ "Tricycle", "Bella" },
			{ "Tumbler", "Chef" },
			{ "Upscream", "Upscream" },
			{ "Valuable Thrower", "Rugrat" }
		};

		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> enemiesDifficulty = EnemyDirector.instance.enemiesDifficulty1;
			List<EnemySetup> enemiesDifficulty2 = EnemyDirector.instance.enemiesDifficulty2;
			List<EnemySetup> enemiesDifficulty3 = EnemyDirector.instance.enemiesDifficulty3;
			List<EnemySetup> list = new List<EnemySetup>(enemiesDifficulty.Count + enemiesDifficulty2.Count + enemiesDifficulty3.Count);
			list.AddRange(enemiesDifficulty);
			list.AddRange(enemiesDifficulty2);
			list.AddRange(enemiesDifficulty3);
			foreach (EnemySetup item in list)
			{
				if (((Object)item).name.StartsWith("Enemy Group"))
				{
					continue;
				}
				string text = ((Object)item).name.Replace("Enemy - ", string.Empty);
				try
				{
					if (enemyDictionary.TryGetValue(text, out var value))
					{
						addEnemySetupSafe(value, item);
					}
					else
					{
						addModEnemySetupSafe(text, item);
					}
				}
				catch
				{
					RepoAdminMenu.mls.LogError((object)("Invalid enemy setup for name '" + ((Object)item).name + "'!"));
				}
			}
		}

		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);
			}
		}

		[IteratorStateMachine(typeof(<SpawnEnemy>d__10))]
		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 decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnEnemy>d__10(0)
			{
				enemySetup = enemySetup,
				position = position
			};
		}
	}
	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 StatsManager.instance.itemDictionary.Values.ToList())
			{
				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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_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.Prefab, val, Quaternion.identity) : Items.SpawnItem(item, val, Quaternion.identity));
			ItemBattery componentInParent = val2.GetComponentInParent<ItemBattery>();
			if (Object.op_Implicit((Object)(object)componentInParent) && componentInParent.batteryBars < 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 SendCommandSteamIDStringInt(string command, string steamId, string str, int num, ReceiverGroup receiverGroup)
		{
			//IL_0020: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			PhotonNetwork.RaiseEvent((byte)180, (object)new object[4] { command, steamId, str, num }, 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;
			}
			object[] array = (object[])photonEvent.CustomData;
			if (array.Length == 1)
			{
				string text = array[0].ToString();
				if (text == "NeedSettings")
				{
					Settings.UpdateClients();
				}
				else
				{
					RepoAdminMenu.mls.LogWarning((object)("Network event: 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)("Network event: Unknown command(" + array.Length + "): " + text2));
				}
			}
			else if (array.Length == 3)
			{
				string text3 = array[0].ToString();
				string text4 = array[1].ToString();
				if ((Object)(object)SemiFunc.PlayerGetFromSteamID(text4) == (Object)null)
				{
					RepoAdminMenu.mls.LogWarning((object)("Network event: Invalid player: " + text4));
				}
				else
				{
					RepoAdminMenu.mls.LogWarning((object)("Unknown command(" + array.Length + "): " + text3));
				}
			}
			else if (array.Length == 4)
			{
				string text5 = array[0].ToString();
				string text6 = array[1].ToString();
				PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(text6);
				if ((Object)(object)val == (Object)null)
				{
					RepoAdminMenu.mls.LogWarning((object)("Network event: Invalid player: " + text6));
				}
				else if (text5 == "UpgradeSync")
				{
					UpgradeUtil.UpgradeSync(val, array[2].ToString(), (int)array[3]);
				}
				else
				{
					RepoAdminMenu.mls.LogWarning((object)("Unknown command(" + array.Length + "): " + text5));
				}
			}
			else
			{
				RepoAdminMenu.mls.LogWarning((object)("Received network event with incorrect argument count: " + array.Length));
			}
		}
	}
	internal class PlayerUtil
	{
		private DateTime lastSync = DateTime.Now;

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

		public static void revivePlayer(PlayerAvatar avatar)
		{
			if (avatar.deadSet && (Object)(object)avatar.playerDeathHead != (Object)null)
			{
				PlayerDeathHead playerDeathHead = avatar.playerDeathHead;
				playerDeathHead.inExtractionPoint = true;
				avatar.Revive(false);
				playerDeathHead.inExtractionPoint = false;
				RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " Revived!"));
			}
			else
			{
				RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " is not dead. Cannot be revived!"));
			}
		}

		public static void healPlayer(PlayerAvatar avatar)
		{
			PlayerHealth playerHealth = avatar.playerHealth;
			avatar.playerHealth.HealOther(playerHealth.maxHealth, true);
			RepoAdminMenu.mls.LogInfo((object)(SemiFunc.PlayerGetName(avatar) + " Healed!"));
		}

		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);
		}

		public static void returnToTruck(PlayerAvatar avatar)
		{
			//IL_000b: 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)
			teleport(avatar, ((Component)TruckSafetySpawnPoint.instance).transform.position, ((Component)TruckSafetySpawnPoint.instance).transform.rotation);
		}

		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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			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;
			}
			teleport(from, position, rotation);
		}

		private static void teleport(PlayerAvatar from, Vector3 pos, Quaternion rot)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			if (!SemiFunc.IsMultiplayer())
			{
				from.Spawn(pos, rot);
			}
			else if ((Object)(object)from.photonView != (Object)null)
			{
				if (from.deadSet)
				{
					from.playerDeathHead.physGrabObject.Teleport(pos, rot);
					return;
				}
				from.photonView.RPC("SpawnRPC", (RpcTarget)0, new object[2] { pos, rot });
			}
		}

		public static void KickPlayer(PlayerAvatar avatar)
		{
			if (!((Object)(object)avatar == (Object)(object)PlayerAvatar.instance))
			{
				RepoAdminMenu.mls.LogInfo((object)("Sending kick to: " + SemiFunc.PlayerGetName(avatar)));
				NetworkManager.instance.KickPlayer(avatar);
			}
		}

		public static void BanPlayer(PlayerAvatar avatar)
		{
			if (!((Object)(object)avatar == (Object)(object)PlayerAvatar.instance))
			{
				RepoAdminMenu.mls.LogInfo((object)("Sending ban to: " + SemiFunc.PlayerGetName(avatar)));
				NetworkManager.instance.BanPlayer(avatar);
			}
		}
	}
	internal class UpgradeUtil
	{
		public class GameUpgrade
		{
			private string id;

			private string name;

			private Action<string, int> punManagerFunction;

			public GameUpgrade(string id, string name, Action<string, int> punManagerFunction)
			{
				this.id = id;
				this.name = name;
				this.punManagerFunction = punManagerFunction;
			}

			public string GetID()
			{
				return id;
			}

			public string GetName()
			{
				return name;
			}

			public int GetPlayerLevel(PlayerAvatar avatar)
			{
				return GetPlayerUpgradeLevel(id, avatar);
			}

			public void Upgrade(PlayerAvatar avatar, int level)
			{
				RepoAdminMenu.mls.LogInfo((object)("Upgrade: " + SemiFunc.PlayerGetName(avatar) + " - '" + id + "' -> " + level));
				if (SemiFunc.IsMultiplayer())
				{
					NetworkUtil.SendCommandSteamIDStringInt("UpgradeSync", avatar.steamID, id, level, (ReceiverGroup)1);
				}
				else
				{
					UpgradeSync(avatar, id, level);
				}
			}

			public void PunUpgrade(PlayerAvatar avatar, int level)
			{
				if (punManagerFunction != null)
				{
					string arg = SemiFunc.PlayerGetSteamID(avatar);
					punManagerFunction(arg, level);
				}
			}
		}

		private static SortedDictionary<string, PlayerUpgrade> modUpgrades = new SortedDictionary<string, PlayerUpgrade>();

		private static SortedDictionary<string, GameUpgrade> gameUpgrades = new SortedDictionary<string, GameUpgrade>
		{
			{
				"playerUpgradeCrouchRest",
				new GameUpgrade("playerUpgradeCrouchRest", "Crouch Rest", (Action<string, int>)PunManager.instance.UpdateCrouchRestRightAway)
			},
			{
				"playerUpgradeHealth",
				new GameUpgrade("playerUpgradeHealth", "Health", (Action<string, int>)PunManager.instance.UpdateCrouchRestRightAway)
			},
			{
				"playerUpgradeExtraJump",
				new GameUpgrade("playerUpgradeExtraJump", "Jump", (Action<string, int>)PunManager.instance.UpdateExtraJumpRightAway)
			},
			{
				"playerUpgradeLaunch",
				new GameUpgrade("playerUpgradeLaunch", "Launch", (Action<string, int>)PunManager.instance.UpdateTumbleLaunchRightAway)
			},
			{
				"playerUpgradeMapPlayerCount",
				new GameUpgrade("playerUpgradeMapPlayerCount", "Map Player Count", (Action<string, int>)PunManager.instance.UpdateMapPlayerCountRightAway)
			},
			{
				"playerUpgradeRange",
				new GameUpgrade("playerUpgradeRange", "Range", (Action<string, int>)PunManager.instance.UpdateGrabRangeRightAway)
			},
			{
				"playerUpgradeSpeed",
				new GameUpgrade("playerUpgradeSpeed", "Speed", (Action<string, int>)PunManager.instance.UpdateSprintSpeedRightAway)
			},
			{
				"playerUpgradeStamina",
				new GameUpgrade("playerUpgradeStamina", "Stamina", (Action<string, int>)PunManager.instance.UpdateEnergyRightAway)
			},
			{
				"playerUpgradeStrength",
				new GameUpgrade("playerUpgradeStrength", "Strength", (Action<string, int>)PunManager.instance.UpdateGrabStrengthRightAway)
			},
			{
				"playerUpgradeThrow",
				new GameUpgrade("playerUpgradeThrow", "Throw", (Action<string, int>)PunManager.instance.UpdateThrowStrengthRightAway)
			},
			{
				"playerUpgradeTumbleWings",
				new GameUpgrade("playerUpgradeTumbleWings", "Tumble Wings", (Action<string, int>)PunManager.instance.UpdateTumbleWingsRightAway)
			},
			{
				"playerUpgradeTumbleClimb",
				new GameUpgrade("playerUpgradeTumbleClimb", "Tumble Climb", (Action<string, int>)PunManager.instance.UpdateTumbleClimbRightAway)
			},
			{
				"playerUpgradeDeathHeadBattery",
				new GameUpgrade("playerUpgradeDeathHeadBattery", "Death Head Battery", (Action<string, int>)PunManager.instance.UpdateDeathHeadBatteryRightAway)
			}
		};

		public static void Init()
		{
			modUpgrades.Clear();
			foreach (PlayerUpgrade item in Upgrades.PlayerUpgrades.ToList())
			{
				string key = Regex.Replace(item.UpgradeId, "((?<=\\p{Ll})\\p{Lu})|((?!\\A)\\p{Lu}(?>\\p{Ll}))", " $0");
				if (!modUpgrades.ContainsKey(key))
				{
					modUpgrades.Add(key, item);
				}
			}
		}

		public static SortedDictionary<string, GameUpgrade> GetGameUpgrades()
		{
			return gameUpgrades;
		}

		public static SortedDictionary<string, PlayerUpgrade> GetModUpgrades()
		{
			return modUpgrades;
		}

		public static void UpgradeLevel(PlayerUpgrade upgrade, PlayerAvatar avatar, int level)
		{
			upgrade.SetLevel(avatar, level);
			RepoAdminMenu.mls.LogInfo((object)("Upgrade: " + SemiFunc.PlayerGetName(avatar) + " - '" + upgrade.UpgradeId + "' -> " + level));
		}

		public static int GetPlayerUpgradeLevel(string type, PlayerAvatar avatar)
		{
			StatsManager instance = StatsManager.instance;
			string key = SemiFunc.PlayerGetSteamID(avatar);
			if ((Object)(object)instance != (Object)null && instance.dictionaryOfDictionaries.ContainsKey(type))
			{
				Dictionary<string, int> dictionary = instance.dictionaryOfDictionaries[type];
				if (dictionary != null && dictionary.ContainsKey(key))
				{
					return dictionary[key];
				}
			}
			return 0;
		}

		public static void UpgradeSync(PlayerAvatar avatar, string key, int level)
		{
			RepoAdminMenu.mls.LogInfo((object)("UpgradeSync: " + SemiFunc.PlayerGetName(avatar) + " - '" + key + "' -> " + level));
			string key2 = SemiFunc.PlayerGetSteamID(avatar);
			Dictionary<string, Dictionary<string, int>> dictionaryOfDictionaries = StatsManager.instance.dictionaryOfDictionaries;
			if (!dictionaryOfDictionaries.ContainsKey(key))
			{
				dictionaryOfDictionaries.Add(key, new Dictionary<string, int>());
			}
			Dictionary<string, int> value = new Dictionary<string, int>();
			if (dictionaryOfDictionaries.TryGetValue(key, out value))
			{
				value[key2] = level;
			}
			if ((Object)(object)avatar == (Object)(object)PlayerAvatar.instance)
			{
				DoImmediateUpgrade(avatar, key, level);
			}
		}

		private static void DoImmediateUpgrade(PlayerAvatar avatar, string key, int level)
		{
			SemiFunc.PlayerGetSteamID(avatar);
			RepoAdminMenu.mls.LogInfo((object)("DoImmediateUpgrade: " + SemiFunc.PlayerGetName(avatar) + " - '" + key + "'"));
			try
			{
				if (gameUpgrades.TryGetValue(key, out var value))
				{
					value.PunUpgrade(avatar, level);
				}
			}
			catch
			{
			}
		}
	}
	internal class ValuableUtil
	{
		private static SortedDictionary<string, PrefabRef> tinyValuables = new SortedDictionary<string, PrefabRef>();

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

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

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

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

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

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

		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 (PrefabRef item in valuablePreset.tiny)
				{
					string key = item.PrefabName.Replace("Valuable ", string.Empty);
					if (!tinyValuables.ContainsKey(key))
					{
						tinyValuables.Add(key, item);
					}
				}
				foreach (PrefabRef item2 in valuablePreset.small)
				{
					string key2 = item2.PrefabName.Replace("Valuable ", string.Empty);
					if (!smallValuables.ContainsKey(key2))
					{
						smallValuables.Add(key2, item2);
					}
				}
				foreach (PrefabRef item3 in valuablePreset.medium)
				{
					string key3 = item3.PrefabName.Replace("Valuable ", string.Empty);
					if (!mediumValuables.ContainsKey(key3))
					{
						mediumValuables.Add(key3, item3);
					}
				}
				foreach (PrefabRef item4 in valuablePreset.big)
				{
					string key4 = item4.PrefabName.Replace("Valuable ", string.Empty);
					if (!bigValuables.ContainsKey(key4))
					{
						bigValuables.Add(key4, item4);
					}
				}
				foreach (PrefabRef item5 in valuablePreset.wide)
				{
					string key5 = item5.PrefabName.Replace("Valuable ", string.Empty);
					if (!wideValuables.ContainsKey(key5))
					{
						wideValuables.Add(key5, item5);
					}
				}
				foreach (PrefabRef item6 in valuablePreset.tall)
				{
					string key6 = item6.PrefabName.Replace("Valuable ", string.Empty);
					if (!tallValuables.ContainsKey(key6))
					{
						tallValuables.Add(key6, item6);
					}
				}
				foreach (PrefabRef item7 in valuablePreset.veryTall)
				{
					string key7 = item7.PrefabName.Replace("Valuable ", string.Empty);
					if (!veryTallValuables.ContainsKey(key7))
					{
						veryTallValuables.Add(key7, item7);
					}
				}
			}
		}

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

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

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

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

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

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

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

		public static void spawnValuable(PrefabRef 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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)
			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.Prefab.TryGetComponent<ValuableObject>(ref val2))
				{
					ItemInfoExtraUI.instance.ItemInfoText("Could not spawn valuable '" + valuable.PrefabName + "'", Color.red);
				}
				else
				{
					Valuables.SpawnValuable(valuable, val, Quaternion.identity);
				}
			}
			else
			{
				Object.Instantiate<GameObject>(valuable.Prefab, 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(SemiFunc), "PlayerGetAllPlayerAvatarWithinRange")]
		[HarmonyPostfix]
		private static void SemiFunc_PlayerGetAllPlayerAvatarWithinRange_Postfix(ref List<PlayerAvatar> __result)
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			foreach (PlayerAvatar item in __result)
			{
				if (!Settings.isNoTarget(item))
				{
					list.Add(item);
				}
			}
			__result = list;
		}

		[HarmonyPatch(typeof(Enemy), "SetChaseTarget")]
		[HarmonyPrefix]
		private static bool Enemy_SetChaseTarget_Prefix(PlayerAvatar playerAvatar)
		{
			return !Settings.isNoTarget(playerAvatar);
		}

		[HarmonyPatch(typeof(EnemyOnScreen), "GetOnScreen")]
		[HarmonyPrefix]
		private static bool EnemyOnScreen_GetOnScreen_Prefix(PlayerAvatar _playerAvatar)
		{
			return !Settings.isNoTarget(_playerAvatar);
		}

		[HarmonyPatch(typeof(Enemy), "Update")]
		[HarmonyPrefix]
		private static void Enemy_Update_Prefix(Enemy __instance, ref PlayerAvatar ___TargetPlayerAvatar)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___TargetPlayerAvatar != (Object)null && Settings.isNoTarget(___TargetPlayerAvatar))
			{
				___TargetPlayerAvatar = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyAnimal), "Update")]
		[HarmonyPrefix]
		private static void EnemyAnimal_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyBangDirector), "Update")]
		[HarmonyPrefix]
		private static void EnemyBangDirector_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyBeamer), "Update")]
		[HarmonyPrefix]
		private static void EnemyBeamer_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyBirthdayBoy), "Update")]
		[HarmonyPrefix]
		private static void EnemyBirthdayBoy_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyBombThrower), "Update")]
		[HarmonyPrefix]
		private static void EnemyBombThrower_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyBowtie), "Update")]
		[HarmonyPrefix]
		private static void EnemyBowtie_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyCeilingEye), "Update")]
		[HarmonyPrefix]
		private static void EnemyCeilingEye_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyElsa), "Update")]
		[HarmonyPrefix]
		private static void EnemyElsa_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyElsa), "OnHurt")]
		[HarmonyPrefix]
		private static bool EnemyElsa_OnHurt_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget == (Object)null || Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyFloater), "Update")]
		[HarmonyPrefix]
		private static void EnemyFloater_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyGnomeDirector), "Update")]
		[HarmonyPrefix]
		private static void EnemyGnomeDirector_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyHeadGrabber), "Update")]
		[HarmonyPrefix]
		private static void EnemyHeadGrabber_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyHeartHugger), "Update")]
		[HarmonyPrefix]
		private static void EnemyHeartHugger_Update_Prefix(Enemy __instance, ref PlayerAvatar ___currentTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___currentTarget != (Object)null && Settings.isNoTarget(___currentTarget))
			{
				___currentTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyHidden), "Update")]
		[HarmonyPrefix]
		private static void EnemyHidden_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyHunter), "Update")]
		[HarmonyPrefix]
		private static void EnemyHunter_Update_Prefix(EnemyHunter __instance)
		{
			if ((Object)(object)__instance.enemy.Rigidbody != (Object)null)
			{
				EnemyRigidbody rigidbody = __instance.enemy.Rigidbody;
				if ((Object)(object)rigidbody.onTouchPlayerAvatar != (Object)null && Settings.isNoTarget(rigidbody.onTouchPlayerAvatar))
				{
					rigidbody.onTouchPlayerAvatar = null;
					__instance.UpdateState((State)2);
				}
				if ((Object)(object)rigidbody.onGrabbedPlayerAvatar != (Object)null && Settings.isNoTarget(rigidbody.onGrabbedPlayerAvatar))
				{
					rigidbody.onGrabbedPlayerAvatar = null;
					__instance.UpdateState((State)2);
				}
			}
		}

		[HarmonyPatch(typeof(EnemyHunter), "UpdateState")]
		[HarmonyPrefix]
		private static bool EnemyHunter_UpdateState_Prefix(EnemyHunter __instance, State _state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if ((int)_state == 5)
			{
				foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
				{
					if (Settings.isNoTarget(item) && (Object)(object)__instance.investigatePointTransform != (Object)null && (Object)(object)item.PlayerVisionTarget != (Object)null && (Object)(object)item.PlayerVisionTarget.VisionTransform != (Object)null && (Object)(object)__instance.investigatePointTransform == (Object)(object)item.PlayerVisionTarget.VisionTransform)
					{
						__instance.currentState = (State)2;
						return false;
					}
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyOogly), "Update")]
		[HarmonyPrefix]
		private static void EnemyOogly_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyRobe), "Update")]
		[HarmonyPrefix]
		private static void EnemyRobe_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyRobe), "ChaseTimer")]
		[HarmonyPrefix]
		private static bool EnemyRobe_ChaseTimer_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			if ((Object)(object)___targetPlayer == (Object)null || Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyRunner), "Update")]
		[HarmonyPrefix]
		private static void EnemyRunner_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyShadow), "Update")]
		[HarmonyPrefix]
		private static void EnemyShadow_Update_Prefix(EnemyShadow __instance, ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.UpdateState((State)1);
			}
		}

		[HarmonyPatch(typeof(EnemyShadow), "BendLogic")]
		[HarmonyPrefix]
		private static bool EnemyShadow_BendLogic_Prefix(EnemyShadow __instance, ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget == (Object)null || Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemySlowMouth), "Update")]
		[HarmonyPrefix]
		private static void EnemySlowMouth_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemySlowWalker), "Update")]
		[HarmonyPrefix]
		private static void EnemySlowWalker_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemySpinny), "Update")]
		[HarmonyPrefix]
		private static void EnemySpinny_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyThinMan), "Update")]
		[HarmonyPrefix]
		private static void EnemyThinMan_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyTick), "Update")]
		[HarmonyPrefix]
		private static void EnemyTick_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyTricycle), "Update")]
		[HarmonyPrefix]
		private static void EnemyTricycle_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyTricycle), "SetState")]
		[HarmonyPrefix]
		private static void EnemyTricycle_SetState_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget, ref PlayerAvatar ___isBlockedByPlayerAvatar, ref State newState)
		{
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				newState = (State)2;
			}
			if ((Object)(object)___isBlockedByPlayerAvatar != (Object)null && Settings.isNoTarget(___isBlockedByPlayerAvatar))
			{
				___isBlockedByPlayerAvatar = null;
				newState = (State)2;
			}
		}

		[HarmonyPatch(typeof(EnemyTricycle), "StateAttack")]
		[HarmonyPrefix]
		private static bool EnemyTricycle_StateAttack_Prefix(EnemyTricycle __instance, ref PlayerAvatar ___playerTarget)
		{
			if ((Object)(object)___playerTarget == (Object)null || Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.SetState((State)14);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyTricycle), "OnGrabbed")]
		[HarmonyPrefix]
		private static bool EnemyTricycle_OnGrabbed_Prefix(EnemyTricycle __instance)
		{
			if ((Object)(object)__instance.enemy.Rigidbody != (Object)null && (Object)(object)__instance.enemy.Rigidbody.onGrabbedPlayerAvatar != (Object)null && Settings.isNoTarget(__instance.enemy.Rigidbody.onGrabbedPlayerAvatar))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyTumbler), "Update")]
		[HarmonyPrefix]
		private static void EnemyTumbler_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyUpscream), "Update")]
		[HarmonyPrefix]
		private static void EnemyUpscream_Update_Prefix(Enemy __instance, ref PlayerAvatar ___targetPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___targetPlayer != (Object)null && Settings.isNoTarget(___targetPlayer))
			{
				___targetPlayer = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyValuableThrower), "Update")]
		[HarmonyPrefix]
		private static void EnemyValuableThrower_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[HarmonyPatch(typeof(EnemyDuck), "Update")]
		[HarmonyPrefix]
		private static void EnemyDuck_Update_Prefix(Enemy __instance, ref PlayerAvatar ___playerTarget)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___playerTarget != (Object)null && Settings.isNoTarget(___playerTarget))
			{
				___playerTarget = null;
				__instance.CurrentState = (EnemyState)2;
				__instance.DisableChase(1f);
			}
		}

		[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(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 _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if ((Object)(object)val == (Object)(object)SemiFunc.PlayerAvatarLocal())
			{
				val.playerHealth.maxHealth = 100 + StatsManager.instance.playerUpgradeHealth[_steamID] * 20;
				val.playerHealth.health = val.playerHealth.maxHealth - 1;
				val.playerHealth.Heal(1, 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 = 5f + (float)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("UpdateCrouchRestRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateCrouchRestRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.upgradeCrouchRest = StatsManager.instance.playerUpgradeCrouchRest[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateTumbleWingsRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateTumbleWingsRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.upgradeTumbleWings = StatsManager.instance.playerUpgradeTumbleWings[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateDeathHeadBatteryRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateDeathHeadBatteryRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.upgradeDeathHeadBattery = StatsManager.instance.playerUpgradeDeathHeadBattery[_steamID];
			}
			return false;
		}

		[HarmonyPatch("UpdateTumbleClimbRightAway")]
		[HarmonyPrefix]
		private static bool Prefix_UpdateTumbleClimbRightAway(ref string _steamID)
		{
			PlayerAvatar val = SemiFunc.PlayerAvatarGetFromSteamID(_steamID);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.upgradeTumbleClimb = StatsManager.instance.playerUpgradeTumbleClimb[_steamID];
			}
			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();
			UpgradeUtil.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;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToA