using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LargePupils")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HP")]
[assembly: AssemblyProduct("LargePupils")]
[assembly: AssemblyCopyright("Copyright © HP 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9c065692-8a25-40c1-b906-72c5ac397789")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LargePupils;

[BepInPlugin("bobismods.largepupils.mod", "LargePupils", "1.0.1")]
public class LargePupils : BaseUnityPlugin
{
	public const string plugin_GUID = "bobismods.largepupils.mod";

	public const string plugin_name = "LargePupils";

	public const string plugin_version = "1.0.1";

	private readonly Harmony harmony = new Harmony("bobismods.largepupils.mod");

	public static LargePupils Instance;

	private void Awake()
	{
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		harmony.PatchAll(typeof(LargePupils));
		harmony.PatchAll(typeof(LargePupilsPatch));
	}
}
[HarmonyPatch(typeof(TruckScreenText))]
internal class LargePupilsPatch
{
	[HarmonyPatch("ArrowPointAtGoalLogic")]
	[HarmonyPostfix]
	private static void PrefixMethod()
	{
		List<PlayerAvatar> list = SemiFunc.PlayerGetAll();
		foreach (PlayerAvatar item in list)
		{
			AccessTools.Field(typeof(PlayerEyes), "pupilSizeMultiplier").SetValue(item.playerAvatarVisuals.playerEyes, 2f);
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CartDuplicator.Patches;
using HarmonyLib;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("CartDuplicator")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CartDuplicator")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c3dd3bd7-b7d1-4490-ad3d-0422f13bcbfd")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace CartDuplicator
{
	[BepInPlugin("Bocon.CartDuplicator", "Cart Duplicator", "1.3.0")]
	public class CartDuplicator : BaseUnityPlugin
	{
		private const string modGUID = "Bocon.CartDuplicator";

		private const string modeName = "Cart Duplicator";

		private const string modVersion = "1.3.0";

		private readonly Harmony harmony = new Harmony("Bocon.CartDuplicator");

		private static CartDuplicator Instance;

		internal ManualLogSource mls;

		private ConfigEntry<Vector3> duplicationOffset;

		private ConfigEntry<int> duplicationAmount;

		private ConfigEntry<bool> smallCartReplacement;

		private void Awake()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Bocon.CartDuplicator");
			duplicationOffset = ((BaseUnityPlugin)this).Config.Bind<Vector3>("General", "DuplicationOffset", new Vector3(2f, 0f, 0f), "Offset for the duplicated cart position");
			duplicationAmount = ((BaseUnityPlugin)this).Config.Bind<int>("General", "DuplicationAmount", 1, new ConfigDescription("Number of additional carts to duplicate", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()));
			smallCartReplacement = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "SmallCartReplacement", false, "Replace the duplicated carts with the pocket C.A.R.T.");
			mls.LogInfo((object)"Cart Duplicator Mod Loaded");
			harmony.PatchAll(typeof(CartDuplicator));
			harmony.PatchAll(typeof(DuplicateCartPatch));
		}

		public static Vector3 GetDuplicationOffset()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Instance.duplicationOffset.Value;
		}

		public static int GetDuplicationAmount()
		{
			return Instance.duplicationAmount.Value;
		}

		public static bool GetSmallCartReplacement()
		{
			return Instance.smallCartReplacement.Value;
		}
	}
}
namespace CartDuplicator.Patches
{
	[HarmonyPatch(typeof(PunManager))]
	[HarmonyPatch("SpawnItem")]
	public class DuplicateCartPatch : MonoBehaviourPunCallbacks
	{
		[HarmonyPostfix]
		public static void After_SpawnItem(Item item, ItemVolume volume)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || (Object)(object)volume == (Object)null || item.itemAssetName != "Item Cart Medium")
			{
				return;
			}
			int duplicationAmount = CartDuplicator.GetDuplicationAmount();
			Vector3 duplicationOffset = CartDuplicator.GetDuplicationOffset();
			string text = (CartDuplicator.GetSmallCartReplacement() ? "Item Cart Small" : ((Object)item.prefab).name);
			if (PhotonNetwork.IsConnected && PhotonNetwork.IsMasterClient)
			{
				for (int i = 0; i < duplicationAmount; i++)
				{
					PhotonNetwork.InstantiateRoomObject("Items/" + text, ((Component)volume).transform.position + duplicationOffset * (float)(i + 1), item.spawnRotationOffset, (byte)0, (object[])null);
				}
			}
			else if (!PhotonNetwork.IsConnected)
			{
				GameObject val = (CartDuplicator.GetSmallCartReplacement() ? Resources.Load<GameObject>("Items/Item Cart Small") : item.prefab);
				for (int j = 0; j < duplicationAmount; j++)
				{
					Object.Instantiate<GameObject>(val, ((Component)volume).transform.position + duplicationOffset * (float)(j + 1), item.spawnRotationOffset);
				}
			}
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("StatManager")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("StatManager")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("179e1f3b-e093-4adf-9132-f04de1bfb69d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace StatManager
{
	[BepInPlugin("Bocon.StatManager", "Stat Manager", "1.0.0")]
	public class StatManager : BaseUnityPlugin
	{
		private const string modGUID = "Bocon.StatManager";

		private const string modeName = "Stat Manager";

		private const string modVersion = "1.0.0";

		private const string ASCII_LOGO = "\n  _____ _        _     __  __                                   \n  / ____| |      | |   |  \\/  |                                  \n | (___ | |_ __ _| |_  | \\  / | __ _ _ __   __ _  __ _  ___ _ __ \n  \\___ \\| __/ _` | __| | |\\/| |/ _` | '_ \\ / _` |/ _` |/ _ \\ '__|\n  ____) | || (_| | |_  | |  | | (_| | | | | (_| | (_| |  __/ |   \n |_____/ \\__\\__,_|\\__| |_|  |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   \n                                                  __/ |          \n                                                 |___/           \n";

		private readonly Harmony harmony = new Harmony("Bocon.StatManager");

		private static StatManager Instance;

		internal ManualLogSource mls;

		internal static ConfigEntry<int> HealthBonus;

		internal static ConfigEntry<int> SpeedBonus;

		internal static ConfigEntry<int> MapCountBonus;

		internal static ConfigEntry<int> EnergyBonus;

		internal static ConfigEntry<int> ExtraJumpBonus;

		internal static ConfigEntry<int> GrabRangeBonus;

		internal static ConfigEntry<int> GrabStrengthBonus;

		internal static ConfigEntry<int> GrabThrowBonus;

		internal static ConfigEntry<int> TumbleLaunchBonus;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Bocon.StatManager");
			mls.LogInfo((object)"\n  _____ _        _     __  __                                   \n  / ____| |      | |   |  \\/  |                                  \n | (___ | |_ __ _| |_  | \\  / | __ _ _ __   __ _  __ _  ___ _ __ \n  \\___ \\| __/ _` | __| | |\\/| |/ _` | '_ \\ / _` |/ _` |/ _ \\ '__|\n  ____) | || (_| | |_  | |  | | (_| | | | | (_| | (_| |  __/ |   \n |_____/ \\__\\__,_|\\__| |_|  |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|   \n                                                  __/ |          \n                                                 |___/           \n");
			HealthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Health", 10, "Amount of Health upgrades.");
			SpeedBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Sprint Speed", 5, "Amount of Sprint Speed upgrades.");
			MapCountBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Player Map Count", 1, "Amount of Player Map Count upgrades.");
			EnergyBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Energy", 10, "Amount of Energy upgrades.");
			ExtraJumpBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Extra Jump", 1, "Amount of Extra Jump upgrades.");
			GrabRangeBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Range", 5, "Amount of Grab Range upgrades.");
			GrabStrengthBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Strength", 5, "Amount of Grab Strength upgrades.");
			GrabThrowBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Grab Throw", 5, "Amount of Grab Throw upgrades.");
			TumbleLaunchBonus = ((BaseUnityPlugin)this).Config.Bind<int>("Stats", "Tumble Launch", 5, "Amount of Tumble Launch upgrades.");
			harmony.PatchAll();
		}
	}
}
namespace StatManager.Patches
{
	internal class Patch
	{
		[HarmonyPatch(typeof(GameDirector), "Start")]
		private class GameDirectorPatch
		{
			private static void Postfix()
			{
				Object.FindObjectOfType<MonoBehaviour>().StartCoroutine(WaitForLevel());
			}
		}

		[HarmonyPatch(typeof(RunManager), "ResetProgress")]
		private class RunManagerResetPatch
		{
			private static void Postfix()
			{
				hasAppliedUpgrade = false;
			}
		}

		[CompilerGenerated]
		private sealed class <WaitForLevel>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private List<PlayerAvatar>.Enumerator <>s__1;

			private PlayerAvatar <player>5__2;

			private int <i>5__3;

			private int <i>5__4;

			private int <i>5__5;

			private int <i>5__6;

			private int <i>5__7;

			private int <i>5__8;

			private int <i>5__9;

			private int <i>5__10;

			private int <i>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<PlayerAvatar>.Enumerator);
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!SemiFunc.LevelGenDone())
				{
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				}
				if (!hasAppliedUpgrade && SemiFunc.RunIsLevel())
				{
					<>s__1 = SemiFunc.PlayerGetAll().GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<player>5__2 = <>s__1.Current;
							<i>5__3 = 0;
							while (<i>5__3 < StatManager.HealthBonus.Value)
							{
								PunManager.instance.UpgradePlayerHealth(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__3++;
							}
							<i>5__4 = 0;
							while (<i>5__4 < StatManager.SpeedBonus.Value)
							{
								PunManager.instance.UpgradePlayerSprintSpeed(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__4++;
							}
							<i>5__5 = 0;
							while (<i>5__5 < StatManager.MapCountBonus.Value)
							{
								PunManager.instance.UpgradeMapPlayerCount(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__5++;
							}
							<i>5__6 = 0;
							while (<i>5__6 < StatManager.EnergyBonus.Value)
							{
								PunManager.instance.UpgradePlayerEnergy(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__6++;
							}
							<i>5__7 = 0;
							while (<i>5__7 < StatManager.ExtraJumpBonus.Value)
							{
								PunManager.instance.UpgradePlayerExtraJump(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__7++;
							}
							<i>5__8 = 0;
							while (<i>5__8 < StatManager.GrabRangeBonus.Value)
							{
								PunManager.instance.UpgradePlayerGrabRange(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__8++;
							}
							<i>5__9 = 0;
							while (<i>5__9 < StatManager.GrabStrengthBonus.Value)
							{
								PunManager.instance.UpgradePlayerGrabStrength(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__9++;
							}
							<i>5__10 = 0;
							while (<i>5__10 < StatManager.GrabThrowBonus.Value)
							{
								PunManager.instance.UpgradePlayerThrowStrength(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__10++;
							}
							<i>5__11 = 0;
							while (<i>5__11 < StatManager.TumbleLaunchBonus.Value)
							{
								PunManager.instance.UpgradePlayerTumbleLaunch(SemiFunc.PlayerGetSteamID(<player>5__2));
								<i>5__11++;
							}
							<player>5__2 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(List<PlayerAvatar>.Enumerator);
					hasAppliedUpgrade = true;
				}
				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 bool hasAppliedUpgrade;

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

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CustomColors;
using HarmonyLib;
using MoreUpgrades.Classes;
using MoreUpgrades.Properties;
using Photon.Pun;
using REPOLib.Modules;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ShrinkItemsInCart")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ShrinkItemsInCart")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5e12a72d-c200-488d-940a-653d1003d96e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MoreUpgrades
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("bulletbot.moreupgrades", "MoreUpgrades", "1.1.8")]
	internal class Plugin : BaseUnityPlugin
	{
		internal static class CustomColors
		{
			internal const string modGUID = "x753.CustomColors";

			internal static bool IsLoaded()
			{
				return Chainloader.PluginInfos.ContainsKey("x753.CustomColors");
			}

			internal static void OnAwake()
			{
				instance.PatchAll("MoreUpgrades.CustomColorsPatches");
			}
		}

		private const string modGUID = "bulletbot.moreupgrades";

		private const string modName = "MoreUpgrades";

		private const string modVer = "1.1.8";

		internal static Plugin instance;

		internal ManualLogSource logger;

		private readonly Harmony harmony = new Harmony("bulletbot.moreupgrades");

		internal AssetBundle assetBundle;

		internal List<UpgradeItem> upgradeItems;

		private void PatchAll(string _namespace)
		{
			foreach (Type item in from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.Namespace == _namespace
				select t)
			{
				harmony.PatchAll(item);
			}
		}

		internal GameObject GetVisualsFromComponent(Component component)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			GameObject val = null;
			if (((object)component).GetType() == typeof(EnemyParent))
			{
				EnemyParent val2 = (EnemyParent)(object)((component is EnemyParent) ? component : null);
				Enemy val3 = (Enemy)AccessTools.Field(typeof(EnemyParent), "Enemy").GetValue(component);
				try
				{
					val = ((Component)val2.EnableObject.gameObject.GetComponentInChildren<Animator>()).gameObject;
				}
				catch
				{
				}
				if ((Object)(object)val == (Object)null)
				{
					try
					{
						val = ((Component)((Component)val3).GetComponent<EnemyVision>().VisionTransform).gameObject;
					}
					catch
					{
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)val3).gameObject;
				}
			}
			else if (((object)component).GetType() == typeof(PlayerAvatar))
			{
				PlayerAvatar val4 = (PlayerAvatar)(object)((component is PlayerAvatar) ? component : null);
				val = ((Component)val4.playerAvatarVisuals).gameObject;
			}
			return val;
		}

		internal void AddEnemyToMap(Component component, string enemyName = null)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			UpgradeItem upgradeItem = upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Enemy Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			EnemyParent val = (EnemyParent)(object)((component is EnemyParent) ? component : null);
			if (val != null && enemyName == null)
			{
				enemyName = val.enemyName;
			}
			if ((from x in upgradeItem.GetConfig<string>("Exclude Enemies").Split(new char[1] { ',' })
				select x.Trim() into x
				where !string.IsNullOrEmpty(x)
				select x).Contains(enemyName))
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent(component);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("AddToMap");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("RemoveFromMap");
			if (!((Object)(object)visuals == (Object)null) && !variable.Any(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals))
			{
				if (variable2.Contains(visuals))
				{
					variable2.Remove(visuals);
				}
				variable.Add((visuals, upgradeItem.GetConfig<Color>("Color")));
			}
		}

		internal void RemoveEnemyFromMap(Component component, string enemyName = null)
		{
			UpgradeItem upgradeItem = upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Enemy Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			EnemyParent val = (EnemyParent)(object)((component is EnemyParent) ? component : null);
			if (val != null && enemyName == null)
			{
				enemyName = val.enemyName;
			}
			if ((from x in upgradeItem.GetConfig<string>("Exclude Enemies").Split(new char[1] { ',' })
				select x.Trim() into x
				where !string.IsNullOrEmpty(x)
				select x).Contains(enemyName))
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent(component);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("AddToMap");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("RemoveFromMap");
			if ((Object)(object)visuals == (Object)null || variable2.Contains(visuals))
			{
				return;
			}
			if (variable.Any(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals))
			{
				variable.RemoveAll(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals);
			}
			variable2.Add(visuals);
		}

		internal void AddPlayerToMap(PlayerAvatar playerAvatar)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			UpgradeItem upgradeItem = upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Player Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent((Component)(object)playerAvatar);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("AddToMap");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("RemoveFromMap");
			if (!((Object)(object)visuals == (Object)null) && !variable.Any(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals))
			{
				if (variable2.Contains(visuals))
				{
					variable2.Remove(visuals);
				}
				Color item = upgradeItem.GetConfig<Color>("Color");
				if (upgradeItem.GetConfig<bool>("Player Color"))
				{
					item = (Color)AccessTools.Field(typeof(PlayerAvatar), "color").GetValue(playerAvatar.playerAvatarVisuals);
				}
				variable.Add((visuals, item));
			}
		}

		internal void RemovePlayerToMap(PlayerAvatar playerAvatar)
		{
			UpgradeItem upgradeItem = upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Player Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent((Component)(object)playerAvatar);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("AddToMap");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("RemoveFromMap");
			if ((Object)(object)visuals == (Object)null || variable2.Contains(visuals))
			{
				return;
			}
			if (variable.Any(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals))
			{
				variable.RemoveAll(((GameObject, Color) x) => (Object)(object)x.Item1 == (Object)(object)visuals);
			}
			variable2.Add(visuals);
		}

		private void Awake()
		{
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			instance = this;
			logger = Logger.CreateLogSource("MoreUpgrades");
			assetBundle = AssetBundle.LoadFromMemory(Resources.moreupgrades);
			if ((Object)(object)assetBundle == (Object)null)
			{
				logger.LogError((object)"Something went wrong when loading the asset bundle.");
				return;
			}
			upgradeItems = new List<UpgradeItem>();
			UpgradeItem sprintUsage = new UpgradeItem("Sprint Usage", 5, 2, 3000f, 4500f);
			sprintUsage.AddConfig("Scaling Factor", 0.15f, "Formula: energySprintDrain / (1 + (upgradeAmount * scalingFactor))");
			UpgradeItem upgradeItem2 = sprintUsage;
			upgradeItem2.onFixedUpdate = (Action)Delegate.Combine(upgradeItem2.onFixedUpdate, (Action)delegate
			{
				int amount = sprintUsage.GetAmount();
				if ((Object)(object)PlayerController.instance != (Object)null && amount != 0)
				{
					if (!sprintUsage.HasVariable("OriginalEnergySprintDrain"))
					{
						sprintUsage.AddVariable("OriginalEnergySprintDrain", PlayerController.instance.EnergySprintDrain);
					}
					float variable8 = sprintUsage.GetVariable<float>("OriginalEnergySprintDrain");
					PlayerController.instance.EnergySprintDrain = variable8 / (1f + (float)amount * sprintUsage.GetConfig<float>("Scaling Factor"));
				}
			});
			upgradeItems.Add(sprintUsage);
			UpgradeItem valuableCount = new UpgradeItem("Valuable Count", 1, 1, 5000f, 6000f, 1);
			valuableCount.AddConfig("Display Total Value", defaultValue: true, "Whether to display the total value next to the valuable counter.");
			UpgradeItem upgradeItem3 = valuableCount;
			upgradeItem3.onInit = (Action)Delegate.Combine(upgradeItem3.onInit, (Action)delegate
			{
				valuableCount.AddVariable("CurrentValuables", new List<ValuableObject>());
				valuableCount.AddVariable("Changed", value: false);
				valuableCount.AddVariable("PreviousCount", 0);
				valuableCount.AddVariable("PreviousValue", 0);
				valuableCount.AddVariable("TextLength", 0);
			});
			UpgradeItem upgradeItem4 = valuableCount;
			upgradeItem4.onUpdate = (Action)Delegate.Combine(upgradeItem4.onUpdate, (Action)delegate
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				if (!SemiFunc.RunIsLobby() && !SemiFunc.RunIsShop() && (Object)(object)MissionUI.instance != (Object)null && valuableCount.GetAmount() != 0)
				{
					TextMeshProUGUI val4 = (TextMeshProUGUI)AccessTools.Field(typeof(MissionUI), "Text").GetValue(MissionUI.instance);
					string text = (string)AccessTools.Field(typeof(MissionUI), "messagePrev").GetValue(MissionUI.instance);
					List<ValuableObject> variable3 = valuableCount.GetVariable<List<ValuableObject>>("CurrentValuables");
					bool variable4 = valuableCount.GetVariable<bool>("Changed");
					int variable5 = valuableCount.GetVariable<int>("PreviousCount");
					int variable6 = valuableCount.GetVariable<int>("PreviousValue");
					int variable7 = valuableCount.GetVariable<int>("TextLength");
					int count = variable3.Count;
					bool config = valuableCount.GetConfig<bool>("Display Total Value");
					int num3 = (config ? variable3.Select((ValuableObject x) => (int)x.dollarValueCurrent).Sum() : 0);
					if (!Utility.IsNullOrWhiteSpace(((TMP_Text)val4).text) && (variable4 || variable5 != count || variable6 != num3))
					{
						string text2 = ((TMP_Text)val4).text;
						if (!variable4 && (variable5 != count || variable6 != num3))
						{
							text2 = text2.Substring(0, text2.Length - variable7);
						}
						string text3 = $"\nValuables: <b>{count}</b>" + (config ? (" (<color=#558B2F>$</color><b>" + SemiFunc.DollarGetString(num3) + "</b>)") : "");
						text2 += text3;
						valuableCount.SetVariable("PreviousCount", count);
						valuableCount.SetVariable("PreviousValue", num3);
						valuableCount.SetVariable("TextLength", text3.Length);
						((TMP_Text)val4).text = text2;
						AccessTools.Field(typeof(MissionUI), "messagePrev").SetValue(MissionUI.instance, text2);
						if (variable4)
						{
							valuableCount.SetVariable("Changed", value: false);
						}
					}
				}
			});
			upgradeItems.Add(valuableCount);
			UpgradeItem mapEnemyTracker = new UpgradeItem("Map Enemy Tracker", 1, 1, 6000f, 7000f, 1);
			mapEnemyTracker.AddConfig("Arrow Icon", defaultValue: true, "Whether the icon should appear as an arrow showing direction instead of a dot.");
			mapEnemyTracker.AddConfig<Color>("Color", Color.red, "The color of the icon.");
			mapEnemyTracker.AddConfig("Exclude Enemies", "", "Exclude specific enemies from displaying their icon by listing their names.\nExample: 'Gnome, Clown', seperated by commas.");
			UpgradeItem upgradeItem5 = mapEnemyTracker;
			upgradeItem5.onInit = (Action)Delegate.Combine(upgradeItem5.onInit, (Action)delegate
			{
				mapEnemyTracker.AddVariable("AddToMap", new List<(GameObject, Color)>());
				mapEnemyTracker.AddVariable("RemoveFromMap", new List<GameObject>());
			});
			UpgradeItem upgradeItem6 = mapEnemyTracker;
			upgradeItem6.onUpdate = (Action)Delegate.Combine(upgradeItem6.onUpdate, (Action)delegate
			{
				UpdateTracker(mapEnemyTracker);
			});
			upgradeItems.Add(mapEnemyTracker);
			UpgradeItem mapPlayerTracker = new UpgradeItem("Map Player Tracker", 1, 1, 9500f, 11000f, 1);
			mapPlayerTracker.AddConfig("Arrow Icon", defaultValue: true, "Whether the icon should appear as an arrow showing direction instead of a dot.");
			mapPlayerTracker.AddConfig("Player Color", defaultValue: false, "Whether the icon should be colored as the player.");
			mapPlayerTracker.AddConfig<Color>("Color", Color.blue, "The color of the icon.");
			UpgradeItem upgradeItem7 = mapPlayerTracker;
			upgradeItem7.onInit = (Action)Delegate.Combine(upgradeItem7.onInit, (Action)delegate
			{
				mapPlayerTracker.AddVariable("AddToMap", new List<(GameObject, Color)>());
				mapPlayerTracker.AddVariable("RemoveFromMap", new List<GameObject>());
			});
			UpgradeItem upgradeItem8 = mapPlayerTracker;
			upgradeItem8.onUpdate = (Action)Delegate.Combine(upgradeItem8.onUpdate, (Action)delegate
			{
				UpdateTracker(mapPlayerTracker);
			});
			upgradeItems.Add(mapPlayerTracker);
			SceneManager.activeSceneChanged += delegate
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				if (!((Object)(object)RunManager.instance == (Object)null) && !((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelMainMenu) && !((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu))
				{
					GameObject val3 = new GameObject();
					PhotonNetwork.AllocateViewID(val3.AddComponent<PhotonView>());
					val3.AddComponent<MoreUpgradesManager>();
					((Object)val3).name = "More Upgrades Manager";
				}
			};
			logger.LogMessage((object)"MoreUpgrades has started.");
			PatchAll("MoreUpgrades.Patches");
			if (CustomColors.IsLoaded())
			{
				CustomColors.OnAwake();
			}
			void UpdateTracker(UpgradeItem upgradeItem)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				if (!SemiFunc.RunIsLobby() && !SemiFunc.RunIsShop() && (Object)(object)SemiFunc.PlayerAvatarLocal() != (Object)null && upgradeItem.GetAmount() != 0)
				{
					List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("AddToMap");
					for (int num = variable.Count - 1; num >= 0; num--)
					{
						var (val, color) = variable[num];
						variable.RemoveAt(num);
						MapCustom component = val.GetComponent<MapCustom>();
						if (!((Object)(object)component != (Object)null))
						{
							component = val.AddComponent<MapCustom>();
							component.color = color;
							component.sprite = (upgradeItem.GetConfig<bool>("Arrow Icon") ? assetBundle.LoadAsset<Sprite>("Map Tracker") : SemiFunc.PlayerAvatarLocal().playerDeathHead.mapCustom.sprite);
						}
					}
					List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("RemoveFromMap");
					for (int num2 = variable2.Count - 1; num2 >= 0; num2--)
					{
						GameObject val2 = variable2[num2];
						variable2.RemoveAt(num2);
						MapCustom component2 = val2.GetComponent<MapCustom>();
						if (!((Object)(object)component2 == (Object)null))
						{
							Object.Destroy((Object)(object)((Component)component2.mapCustomEntity).gameObject);
							Object.Destroy((Object)(object)component2);
						}
					}
				}
			}
		}
	}
}
namespace MoreUpgrades.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("MoreUpgrades.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] moreupgrades
		{
			get
			{
				object @object = ResourceManager.GetObject("moreupgrades", resourceCulture);
				return (byte[])@object;
			}
		}

		internal Resources()
		{
		}
	}
}
namespace MoreUpgrades.Patches
{
	[HarmonyPatch(typeof(PlayerAvatar))]
	internal class PlayerAvatarPatch
	{
		[HarmonyPatch("LateStart")]
		[HarmonyPostfix]
		private static void LateStart(PlayerAvatar __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null) && !((Object)(object)__instance == (Object)(object)SemiFunc.PlayerAvatarLocal()))
			{
				Plugin.instance.AddPlayerToMap(__instance);
			}
		}

		[HarmonyPatch("ReviveRPC")]
		[HarmonyPostfix]
		private static void ReviveRPC(PlayerAvatar __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null) && !((Object)(object)__instance == (Object)(object)SemiFunc.PlayerAvatarLocal()))
			{
				Plugin.instance.AddPlayerToMap(__instance);
			}
		}

		[HarmonyPatch("PlayerDeathRPC")]
		[HarmonyPostfix]
		private static void PlayerDeathRPC(PlayerAvatar __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null) && !((Object)(object)__instance == (Object)(object)SemiFunc.PlayerAvatarLocal()))
			{
				Plugin.instance.RemovePlayerToMap(__instance);
				Plugin.instance.RemoveEnemyFromMap((Component)(object)__instance);
			}
		}

		[HarmonyPatch("SetColorRPC")]
		[HarmonyPostfix]
		private static void SetColorRPC(PlayerAvatar __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null) && !((Object)(object)__instance == (Object)(object)SemiFunc.PlayerAvatarLocal()))
			{
				UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Player Tracker");
				if (upgradeItem != null && upgradeItem.GetConfig<bool>("Player Color"))
				{
					Plugin.instance.RemovePlayerToMap(__instance);
					Plugin.instance.AddPlayerToMap(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemySlowMouth))]
	internal class EnemySlowMouthPatch
	{
		[HarmonyPatch("UpdateStateRPC")]
		[HarmonyPostfix]
		private static void UpdateStateRPC(EnemySlowMouth __instance, Enemy ___enemy)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Invalid comparison between Unknown and I4
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return;
			}
			PlayerAvatar val = (PlayerAvatar)AccessTools.Field(typeof(EnemySlowMouth), "playerTarget").GetValue(__instance);
			EnemyParent val2 = (EnemyParent)AccessTools.Field(typeof(Enemy), "EnemyParent").GetValue(___enemy);
			State currentState = __instance.currentState;
			if ((int)currentState == 9)
			{
				Plugin.instance.RemoveEnemyFromMap((Component)(object)val2);
				if (!((Object)(object)val == (Object)(object)SemiFunc.PlayerAvatarLocal()))
				{
					Plugin.instance.RemovePlayerToMap(val);
					Plugin.instance.AddEnemyToMap((Component)(object)val, val2.enemyName);
				}
			}
			else if ((int)currentState == 11)
			{
				Plugin.instance.AddEnemyToMap((Component)(object)val2);
				if (!((Object)(object)val == (Object)(object)SemiFunc.PlayerAvatarLocal()))
				{
					Plugin.instance.AddPlayerToMap(val);
					Plugin.instance.RemoveEnemyFromMap((Component)(object)val, val2.enemyName);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyParent))]
	internal class EnemyParentPatch
	{
		[HarmonyPatch("SpawnRPC")]
		[HarmonyPostfix]
		private static void SpawnRPC(EnemyParent __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null))
			{
				Plugin.instance.AddEnemyToMap((Component)(object)__instance);
			}
		}

		[HarmonyPatch("DespawnRPC")]
		[HarmonyPostfix]
		private static void DespawnRPC(EnemyParent __instance)
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null))
			{
				Plugin.instance.RemoveEnemyFromMap((Component)(object)__instance);
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHealth))]
	internal class EnemyHealthPatch
	{
		[HarmonyPatch("DeathRPC")]
		[HarmonyPostfix]
		private static void DeathRPC(EnemyHealth __instance, Enemy ___enemy)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null))
			{
				Plugin.instance.RemoveEnemyFromMap((Component)(EnemyParent)AccessTools.Field(typeof(Enemy), "EnemyParent").GetValue(___enemy));
			}
		}
	}
	[HarmonyPatch(typeof(MissionUIPatch))]
	internal class MissionUIPatch
	{
		[HarmonyPatch(typeof(MissionUI), "MissionText")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: 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_0036: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(MissionUI), "messagePrev"), (string)null)
			}).Advance(1).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MissionUIPatch), "MissionText", (Type[])null, (Type[])null))
			})
				.InstructionEnumeration();
		}

		private static void MissionText()
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null))
			{
				Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Valuable Count")?.SetVariable("Changed", value: true);
			}
		}
	}
	[HarmonyPatch(typeof(StatsManager))]
	internal class StatsManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start(StatsManager __instance)
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				string text = new string(upgradeItem.name.Where((char x) => !char.IsWhiteSpace(x)).ToArray());
				__instance.dictionaryOfDictionaries.Add("playerUpgrade" + text, upgradeItem.playerUpgrades);
				__instance.dictionaryOfDictionaries.Add("appliedPlayerUpgrade" + text, upgradeItem.appliedPlayerUpgrades);
			}
		}
	}
	[HarmonyPatch(typeof(ValuableObject))]
	internal class ValuableObjectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start(ValuableObject __instance)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Valuable Count");
			if (upgradeItem != null)
			{
				List<ValuableObject> variable = upgradeItem.GetVariable<List<ValuableObject>>("CurrentValuables");
				if (!variable.Contains(__instance))
				{
					variable.Add(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject))]
	internal class PhysGrabObjectPatch
	{
		[HarmonyPatch("OnDestroy")]
		[HarmonyPostfix]
		private static void OnDestroy(PhysGrabObject __instance)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return;
			}
			ValuableObject component = ((Component)__instance).gameObject.GetComponent<ValuableObject>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Valuable Count");
			if (upgradeItem != null)
			{
				List<ValuableObject> variable = upgradeItem.GetVariable<List<ValuableObject>>("CurrentValuables");
				if (variable.Contains(component))
				{
					variable.Remove(component);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemUpgrade))]
	internal class ItemUpgradePatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start(ItemUpgrade __instance)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				if (!(gameObject.GetComponent<ItemAttributes>().item.itemAssetName == upgradeItem.fullName))
				{
					continue;
				}
				__instance.upgradeEvent = new UnityEvent();
				__instance.upgradeEvent.AddListener((UnityAction)delegate
				{
					if (upgradeItem.GetConfig<bool>("Allow Team Upgrades"))
					{
						foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
						{
							MoreUpgradesManager.instance.Upgrade(upgradeItem.name, SemiFunc.PlayerGetSteamID(item));
						}
						return;
					}
					MoreUpgradesManager.instance.Upgrade(upgradeItem.name, SemiFunc.PlayerGetSteamID(SemiFunc.PlayerAvatarGetFromPhotonID((int)AccessTools.Field(typeof(ItemToggle), "playerTogglePhotonID").GetValue(gameObject.GetComponent<ItemToggle>()))));
				});
			}
		}
	}
	[HarmonyPatch(typeof(ShopManager))]
	internal class ShopManagerPatch
	{
		[HarmonyPatch("GetAllItemsFromStatsManager")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Br, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Dictionary<string, Item>.ValueCollection.Enumerator), "get_Current", (Type[])null, (Type[])null), (string)null)
			});
			object operand = val.Operand;
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Dictionary<string, Item>.ValueCollection.Enumerator), "get_Current", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_1, (object)null, (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopManagerPatch), "GetAllItemsFromStatsManager", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Brtrue, operand)
			});
			return val.InstructionEnumeration();
		}

		private static bool GetAllItemsFromStatsManager(Item item)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return false;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.fullName == item.itemAssetName);
			return upgradeItem != null && !upgradeItem.GetConfig<bool>("Enabled");
		}
	}
}
namespace MoreUpgrades.CustomColorsPatches
{
	[HarmonyPatch(typeof(ModdedColorPlayerAvatar))]
	internal class ModdedColorPlayerAvatarPatch
	{
		[HarmonyPatch("ModdedSetColorRPC")]
		[HarmonyPostfix]
		private static void ModdedSetColorRPC(ModdedColorPlayerAvatar __instance)
		{
			PlayerAvatar avatar = __instance.avatar;
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null) && !((Object)(object)avatar == (Object)(object)SemiFunc.PlayerAvatarLocal()))
			{
				UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == "Map Player Tracker");
				if (upgradeItem != null && upgradeItem.GetConfig<bool>("Player Color"))
				{
					Plugin.instance.RemovePlayerToMap(avatar);
					Plugin.instance.AddPlayerToMap(avatar);
				}
			}
		}
	}
}
namespace MoreUpgrades.Classes
{
	public static class MoreUpgradesLib
	{
		public static IReadOnlyList<UpgradeItem> GetCoreUpgradeItems()
		{
			return Plugin.instance.upgradeItems.Where((UpgradeItem x) => x.modGUID == null).ToList();
		}

		public static IReadOnlyList<UpgradeItem> GetUpgradeItemsByMod(string modGUID)
		{
			return Plugin.instance.upgradeItems.Where((UpgradeItem x) => x.modGUID == modGUID).ToList();
		}

		public static UpgradeItem Register(string modGUID, Item item, GameObject prefab, string name, int maxAmount, int maxAmountInShop, float minPrice, float maxPrice, int maxPurchaseAmount = 0)
		{
			if ((Object)(object)Plugin.instance.assetBundle == (Object)null)
			{
				Plugin.instance.logger.LogWarning((object)"Couldn't register the upgrade item because the core mod failed to start. Contact the mod creator.");
				return null;
			}
			if (Plugin.instance.upgradeItems.Any((UpgradeItem x) => x.name.ToLower().Trim() == name.ToLower().Trim()))
			{
				Plugin.instance.logger.LogWarning((object)("An upgrade item with the name '" + name.Trim() + "' already exists. Duplicate upgrade items are not allowed."));
				return null;
			}
			UpgradeItem upgradeItem = new UpgradeItem(name, maxAmount, maxAmountInShop, minPrice, maxPrice, maxPurchaseAmount, modGUID, item, prefab);
			Plugin.instance.upgradeItems.Add(upgradeItem);
			return upgradeItem;
		}
	}
	internal class MoreUpgradesManager : MonoBehaviour
	{
		internal static MoreUpgradesManager instance;

		internal PhotonView photonView;

		private bool checkAppliedPlayerUpgrades;

		private void Awake()
		{
			instance = this;
			photonView = ((Component)this).GetComponent<PhotonView>();
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				upgradeItem.variables.Clear();
				upgradeItem.onInit?.Invoke();
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				((MonoBehaviour)this).StartCoroutine("WaitUntilLevel");
			}
		}

		private void LateUpdate()
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				upgradeItem.onLateUpdate?.Invoke();
			}
		}

		private void FixedUpdate()
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				if (checkAppliedPlayerUpgrades)
				{
					int config = upgradeItem.GetConfig<int>("Starting Amount");
					if (config >= 0)
					{
						foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
						{
							string text = SemiFunc.PlayerGetSteamID(item);
							if (!upgradeItem.appliedPlayerUpgrades.ContainsKey(text))
							{
								upgradeItem.appliedPlayerUpgrades[text] = 0;
							}
							if (upgradeItem.appliedPlayerUpgrades[text] != config)
							{
								Upgrade(upgradeItem.name, text, config - upgradeItem.appliedPlayerUpgrades[text]);
								upgradeItem.appliedPlayerUpgrades[text] = config;
							}
						}
					}
				}
				upgradeItem.onFixedUpdate?.Invoke();
			}
		}

		private void Update()
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				upgradeItem.onUpdate?.Invoke();
			}
		}

		private IEnumerator WaitUntilLevel()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => SemiFunc.LevelGenDone()));
			checkAppliedPlayerUpgrades = true;
		}

		internal void Upgrade(string upgradeItemName, string steamId, int amount = 1)
		{
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == upgradeItemName);
			if (upgradeItem != null)
			{
				upgradeItem.playerUpgrades[steamId] += amount;
				if ((Object)(object)SemiFunc.PlayerAvatarGetFromSteamID(steamId) == (Object)(object)SemiFunc.PlayerAvatarLocal())
				{
					upgradeItem.onChanged?.Invoke();
				}
				if (SemiFunc.IsMasterClient())
				{
					photonView.RPC("UpgradeRPC", (RpcTarget)1, new object[3]
					{
						upgradeItemName,
						steamId,
						upgradeItem.playerUpgrades[steamId]
					});
				}
			}
		}

		[PunRPC]
		internal void UpgradeRPC(string upgradeItemName, string steamId, int amount)
		{
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.name == upgradeItemName);
			if (upgradeItem != null)
			{
				upgradeItem.playerUpgrades[steamId] = amount;
				if ((Object)(object)SemiFunc.PlayerAvatarGetFromSteamID(steamId) == (Object)(object)SemiFunc.PlayerAvatarLocal())
				{
					upgradeItem.onChanged?.Invoke();
				}
			}
		}
	}
	public class UpgradeItem
	{
		private static int staticId;

		private readonly int id;

		private Dictionary<string, ConfigEntryBase> configEntries;

		internal Dictionary<string, int> playerUpgrades;

		internal Dictionary<string, int> appliedPlayerUpgrades;

		internal Dictionary<string, object> variables;

		public Action onInit;

		public Action onLateUpdate;

		public Action onFixedUpdate;

		public Action onUpdate;

		public Action onChanged;

		public string name { get; private set; }

		public string fullName { get; private set; }

		public string modGUID { get; private set; }

		public void AddConfig<T>(string key, T defaultValue, string description = "")
		{
			if (configEntries.ContainsKey(key))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' already exists. Duplicates are not allowed."));
			}
			else
			{
				configEntries.Add(key, (ConfigEntryBase)(object)((BaseUnityPlugin)Plugin.instance).Config.Bind<T>(string.Format("{0}: {1}{2}", id + 1, name, (modGUID != null) ? (" (" + modGUID + ")") : ""), key, defaultValue, description));
			}
		}

		public T GetConfig<T>(string key)
		{
			if (!configEntries.TryGetValue(key, out var value))
			{
				Plugin.instance.logger.LogWarning((object)("Missing config entry '" + key + "'."));
				return default(T);
			}
			if (typeof(T) != value.SettingType)
			{
				Plugin.instance.logger.LogWarning((object)("Type mismatch for config entry '" + key + "'. Expected: " + value.SettingType.FullName + ", but got: " + typeof(T).FullName + "."));
				return default(T);
			}
			return (T)value.BoxedValue;
		}

		public bool HasVariable(string key)
		{
			object value;
			return variables.TryGetValue(key, out value);
		}

		public void AddVariable<T>(string key, T value)
		{
			if (HasVariable(key))
			{
				Plugin.instance.logger.LogWarning((object)("A variable with the key '" + key + "' already exists. Duplicates are not allowed."));
			}
			else
			{
				variables.Add(key, value);
			}
		}

		public void SetVariable<T>(string key, T value)
		{
			if (!HasVariable(key))
			{
				Plugin.instance.logger.LogWarning((object)("Variable '" + key + "' does not exist."));
				return;
			}
			if (value != null)
			{
				T val = value;
				if (true)
				{
					variables[key] = val;
					return;
				}
			}
			Plugin.instance.logger.LogError((object)("Type mismatch for variable '" + key + "'. Expected: " + value.GetType().FullName + ", but got: " + typeof(T).FullName + "."));
		}

		public T GetVariable<T>(string key)
		{
			if (!variables.TryGetValue(key, out var value))
			{
				Plugin.instance.logger.LogWarning((object)("Variable '" + key + "' not found. Returning default value."));
				return default(T);
			}
			if (value is T result)
			{
				return result;
			}
			Plugin.instance.logger.LogWarning((object)("Type mismatch for variable '" + key + "'. Expected: " + value.GetType().FullName + ", but got: " + typeof(T).FullName + ". Returning default value."));
			return default(T);
		}

		public int GetAmount(string steamId = null)
		{
			if (steamId != null)
			{
				return playerUpgrades.ContainsKey(steamId) ? playerUpgrades[steamId] : 0;
			}
			PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
			if ((Object)(object)val != (Object)null)
			{
				steamId = SemiFunc.PlayerGetSteamID(val);
			}
			return (steamId != null && playerUpgrades.ContainsKey(steamId)) ? playerUpgrades[steamId] : 0;
		}

		internal UpgradeItem(string name, int maxAmount, int maxAmountInShop, float minPrice, float maxPrice, int maxPurchaseAmount = 0, string modGUID = null, Item modItem = null, GameObject modPrefab = null)
		{
			id = staticId++;
			this.name = name;
			fullName = "Item Upgrade Player " + name;
			this.modGUID = modGUID;
			configEntries = new Dictionary<string, ConfigEntryBase>();
			AddConfig("Enabled", defaultValue: true, "Whether the upgrade item can be added to the shop.");
			AddConfig("Max Amount", maxAmount, "The maximum number of times the upgrade item can be bought at once.");
			AddConfig("Max Amount In Shop", maxAmountInShop, "The maximum number of times the upgrade item can appear in the shop.");
			AddConfig("Minimum Price", minPrice, "The minimum cost to purchase the upgrade item.");
			AddConfig("Maximum Price", maxPrice, "The maximum cost to purchase the upgrade item.");
			AddConfig("Max Purchase Amount", maxPurchaseAmount, "The total number of times the upgrade item can be purchased.");
			AddConfig("Allow Team Upgrades", defaultValue: false, "Whether the upgrade item applies to the entire team instead of just one player.");
			AddConfig("Starting Amount", 0, "The number of times the upgrade item is applied at the start of the game.");
			playerUpgrades = new Dictionary<string, int>();
			appliedPlayerUpgrades = new Dictionary<string, int>();
			variables = new Dictionary<string, object>();
			Item val = modItem ?? Plugin.instance.assetBundle.LoadAsset<Item>(name);
			((Object)val).name = fullName;
			val.itemAssetName = fullName;
			val.itemName = name + " Upgrade";
			val.maxAmount = maxAmount;
			val.maxAmountInShop = maxAmountInShop;
			val.maxPurchase = maxPurchaseAmount > 0;
			val.maxPurchaseAmount = maxPurchaseAmount;
			val.value = ScriptableObject.CreateInstance<Value>();
			val.value.valueMin = minPrice;
			val.value.valueMax = maxPrice;
			GameObject val2 = modPrefab ?? Plugin.instance.assetBundle.LoadAsset<GameObject>(name + " Prefab");
			((Object)val2).name = fullName;
			val2.GetComponent<ItemAttributes>().item = val;
			val.prefab = val2;
			Items.RegisterItem(val);
		}
	}
}