using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
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 Photon.Pun;
using Photon.Realtime;
using REPOLib.Modules;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace UpgradeEveryRound
{
	[HarmonyPatch(typeof(StatsUI), "Update")]
	public static class StatsUIPatch
	{
		private static void Prefix(ref float ___showStatsTimer)
		{
			if (UpgradeMenu.isOpen)
			{
				___showStatsTimer = 5f;
			}
		}
	}
	[HarmonyPatch(typeof(StatsManager))]
	[HarmonyPatch("Start")]
	public static class StatsManagerStartPatch
	{
		private static void Prefix(StatsManager __instance)
		{
			__instance.dictionaryOfDictionaries.Add("playerUpgradesUsed", new Dictionary<string, int>());
		}

		private static void Postfix(ref StatsManager __instance)
		{
			ModUpgradeHandler.BuildExtraUpgradeList();
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	[HarmonyPatch("LeaveToMainMenu")]
	public static class RunManagerMainMenuPatch
	{
		private static void Prefix()
		{
			UpgradeMenu.isOpen = false;
		}
	}
	internal static class ModUpgradeHandler
	{
		private static bool initialized = false;

		public static Dictionary<int, ConfigEntry<bool>> AllowExtras = new Dictionary<int, ConfigEntry<bool>>();

		public static Dictionary<int, string> ExtraLabels = new Dictionary<int, string>();

		public static Dictionary<string, GameObject> ExtraUpgrades = new Dictionary<string, GameObject>();

		public static List<BitVector32> ExtraConfigs = new List<BitVector32>();

		internal static void DoUpgrade(string upgradeLabel, string _steamID)
		{
			if ((Object)(object)ExtraUpgrades[upgradeLabel] == (Object)null)
			{
				PlayerUpgrade upgrade = Upgrades.GetUpgrade(upgradeLabel.Replace(" ", ""));
				if (upgrade != null)
				{
					upgrade.AddLevel(_steamID, 1);
				}
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(ExtraUpgrades[upgradeLabel]);
			MonoBehaviour[] components = val.GetComponents<MonoBehaviour>();
			for (int i = 0; i < components.Length; i++)
			{
				Traverse val2 = Traverse.Create((object)components[i]).Method("Start", Array.Empty<Type>(), (object[])null);
				if (val2.MethodExists())
				{
					val2.GetValue(Array.Empty<object>());
				}
			}
			ItemToggle component = val.GetComponent<ItemToggle>();
			ItemUpgrade component2 = val.GetComponent<ItemUpgrade>();
			Traverse.Create((object)component).Field<int>("playerTogglePhotonID").Value = SemiFunc.PlayerGetFromSteamID(_steamID).photonView.ViewID;
			Traverse obj = Traverse.Create((object)component2);
			obj.Field<PhysGrabObjectImpactDetector>("impactDetector").Value.destroyDisable = true;
			obj.Method("PlayerUpgrade", Array.Empty<Type>(), (object[])null).GetValue(Array.Empty<object>());
			Object.Destroy((Object)(object)val);
		}

		public static void BuildExtraUpgradeList()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Expected O, but got Unknown
			if (initialized)
			{
				return;
			}
			Plugin.Logger.LogMessage((object)"Building extra upgrades list");
			int num = 0;
			Regex regex = new Regex("(?<!^)(?=[A-Z])");
			AllowExtras.Clear();
			ExtraLabels.Clear();
			ExtraConfigs.Clear();
			foreach (PlayerUpgrade playerUpgrade in Upgrades.PlayerUpgrades)
			{
				string text = string.Join(" ", regex.Split(playerUpgrade.UpgradeId));
				ConfigEntry<bool> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Enabled upgrades", "Enable " + text, true, new ConfigDescription("Allows " + text + " Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
				AllowExtras.Add(num, val);
				ExtraLabels.Add(num, text);
				ExtraUpgrades.Add(text, null);
				val.SettingChanged += Plugin.ConfigUpdated;
				UpdateExtraConfig(num, val);
				num++;
			}
			string[] source = new string[8] { "Map Player Count", "Stamina", "Extra Jump", "Range", "Strength", "Health", "Sprint Speed", "Tumble Launch" };
			foreach (Item item in from x in Items.GetItems()
				where (int)x.itemType == 3
				select x)
			{
				string itemName = item.itemName;
				string text2 = itemName.Substring(0, itemName.Length - 8).Trim();
				if (!ExtraUpgrades.ContainsKey(text2) && !source.Contains(text2))
				{
					ConfigEntry<bool> val2 = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Enabled upgrades", "Enable " + text2, true, new ConfigDescription("Allows " + text2 + " Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
					AllowExtras.Add(num, val2);
					ExtraLabels.Add(num, text2);
					ExtraUpgrades.Add(text2, item.prefab);
					val2.SettingChanged += Plugin.ConfigUpdated;
					UpdateExtraConfig(num, val2);
					num++;
				}
			}
			Plugin.localNetworkData = new NetworkData();
			initialized = true;
		}

		private static int UpdateExtraConfig(int configIndex, ConfigEntry<bool> allowCustomUpgrade)
		{
			int num = configIndex / 32;
			int bit = configIndex % 32;
			while (ExtraConfigs.Count <= num)
			{
				ExtraConfigs.Add(default(BitVector32));
			}
			BitVector32 value = ExtraConfigs[num];
			value[bit] = allowCustomUpgrade.Value;
			ExtraConfigs[num] = value;
			return num;
		}

		public static bool AllowCustomUpgradeByIndex(int configIndex)
		{
			int num = configIndex / 32;
			int bit = configIndex % 32;
			return new BitVector32(Plugin.CurrentNetworkData.extraData[num])[bit];
		}
	}
	[Serializable]
	public record NetworkData
	{
		public int upgradesPerRound;

		public bool limitedChoices;

		public int numChoices;

		public bool allowMapCount;

		public bool allowEnergy;

		public bool allowExtraJump;

		public bool allowRange;

		public bool allowStrength;

		public bool allowHealth;

		public bool allowSpeed;

		public bool allowTumbleLaunch;

		public int[] extraData;

		public NetworkData()
		{
			upgradesPerRound = Plugin.upgradesPerRound.Value;
			limitedChoices = Plugin.limitedChoices.Value;
			numChoices = Plugin.numChoices.Value;
			allowMapCount = Plugin.allowMapCount.Value;
			allowEnergy = Plugin.allowEnergy.Value;
			allowExtraJump = Plugin.allowExtraJump.Value;
			allowRange = Plugin.allowRange.Value;
			allowStrength = Plugin.allowStrength.Value;
			allowHealth = Plugin.allowHealth.Value;
			allowSpeed = Plugin.allowSpeed.Value;
			allowTumbleLaunch = Plugin.allowTumbleLaunch.Value;
			extraData = ModUpgradeHandler.ExtraConfigs.Select((BitVector32 config) => config.Data).ToArray();
		}

		public static byte[] Serealize(object data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream();
			binaryFormatter.Serialize(memoryStream, data);
			return memoryStream.ToArray();
		}

		public static NetworkData Deserialize(byte[] arrBytes)
		{
			using MemoryStream memoryStream = new MemoryStream();
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			memoryStream.Write(arrBytes, 0, arrBytes.Length);
			memoryStream.Seek(0L, SeekOrigin.Begin);
			return (NetworkData)binaryFormatter.Deserialize(memoryStream);
		}
	}
	[HarmonyPatch(typeof(SemiFunc))]
	[HarmonyPatch("OnLevelGenDone")]
	internal static class OnLevelGenDonePatch
	{
		internal static void Postfix()
		{
			UERNetworkManager.levelLoaded = true;
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				UpgradeMenu.OpenMenu();
			}
		}
	}
	[BepInPlugin("dev.redfops.repo.upgradeeveryround", "Upgrade Every Round", "2.0.3")]
	[BepInDependency("nickklmao.menulib", "2.1.3")]
	[BepInDependency("REPOLib", "2.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static EventHandler <0>__ConfigUpdated;

			public static Action<EventData> <1>__HandleConfigUpdateEvent;

			public static Action<EventData> <2>__HandleClientUpgradeEvent;

			public static DeserializeMethod <3>__Deserialize;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static SerializeMethod <>9__25_0;

			internal byte[] <Awake>b__25_0(object x)
			{
				return NetworkData.Serealize(x);
			}
		}

		public const string modGUID = "dev.redfops.repo.upgradeeveryround";

		public const string modName = "Upgrade Every Round";

		public const string modVersion = "2.0.3";

		public static ConfigEntry<int> upgradesPerRound;

		public static ConfigEntry<bool> limitedChoices;

		public static ConfigEntry<int> numChoices;

		public static Plugin Instance;

		public static ConfigEntry<bool> allowMapCount;

		public static ConfigEntry<bool> allowEnergy;

		public static ConfigEntry<bool> allowExtraJump;

		public static ConfigEntry<bool> allowRange;

		public static ConfigEntry<bool> allowStrength;

		public static ConfigEntry<bool> allowHealth;

		public static ConfigEntry<bool> allowSpeed;

		public static ConfigEntry<bool> allowTumbleLaunch;

		public static NetworkData localNetworkData;

		public static NetworkData remoteNetworkData;

		public static NetworkedEvent ConfigUpdateEvent;

		public static NetworkedEvent ClientUpgradeEvent;

		public static RaiseEventOptions ConfigUpdateEventOptions = new RaiseEventOptions
		{
			CachingOption = (EventCaching)4,
			Receivers = (ReceiverGroup)0
		};

		public static RaiseEventOptions ClientUpgradeEventOptions = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)2
		};

		internal static ManualLogSource Logger;

		private readonly Harmony harmony = new Harmony("dev.redfops.repo.upgradeeveryround");

		public static NetworkData CurrentNetworkData
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)GameManager.instance) || SemiFunc.IsMasterClientOrSingleplayer())
				{
					return localNetworkData;
				}
				if (remoteNetworkData == null)
				{
					Logger.LogError((object)"Missing remote data");
					return localNetworkData;
				}
				return remoteNetworkData;
			}
		}

		public static int UpgradesPerRound => CurrentNetworkData.upgradesPerRound;

		public static bool LimitedChoices => CurrentNetworkData.limitedChoices;

		public static int NumChoices => CurrentNetworkData.numChoices;

		public static bool AllowMapCount => CurrentNetworkData.allowMapCount;

		public static bool AllowEnergy => CurrentNetworkData.allowEnergy;

		public static bool AllowExtraJump => CurrentNetworkData.allowExtraJump;

		public static bool AllowRange => CurrentNetworkData.allowRange;

		public static bool AllowStrength => CurrentNetworkData.allowStrength;

		public static bool AllowHealth => CurrentNetworkData.allowHealth;

		public static bool AllowSpeed => CurrentNetworkData.allowSpeed;

		public static bool AllowTumbleLaunch => CurrentNetworkData.allowTumbleLaunch;

		private void Awake()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Expected O, but got Unknown
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			upgradesPerRound = ((BaseUnityPlugin)this).Config.Bind<int>("Upgrades", "Upgrades Per Round", 1, new ConfigDescription("Number of upgrades per round", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 7), Array.Empty<object>()));
			limitedChoices = ((BaseUnityPlugin)this).Config.Bind<bool>("Upgrades", "Limited random choices", false, new ConfigDescription("Only presents a fixed number of random options", (AcceptableValueBase)null, Array.Empty<object>()));
			numChoices = ((BaseUnityPlugin)this).Config.Bind<int>("Upgrades", "Number of choices", 3, new ConfigDescription("Number of options to choose from per upgrade", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()));
			allowMapCount = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Map Player Count", true, new ConfigDescription("Allows Map Player Count Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowEnergy = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Stamina", true, new ConfigDescription("Allows Stamina Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowExtraJump = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Extra Jump", true, new ConfigDescription("Allows Extra Jump Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowRange = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Range", true, new ConfigDescription("Allows Range Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowStrength = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Strength", true, new ConfigDescription("Allows Strength Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowHealth = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Health", true, new ConfigDescription("Allows Health Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowSpeed = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Speed", true, new ConfigDescription("Allows Speed Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			allowTumbleLaunch = ((BaseUnityPlugin)this).Config.Bind<bool>("Enabled upgrades", "Enable Tumble Launch", true, new ConfigDescription("Allows Tumble Launch Upgrade to be chosen", (AcceptableValueBase)null, Array.Empty<object>()));
			upgradesPerRound.SettingChanged += ConfigUpdated;
			limitedChoices.SettingChanged += ConfigUpdated;
			numChoices.SettingChanged += ConfigUpdated;
			allowMapCount.SettingChanged += ConfigUpdated;
			allowEnergy.SettingChanged += ConfigUpdated;
			allowExtraJump.SettingChanged += ConfigUpdated;
			allowRange.SettingChanged += ConfigUpdated;
			allowStrength.SettingChanged += ConfigUpdated;
			allowHealth.SettingChanged += ConfigUpdated;
			allowSpeed.SettingChanged += ConfigUpdated;
			allowTumbleLaunch.SettingChanged += ConfigUpdated;
			ConfigUpdateEvent = new NetworkedEvent("ConfigUpdate", (Action<EventData>)HandleConfigUpdateEvent);
			ClientUpgradeEvent = new NetworkedEvent("ClientUpgrade", (Action<EventData>)HandleClientUpgradeEvent);
			harmony.PatchAll(typeof(SceneSwitchPatch));
			harmony.PatchAll(typeof(OnLevelGenDonePatch));
			harmony.PatchAll(typeof(SteamManagerPatch));
			harmony.PatchAll(typeof(RunManagerMainMenuPatch));
			harmony.PatchAll(typeof(StatsManagerStartPatch));
			harmony.PatchAll(typeof(StatsUIPatch));
			Type typeFromHandle = typeof(NetworkData);
			object obj = <>c.<>9__25_0;
			if (obj == null)
			{
				SerializeMethod val = (object x) => NetworkData.Serealize(x);
				<>c.<>9__25_0 = val;
				obj = (object)val;
			}
			object obj2 = <>O.<3>__Deserialize;
			if (obj2 == null)
			{
				DeserializeMethod val2 = NetworkData.Deserialize;
				<>O.<3>__Deserialize = val2;
				obj2 = (object)val2;
			}
			PhotonPeer.RegisterType(typeFromHandle, (byte)248, (SerializeMethod)obj, (DeserializeMethod)obj2);
			((MonoBehaviour)this).StartCoroutine(UERNetworkManager.Go());
			Logger.LogInfo((object)"Plugin UpgradeEveryRound is loaded!");
		}

		internal static void ConfigUpdated(object sender, EventArgs args)
		{
			localNetworkData = new NetworkData();
			if (SemiFunc.IsMultiplayer() && PhotonNetwork.IsMasterClient)
			{
				SendConfig();
			}
		}

		public static void SendConfig()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			ConfigUpdateEvent.RaiseEvent((object)localNetworkData, ConfigUpdateEventOptions, SendOptions.SendReliable);
		}

		private static void HandleConfigUpdateEvent(EventData eventData)
		{
			remoteNetworkData = (NetworkData)eventData.CustomData;
		}

		public static void DoUpgradeClient(string upgradeLabel, string _steamID)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			string text = upgradeLabel + ";;;" + _steamID;
			ClientUpgradeEvent.RaiseEvent((object)text, ClientUpgradeEventOptions, SendOptions.SendReliable);
		}

		private static void HandleClientUpgradeEvent(EventData eventData)
		{
			string obj = (string)eventData.CustomData;
			string text = obj.Split(";;;")[0];
			string text2 = obj.Split(";;;")[1];
			switch (text)
			{
			case "Stamina":
				PunManager.instance.UpgradePlayerEnergy(text2);
				break;
			case "Extra Jump":
				PunManager.instance.UpgradePlayerExtraJump(text2);
				break;
			case "Range":
				PunManager.instance.UpgradePlayerGrabRange(text2);
				break;
			case "Strength":
				PunManager.instance.UpgradePlayerGrabStrength(text2);
				break;
			case "Health":
				PunManager.instance.UpgradePlayerHealth(text2);
				break;
			case "Sprint Speed":
				PunManager.instance.UpgradePlayerSprintSpeed(text2);
				break;
			case "Tumble Launch":
				PunManager.instance.UpgradePlayerTumbleLaunch(text2);
				break;
			case "Map Player Count":
				PunManager.instance.UpgradeMapPlayerCount(text2);
				break;
			default:
				ModUpgradeHandler.DoUpgrade(text, text2);
				break;
			}
			PunManager.instance.UpdateStat("playerUpgradesUsed", text2, StatsManager.instance.dictionaryOfDictionaries["playerUpgradesUsed"][text2] + 1);
		}

		public static void ApplyUpgrade(string _steamID, REPOPopupPage popupPage)
		{
			StatsUI.instance.Fetch();
			StatsUI.instance.ShowStats();
			CameraGlitch.Instance.PlayUpgrade();
			int num = (UERNetworkManager.upgradesUsedLocal = NumUpgradesUsed(_steamID) + 1);
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				PunManager.instance.UpdateStat("playerUpgradesUsed", _steamID, num);
			}
			UpgradeMenu.isOpen = false;
			popupPage.ClosePage(true);
			if (RunManager.instance.levelsCompleted * UpgradesPerRound > num)
			{
				UpgradeMenu.createMenu(_steamID).OpenPage(false);
				UpgradeMenu.isOpen = true;
			}
		}

		public static int NumUpgradesUsed(string _steamID)
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return UERNetworkManager.upgradesUsedLocal;
			}
			return StatsManager.instance.dictionaryOfDictionaries["playerUpgradesUsed"][_steamID];
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradeMapPlayerCount")]
	public static class UpgradeMapPlayerCountPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradeMapPlayerCountRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeMapPlayerCount[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerEnergy")]
	public static class UpgradePlayerEnergyPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerEnergyCountRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeStamina[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerExtraJump")]
	public static class UpgradePlayerExtraJumpPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerExtraJumpRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeExtraJump[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerGrabRange")]
	public static class UpgradePlayerGrabRangePatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerGrabRangeRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeRange[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerGrabStrength")]
	public static class UpgradePlayerGrabStrengthPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerGrabStrengthRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeStrength[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerHealth")]
	public static class UpgradePlayerHealthPatch
	{
		private static void Postfix(string playerName, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerHealthRPC", (RpcTarget)1, new object[2]
				{
					playerName,
					___statsManager.playerUpgradeHealth[playerName]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerSprintSpeed")]
	public static class UpgradePlayerSprintSpeedPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerSprintSpeedRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeSpeed[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("UpgradePlayerTumbleLaunch")]
	public static class UpgradePlayerTumbleLaunchPatch
	{
		private static void Postfix(string _steamID, PhotonView ___photonView, StatsManager ___statsManager)
		{
			if (!SemiFunc.IsMasterClient() && GameManager.Multiplayer() && UpgradeMenu.isOpen)
			{
				___photonView.RPC("UpgradePlayerTumbleLaunchRPC", (RpcTarget)1, new object[2]
				{
					_steamID,
					___statsManager.playerUpgradeLaunch[_steamID]
				});
			}
		}
	}
	[HarmonyPatch(typeof(SemiFunc))]
	[HarmonyPatch("OnSceneSwitch")]
	internal static class SceneSwitchPatch
	{
		private static void Prefix()
		{
			UERNetworkManager.LevelChange();
		}
	}
	[HarmonyPatch(typeof(SteamManager))]
	internal static class SteamManagerPatch
	{
		[HarmonyPatch("UnlockLobby")]
		[HarmonyPostfix]
		internal static void UnlockLobbyPostfix()
		{
			Plugin.SendConfig();
		}
	}
	public static class UERNetworkManager
	{
		[CompilerGenerated]
		private sealed class <Go>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!Object.op_Implicit((Object)(object)GameManager.instance) || SemiFunc.IsMasterClientOrSingleplayer())
					{
						synced = false;
						levelLoaded = false;
						menuOpened = false;
						upgradesUsedLocal = -1;
					}
					else
					{
						if (!joinedGame)
						{
							StatsManager.instance.dictionaryOfDictionaries["playerUpgradesUsed"][SteamClient.SteamId.Value.ToString()] = -1;
							joinedGame = true;
						}
						if (levelLoaded)
						{
							synced = StatsManager.instance.statsSynced;
							if (synced && levelLoaded && !menuOpened && StatsManager.instance.dictionaryOfDictionaries["playerUpgradesUsed"][SteamClient.SteamId.Value.ToString()] != -1)
							{
								if (upgradesUsedLocal == -1)
								{
									upgradesUsedLocal = StatsManager.instance.dictionaryOfDictionaries["playerUpgradesUsed"][SteamClient.SteamId.Value.ToString()];
								}
								UpgradeMenu.OpenMenu();
								menuOpened = true;
							}
						}
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}

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

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

		public static bool synced = false;

		public static bool levelLoaded = false;

		public static bool menuOpened = false;

		private static bool joinedGame = false;

		public static int upgradesUsedLocal = -1;

		[IteratorStateMachine(typeof(<Go>d__5))]
		public static IEnumerator Go()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Go>d__5(0);
		}

		public static void LevelChange()
		{
			synced = false;
			levelLoaded = false;
			menuOpened = false;
		}
	}
	public static class UpgradeMenu
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__3_0;

			internal void <createMenu>b__3_0()
			{
				isOpen = false;
			}
		}

		public static bool isOpen;

		public static bool choseUpgrade;

		public static void OpenMenu()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (!isOpen && !((IEnumerable<Level>)(object)new Level[3]
			{
				RunManager.instance.levelMainMenu,
				RunManager.instance.levelLobbyMenu,
				RunManager.instance.levelTutorial
			}).Contains(RunManager.instance.levelCurrent))
			{
				string steamID = SteamClient.SteamId.Value.ToString();
				int num = RunManager.instance.levelsCompleted * Plugin.UpgradesPerRound;
				if (Plugin.NumUpgradesUsed(steamID) < num)
				{
					MenuManager.instance.PageCloseAll();
					REPOPopupPage obj = createMenu(steamID);
					isOpen = true;
					obj.OpenPage(false);
				}
			}
		}

		public static REPOPopupPage createMenu(string _steamID)
		{
			//IL_0063: 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_006e: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Expected O, but got Unknown
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Expected O, but got Unknown
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Expected O, but got Unknown
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Expected O, but got Unknown
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Expected O, but got Unknown
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Expected O, but got Unknown
			choseUpgrade = false;
			StatsUI.instance.Fetch();
			StatsUI.instance.ShowStats();
			REPOPopupPage repoPopupPage = MenuAPI.CreateREPOPopupPage("Choose an upgrade", (PresetSide)1, false, true, 1.5f);
			UnityEvent onPageEnd = repoPopupPage.menuPage.onPageEnd;
			object obj = <>c.<>9__3_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					isOpen = false;
				};
				<>c.<>9__3_0 = val;
				obj = (object)val;
			}
			onPageEnd.AddListener((UnityAction)obj);
			List<int> list = new List<int>(8) { 0, 1, 2, 3, 4, 5, 6, 7 };
			List<bool> list2 = new List<bool>(8)
			{
				Plugin.AllowEnergy,
				Plugin.AllowExtraJump,
				Plugin.AllowRange,
				Plugin.AllowStrength,
				Plugin.AllowHealth,
				Plugin.AllowSpeed,
				Plugin.AllowTumbleLaunch,
				Plugin.AllowMapCount
			};
			foreach (KeyValuePair<int, ConfigEntry<bool>> allowExtra in ModUpgradeHandler.AllowExtras)
			{
				int key = allowExtra.Key;
				list.Add(list.Count);
				list2.Add(ModUpgradeHandler.AllowCustomUpgradeByIndex(key));
			}
			int numChoices = (Plugin.LimitedChoices ? Plugin.NumChoices : list.Count);
			int num = 0;
			for (int j = 0; j < list.Count; j++)
			{
				if (!list2[j])
				{
					list.RemoveAt(j - num);
					num++;
				}
			}
			numChoices = Mathf.Min(numChoices, list.Count);
			_ = new Vector2[8]
			{
				new Vector2(390f, 18f),
				new Vector2(530f, 18f),
				new Vector2(390f, 60f),
				new Vector2(530f, 60f),
				new Vector2(390f, 102f),
				new Vector2(530f, 102f),
				new Vector2(390f, 144f),
				new Vector2(530f, 144f)
			};
			for (int i = 0; i < numChoices; i++)
			{
				int index = (Plugin.LimitedChoices ? Random.Range(0, list.Count) : 0);
				int choice = list[index];
				list.RemoveAt(index);
				_ = i;
				switch (choice)
				{
				case 0:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Stamina", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerEnergy(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Stamina", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 1:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Extra Jump", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerExtraJump(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Extra Jump", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 2:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Range", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerGrabRange(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Range", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 3:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Strength", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerGrabStrength(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Strength", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 4:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Health", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerHealth(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Health", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 5:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Sprint Speed", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerSprintSpeed(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Sprint Speed", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 6:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Tumble Launch", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradePlayerTumbleLaunch(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Tumble Launch", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				case 7:
					repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
					{
						CreateButton(parent, "Map Player Count", delegate
						{
							if (SemiFunc.IsMasterClientOrSingleplayer())
							{
								PunManager.instance.UpgradeMapPlayerCount(_steamID);
							}
							else
							{
								Plugin.DoUpgradeClient("Map Player Count", _steamID);
							}
						}, i, numChoices, _steamID, repoPopupPage);
					});
					continue;
				}
				repoPopupPage.AddElement((BuilderDelegate)delegate(Transform parent)
				{
					CreateButton(parent, ModUpgradeHandler.ExtraLabels[choice - 8], delegate
					{
						if (SemiFunc.IsMasterClientOrSingleplayer())
						{
							ModUpgradeHandler.DoUpgrade(ModUpgradeHandler.ExtraLabels[choice - 8], _steamID);
						}
						else
						{
							Plugin.DoUpgradeClient(ModUpgradeHandler.ExtraLabels[choice - 8], _steamID);
						}
					}, i, numChoices, _steamID, repoPopupPage);
				});
			}
			return repoPopupPage;
		}

		private static REPOButton CreateButton(Transform parent, string buttonText, Action upgradeStat, int buttonNumber, int totalButtons, string _steamID, REPOPopupPage page)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			(Vector2, float) buttonPos = GetButtonPos(buttonNumber, totalButtons);
			Vector2 item = buttonPos.Item1;
			float item2 = buttonPos.Item2;
			REPOButton obj = MenuAPI.CreateREPOButton(buttonText, (Action)delegate
			{
				if (!choseUpgrade)
				{
					choseUpgrade = true;
					upgradeStat();
					Plugin.ApplyUpgrade(_steamID, page);
				}
			}, parent, item);
			TextMeshProUGUI labelTMP = obj.labelTMP;
			((TMP_Text)labelTMP).fontSize = ((TMP_Text)labelTMP).fontSize * item2;
			return obj;
		}

		private static (Vector2, float) GetButtonPos(int buttonNumber, int totalButtons)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (totalButtons <= 8)
			{
				return (new Vector2(370f + (float)(140 * (buttonNumber % 2)), 270f - 52f * (float)(buttonNumber / 2)), 0.9f);
			}
			float num = 252f;
			int num2 = 8;
			float num3 = num / (42f * (float)(totalButtons / num2));
			float num4 = num3 * 42f;
			float num5 = num3 * 180f;
			num2 = Math.Max((int)(370f / num5), 2);
			while (num2 != 1)
			{
				num2--;
				num3 = Math.Min(num / (42f * (float)(totalButtons / num2)), 2f / (float)num2);
				num4 = num3 * 42f;
				num5 = num3 * 180f;
				if (!((float)(totalButtons / num2) * num4 < num))
				{
					break;
				}
			}
			num2++;
			num3 = Math.Min(num / (42f * (float)(totalButtons / num2)), 2f / (float)num2);
			num4 = num3 * 42f;
			num5 = num3 * 180f;
			return (new Vector2(370f + (float)(buttonNumber % num2) * num5, 270f - (float)(buttonNumber / num2) * num4), num3 * 0.9f);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "UpgradeEveryRound";

		public const string PLUGIN_NAME = "Upgrade Every Round";

		public const string PLUGIN_VERSION = "2.0.3";
	}
}