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.Compatibility;
using MoreUpgrades.Properties;
using REPOLib.Modules;
using TMPro;
using UnityEngine;
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.5.4")]
	internal class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "bulletbot.moreupgrades";

		private const string modName = "MoreUpgrades";

		private const string modVer = "1.5.4";

		internal static Plugin instance;

		internal ManualLogSource logger;

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

		internal ConfigEntry<bool> importUpgrades;

		internal ConfigEntry<string> excludeUpgradeIds;

		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.upgradeBase.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)>>("Add To Map");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("Remove From Map");
			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.upgradeBase.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)>>("Add To Map");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("Remove From Map");
			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.upgradeBase.name == "Map Player Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent((Component)(object)playerAvatar);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("Add To Map");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("Remove From Map");
			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.upgradeBase.name == "Map Player Tracker");
			if (upgradeItem == null)
			{
				return;
			}
			GameObject visuals = GetVisualsFromComponent((Component)(object)playerAvatar);
			List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("Add To Map");
			List<GameObject> variable2 = upgradeItem.GetVariable<List<GameObject>>("Remove From Map");
			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, Item item)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return itemValueMultiplier;
			}
			UpgradeItem upgradeItem = instance.upgradeItems.FirstOrDefault((UpgradeItem x) => (Object)(object)x.playerUpgrade.Item == (Object)(object)item);
			if (upgradeItem == null)
			{
				return itemValueMultiplier;
			}
			float num = (upgradeItem.HasConfig("Price Multiplier") ? upgradeItem.GetConfig<float>("Price Multiplier") : itemValueMultiplier);
			if (num < 0f)
			{
				num = itemValueMultiplier;
			}
			return num;
		}

		private void Awake()
		{
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: 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;
			}
			importUpgrades = ((BaseUnityPlugin)this).Config.Bind<bool>("! REPOLib Configuration !", "Import Upgrades", false, "Whether to import the upgrades from REPOLib.");
			excludeUpgradeIds = ((BaseUnityPlugin)this).Config.Bind<string>("! REPOLib Configuration !", "Exclude Upgrade IDs", "", "Exclude specific REPOLib upgrades by listing their IDs, seperated by commas.\nThis setting only has an effect if 'Import Upgrades' is enabled.");
			upgradeItems = new List<UpgradeItem>();
			UpgradeItem.Base @base = new UpgradeItem.Base
			{
				name = "Sprint Usage",
				maxAmount = 10,
				maxAmountInShop = 2,
				minPrice = 9000f,
				maxPrice = 14000f
			};
			UpgradeItem sprintUsage = null;
			@base.onStart = (Action<PlayerAvatar, int>)Delegate.Combine(@base.onStart, new Action<PlayerAvatar, int>(UpdateSprintUsage));
			@base.onUpgrade = (Action<PlayerAvatar, int>)Delegate.Combine(@base.onUpgrade, new Action<PlayerAvatar, int>(UpdateSprintUsage));
			sprintUsage = new UpgradeItem(@base);
			sprintUsage.AddConfig("Scaling Factor", 0.9f, "Formula: energySprintDrain * (scalingFactor ^ upgradeLevel))");
			upgradeItems.Add(sprintUsage);
			UpgradeItem.Base base2 = new UpgradeItem.Base
			{
				name = "Valuable Count",
				minPrice = 30000f,
				maxPrice = 40000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			};
			UpgradeItem valuableCount = null;
			base2.onVariablesStart = (Action)Delegate.Combine(base2.onVariablesStart, (Action)delegate
			{
				valuableCount.AddVariable("Current Valuables", new List<ValuableObject>());
				valuableCount.AddVariable("Changed", value: false);
				valuableCount.AddVariable("Previous Count", 0);
				valuableCount.AddVariable("Previous Value", 0);
				valuableCount.AddVariable("Text Length", 0);
			});
			base2.onUpdate = (Action)Delegate.Combine(base2.onUpdate, (Action)delegate
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				if (!SemiFunc.RunIsLobby() && !SemiFunc.RunIsShop())
				{
					PlayerAvatar val5 = SemiFunc.PlayerAvatarLocal();
					if ((Object)(object)val5 != (Object)null && (Object)(object)MissionUI.instance != (Object)null && valuableCount.playerUpgrade.GetLevel(val5) != 0)
					{
						TextMeshProUGUI val6 = (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>>("Current Valuables");
						bool variable4 = valuableCount.GetVariable<bool>("Changed");
						int variable5 = valuableCount.GetVariable<int>("Previous Count");
						int variable6 = valuableCount.GetVariable<int>("Previous Value");
						int variable7 = valuableCount.GetVariable<int>("Text Length");
						int count = variable3.Count;
						bool config = valuableCount.GetConfig<bool>("Display Total Value");
						int num3 = (config ? variable3.Select((ValuableObject x) => (int)(float)AccessTools.Field(typeof(ValuableObject), "dollarValueCurrent").GetValue(x)).Sum() : 0);
						if (!Utility.IsNullOrWhiteSpace(((TMP_Text)val6).text) && (variable4 || variable5 != count || variable6 != num3))
						{
							string text2 = ((TMP_Text)val6).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("Previous Count", count);
							valuableCount.SetVariable("Previous Value", num3);
							valuableCount.SetVariable("Text Length", text3.Length);
							((TMP_Text)val6).text = text2;
							AccessTools.Field(typeof(MissionUI), "messagePrev").SetValue(MissionUI.instance, text2);
							if (variable4)
							{
								valuableCount.SetVariable("Changed", value: false);
							}
						}
					}
				}
			});
			valuableCount = new UpgradeItem(base2);
			valuableCount.AddConfig("Display Total Value", defaultValue: true, "Whether to display the total value next to the valuable counter.");
			valuableCount.AddConfig("Ignore Money Bags", defaultValue: false, "Whether to ignore the money bags from the extraction points.");
			upgradeItems.Add(valuableCount);
			UpgradeItem.Base base3 = new UpgradeItem.Base
			{
				name = "Map Enemy Tracker",
				minPrice = 50000f,
				maxPrice = 60000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			};
			UpgradeItem mapEnemyTracker = null;
			base3.onVariablesStart = (Action)Delegate.Combine(base3.onVariablesStart, (Action)delegate
			{
				mapEnemyTracker.AddVariable("Add To Map", new List<(GameObject, Color)>());
				mapEnemyTracker.AddVariable("Remove From Map", new List<GameObject>());
			});
			base3.onUpdate = (Action)Delegate.Combine(base3.onUpdate, (Action)delegate
			{
				if (!SemiFunc.RunIsLobby() && !SemiFunc.RunIsShop())
				{
					UpdateTracker(mapEnemyTracker);
				}
			});
			mapEnemyTracker = new UpgradeItem(base3);
			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.");
			upgradeItems.Add(mapEnemyTracker);
			UpgradeItem.Base base4 = new UpgradeItem.Base
			{
				name = "Map Player Tracker",
				minPrice = 30000f,
				maxPrice = 40000f,
				maxPurchaseAmount = 1,
				priceIncreaseScaling = 0f
			};
			UpgradeItem mapPlayerTracker = null;
			base4.onVariablesStart = delegate
			{
				mapPlayerTracker.AddVariable("Add To Map", new List<(GameObject, Color)>());
				mapPlayerTracker.AddVariable("Remove From Map", new List<GameObject>());
			};
			base4.onUpdate = (Action)Delegate.Combine(base4.onUpdate, (Action)delegate
			{
				UpdateTracker(mapPlayerTracker);
			});
			mapPlayerTracker = new UpgradeItem(base4);
			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.");
			upgradeItems.Add(mapPlayerTracker);
			UpgradeItem.Base base5 = new UpgradeItem.Base
			{
				name = "Item Resist",
				maxAmount = 10,
				maxAmountInShop = 2,
				minPrice = 4000f,
				maxPrice = 6000f
			};
			UpgradeItem itemResist = null;
			base5.onVariablesStart = delegate
			{
				itemResist.AddVariable("Last Player Grabbed", new Dictionary<PhysGrabObject, PlayerAvatar>());
			};
			itemResist = new UpgradeItem(base5);
			itemResist.AddConfig("Scaling Factor", 0.9f, "Formula: valueLost * (scalingFactor ^ upgradeLevel)");
			upgradeItems.Add(itemResist);
			SceneManager.activeSceneChanged += delegate
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: 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) && !((Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelSplashScreen))
				{
					GameObject val4 = new GameObject("More Upgrades Manager");
					val4.AddComponent<MoreUpgradesManager>();
				}
			};
			logger.LogMessage((object)"MoreUpgrades has started.");
			PatchAll("Patches");
			PatchAll("REPOLibPatches");
			if (CustomColors.IsLoaded())
			{
				PatchAll("CustomColorsPatches");
			}
			void UpdateSprintUsage(PlayerAvatar playerAvatar, int level)
			{
				if (!((Object)(object)PlayerController.instance.playerAvatarScript != (Object)(object)playerAvatar))
				{
					string key = "Energy Sprint Drain";
					if (!sprintUsage.HasVariable(key))
					{
						sprintUsage.AddVariable(key, PlayerController.instance.EnergySprintDrain);
					}
					PlayerController.instance.EnergySprintDrain = sprintUsage.GetVariable<float>(key) * Mathf.Pow(sprintUsage.GetConfig<float>("Scaling Factor"), (float)level);
				}
			}
			void UpdateTracker(UpgradeItem upgradeItem)
			{
				//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_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
				if ((Object)(object)val != (Object)null && upgradeItem.playerUpgrade.GetLevel(val) != 0)
				{
					List<(GameObject, Color)> variable = upgradeItem.GetVariable<List<(GameObject, Color)>>("Add To Map");
					for (int num = variable.Count - 1; num >= 0; num--)
					{
						var (val2, color) = variable[num];
						variable.RemoveAt(num);
						MapCustom component = val2.GetComponent<MapCustom>();
						if (!((Object)(object)component != (Object)null))
						{
							component = val2.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>>("Remove From Map");
					for (int num2 = variable2.Count - 1; num2 >= 0; num2--)
					{
						GameObject val3 = variable2[num2];
						variable2.RemoveAt(num2);
						MapCustom component2 = val3.GetComponent<MapCustom>();
						if (!((Object)(object)component2 == (Object)null))
						{
							Object.Destroy((Object)(object)((Component)component2.mapCustomEntity).gameObject);
							Object.Destroy((Object)(object)component2);
						}
					}
				}
			}
		}
	}
}
namespace MoreUpgrades.REPOLibPatches
{
	[HarmonyPatch(typeof(REPOLibItemUpgrade))]
	internal class REPOLibItemUpgradePatch
	{
		[HarmonyPatch("Upgrade")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpgradeTranspiler(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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(PlayerUpgrade), "AddLevel", new Type[2]
				{
					typeof(PlayerAvatar),
					typeof(int)
				}, (Type[])null), (string)null)
			});
			val.RemoveInstructions(2);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(REPOLibItemUpgradePatch), "Upgrade", (Type[])null, (Type[])null))
			});
			return val.InstructionEnumeration();
		}

		private static void Upgrade(PlayerUpgrade playerUpgrade, PlayerAvatar playerAvatar, int amount)
		{
			if ((Object)(object)MoreUpgradesManager.instance != (Object)null)
			{
				UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => (Object)(object)x.playerUpgrade.Item == (Object)(object)playerUpgrade.Item);
				if (upgradeItem != null && upgradeItem.HasConfig("Allow Team Upgrades") && upgradeItem.GetConfig<bool>("Allow Team Upgrades"))
				{
					foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
					{
						playerUpgrade.AddLevel(item, amount);
					}
					return;
				}
			}
			playerUpgrade.AddLevel(playerAvatar, amount);
		}
	}
	[HarmonyPatch(typeof(Upgrades))]
	internal class UpgradesPatch
	{
		[HarmonyPatch("RegisterUpgrades")]
		[HarmonyPostfix]
		private static void RegisterUpgrades(Dictionary<string, PlayerUpgrade> ____playerUpgrades)
		{
			if ((Object)(object)Plugin.instance.assetBundle == (Object)null || (Object)(object)StatsManager.instance == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, PlayerUpgrade> pair in ____playerUpgrades)
			{
				UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => (Object)(object)x.playerUpgrade.Item == (Object)(object)pair.Value.Item);
				if (upgradeItem != null)
				{
					string key = "appliedPlayerUpgrade" + pair.Key;
					Dictionary<string, int> appliedPlayerDictionary = upgradeItem.appliedPlayerDictionary;
					if (StatsManager.instance.dictionaryOfDictionaries.TryGetValue(key, out var value))
					{
						appliedPlayerDictionary = value;
						continue;
					}
					appliedPlayerDictionary.Clear();
					StatsManager.instance.dictionaryOfDictionaries.Add(key, appliedPlayerDictionary);
				}
			}
		}

		[HarmonyPatch("RegisterUpgrade")]
		[HarmonyPostfix]
		private static void RegisterUpgrade(ref PlayerUpgrade __result)
		{
			if (!((Object)(object)Plugin.instance.assetBundle == (Object)null) && __result != null && Plugin.instance.importUpgrades.Value && !(from x in Plugin.instance.excludeUpgradeIds.Value.Split(new char[1] { ',' })
				select x.Trim() into x
				where !string.IsNullOrEmpty(x)
				select x).Contains(__result.UpgradeId))
			{
				Plugin.instance.upgradeItems.Add(new UpgradeItem(__result));
			}
		}
	}
}
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
			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), "item")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "ItemValueMultiplier", (Type[])null, (Type[])null))
			});
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector))]
	internal class PhysGrabObjectImpactDetectorPatch
	{
		[HarmonyPatch("Break")]
		[HarmonyPrefix]
		private static void Break(PhysGrabObjectImpactDetector __instance, PhysGrabObject ___physGrabObject, bool ___isValuable, ref float valueLost)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null || !___isValuable)
			{
				return;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.upgradeBase.name == "Item Resist");
			if (upgradeItem == null)
			{
				return;
			}
			List<PhysGrabber> playerGrabbing = ___physGrabObject.playerGrabbing;
			if (playerGrabbing != null && playerGrabbing.Count > 0)
			{
				List<PlayerAvatar> list = playerGrabbing.Select((PhysGrabber player) => player.playerAvatar).ToList();
				int num = 0;
				foreach (PlayerAvatar item in list)
				{
					num += upgradeItem.playerUpgrade.GetLevel(item);
				}
				valueLost = ReduceValueLost(upgradeItem, valueLost, num);
			}
			else
			{
				Dictionary<PhysGrabObject, PlayerAvatar> variable = upgradeItem.GetVariable<Dictionary<PhysGrabObject, PlayerAvatar>>("Last Player Grabbed");
				if (variable.TryGetValue(___physGrabObject, out var value))
				{
					valueLost = ReduceValueLost(upgradeItem, valueLost, upgradeItem.playerUpgrade.GetLevel(value));
				}
			}
		}

		private static float ReduceValueLost(UpgradeItem upgradeItem, float valueLost, int level)
		{
			return valueLost * Mathf.Pow(upgradeItem.GetConfig<float>("Scaling Factor"), (float)level);
		}
	}
	[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.upgradeBase.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> MissionTextTranspiler(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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(MissionUI), "messagePrev"), (string)null)
			});
			val.Advance(1);
			val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MissionUIPatch), "MissionText", (Type[])null, (Type[])null))
			});
			return val.InstructionEnumeration();
		}

		private static void MissionText()
		{
			if (!((Object)(object)MoreUpgradesManager.instance == (Object)null))
			{
				Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.upgradeBase.name == "Valuable Count")?.SetVariable("Changed", value: true);
			}
		}
	}
	[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.upgradeBase.name == "Valuable Count");
			if (upgradeItem != null && (!Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<SurplusValuable>()) || !upgradeItem.GetConfig<bool>("Ignore Money Bags")))
			{
				List<ValuableObject> variable = upgradeItem.GetVariable<List<ValuableObject>>("Current Valuables");
				if (!variable.Contains(__instance))
				{
					variable.Add(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject))]
	internal class PhysGrabObjectPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update(PhysGrabObject __instance, bool ___isValuable, PlayerAvatar ___lastPlayerGrabbing)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null || !___isValuable)
			{
				return;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => x.upgradeBase.name == "Item Resist");
			if (upgradeItem == null || !((Object)(object)___lastPlayerGrabbing != (Object)null))
			{
				return;
			}
			Dictionary<PhysGrabObject, PlayerAvatar> variable = upgradeItem.GetVariable<Dictionary<PhysGrabObject, PlayerAvatar>>("Last Player Grabbed");
			if (!variable.TryGetValue(__instance, out var value) || !((Object)(object)value == (Object)(object)___lastPlayerGrabbing))
			{
				if (variable.ContainsKey(__instance))
				{
					variable.Remove(__instance);
				}
				variable.Add(__instance, ___lastPlayerGrabbing);
			}
		}

		[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.upgradeBase.name == "Valuable Count");
			if (upgradeItem != null && (!Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<SurplusValuable>()) || !upgradeItem.GetConfig<bool>("Ignore Money Bags")))
			{
				List<ValuableObject> variable = upgradeItem.GetVariable<List<ValuableObject>>("Current Valuables");
				if (variable.Contains(component))
				{
					variable.Remove(component);
				}
			}
		}
	}
	[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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: 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[2]
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "ItemValueMultiplier", (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) => (Object)(object)x.playerUpgrade.Item == (Object)(object)item);
			return upgradeItem != null && upgradeItem.HasConfig("Enabled") && !upgradeItem.GetConfig<bool>("Enabled");
		}

		[HarmonyPatch("UpgradeValueGet")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpgradeValueGetTranspiler(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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)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[2]
			{
				new CodeInstruction(OpCodes.Ldarg_2, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopManagerPatch), "UpgradeValueIncrease", (Type[])null, (Type[])null))
			});
			return val.InstructionEnumeration();
		}

		internal static float UpgradeValueIncrease(float upgradeValueIncrease, Item item)
		{
			if ((Object)(object)MoreUpgradesManager.instance == (Object)null)
			{
				return upgradeValueIncrease;
			}
			UpgradeItem upgradeItem = Plugin.instance.upgradeItems.FirstOrDefault((UpgradeItem x) => (Object)(object)x.playerUpgrade.Item == (Object)(object)item);
			if (upgradeItem == null)
			{
				return upgradeValueIncrease;
			}
			float num = (upgradeItem.HasConfig("Price Increase Scaling") ? upgradeItem.GetConfig<float>("Price Increase Scaling") : upgradeItem.upgradeBase.priceIncreaseScaling);
			if (num < 0f)
			{
				num = upgradeValueIncrease;
			}
			return num;
		}
	}
}
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.upgradeBase.name == "Map Player Tracker");
				if (upgradeItem != null && upgradeItem.GetConfig<bool>("Player Color"))
				{
					Plugin.instance.RemovePlayerToMap(avatar);
					Plugin.instance.AddPlayerToMap(avatar);
				}
			}
		}
	}
}
namespace MoreUpgrades.Compatibility
{
	internal static class CustomColors
	{
		internal const string modGUID = "x753.CustomColors";

		internal static bool IsLoaded()
		{
			return Chainloader.PluginInfos.ContainsKey("x753.CustomColors");
		}
	}
	internal static class REPOLib
	{
		internal const string modGUID = "REPOLib";
	}
}
namespace MoreUpgrades.Classes
{
	internal class MoreUpgradesManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <WaitUntilLevel>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public MoreUpgradesManager <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => SemiFunc.LevelGenDone()));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.checkPlayerUpgrades = 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();
			}
		}

		internal static MoreUpgradesManager instance;

		private bool checkPlayerUpgrades;

		private void Awake()
		{
			instance = this;
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				upgradeItem.variables?.Clear();
				upgradeItem.upgradeBase.onVariablesStart?.Invoke();
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				((MonoBehaviour)this).StartCoroutine("WaitUntilLevel");
			}
		}

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

		private void LateUpdate()
		{
			foreach (UpgradeItem upgradeItem in Plugin.instance.upgradeItems)
			{
				upgradeItem.upgradeBase.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 key = SemiFunc.PlayerGetSteamID(item);
								if (!upgradeItem.appliedPlayerDictionary.ContainsKey(key))
								{
									upgradeItem.appliedPlayerDictionary[key] = 0;
								}
								if (upgradeItem.appliedPlayerDictionary[key] != config)
								{
									upgradeItem.playerUpgrade.SetLevel(item, config);
									upgradeItem.appliedPlayerDictionary[key] = config;
								}
							}
						}
					}
					if (upgradeItem.HasConfig("Sync Host Upgrades") && upgradeItem.GetConfig<bool>("Sync Host Upgrades"))
					{
						PlayerAvatar localPlayerAvatar = SemiFunc.PlayerAvatarLocal();
						int level = upgradeItem.playerUpgrade.GetLevel(localPlayerAvatar);
						foreach (PlayerAvatar item2 in from x in SemiFunc.PlayerGetAll()
							where (Object)(object)x != (Object)(object)localPlayerAvatar
							select x)
						{
							if (level != upgradeItem.playerUpgrade.GetLevel(item2))
							{
								upgradeItem.playerUpgrade.SetLevel(item2, level);
							}
						}
					}
				}
				upgradeItem.upgradeBase.onFixedUpdate?.Invoke();
			}
		}

		[IteratorStateMachine(typeof(<WaitUntilLevel>d__6))]
		private IEnumerator WaitUntilLevel()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitUntilLevel>d__6(0)
			{
				<>4__this = this
			};
		}
	}
	internal class UpgradeItem
	{
		internal class Base
		{
			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 Action<PlayerAvatar, int> onStart;

			public Action<PlayerAvatar, int> onUpgrade;

			public Action onVariablesStart;

			public Action onUpdate;

			public Action onLateUpdate;

			public Action onFixedUpdate;

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

		public bool isRepoLibImported;

		private string sectionName;

		internal Base upgradeBase;

		internal PlayerUpgrade playerUpgrade;

		private Dictionary<string, ConfigEntryBase> configEntries;

		internal Dictionary<string, int> appliedPlayerDictionary;

		internal Dictionary<string, object> variables;

		public bool HasConfig(string key)
		{
			ConfigEntryBase value;
			return configEntries.TryGetValue(key, out value);
		}

		public bool AddConfig<T>(string key, T defaultValue, string description = "")
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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;
			}
			if (upgradeBase.excludeConfigs.Contains(key))
			{
				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);
		}

		private void SetupConfig()
		{
			configEntries = new Dictionary<string, ConfigEntryBase>();
			AddConfig("Enabled", defaultValue: true, "Whether the upgrade item can be spawned to the shop.");
			AddConfig("Max Amount", upgradeBase.maxAmount, "The maximum number of times the upgrade item can appear in the truck.");
			AddConfig("Max Amount In Shop", upgradeBase.maxAmountInShop, "The maximum number of times the upgrade item can appear in the shop.");
			AddConfig("Minimum Price", upgradeBase.minPrice, "The minimum cost to purchase the upgrade item.");
			AddConfig("Maximum Price", upgradeBase.maxPrice, "The maximum cost to purchase the upgrade item.");
			AddConfig("Price Increase Scaling", upgradeBase.priceIncreaseScaling, "The scale of the price increase based on the total number of upgrade item purchased.\nSet this value under 0 to use the default scaling.");
			AddConfig("Price Multiplier", isRepoLibImported ? (-1f) : 1f, "The multiplier of the price.\nSet this value under 0 to use the default multiplier.");
			AddConfig("Max Purchase Amount", upgradeBase.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.");
			AddConfig("Allow Team Upgrades", defaultValue: false, "Whether the upgrade item applies to the entire team instead of just one player.");
			AddConfig("Sync Host Upgrades", defaultValue: false, "Whether the host should sync the item upgrade for the entire team.");
			AddConfig("Starting Amount", 0, "The number of times the upgrade item is applied at the start of the game.");
		}

		internal UpgradeItem(Base upgradeBase)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			sectionName = upgradeBase.name;
			this.upgradeBase = upgradeBase;
			appliedPlayerDictionary = new Dictionary<string, int>();
			variables = new Dictionary<string, object>();
			SetupConfig();
			Item val = ScriptableObject.CreateInstance<Item>();
			val.itemType = (itemType)3;
			val.emojiIcon = (emojiIcon)11;
			val.itemVolume = (itemVolume)6;
			string name = (((Object)val).name = "Modded Item Upgrade Player " + upgradeBase.name);
			val.itemName = upgradeBase.name + " Upgrade";
			val.maxAmount = (HasConfig("Max Amount") ? GetConfig<int>("Max Amount") : upgradeBase.maxAmount);
			val.maxAmountInShop = (HasConfig("Max Amount In Shop") ? GetConfig<int>("Max Amount In Shop") : upgradeBase.maxAmountInShop);
			val.maxPurchaseAmount = (HasConfig("Max Purchase Amount") ? GetConfig<int>("Max Purchase Amount") : upgradeBase.maxPurchaseAmount);
			val.maxPurchase = val.maxPurchaseAmount > 0;
			Value val2 = ScriptableObject.CreateInstance<Value>();
			val2.valueMin = (HasConfig("Minimum Price") ? GetConfig<float>("Minimum Price") : upgradeBase.minPrice);
			val2.valueMax = (HasConfig("Maximum Price") ? GetConfig<float>("Maximum Price") : upgradeBase.maxPrice);
			val.value = val2;
			GameObject val3 = Plugin.instance.assetBundle.LoadAsset<GameObject>(upgradeBase.name);
			((Object)val3).name = name;
			REPOLibItemUpgrade component = val3.GetComponent<REPOLibItemUpgrade>();
			AccessTools.Field(typeof(REPOLibItemUpgrade), "_upgradeId").SetValue(component, upgradeBase.name);
			ItemAttributes component2 = val3.GetComponent<ItemAttributes>();
			component2.item = val;
			Items.RegisterItem(component2);
			playerUpgrade = Upgrades.RegisterUpgrade(upgradeBase.name, val, upgradeBase.onStart, upgradeBase.onUpgrade);
		}

		internal UpgradeItem(PlayerUpgrade playerUpgrade)
		{
			isRepoLibImported = true;
			Item item = playerUpgrade.Item;
			upgradeBase = new Base
			{
				name = playerUpgrade.UpgradeId,
				maxAmount = item.maxAmount,
				maxAmountInShop = item.maxAmountInShop,
				maxPurchaseAmount = item.maxPurchaseAmount,
				minPrice = item.value.valueMin,
				maxPrice = item.value.valueMax
			};
			sectionName = upgradeBase.name + " (REPOLib)";
			appliedPlayerDictionary = new Dictionary<string, int>();
			SetupConfig();
			item.maxAmount = (HasConfig("Max Amount") ? GetConfig<int>("Max Amount") : upgradeBase.maxAmount);
			item.maxAmountInShop = (HasConfig("Max Amount In Shop") ? GetConfig<int>("Max Amount In Shop") : upgradeBase.maxAmountInShop);
			item.maxPurchaseAmount = (HasConfig("Max Purchase Amount") ? GetConfig<int>("Max Purchase Amount") : upgradeBase.maxPurchaseAmount);
			item.maxPurchase = item.maxPurchaseAmount > 0;
			item.value.valueMin = (HasConfig("Minimum Price") ? GetConfig<float>("Minimum Price") : upgradeBase.minPrice);
			item.value.valueMax = (HasConfig("Maximum Price") ? GetConfig<float>("Maximum Price") : upgradeBase.maxPrice);
			this.playerUpgrade = playerUpgrade;
		}
	}
}