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("MoreUpgrades")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("MoreUpgrades")]
[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.4.5")]
	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("CustomColorsPatches");
			}
		}

		private const string modGUID = "bulletbot.moreupgrades";

		private const string modName = "MoreUpgrades";

		private const string modVer = "1.4.5";

		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 name)
		{
			foreach (Type item in from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.Namespace == "MoreUpgrades." + name
				select t)
			{
				harmony.PatchAll(item);
			}
		}

		private 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(PlayerAvatarVisuals), "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);
		}

		internal static float ItemValueMultiplier(float itemValueMultiplier, string itemAssetName)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return itemValueMultiplier;
			}
			return (instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.fullName == itemAssetName) != null) ? 1f : itemValueMultiplier;
		}

		internal static float UpgradeValueIncrease(float upgradeValueIncrease, string itemAssetName)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return upgradeValueIncrease;
			}
			UpgradeItem upgradeItem = instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.fullName == itemAssetName);
			if (upgradeItem == null)
			{
				return upgradeValueIncrease;
			}
			float num = (upgradeItem.HasConfig("Price Increase Scaling") ? upgradeItem.GetConfig<float>("Price Increase Scaling") : upgradeItem.upgradeItemBase.priceIncreaseScaling);
			if (num < 0f)
			{
				num = upgradeValueIncrease;
			}
			return num;
		}

		private void Awake()
		{
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: 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(new UpgradeItemBase
			{
				name = "Sprint Usage",
				maxAmount = 10,
				maxAmountInShop = 2,
				minPrice = 9000f,
				maxPrice = 14000f
			});
			sprintUsage.AddConfig("Scaling Factor", 0.1f, "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(new UpgradeItemBase
			{
				name = "Valuable Count",
				minPrice = 30000f,
				maxPrice = 40000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			});
			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 val5 = (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)val5).text) && (variable4 || variable5 != count || variable6 != num3))
					{
						string text2 = ((TMP_Text)val5).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)val5).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(new UpgradeItemBase
			{
				name = "Map Enemy Tracker",
				minPrice = 50000f,
				maxPrice = 60000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			});
			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
			{
				if (!SemiFunc.RunIsLobby() && !SemiFunc.RunIsShop())
				{
					UpdateTracker(mapEnemyTracker);
				}
			});
			upgradeItems.Add(mapEnemyTracker);
			UpgradeItem mapPlayerTracker = new UpgradeItem(new UpgradeItemBase
			{
				name = "Map Player Tracker",
				minPrice = 30000f,
				maxPrice = 40000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			});
			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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: 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("More Upgrades Manager");
					PhotonView val4 = val3.AddComponent<PhotonView>();
					val4.ViewID = 1863;
					val3.AddComponent<MoreUpgradesManager>();
				}
			};
			logger.LogMessage((object)"MoreUpgrades has started.");
			PatchAll("Patches");
			if (CustomColors.IsLoaded())
			{
				CustomColors.OnAwake();
			}
			void UpdateTracker(UpgradeItem upgradeItem)
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				if ((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(ItemAttributes))]
	internal class ItemAttributesPatch
	{
		[HarmonyPatch("GetValue")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GetValueTranspiler(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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ShopManager), "instance"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShopManager), "itemValueMultiplier"), (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ItemAttributes), "itemAssetName")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "ItemValueMultiplier", (Type[])null, (Type[])null))
			});
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ShopManager), "instance"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShopManager), "upgradeValueIncrease"), (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ItemAttributes), "itemAssetName")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "UpgradeValueIncrease", (Type[])null, (Type[])null))
			});
			return val.InstructionEnumeration();
		}
	}
	[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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_006b: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null || (Object)(object)___enemy == (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")]
		[HarmonyPrefix]
		private static void Start(StatsManager __instance)
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				__instance.dictionaryOfDictionaries.Add("playerUpgradeModded" + upgradeItem.saveName, upgradeItem.playerUpgrades);
				__instance.dictionaryOfDictionaries.Add("appliedPlayerUpgradeModded" + upgradeItem.saveName, upgradeItem.appliedPlayerUpgrades);
			}
		}

		[HarmonyPatch("FetchPlayerUpgrades")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> FetchPlayerUpgradesTranspiler(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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(KeyValuePair<string, Dictionary<string, int>>), "get_Key", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"playerUpgrade", (string)null)
			});
			object operand = val.Operand;
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(string), "Trim", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_S, (object)null, (string)null)
			});
			object operand2 = val.Operand;
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldloca_S, operand),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(KeyValuePair<string, Dictionary<string, int>>), "get_Key", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Ldloc_S, operand2),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(StatsManagerPatch), "FetchPlayerUpgrades", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stloc_S, operand2)
			});
			return val.InstructionEnumeration();
		}

		private static string FetchPlayerUpgrades(string key, string text)
		{
			string prefix = "playerUpgradeModded";
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null || !key.StartsWith(prefix))
			{
				return text;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.saveName == key.Substring(prefix.Length));
			if (upgradeItem == null)
			{
				return text;
			}
			return upgradeItem.HasConfig("Display Name") ? upgradeItem.GetConfig<string>("Display Name") : upgradeItem.name;
		}
	}
	[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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)__instance).gameObject;
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.fullName == gameObject.GetComponent<ItemAttributes>().item.itemAssetName);
			if (upgradeItem == null)
			{
				return;
			}
			__instance.upgradeEvent = new UnityEvent();
			__instance.upgradeEvent.AddListener((UnityAction)delegate
			{
				if (upgradeItem.HasConfig("Allow Team Upgrades") && 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> GetAllItemsFromStatsManagerTranspiler(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
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: 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)
			});
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShopManager), "itemValueMultiplier"), (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Item), "itemAssetName")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "ItemValueMultiplier", (Type[])null, (Type[])null))
			});
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ShopManager), "upgradeValueIncrease"), (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Item), "itemAssetName")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "UpgradeValueIncrease", (Type[])null, (Type[])null))
			});
			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.HasConfig("Enabled") && !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 bool IsManagerActive()
		{
			return (Object)(object)MoreUpgradesManager.instance != (Object)null;
		}

		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, UpgradeItemBase upgradeItemBase)
		{
			if (string.IsNullOrEmpty(modGUID))
			{
				Plugin.instance.logger.LogWarning((object)"Couldn't register the upgrade item because the modGUID is not valid.");
				return null;
			}
			if ((Object)(object)Plugin.instance.assetBundle == (Object)null)
			{
				Plugin.instance.logger.LogWarning((object)(modGUID + ": Couldn't register the upgrade item because the core mod failed to start. Contact the mod creator."));
				return null;
			}
			if ((Object)(object)item == (Object)null || (Object)(object)prefab == (Object)null)
			{
				Plugin.instance.logger.LogWarning((object)(modGUID + ": Couldn't register the upgrade item because the item or prefab are not valid."));
				return null;
			}
			string name = upgradeItemBase.name;
			if (string.IsNullOrEmpty(name))
			{
				Plugin.instance.logger.LogWarning((object)(modGUID + ": Couldn't register the upgrade item because the base name is not valid."));
				return null;
			}
			if (Plugin.instance.upgradeItems.Any((UpgradeItem x) => x.name.ToLower().Trim() == name.ToLower().Trim()))
			{
				Plugin.instance.logger.LogWarning((object)(modGUID + ": An upgrade item with the name '" + name.Trim() + "' already exists. Duplicate upgrade items are not allowed."));
				return null;
			}
			UpgradeItem upgradeItem = new UpgradeItem(upgradeItemBase, modGUID, item, prefab);
			Plugin.instance.upgradeItems.Add(upgradeItem);
			return upgradeItem;
		}
	}
	internal class MoreUpgradesManager : MonoBehaviour
	{
		internal static MoreUpgradesManager instance;

		internal PhotonView photonView;

		private bool checkPlayerUpgrades;

		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 (checkPlayerUpgrades)
				{
					if (upgradeItem.HasConfig("Starting Amount"))
					{
						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;
								}
							}
						}
					}
					if (upgradeItem.HasConfig("Sync Host Upgrades") && upgradeItem.GetConfig<bool>("Sync Host Upgrades"))
					{
						int amount = upgradeItem.GetAmount();
						foreach (PlayerAvatar item2 in from x in SemiFunc.PlayerGetAll()
							where (Object)(object)x != (Object)(object)SemiFunc.PlayerAvatarLocal()
							select x)
						{
							string steamId = SemiFunc.PlayerGetSteamID(item2);
							int amount2 = upgradeItem.GetAmount(steamId);
							int num = amount - amount2;
							if (num != 0)
							{
								Upgrade(upgradeItem.name, steamId, num);
							}
						}
					}
				}
				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()));
			checkPlayerUpgrades = true;
			if (!SemiFunc.IsMasterClient())
			{
				yield break;
			}
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				foreach (PlayerAvatar playerAvatar in SemiFunc.PlayerGetAll())
				{
					string steamId = SemiFunc.PlayerGetSteamID(playerAvatar);
					photonView.RPC("UpgradeRPC", (RpcTarget)4, new object[3]
					{
						upgradeItem.name,
						steamId,
						upgradeItem.GetAmount(steamId)
					});
				}
			}
		}

		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 (GameManager.Multiplayer())
				{
					photonView.RPC("UpgradeRPC", (RpcTarget)(SemiFunc.IsMasterClient() ? 1 : 2), 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)
			{
				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, amount });
				}
			}
		}
	}
	public class UpgradeItem
	{
		internal string saveName;

		internal string sectionName;

		internal UpgradeItemBase upgradeItemBase;

		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 bool HasConfig(string key)
		{
			ConfigEntryBase value;
			return configEntries.TryGetValue(key, out value);
		}

		public bool AddConfig<T>(string key, T defaultValue, string description = "")
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			if (configEntries.ContainsKey(key))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' already exists. Duplicates are not allowed."));
				return false;
			}
			ConfigEntryBase val = null;
			val = (ConfigEntryBase)(object)((defaultValue is int) ? ((BaseUnityPlugin)Plugin.instance).Config.Bind<T>(sectionName, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000), Array.Empty<object>())) : ((!(defaultValue is float)) ? ((BaseUnityPlugin)Plugin.instance).Config.Bind<T>(sectionName, key, defaultValue, description) : ((BaseUnityPlugin)Plugin.instance).Config.Bind<T>(sectionName, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(-1f, 100000f), Array.Empty<object>()))));
			configEntries.Add(key, val);
			return true;
		}

		public bool AddConfig<T>(string key, T defaultValue, ConfigDescription description = null)
		{
			if (configEntries.ContainsKey(key))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' already exists. Duplicates are not allowed."));
				return false;
			}
			configEntries.Add(key, (ConfigEntryBase)(object)((BaseUnityPlugin)Plugin.instance).Config.Bind<T>(sectionName, key, defaultValue, description));
			return true;
		}

		public bool AddConfig(string key, ConfigEntryBase value)
		{
			if (configEntries.ContainsKey(key))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' already exists. Duplicates are not allowed."));
				return false;
			}
			configEntries.Add(key, value);
			return true;
		}

		public bool SetConfig<T>(string key, T value)
		{
			if (!configEntries.TryGetValue(key, out var value2))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' does not exist. Returning default value."));
				return false;
			}
			if (value2 is ConfigEntry<T> val)
			{
				val.Value = value;
				return true;
			}
			Plugin.instance.logger.LogWarning((object)("Type mismatch for config entry '" + key + "'. Expected: " + value2.SettingType.FullName + ", but got: " + typeof(T).FullName + ". Returning default value."));
			return false;
		}

		public T GetConfig<T>(string key)
		{
			if (!configEntries.TryGetValue(key, out var value))
			{
				Plugin.instance.logger.LogWarning((object)("A config entry with the key '" + key + "' does not exist. Returning default value."));
				return default(T);
			}
			if (value is ConfigEntry<T> val)
			{
				return val.Value;
			}
			Plugin.instance.logger.LogWarning((object)("Type mismatch for config entry '" + key + "'. Expected: " + value.SettingType.FullName + ", but got: " + typeof(T).FullName + ". Returning default value."));
			return default(T);
		}

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

		public bool 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."));
				return false;
			}
			variables.Add(key, value);
			return true;
		}

		public bool SetVariable<T>(string key, T value)
		{
			if (!variables.TryGetValue(key, out var value2))
			{
				Plugin.instance.logger.LogWarning((object)("A variable with the key '" + key + "' does not exist."));
				return false;
			}
			if (value2 is T)
			{
				variables[key] = value;
				return true;
			}
			Plugin.instance.logger.LogWarning((object)("Type mismatch for variable '" + key + "'. Expected: " + value2.GetType().FullName + ", but got: " + typeof(T).FullName + "."));
			return false;
		}

		public T GetVariable<T>(string key)
		{
			if (!variables.TryGetValue(key, out var value))
			{
				Plugin.instance.logger.LogWarning((object)("A variable with the key '" + key + "' does not exist. 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(UpgradeItemBase upgradeItemBase, string modGUID = null, Item modItem = null, GameObject modPrefab = null)
		{
			UpgradeItem upgradeItem = this;
			name = upgradeItemBase.name;
			fullName = "Modded Item Upgrade Player " + name;
			this.modGUID = modGUID;
			saveName = new string(name.Where((char x) => !char.IsWhiteSpace(x)).ToArray());
			sectionName = name + ((!Utility.IsNullOrWhiteSpace(modGUID)) ? (" (" + modGUID + ")") : "");
			this.upgradeItemBase = upgradeItemBase;
			configEntries = new Dictionary<string, ConfigEntryBase>();
			playerUpgrades = new Dictionary<string, int>();
			appliedPlayerUpgrades = new Dictionary<string, int>();
			variables = new Dictionary<string, object>();
			TryAddConfig<bool>("Enabled", defaultValue: true, "Whether the upgrade item can be spawned to the shop.");
			TryAddConfig<int>("Max Amount", upgradeItemBase.maxAmount, "The maximum number of times the upgrade item can appear in the truck.");
			TryAddConfig<int>("Max Amount In Shop", upgradeItemBase.maxAmountInShop, "The maximum number of times the upgrade item can appear in the shop.");
			TryAddConfig<float>("Minimum Price", upgradeItemBase.minPrice, "The minimum cost to purchase the upgrade item.");
			TryAddConfig<float>("Maximum Price", upgradeItemBase.maxPrice, "The maximum cost to purchase the upgrade item.");
			TryAddConfig<float>("Price Increase Scaling", upgradeItemBase.priceIncreaseScaling, "The scale of the price increase based on the total number of upgrade item purchased.\nDefault scaling is set to 0.5. (Note: This value may be modified by other mods that adjust the game's default scaling.)\nSet to -1 to use the default scaling.");
			TryAddConfig<int>("Max Purchase Amount", upgradeItemBase.maxPurchaseAmount, "The maximum number of times the upgrade item can be purchased before it is no longer available in the shop.\nSet to 0 to disable the limit.");
			TryAddConfig<bool>("Allow Team Upgrades", defaultValue: false, "Whether the upgrade item applies to the entire team instead of just one player.");
			TryAddConfig<bool>("Sync Host Upgrades", defaultValue: false, "Whether the host should sync the item upgrade for the entire team.");
			TryAddConfig<int>("Starting Amount", 0, "The number of times the upgrade item is applied at the start of the game.");
			TryAddConfig<string>("Display Name", name, "The display name of the upgrade item.");
			Item val = modItem ?? Plugin.instance.assetBundle.LoadAsset<Item>(name);
			((Object)val).name = fullName;
			val.itemAssetName = fullName;
			val.itemName = (HasConfig("Display Name") ? GetConfig<string>("Display Name") : name) + " Upgrade";
			val.maxAmount = (HasConfig("Max Amount") ? GetConfig<int>("Max Amount") : upgradeItemBase.maxAmount);
			val.maxAmountInShop = (HasConfig("Max Amount In Shop") ? GetConfig<int>("Max Amount In Shop") : upgradeItemBase.maxAmountInShop);
			val.maxPurchaseAmount = (HasConfig("Max Purchase Amount") ? GetConfig<int>("Max Purchase Amount") : upgradeItemBase.maxPurchaseAmount);
			val.maxPurchase = val.maxPurchaseAmount > 0;
			val.value = ScriptableObject.CreateInstance<Value>();
			val.value.valueMin = (HasConfig("Minimum Price") ? GetConfig<float>("Minimum Price") : upgradeItemBase.minPrice);
			val.value.valueMax = (HasConfig("Maximum Price") ? GetConfig<float>("Maximum Price") : upgradeItemBase.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);
			void TryAddConfig<T>(string key, T defaultValue, string description = "")
			{
				if (!upgradeItemBase.excludeConfigs.Contains(key))
				{
					AddConfig(key, defaultValue, description);
				}
			}
		}
	}
	public class UpgradeItemBase
	{
		public string name = null;

		public int maxAmount = 1;

		public int maxAmountInShop = 1;

		public float minPrice = 1000f;

		public float maxPrice = 1000f;

		public int maxPurchaseAmount = 0;

		public float priceIncreaseScaling = -1f;

		public List<string> excludeConfigs = new List<string>();
	}
}