using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BrutalCompanyMinus;
using BrutalCompanyMinus.Minus.Handlers;
using BrutalCompanyMinus.Minus.MonoBehaviours;
using CSync.Extensions;
using CSync.Lib;
using CustomItemBehaviourLibrary.AbstractItems;
using Dawn;
using GameNetcodeStuff;
using GoodItemScan;
using HarmonyLib;
using InteractiveTerminalAPI.Compat;
using InteractiveTerminalAPI.UI;
using InteractiveTerminalAPI.UI.Application;
using InteractiveTerminalAPI.UI.Cursor;
using InteractiveTerminalAPI.UI.Page;
using InteractiveTerminalAPI.UI.Screen;
using LCVR.Player;
using LethalCompanyInputUtils.Api;
using LethalConstellations.PluginCore;
using LethalLevelLoader;
using LethalLib.Extras;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using MissileTurret;
using MoreShipUpgrades.API;
using MoreShipUpgrades.Compat;
using MoreShipUpgrades.Configuration;
using MoreShipUpgrades.Configuration.Contracts;
using MoreShipUpgrades.Configuration.Contracts.Abstractions;
using MoreShipUpgrades.Configuration.Upgrades.Abstractions.OneTimeUpgrades;
using MoreShipUpgrades.Configuration.Upgrades.Abstractions.TIerUpgrades;
using MoreShipUpgrades.Configuration.Upgrades.Custom;
using MoreShipUpgrades.Configuration.Upgrades.Interfaces;
using MoreShipUpgrades.Configuration.Upgrades.Interfaces.OneTimeUpgrades;
using MoreShipUpgrades.Configuration.Upgrades.Interfaces.TierUpgrades;
using MoreShipUpgrades.Extensions;
using MoreShipUpgrades.Input;
using MoreShipUpgrades.Managers;
using MoreShipUpgrades.Misc;
using MoreShipUpgrades.Misc.Commands;
using MoreShipUpgrades.Misc.Upgrades;
using MoreShipUpgrades.Misc.Util;
using MoreShipUpgrades.NetcodePatcher;
using MoreShipUpgrades.Patches.Enemies;
using MoreShipUpgrades.Patches.HUD;
using MoreShipUpgrades.Patches.Interactables;
using MoreShipUpgrades.Patches.Items;
using MoreShipUpgrades.Patches.NetworkManager;
using MoreShipUpgrades.Patches.PlayerController;
using MoreShipUpgrades.Patches.RoundComponents;
using MoreShipUpgrades.Patches.TerminalComponents;
using MoreShipUpgrades.Patches.Weather;
using MoreShipUpgrades.UI.Application;
using MoreShipUpgrades.UI.Cursor;
using MoreShipUpgrades.UI.TerminalNodes;
using MoreShipUpgrades.UpgradeComponents.Commands;
using MoreShipUpgrades.UpgradeComponents.Contracts;
using MoreShipUpgrades.UpgradeComponents.Interfaces;
using MoreShipUpgrades.UpgradeComponents.Items;
using MoreShipUpgrades.UpgradeComponents.Items.Contracts.BombDefusal;
using MoreShipUpgrades.UpgradeComponents.Items.Contracts.DataRetrieval;
using MoreShipUpgrades.UpgradeComponents.Items.Contracts.Exorcism;
using MoreShipUpgrades.UpgradeComponents.Items.Contracts.Exterminator;
using MoreShipUpgrades.UpgradeComponents.Items.Contracts.Extraction;
using MoreShipUpgrades.UpgradeComponents.Items.RadarBooster;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Enemies;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Items;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Player;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Ship;
using MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Store;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.AttributeUpgrades;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Enemies;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Jetpack;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.RadarBooster;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Shotgun;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.WeedKiller;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Zapgun;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Player;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Ship;
using MoreShipUpgrades.UpgradeComponents.TierUpgrades.Store;
using Newtonsoft.Json;
using Oxygen.General;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;
using com.github.zehsteam.ToilHead.MonoBehaviours;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MoreShipUpgrades
{
	[BepInPlugin("com.malco.lethalcompany.moreshipupgrades", "More Ship Upgrades", "3.13.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource mls;

		internal static readonly Dictionary<string, GameObject> networkPrefabs = new Dictionary<string, GameObject>();

		private void Awake()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			mls = ((BaseUnityPlugin)this).Logger;
			LategameConfiguration lategameConfiguration = new LategameConfiguration(((BaseUnityPlugin)this).Config);
			IEnumerable<Type> types;
			try
			{
				types = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = ex.Types.Where((Type t) => t != null);
			}
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "shipupgrades");
			AssetBundle bundle = AssetBundle.LoadFromFile(text);
			GameObject val = new GameObject("UpgradeBus")
			{
				hideFlags = (HideFlags)61
			};
			val.AddComponent<UpgradeBus>();
			val = new GameObject("SpawnItemManager");
			val.AddComponent<ItemManager>();
			UpgradeBus.Instance.UpgradeAssets = bundle;
			UpgradeBus.Instance.SetConfiguration(lategameConfiguration);
			SetupModStore(ref bundle);
			SetupItems(ref types);
			SetupCommands(ref types);
			SetupPerks(ref types);
			ContractManager.SetupContractMapObjects(ref bundle);
			InputUtilsCompat.Init();
			PatchManager.PatchMainVersion();
			if (CurrencyManager.Enabled)
			{
				InteractiveTerminalManager.RegisterApplication<TradePlayerCreditsApplication>(LguConstants.TRADE_PLAYER_CREDITS_COMMAND_PROMPT, false);
				InteractiveTerminalManager.RegisterApplication<ConvertPlayerCreditApplication>(LguConstants.CONVERT_PLAYER_CREDITS_COMMAND_PROMPT, false);
			}
			InteractiveTerminalManager.RegisterApplication<UpgradeStoreApplication>(LguConstants.LGU_COMMAND_PROMPTS, false);
			if (SyncedEntry<bool>.op_Implicit(lategameConfiguration.ContractsConfiguration.Enabled))
			{
				List<string> list = new List<string>(LguConstants.CONTRACT_COMMAND_PROMPT);
				if (SyncedEntry<bool>.op_Implicit(lategameConfiguration.ContractsConfiguration.RandomOnly))
				{
					list.Remove("contract");
				}
				InteractiveTerminalManager.RegisterApplication<ContractApplication>(list.ToArray(), false);
			}
			mls.LogInfo((object)"More Ship Upgrades 3.13.1 has been loaded successfully.");
		}

		private void SetupModStore(ref AssetBundle bundle)
		{
			GameObject val = AssetBundleHandler.TryLoadGameObjectAsset(ref bundle, "Assets/ShipUpgrades/LguStore.prefab");
			val.AddComponent<ContractManager>();
			val.AddComponent<CurrencyManager>();
			val.AddComponent<LguStore>();
			ItemManager.RegisterNetworkPrefab(val);
			UpgradeBus.Instance.modStorePrefab = val;
		}

		private void SetupItems(ref IEnumerable<Type> types)
		{
			foreach (Type type in types)
			{
				if (type.IsSubclassOf(typeof(LategameItem)) && !(type == typeof(LategameItem)))
				{
					UpgradeBus.Instance.itemTypes.Add(type);
					MethodInfo method = type.GetMethod("LoadItem", BindingFlags.Static | BindingFlags.Public);
					if (!(method == null))
					{
						method.Invoke(null, null);
					}
				}
			}
			mls.LogInfo((object)"Items have been setup");
		}

		private void SetupPerks(ref IEnumerable<Type> types)
		{
			foreach (Type type in types)
			{
				if (type.IsSubclassOf(typeof(BaseUpgrade)) && !(type == typeof(OneTimeUpgrade)) && !(type == typeof(TierUpgrade)) && !(type == typeof(GameAttributeTierUpgrade)))
				{
					UpgradeBus.Instance.upgradeTypes.Add(type);
					MethodInfo method = type.GetMethod("RegisterUpgrade", BindingFlags.Static | BindingFlags.Public);
					method.Invoke(null, null);
				}
			}
			mls.LogInfo((object)"Upgrades have been setup");
		}

		private void SetupCommands(ref IEnumerable<Type> types)
		{
			foreach (Type type in types)
			{
				if (type.IsSubclassOf(typeof(BaseCommand)))
				{
					UpgradeBus.Instance.commandTypes.Add(type);
					MethodInfo method = type.GetMethod("RegisterCommand", BindingFlags.Static | BindingFlags.Public);
					method.Invoke(null, null);
				}
			}
			mls.LogInfo((object)"Commands have been setup");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "MoreShipUpgrades";

		public const string PLUGIN_NAME = "MoreShipUpgrades";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades
{
	internal class Beekeeper : TierUpgrade, IUpgradeWorldBuilding
	{
		internal static Beekeeper Instance;

		public const string UPGRADE_NAME = "Beekeeper";

		public const string PRICES_DEFAULT = "450,225,280,340";

		internal const string WORLD_BUILDING_TEXT = "\n\nOn-the-job training package that instructs {0} how to more safely and efficiently handle Circuit Bee Nests. Departments with a LVL {1} Certification in Circuit Bee Nest Handling earn an extra commission for every Nest they sell.\n\n";

		protected bool CanIncreaseHivePrice => BaseUpgrade.GetUpgradeLevel("Beekeeper") == BaseUpgrade.GetConfiguration().BeekeeperConfiguration.Prices.Value.Split(',').Length;

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierMultipleEffectUpgradeConfiguration<float> beekeeperConfiguration = BaseUpgrade.GetConfiguration().BeekeeperConfiguration;
				string[] array = beekeeperConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Beekeeper";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BeekeeperConfiguration.OverrideName);
			Instance = this;
		}

		public static int CalculateBeeDamage(int damageNumber)
		{
			ITierMultipleEffectUpgradeConfiguration<float> beekeeperConfiguration = BaseUpgrade.GetConfiguration().BeekeeperConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(beekeeperConfiguration.Enabled))
			{
				return damageNumber;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Beekeeper"))
			{
				return damageNumber;
			}
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = beekeeperConfiguration.GetEffectPair(0);
			return Mathf.Clamp((int)((float)damageNumber * (effectPair.Item1.Value - (float)BaseUpgrade.GetUpgradeLevel("Beekeeper") * effectPair.Item2.Value)), 0, damageNumber);
		}

		public static int GetHiveScrapValue(int originalValue)
		{
			ITierMultipleEffectUpgradeConfiguration<float> beekeeperConfiguration = BaseUpgrade.GetConfiguration().BeekeeperConfiguration;
			if (!beekeeperConfiguration.Enabled.Value || !Instance.CanIncreaseHivePrice)
			{
				return originalValue;
			}
			return (int)((float)originalValue * beekeeperConfiguration.GetEffectPair(1).Item1.Value);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nOn-the-job training package that instructs {0} how to more safely and efficiently handle Circuit Bee Nests. Departments with a LVL {1} Certification in Circuit Bee Nest Handling earn an extra commission for every Nest they sell.\n\n", shareStatus ? "your crew" : "you", BaseUpgrade.GetConfiguration().BeekeeperConfiguration.Prices.Value.Split(',').Length);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Beekeeper");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().BeekeeperConfiguration.PurchaseMode)) + $"\nOn maximum level, applies a {(SyncedEntry<float>.op_Implicit(BaseUpgrade.GetConfiguration().BeekeeperConfiguration.GetEffectPair(1).Item1) - 1f) * 100f:F0}% scrap value increase on beehives.";
			static float infoFunction(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<float> beekeeperConfiguration = BaseUpgrade.GetConfiguration().BeekeeperConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) effectPair = beekeeperConfiguration.GetEffectPair(0);
				return 100f * (effectPair.Item1.Value - (float)level * effectPair.Item2.Value);
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Beekeeper", BaseUpgrade.GetConfiguration().BeekeeperConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<Beekeeper>("Beekeeper");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Beekeeper", BaseUpgrade.GetConfiguration().BeekeeperConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "Beekeeper";
		}
	}
	internal class BiggerLungs : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Bigger Lungs";

		internal const string PRICES_DEFAULT = "600,350,450,550";

		internal const string WORLD_BUILDING_TEXT = "\n\nService package for {0}. Opting into every maintenance procedure will arrange for your suit's pipes to be cleaned and repaired, filters re-issued, and DRM removed from the integrated air conditioning system.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				BiggerLungsUpgradeConfiguration biggerLungsConfiguration = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
				string[] array = biggerLungsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Bigger Lungs";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BiggerLungsConfiguration.OverrideName);
		}

		public static float ApplyPossibleIncreasedStaminaRegen(float regenValue)
		{
			BiggerLungsUpgradeConfiguration biggerLungsConfiguration = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
			if (!biggerLungsConfiguration.Enabled.Value)
			{
				return regenValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Bigger Lungs") || BaseUpgrade.GetUpgradeLevel("Bigger Lungs") < biggerLungsConfiguration.StaminaRegenerationLevel.Value - 1)
			{
				return regenValue;
			}
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = biggerLungsConfiguration.GetEffectPair(1);
			return regenValue * Mathf.Clamp(effectPair.Item1.Value + SyncedEntry<float>.op_Implicit(effectPair.Item2) * (float)Mathf.Abs(BaseUpgrade.GetUpgradeLevel("Bigger Lungs") - biggerLungsConfiguration.StaminaRegenerationLevel.Value - 1), 0f, 10f);
		}

		public static float GetAdditionalStaminaTime(float defaultValue)
		{
			BiggerLungsUpgradeConfiguration biggerLungsConfiguration = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(biggerLungsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Bigger Lungs"))
			{
				return defaultValue;
			}
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = biggerLungsConfiguration.GetEffectPair(0);
			float num = SyncedEntry<float>.op_Implicit(effectPair.Item1) + (float)BaseUpgrade.GetUpgradeLevel("Bigger Lungs") * SyncedEntry<float>.op_Implicit(effectPair.Item2);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public static float ApplyPossibleReducedJumpStaminaCost(float jumpCost)
		{
			BiggerLungsUpgradeConfiguration biggerLungsConfiguration = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
			if (!biggerLungsConfiguration.Enabled.Value)
			{
				return jumpCost;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Bigger Lungs") || BaseUpgrade.GetUpgradeLevel("Bigger Lungs") < biggerLungsConfiguration.JumpReductionLevel.Value - 1)
			{
				return jumpCost;
			}
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = biggerLungsConfiguration.GetEffectPair(2);
			return jumpCost * Mathf.Clamp(effectPair.Item1.Value - SyncedEntry<float>.op_Implicit(effectPair.Item2) * (float)Mathf.Abs(BaseUpgrade.GetUpgradeLevel("Bigger Lungs") - biggerLungsConfiguration.JumpReductionLevel.Value - 1), 0f, 10f);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nService package for {0}. Opting into every maintenance procedure will arrange for your suit's pipes to be cleaned and repaired, filters re-issued, and DRM removed from the integrated air conditioning system.\n\n", shareStatus ? "your crew's suit oxigen delivery systems" : "your suit's oxygen delivery system");
		}

		private string GetBiggerlungsInfo(int level, int price)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendFormat(AssetBundleHandler.GetInfoFromJSON("Bigger Lungs"), level, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().BiggerLungsConfiguration.PurchaseMode)), infoFunction(level - 1));
			BiggerLungsUpgradeConfiguration biggerLungsConfiguration = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
			if (level >= SyncedEntry<int>.op_Implicit(biggerLungsConfiguration.StaminaRegenerationLevel))
			{
				stringBuilder.Append($"Stamina regeneration is increased by {Mathf.FloorToInt(staminaRegenerationInfo(level) * 100f)}%\n");
			}
			if (level >= biggerLungsConfiguration.JumpReductionLevel.Value)
			{
				stringBuilder.Append($"Stamina used when jumping is reduced by {Mathf.FloorToInt(costReductionInfo(level) * 100f)}%\n");
			}
			return stringBuilder.ToString();
			static float costReductionInfo(int level)
			{
				BiggerLungsUpgradeConfiguration biggerLungsConfiguration2 = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) effectPair = biggerLungsConfiguration2.GetEffectPair(2);
				return 1f - (effectPair.Item1.Value - (float)level * effectPair.Item2.Value);
			}
			static float infoFunction(int level)
			{
				BiggerLungsUpgradeConfiguration biggerLungsConfiguration4 = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) effectPair3 = biggerLungsConfiguration4.GetEffectPair(0);
				return effectPair3.Item1.Value + (float)level * effectPair3.Item2.Value;
			}
			static float staminaRegenerationInfo(int level)
			{
				BiggerLungsUpgradeConfiguration biggerLungsConfiguration3 = BaseUpgrade.GetConfiguration().BiggerLungsConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) effectPair2 = biggerLungsConfiguration3.GetEffectPair(1);
				return effectPair2.Item1.Value + (float)level * effectPair2.Item2.Value - 1f;
			}
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetBiggerlungsInfo(1, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetBiggerlungsInfo(i + 2, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Bigger Lungs", BaseUpgrade.GetConfiguration().BiggerLungsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<BiggerLungs>("Bigger Lungs");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Bigger Lungs", BaseUpgrade.GetConfiguration().BiggerLungsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BiggerLungs";
		}
	}
	internal class ClimbingGloves : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Climbing Gloves";

		internal const string DEFAULT_PRICES = "150,200,250,300";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the 'GEAR' section of the Company Catalogue, at the bottom of the last page sandwiched between two ads, you find an entry for this product. They are Premium Synthetic Proprietary Ladder Gripping Gloves. The sales screed promises a 2% increase in your department's efficiency at outdoor traversal if you buy this.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<float> climblingGlovesConfiguration = BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration;
				string[] array = climblingGlovesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the 'GEAR' section of the Company Catalogue, at the bottom of the last page sandwiched between two ads, you find an entry for this product. They are Premium Synthetic Proprietary Ladder Gripping Gloves. The sales screed promises a 2% increase in your department's efficiency at outdoor traversal if you buy this.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Climbing Gloves";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ClimblingGlovesConfiguration.OverrideName);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the speed of climbing ladders by {2} units.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<float> climblingGlovesConfiguration = BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration;
				return climblingGlovesConfiguration.InitialEffect.Value + (float)level * climblingGlovesConfiguration.IncrementalEffect.Value;
			}
		}

		public static float GetAdditionalClimbingSpeed(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<float> climblingGlovesConfiguration = BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(climblingGlovesConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Climbing Gloves"))
			{
				return defaultValue;
			}
			float num = SyncedEntry<float>.op_Implicit(climblingGlovesConfiguration.InitialEffect) + (float)BaseUpgrade.GetUpgradeLevel("Climbing Gloves") * SyncedEntry<float>.op_Implicit(climblingGlovesConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Climbing Gloves", BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ClimbingGloves>("Climbing Gloves");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Climbing Gloves", BaseUpgrade.GetConfiguration().ClimblingGlovesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ClimbingGloves";
		}
	}
	internal class ProteinPowder : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Protein Powder";

		internal const string WORLD_BUILDING_TEXT = "\n\nMultivitamins, creatine, and military surplus stimulants blended together and repackaged, then offered on subscription. Known to be habit-forming. The label includes a Company Surgeon General's warning about increased aggression.\n\n";

		private const int CRIT_DAMAGE_VALUE = 100;

		public const string ENABLED_SECTION = "Enable Protein Powder Upgrade";

		public const bool ENABLED_DEFAULT = true;

		public const string ENABLED_DESCRIPTION = "Do more damage with shovels";

		public const string PRICE_SECTION = "Price of Protein Powder Upgrade";

		public const int PRICE_DEFAULT = 1000;

		public const string UNLOCK_FORCE_SECTION = "Initial additional hit force";

		public const int UNLOCK_FORCE_DEFAULT = 1;

		public const string UNLOCK_FORCE_DESCRIPTION = "The value added to hit force on initial unlock.";

		public const string INCREMENT_FORCE_SECTION = "Additional hit force per level";

		public const int INCREMENT_FORCE_DEFAULT = 1;

		public const string INCREMENT_FORCE_DESCRIPTION = "Every time Protein Powder is upgraded this value will be added to the value above.";

		public const string PRICES_DEFAULT = "1000,700";

		public const string CRIT_CHANCE_SECTION = "Chance of dealing a crit which will instakill the enemy.";

		public const float CRIT_CHANCE_DEFAULT = 0.01f;

		public const string CRIT_CHANCE_DESCRIPTION = "This value is only valid when maxed out Protein Powder. Any previous levels will not apply crit.";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration proteinPowderConfiguration = BaseUpgrade.GetConfiguration().ProteinPowderConfiguration;
				string[] array = proteinPowderConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Protein Powder";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ProteinPowderConfiguration.OverrideName);
			base.Start();
		}

		public static int GetShovelHitForce(int force)
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> proteinPowderConfiguration = BaseUpgrade.GetConfiguration().ProteinPowderConfiguration;
			if (!proteinPowderConfiguration.Enabled.Value)
			{
				return force;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Protein Powder"))
			{
				return force;
			}
			(SyncedEntry<int>, SyncedEntry<int>) effectPair = proteinPowderConfiguration.GetEffectPair(0);
			int num = (TryToCritEnemy() ? 100 : (effectPair.Item1.Value + effectPair.Item2.Value * BaseUpgrade.GetUpgradeLevel("Protein Powder")));
			return force + num;
		}

		private static bool TryToCritEnemy()
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> proteinPowderConfiguration = BaseUpgrade.GetConfiguration().ProteinPowderConfiguration;
			string[] array = proteinPowderConfiguration.Prices.Value.Split(',');
			int num = array.Length;
			int upgradeLevel = BaseUpgrade.GetUpgradeLevel("Protein Powder");
			if (upgradeLevel != num && (array.Length != 1 || (array[0].Length != 0 && !(array[0] == "0"))))
			{
				return false;
			}
			(SyncedEntry<float>, SyncedEntry<float>) secondEffectPair = proteinPowderConfiguration.GetSecondEffectPair(0);
			return Random.value < secondEffectPair.Item1.Value;
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nMultivitamins, creatine, and military surplus stimulants blended together and repackaged, then offered on subscription. Known to be habit-forming. The label includes a Company Surgeon General's warning about increased aggression.\n\n";
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Protein Powder");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ProteinPowderConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> proteinPowderConfiguration = BaseUpgrade.GetConfiguration().ProteinPowderConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = proteinPowderConfiguration.GetEffectPair(0);
				return effectPair.Item1.Value + effectPair.Item2.Value * level;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Protein Powder", BaseUpgrade.GetConfiguration().ProteinPowderConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ProteinPowder>("Protein Powder");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Protein Powder", BaseUpgrade.GetConfiguration().ProteinPowderConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ProteinPowder";
		}
	}
	internal class EfficientEngines : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Efficient Engines";

		internal const string DEFAULT_PRICES = "450,600, 750, 900";

		internal const string WORLD_BUILDING_TEXT = "\n\nService package for your Ship's autopiloting system that tweaks the parameters by which it routes between moons. By default, the autopiloting software is configured to only use the safest routes, but this package will authorize it to use faster but slightly more dangerous \"Liability Routes\" and certain spatial anomalies to expedite travel, conserving fuel costs.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nService package for your Ship's autopiloting system that tweaks the parameters by which it routes between moons. By default, the autopiloting software is configured to only use the safest routes, but this package will authorize it to use faster but slightly more dangerous \"Liability Routes\" and certain spatial anomalies to expedite travel, conserving fuel costs.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Efficient Engines";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration.OverrideName);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Moon routing will be {2}% cheaper\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> efficientEnginesConfiguration = BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration;
				return efficientEnginesConfiguration.InitialEffect.Value + level * efficientEnginesConfiguration.IncrementalEffect.Value;
			}
		}

		public static int GetDiscountedMoonPrice(int defaultPrice)
		{
			ITierEffectUpgradeConfiguration<int> efficientEnginesConfiguration = BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration;
			if (!efficientEnginesConfiguration.Enabled.Value)
			{
				return defaultPrice;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Efficient Engines"))
			{
				return defaultPrice;
			}
			if (defaultPrice == 0)
			{
				return defaultPrice;
			}
			float num = (float)defaultPrice * (1f - (float)(efficientEnginesConfiguration.InitialEffect.Value + BaseUpgrade.GetUpgradeLevel("Efficient Engines") * efficientEnginesConfiguration.IncrementalEffect.Value) / 100f);
			return Mathf.CeilToInt(Mathf.Clamp(num, 0f, (float)defaultPrice));
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Efficient Engines", BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<EfficientEngines>("Efficient Engines");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Efficient Engines", BaseUpgrade.GetConfiguration().EfficientEnginesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "EfficientEngines";
		}
	}
	internal class LandingThrusters : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Landing Thrusters";

		internal const string DEFAULT_PRICES = "300,250,450,650";

		internal const string WORLD_BUILDING_TEXT = "\n\nOptimization procedure for your Ship's in-atmosphere thrusters that makes quicker landings possible by ordering the autopilot to commit to a longer freefall. Technically more dangerous, but it'll be fine.";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration landingThrustersConfiguration = BaseUpgrade.GetConfiguration().LandingThrustersConfiguration;
				string[] array = landingThrustersConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOptimization procedure for your Ship's in-atmosphere thrusters that makes quicker landings possible by ordering the autopilot to commit to a longer freefall. Technically more dangerous, but it'll be fine.";
		}

		private void Awake()
		{
			upgradeName = "Landing Thrusters";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LandingThrustersConfiguration.OverrideName);
		}

		public static float GetInteractMutliplier()
		{
			LandingThrusterUpgradeConfiguration landingThrustersConfiguration = BaseUpgrade.GetConfiguration().LandingThrustersConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(landingThrustersConfiguration.Enabled))
			{
				return 1f;
			}
			if (!SyncedEntry<bool>.op_Implicit(landingThrustersConfiguration.AffectLanding))
			{
				return 1f;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Landing Thrusters"))
			{
				return 1f;
			}
			return 1f + Mathf.Max(0f, (float)(SyncedEntry<int>.op_Implicit(landingThrustersConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Landing Thrusters") * SyncedEntry<int>.op_Implicit(landingThrustersConfiguration.IncrementalEffect)) / 100f);
		}

		public static float GetLandingSpeedMultiplier()
		{
			LandingThrusterUpgradeConfiguration landingThrustersConfiguration = BaseUpgrade.GetConfiguration().LandingThrustersConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(landingThrustersConfiguration.Enabled))
			{
				return 1f;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Landing Thrusters"))
			{
				return 1f;
			}
			return 1f + Mathf.Max(0f, (float)(SyncedEntry<int>.op_Implicit(landingThrustersConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Landing Thrusters") * SyncedEntry<int>.op_Implicit(landingThrustersConfiguration.IncrementalEffect)) / 100f);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the ship's landing speed by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LandingThrustersConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				LandingThrusterUpgradeConfiguration landingThrustersConfiguration = BaseUpgrade.GetConfiguration().LandingThrustersConfiguration;
				return landingThrustersConfiguration.InitialEffect.Value + level * landingThrustersConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Landing Thrusters", BaseUpgrade.GetConfiguration().LandingThrustersConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<LandingThrusters>("Landing Thrusters");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Landing Thrusters", BaseUpgrade.GetConfiguration().LandingThrustersConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LandingThrusters";
		}
	}
	internal class ShutterBatteries : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Shutter Batteries";

		public const string PRICES_DEFAULT = "300,200,300,400";

		public const string ENABLED_SECTION = "Enable Shutter Batteries";

		public const string ENABLED_DESCRIPTION = "Increases the amount of time the doors can remain shut";

		public const string PRICE_SECTION = "Price of Shutter Batteries";

		public const int PRICE_DEFAULT = 300;

		public const string INITIAL_SECTION = "Initial battery boost";

		public const float INITIAL_DEFAULT = 5f;

		public const string INITIAL_DESCRIPTION = "Initial battery boost for the doors' lock on first purchase";

		public const string INCREMENTAL_SECTION = "Incremental battery boost";

		public const float INCREMENTAL_DEFAULT = 5f;

		public const string INCREMENTAL_DESCRIPTION = "Incremental battery boost for the doors' lock after purchase";

		internal const string WORLD_BUILDING_TEXT = "\n\nService package of maintenance procedures for your Ship's Proprietary Emergency Lockout Door System, the two-button monitor you control the Ship's airlock from while moonside. Opting into all of the procedures will improve the uptime of the lockout function, which may improve your department's Fatality Record Over Time by up to 11%.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<float> shutterBatteriesConfiguration = BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration;
				string[] array = shutterBatteriesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nService package of maintenance procedures for your Ship's Proprietary Emergency Lockout Door System, the two-button monitor you control the Ship's airlock from while moonside. Opting into all of the procedures will improve the uptime of the lockout function, which may improve your department's Fatality Record Over Time by up to 11%.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Shutter Batteries";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration.OverrideName);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the door's hydraulic capacity to remain closed by {2} units\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<float> shutterBatteriesConfiguration = BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration;
				return shutterBatteriesConfiguration.InitialEffect.Value + (float)level * shutterBatteriesConfiguration.IncrementalEffect.Value;
			}
		}

		public static float GetAdditionalDoorTime(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<float> shutterBatteriesConfiguration = BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(shutterBatteriesConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Shutter Batteries"))
			{
				return defaultValue;
			}
			float num = SyncedEntry<float>.op_Implicit(shutterBatteriesConfiguration.InitialEffect) + (float)BaseUpgrade.GetUpgradeLevel("Shutter Batteries") * SyncedEntry<float>.op_Implicit(shutterBatteriesConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Shutter Batteries", BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ShutterBatteries>("Shutter Batteries");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Shutter Batteries", BaseUpgrade.GetConfiguration().ShutterBatteriesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ShutterBatteries";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Store
{
	internal class BargainConnections : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Bargain Connections";

		internal const string PRICES_DEFAULT = "200,225,300,375";

		internal const string WORLD_BUILDING_TEXT = "\n\nSubscription to 'Coupon Cutters' magazine. Every once in a while the magazine comes with coupons already cut out from it. Strange.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> bargainConnectionsConfiguration = BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration;
				string[] array = bargainConnectionsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Bargain Connections";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration.OverrideName);
			base.Start();
		}

		public static int GetBargainConnectionsAdditionalItems(int defaultAmountItems)
		{
			ITierEffectUpgradeConfiguration<int> bargainConnectionsConfiguration = BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration;
			if (!BaseUpgrade.GetActiveUpgrade("Bargain Connections"))
			{
				return defaultAmountItems;
			}
			return defaultAmountItems + bargainConnectionsConfiguration.InitialEffect.Value + BaseUpgrade.GetUpgradeLevel("Bargain Connections") * bargainConnectionsConfiguration.IncrementalEffect.Value;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the amount of items that can be on sale by {2}\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> bargainConnectionsConfiguration = BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration;
				return bargainConnectionsConfiguration.InitialEffect.Value + level * bargainConnectionsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Bargain Connections", BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<BargainConnections>("Bargain Connections");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Bargain Connections", BaseUpgrade.GetConfiguration().BargainConnectionsConfiguration);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSubscription to 'Coupon Cutters' magazine. Every once in a while the magazine comes with coupons already cut out from it. Strange.\n\n";
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BargainConnections";
		}
	}
	internal class MarketInfluence : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Market Influence";

		internal const string PRICES_DEFAULT = "200,350,500";

		internal const string WORLD_BUILDING_TEXT = "\n\nBy investing scrip into the Company's subsidiaries that produce your equipment instead of buying the equipment itself, you are sometimes awarded coupons in the mail for various Company Store offerings.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> marketInfluenceConfiguration = BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration;
				string[] array = marketInfluenceConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nBy investing scrip into the Company's subsidiaries that produce your equipment instead of buying the equipment itself, you are sometimes awarded coupons in the mail for various Company Store offerings.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Market Influence";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration.OverrideName);
			base.Start();
		}

		public static int GetGuaranteedPercentageSale(int defaultPercentage, int maxValue)
		{
			ITierEffectUpgradeConfiguration<int> marketInfluenceConfiguration = BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(marketInfluenceConfiguration.Enabled))
			{
				return defaultPercentage;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Market Influence"))
			{
				return defaultPercentage;
			}
			return Mathf.Clamp(defaultPercentage + marketInfluenceConfiguration.InitialEffect.Value + BaseUpgrade.GetUpgradeLevel("Market Influence") * marketInfluenceConfiguration.IncrementalEffect.Value, 0, maxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Guarantees the item sales' percentage to be at least {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> marketInfluenceConfiguration = BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration;
				return marketInfluenceConfiguration.InitialEffect.Value + level * marketInfluenceConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Market Influence", BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<MarketInfluence>("Market Influence");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Market Influence", BaseUpgrade.GetConfiguration().MarketInfluenceConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "MarketInfluence";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Ship
{
	internal class Discombobulator : TierUpgrade, IUpgradeWorldBuilding
	{
		[CompilerGenerated]
		private sealed class <ResetRange>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Terminal terminal;

			public Discombobulator <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					terminal.terminalAudio.maxDistance = 17f;
					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 float flashCooldown = 0f;

		public static Discombobulator instance;

		public const string UPGRADE_NAME = "Discombobulator";

		public const string PRICES_DEFAULT = "450,330,460,620";

		internal const string WORLD_BUILDING_TEXT = "\n\nService key for the Ship's terminal which allows {0} to legally use the Ship's 'Discombobulator' module. Comes with a list of opt-in maintenance procedures that promise to optimze the discharge and refractory of the system. Said document contains no mention of whatever it might be that it was included in the Ship's design to discombobulate.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				DiscombobulatorUpgradeConfiguration discombobulatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration;
				string[] array = discombobulatorUpgradeConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Discombobulator";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.OverrideName);
			instance = this;
		}

		private void Update()
		{
			if (flashCooldown > 0f)
			{
				flashCooldown -= Time.deltaTime;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void UseDiscombobulatorServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3612237191u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3612237191u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UseDiscombobulatorClientRpc();
				}
			}
		}

		[ClientRpc]
		internal void UseDiscombobulatorClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(760292881u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 760292881u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					Terminal terminal = UpgradeBus.Instance.GetTerminal();
					PlayAudio(ref terminal);
					flashCooldown = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.Cooldown.Value;
					StunNearbyEnemies(ref terminal);
				}
			}
		}

		private void StunNearbyEnemies(ref Terminal terminal)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			DiscombobulatorUpgradeConfiguration discombobulatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration;
			Collider[] array = Physics.OverlapSphere(((Component)terminal).transform.position, discombobulatorUpgradeConfiguration.Radius.Value, 524288);
			if (array.Length == 0)
			{
				return;
			}
			for (int i = 0; i < array.Length; i++)
			{
				EnemyAICollisionDetect component = ((Component)array[i]).GetComponent<EnemyAICollisionDetect>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				EnemyAI mainScript = component.mainScript;
				if (!IsEnemyBlacklisted(mainScript))
				{
					if (CanDealDamage())
					{
						int num = discombobulatorUpgradeConfiguration.InitialDamage.Value + discombobulatorUpgradeConfiguration.IncrementalDamage.Value * Mathf.Max(BaseUpgrade.GetUpgradeLevel("Discombobulator") - discombobulatorUpgradeConfiguration.DamageLevel.Value, 0);
						mainScript.HitEnemy(num, (PlayerControllerB)null, false, -1);
					}
					float num2 = discombobulatorUpgradeConfiguration.InitialEffect.Value + discombobulatorUpgradeConfiguration.IncrementalEffect.Value * (float)BaseUpgrade.GetUpgradeLevel("Discombobulator");
					if (SyncedEntry<bool>.op_Implicit(discombobulatorUpgradeConfiguration.Absolute))
					{
						num2 /= mainScript.enemyType.stunTimeMultiplier;
					}
					if (!mainScript.isEnemyDead)
					{
						mainScript.SetEnemyStunned(true, num2, (PlayerControllerB)null);
					}
				}
			}
		}

		private bool IsEnemyBlacklisted(EnemyAI enemy)
		{
			string enemyName = enemy.enemyType.enemyName;
			string[] blacklistedEnemies = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.BlacklistEnemies.Value.Split(",");
			if (ContainsEnemyName(enemyName, blacklistedEnemies))
			{
				return true;
			}
			ScanNodeProperties componentInChildren = ((Component)enemy).gameObject.GetComponentInChildren<ScanNodeProperties>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			enemyName = componentInChildren.headerText;
			return ContainsEnemyName(enemyName, blacklistedEnemies);
		}

		private bool ContainsEnemyName(string enemyName, string[] blacklistedEnemies)
		{
			foreach (string value in blacklistedEnemies)
			{
				if (enemyName.Equals(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private void PlayAudio(ref Terminal terminal)
		{
			terminal.terminalAudio.maxDistance = 100f;
			terminal.terminalAudio.PlayOneShot(UpgradeBus.Instance.flashNoise);
			((MonoBehaviour)this).StartCoroutine(ResetRange(terminal));
		}

		private bool CanDealDamage()
		{
			DiscombobulatorUpgradeConfiguration discombobulatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration;
			return discombobulatorUpgradeConfiguration.DamageLevel.Value > 0 && BaseUpgrade.GetUpgradeLevel("Discombobulator") + 1 >= discombobulatorUpgradeConfiguration.DamageLevel.Value;
		}

		[IteratorStateMachine(typeof(<ResetRange>d__14))]
		private IEnumerator ResetRange(Terminal terminal)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResetRange>d__14(0)
			{
				<>4__this = this,
				terminal = terminal
			};
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nService key for the Ship's terminal which allows {0} to legally use the Ship's 'Discombobulator' module. Comes with a list of opt-in maintenance procedures that promise to optimze the discharge and refractory of the system. Said document contains no mention of whatever it might be that it was included in the Ship's design to discombobulate.\n\n", shareStatus ? "your crew" : "you");
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Discombobulator");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				DiscombobulatorUpgradeConfiguration discombobulatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration;
				return discombobulatorUpgradeConfiguration.InitialEffect.Value + (float)level * discombobulatorUpgradeConfiguration.IncrementalEffect.Value;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetCooldownServerRpc(float cooldown)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1424881251u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref cooldown, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1424881251u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SetCooldownClientRpc(cooldown);
				}
			}
		}

		[ClientRpc]
		public void SetCooldownClientRpc(float cooldown)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(550063720u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref cooldown, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 550063720u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					flashCooldown = Mathf.Clamp(cooldown, 0f, SyncedEntry<float>.op_Implicit(BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.Cooldown));
				}
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Discombobulator", BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			UpgradeBus.Instance.flashNoise = AssetBundleHandler.GetAudioClip("Flashbang");
			BaseUpgrade.SetupGenericPerk<Discombobulator>("Discombobulator");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			AudioClip audioClip = AssetBundleHandler.GetAudioClip("Flashbang");
			if (!Object.op_Implicit((Object)(object)audioClip))
			{
				return null;
			}
			UpgradeBus.Instance.flashNoise = audioClip;
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Discombobulator", BaseUpgrade.GetConfiguration().DiscombobulatorUpgradeConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3612237191u, new RpcReceiveHandler(__rpc_handler_3612237191), "UseDiscombobulatorServerRpc");
			((NetworkBehaviour)this).__registerRpc(760292881u, new RpcReceiveHandler(__rpc_handler_760292881), "UseDiscombobulatorClientRpc");
			((NetworkBehaviour)this).__registerRpc(1424881251u, new RpcReceiveHandler(__rpc_handler_1424881251), "SetCooldownServerRpc");
			((NetworkBehaviour)this).__registerRpc(550063720u, new RpcReceiveHandler(__rpc_handler_550063720), "SetCooldownClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_3612237191(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Discombobulator)(object)target).UseDiscombobulatorServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_760292881(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Discombobulator)(object)target).UseDiscombobulatorClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1424881251(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float cooldownServerRpc = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref cooldownServerRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Discombobulator)(object)target).SetCooldownServerRpc(cooldownServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_550063720(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float cooldownClientRpc = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref cooldownClientRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Discombobulator)(object)target).SetCooldownClientRpc(cooldownClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Discombobulator";
		}
	}
	internal class FusionMatter : TierUpgrade, IUpgradeWorldBuilding
	{
		public enum ItemCategories
		{
			All,
			Tools,
			Scrap
		}

		internal const string UPGRADE_NAME = "Fusion Matter";

		internal const string DEFAULT_PRICES = "500, 650, 700";

		internal const string WORLD_BUILDING_TEXT = "\n\nBy default, the Ship's onboard Teleporter system is configured not to bring any objects along with it... but isn't it kind of strange how you don't arrive naked anytime you use the Teleporter? As it turns out, this limitation is imposed and not inherent. By requesting & signing a handful of certain liability waivers by their technical names and paying forward a series of fees, you can expand the capabilities of your Ship's Teleporter. The Teleporter can still only safely transport Company-issued equipment, since the rough dimensions of these objects are well-documented. The same cannot be said for salvage materials.\n\n";

		private static Dictionary<string, int> levels;

		private static Dictionary<ItemCategories, int> categoryLevels;

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = BaseUpgrade.GetConfiguration().FusionMatterConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nBy default, the Ship's onboard Teleporter system is configured not to bring any objects along with it... but isn't it kind of strange how you don't arrive naked anytime you use the Teleporter? As it turns out, this limitation is imposed and not inherent. By requesting & signing a handful of certain liability waivers by their technical names and paying forward a series of fees, you can expand the capabilities of your Ship's Teleporter. The Teleporter can still only safely transport Company-issued equipment, since the rough dimensions of these objects are well-documented. The same cannot be said for salvage materials.\n\n";
		}

		internal static void SetupLevels()
		{
			levels = new Dictionary<string, int>();
			categoryLevels = new Dictionary<ItemCategories, int>();
			string[] array = BaseUpgrade.GetConfiguration().FusionMatterConfiguration.TierCollection.Value.ToLower().Split('@');
			for (int i = 0; i < array.Length; i++)
			{
				foreach (string item in from x in array[i].Split(',')
					select x.Trim().ToLower())
				{
					ItemCategories result;
					if (levels.ContainsKey(item))
					{
						Plugin.mls.LogWarning((object)(item + " is already registered in the tiers collection of Fusion Matter"));
					}
					else if (Enum.TryParse<ItemCategories>(item, ignoreCase: true, out result) && !categoryLevels.ContainsKey(result))
					{
						Plugin.mls.LogInfo((object)string.Format("Registering \"{0}\" category under level {1} of {2}", item, i, "Fusion Matter"));
						categoryLevels[result] = i;
					}
					else
					{
						Plugin.mls.LogInfo((object)string.Format("Registering {0} item under level {1} of {2}", item, i, "Fusion Matter"));
						levels[item] = i;
					}
				}
			}
		}

		public static bool IsItemWithinCategory(GrabbableObject grabbableObject, ItemCategories category)
		{
			return category switch
			{
				ItemCategories.All => true, 
				ItemCategories.Tools => !grabbableObject.itemProperties.isScrap, 
				ItemCategories.Scrap => grabbableObject.itemProperties.isScrap, 
				_ => false, 
			};
		}

		public static bool CanHoldItem(GrabbableObject grabbableObject, PlayerControllerB player)
		{
			if ((Object)(object)grabbableObject == (Object)null || !player.IsTeleporting() || player.isPlayerDead)
			{
				return false;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Fusion Matter"))
			{
				return false;
			}
			bool flag = false;
			foreach (KeyValuePair<ItemCategories, int> categoryLevel in categoryLevels)
			{
				flag |= IsItemWithinCategory(grabbableObject, categoryLevel.Key) && BaseUpgrade.GetUpgradeLevel("Fusion Matter") >= categoryLevel.Value;
			}
			if (flag)
			{
				return flag;
			}
			string text = grabbableObject.itemProperties.itemName.Trim().ToLower();
			if (levels.TryGetValue(text, out var value))
			{
				Plugin.mls.LogDebug((object)$"{text} can be safeguarded by Fusion Matter at level {value + 1}");
				return BaseUpgrade.GetUpgradeLevel("Fusion Matter") >= value;
			}
			Plugin.mls.LogDebug((object)(text + " from item properties was not found, checking other sources..."));
			ScanNodeProperties componentInChildren = ((Component)grabbableObject).GetComponentInChildren<ScanNodeProperties>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Plugin.mls.LogDebug((object)(text + " does not contain a scan node, ran out of sources..."));
				return false;
			}
			text = componentInChildren.headerText.Trim().ToLower();
			if (levels.TryGetValue(text, out value))
			{
				Plugin.mls.LogDebug((object)$"{text} can be safeguarded by Fusion Matter at level {value + 1}");
				return BaseUpgrade.GetUpgradeLevel("Fusion Matter") >= value;
			}
			Plugin.mls.LogDebug((object)(text + " from scan node was not found, ran out of sources..."));
			return false;
		}

		private void Awake()
		{
			upgradeName = "Fusion Matter";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().FusionMatterConfiguration.OverrideName);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetFusionMatterInfo(0, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetFusionMatterInfo(i + 1, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public static string GetFusionMatterInfo(int level, int price)
		{
			IEnumerable<string> first = from item in levels
				where item.Value == level
				select item.Key;
			IEnumerable<string> second = from category in categoryLevels
				where category.Value == level
				select category.Key.ToString();
			string arg = string.Join(", ", first.Concat(second));
			return $"LVL {level + 1} - {BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().FusionMatterConfiguration.PurchaseMode))} - Allows safekeeping the following items when teleporting: {arg}\n";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Fusion Matter", BaseUpgrade.GetConfiguration().FusionMatterConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Fusion Matter");
			val.AddComponent<FusionMatter>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Fusion Matter"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			SetupLevels();
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Fusion Matter", UpgradeBus.Instance.PluginConfiguration.FusionMatterConfiguration, Plugin.networkPrefabs["Fusion Matter"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "FusionMatter";
		}
	}
	public class LifeInsurance : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Life Insurance";

		internal const string DEFAULT_PRICES = "200,200,250,300";

		internal const string WORLD_BUILDING_TEXT = "\n\nHigh-grossing departments that operate in sectors of severe risk can optimize body retrieval costs by essentially hiring the cleanup crew on a retainer. These arrangements are made Ship-to-Ship between individual Company Departments and require a lot of phonecalls and paperwork.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> lifeInsuranceConfiguration = BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration;
				string[] array = lifeInsuranceConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nHigh-grossing departments that operate in sectors of severe risk can optimize body retrieval costs by essentially hiring the cleanup crew on a retainer. These arrangements are made Ship-to-Ship between individual Company Departments and require a lot of phonecalls and paperwork.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Life Insurance";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration.OverrideName);
		}

		public static float CalculateDecreaseMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> lifeInsuranceConfiguration = BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(lifeInsuranceConfiguration.Enabled) || !BaseUpgrade.GetActiveUpgrade("Life Insurance"))
			{
				return 0f;
			}
			return (float)(SyncedEntry<int>.op_Implicit(lifeInsuranceConfiguration.InitialEffect) + SyncedEntry<int>.op_Implicit(lifeInsuranceConfiguration.IncrementalEffect) * BaseUpgrade.GetUpgradeLevel("Life Insurance")) / 100f;
		}

		public static float ReduceCreditCostPercentage(float defaultValue)
		{
			float num = CalculateDecreaseMultiplier();
			return Mathf.Clamp(1f - num, 0f, 1f) * defaultValue;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces the credit loss when leaving a body behind when exiting a moon by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> lifeInsuranceConfiguration = BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration;
				return lifeInsuranceConfiguration.InitialEffect.Value + level * lifeInsuranceConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Life Insurance", BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Life Insurance");
			val.AddComponent<LifeInsurance>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Life Insurance"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Life Insurance", BaseUpgrade.GetConfiguration().LifeInsuranceConfiguration, Plugin.networkPrefabs["Life Insurance"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LifeInsurance";
		}
	}
	internal class MidasTouch : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Midas Touch";

		internal const string DEFAULT_PRICES = "1000,1000,1500,1800,2000";

		internal const string WORLD_BUILDING_TEXT = "\n\nYour commitment to Company Standards & Values 3E-60-92-43 and adherence to Work Code & Ethics 429-A-71-36 has appeased The Company a little bit. The memories attached to objects handled by your department are among The Company's favorites to review.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> midasTouchConfiguration = BaseUpgrade.GetConfiguration().MidasTouchConfiguration;
				string[] array = midasTouchConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nYour commitment to Company Standards & Values 3E-60-92-43 and adherence to Work Code & Ethics 429-A-71-36 has appeased The Company a little bit. The memories attached to objects handled by your department are among The Company's favorites to review.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Midas Touch";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().MidasTouchConfiguration.OverrideName);
		}

		private static float GetIncreasedScrapValueMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> midasTouchConfiguration = BaseUpgrade.GetConfiguration().MidasTouchConfiguration;
			return (float)(SyncedEntry<int>.op_Implicit(midasTouchConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Midas Touch") * SyncedEntry<int>.op_Implicit(midasTouchConfiguration.IncrementalEffect)) / 100f;
		}

		public static float IncreaseScrapValue(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> midasTouchConfiguration = BaseUpgrade.GetConfiguration().MidasTouchConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(midasTouchConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Midas Touch"))
			{
				return defaultValue;
			}
			float increasedScrapValueMultiplier = GetIncreasedScrapValueMultiplier();
			return Mathf.Clamp(defaultValue + defaultValue * increasedScrapValueMultiplier, defaultValue, float.MaxValue);
		}

		public static int IncreaseScrapValueInteger(int defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> midasTouchConfiguration = BaseUpgrade.GetConfiguration().MidasTouchConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(midasTouchConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Midas Touch"))
			{
				return defaultValue;
			}
			float num = 1f + GetIncreasedScrapValueMultiplier();
			return Mathf.Clamp(Mathf.CeilToInt((float)defaultValue * num), defaultValue, int.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the value of the scrap found in the moons by {2}%.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().MidasTouchConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> midasTouchConfiguration = BaseUpgrade.GetConfiguration().MidasTouchConfiguration;
				return midasTouchConfiguration.InitialEffect.Value + level * midasTouchConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Midas Touch", BaseUpgrade.GetConfiguration().MidasTouchConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Midas Touch");
			val.AddComponent<MidasTouch>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Midas Touch"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Midas Touch", BaseUpgrade.GetConfiguration().MidasTouchConfiguration, Plugin.networkPrefabs["Midas Touch"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "MidasTouch";
		}
	}
	internal class ParticleInfuser : TierUpgrade, IUpgradeWorldBuilding
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass15_0
		{
			public ShipTeleporter teleporter;

			internal bool <ResetTeleporterSpeed>b__0()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				AnimatorStateInfo currentAnimatorStateInfo = teleporter.teleporterAnimator.GetCurrentAnimatorStateInfo(0);
				return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime < 1f;
			}
		}

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

			private object <>2__current;

			public ShipTeleporter teleporter;

			public ParticleInfuser <>4__this;

			private <>c__DisplayClass15_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass15_0();
					<>8__1.teleporter = teleporter;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitWhile((Func<bool>)delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						//IL_0011: Unknown result type (might be due to invalid IL or missing references)
						AnimatorStateInfo currentAnimatorStateInfo = <>8__1.teleporter.teleporterAnimator.GetCurrentAnimatorStateInfo(0);
						return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime < 1f;
					});
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					Animator teleporterAnimator = <>8__1.teleporter.teleporterAnimator;
					teleporterAnimator.speed /= IncreaseTeleportSpeed();
					AudioSource shipTeleporterAudio = <>8__1.teleporter.shipTeleporterAudio;
					shipTeleporterAudio.pitch /= IncreaseTeleportSpeed();
					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 const string UPGRADE_NAME = "Particle Infuser";

		internal const string DEFAULT_PRICES = "650,400,600";

		internal static ParticleInfuser instance;

		internal const string WORLD_BUILDING_TEXT = "\n\nThe original spooling process of the Ship's onboard Teleporter is overly long for legal reasons. There are several redundant safety checks that must be completed by the Ship's computer before the Teleporter system can fire. Under duress, it's actually more important that the Teleporter operates quickly than safely. Health complications will kill your coworker in a matter of months or years, but the facility will kill them in a matter of minutes or even seconds. Any amount of timesaving matters.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> particleInfuserConfiguration = BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration;
				string[] array = particleInfuserConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nThe original spooling process of the Ship's onboard Teleporter is overly long for legal reasons. There are several redundant safety checks that must be completed by the Ship's computer before the Teleporter system can fire. Under duress, it's actually more important that the Teleporter operates quickly than safely. Health complications will kill your coworker in a matter of months or years, but the facility will kill them in a matter of minutes or even seconds. Any amount of timesaving matters.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Particle Infuser";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration.OverrideName);
			instance = this;
		}

		public static float GetIncreasedTeleportSpeedMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> particleInfuserConfiguration = BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration;
			return (float)(SyncedEntry<int>.op_Implicit(particleInfuserConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Particle Infuser") * SyncedEntry<int>.op_Implicit(particleInfuserConfiguration.IncrementalEffect)) / 100f;
		}

		public static float DecreaseTeleportTime(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> particleInfuserConfiguration = BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(particleInfuserConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Particle Infuser"))
			{
				return defaultValue;
			}
			float increasedTeleportSpeedMultiplier = GetIncreasedTeleportSpeedMultiplier();
			return Mathf.Clamp(defaultValue - defaultValue * increasedTeleportSpeedMultiplier, 0f, defaultValue);
		}

		public static float IncreaseTeleportSpeed()
		{
			ITierEffectUpgradeConfiguration<int> particleInfuserConfiguration = BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(particleInfuserConfiguration.Enabled))
			{
				return 1f;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Particle Infuser"))
			{
				return 1f;
			}
			float increasedTeleportSpeedMultiplier = GetIncreasedTeleportSpeedMultiplier();
			return Mathf.Clamp(3f + increasedTeleportSpeedMultiplier, 1f, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the teleporter's speed by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> particleInfuserConfiguration = BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration;
				return particleInfuserConfiguration.InitialEffect.Value + level * particleInfuserConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Particle Infuser", BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Particle Infuser");
			val.AddComponent<ParticleInfuser>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Particle Infuser"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Particle Infuser", BaseUpgrade.GetConfiguration().ParticleInfuserConfiguration, Plugin.networkPrefabs["Particle Infuser"]);
		}

		[IteratorStateMachine(typeof(<ResetTeleporterSpeed>d__15))]
		public IEnumerator ResetTeleporterSpeed(ShipTeleporter teleporter)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResetTeleporterSpeed>d__15(0)
			{
				<>4__this = this,
				teleporter = teleporter
			};
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ParticleInfuser";
		}
	}
	public class QuantumDisruptor : TierUpgrade, IUpgradeWorldBuilding
	{
		public enum UpgradeModes
		{
			SlowdownTime,
			RevertTime
		}

		public enum ResetModes
		{
			MoonLanding,
			MoonRerouting,
			NewQuota
		}

		internal const string UPGRADE_NAME = "Quantum Disruptor";

		internal const string PRICES_DEFAULT = "1000,1200,1500,1800";

		internal const string WORLD_BUILDING_TEXT = "\n\nSigning the Overtime Risk Waiver and paying forward a series of fees authorizes your department to override the Ship's autopilot system and stay moonside for longer.\n\n";

		internal int availableUsages = -1;

		internal int currentUsages = 0;

		internal int hoursToReduce = -1;

		internal static QuantumDisruptor Instance { get; set; }

		internal static UpgradeModes CurrentMode => SyncedEntry<UpgradeModes>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.AlternativeMode);

		internal static ResetModes CurrentResetMode => SyncedEntry<ResetModes>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.ResetMode);

		public override bool CanInitializeOnStart
		{
			get
			{
				QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
				string[] array = quantumDisruptorConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private static void SetInstance(QuantumDisruptor instance)
		{
			Instance = instance;
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSigning the Overtime Risk Waiver and paying forward a series of fees authorizes your department to override the Ship's autopilot system and stay moonside for longer.\n\n";
		}

		private void Awake()
		{
			SetInstance(this);
			upgradeName = "Quantum Disruptor";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.OverrideName);
		}

		public override void Unwind()
		{
			switch (CurrentMode)
			{
			case UpgradeModes.SlowdownTime:
				base.Unwind();
				break;
			case UpgradeModes.RevertTime:
				availableUsages = -1;
				hoursToReduce = -1;
				base.Unwind();
				break;
			}
		}

		public override void Increment()
		{
			switch (CurrentMode)
			{
			case UpgradeModes.SlowdownTime:
				base.Increment();
				break;
			case UpgradeModes.RevertTime:
			{
				QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = quantumDisruptorConfiguration.GetEffectPair(1);
				(SyncedEntry<int>, SyncedEntry<int>) effectPair2 = quantumDisruptorConfiguration.GetEffectPair(2);
				availableUsages += SyncedEntry<int>.op_Implicit(effectPair.Item2);
				hoursToReduce += SyncedEntry<int>.op_Implicit(effectPair2.Item2);
				base.Increment();
				break;
			}
			}
		}

		public override void Load()
		{
			switch (CurrentMode)
			{
			case UpgradeModes.SlowdownTime:
				base.Load();
				break;
			case UpgradeModes.RevertTime:
			{
				QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = quantumDisruptorConfiguration.GetEffectPair(1);
				(SyncedEntry<int>, SyncedEntry<int>) effectPair2 = quantumDisruptorConfiguration.GetEffectPair(2);
				availableUsages = SyncedEntry<int>.op_Implicit(effectPair.Item1) + BaseUpgrade.GetUpgradeLevel("Quantum Disruptor") * SyncedEntry<int>.op_Implicit(effectPair.Item2);
				hoursToReduce = SyncedEntry<int>.op_Implicit(effectPair2.Item1) + BaseUpgrade.GetUpgradeLevel("Quantum Disruptor") * SyncedEntry<int>.op_Implicit(effectPair2.Item2);
				base.Load();
				break;
			}
			}
		}

		public static float GetGlobalSpeedMultiplier(float defaultValue)
		{
			QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(quantumDisruptorConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Quantum Disruptor"))
			{
				return defaultValue;
			}
			if (CurrentMode != 0)
			{
				return defaultValue;
			}
			(SyncedEntry<int>, SyncedEntry<int>) effectPair = quantumDisruptorConfiguration.GetEffectPair(0);
			float num = (float)(SyncedEntry<int>.op_Implicit(effectPair.Item1) + BaseUpgrade.GetUpgradeLevel("Quantum Disruptor") * SyncedEntry<int>.op_Implicit(effectPair.Item2)) / 100f;
			return Mathf.Clamp(defaultValue - defaultValue * num, 0.01f, defaultValue);
		}

		private string GetQuantumDisruptorRevertInfo(int level, int price)
		{
			string text = string.Empty;
			switch (CurrentResetMode)
			{
			case ResetModes.MoonLanding:
				text = "moon landing";
				break;
			case ResetModes.MoonRerouting:
				text = "moon routing";
				break;
			case ResetModes.NewQuota:
				text = "completed quota";
				break;
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (level == 1)
			{
				stringBuilder.Append($"LVL {level} - {BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.PurchaseMode))}: Unlocks 'quantum' command which reverts curret moon's time by {infoFunctionHours(level - 1)} hours and can only be used {infoFunctionUsages(level - 1)} times per {text}\n");
			}
			else
			{
				stringBuilder.Append($"LVL {level} - {BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.PurchaseMode))}: Reverts curret moon's time by {infoFunctionHours(level - 1)} hours and can only be used {infoFunctionUsages(level - 1)} times per {text}\n");
			}
			return stringBuilder.ToString();
			static float infoFunctionHours(int level)
			{
				QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration2 = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair2 = quantumDisruptorConfiguration2.GetEffectPair(2);
				return effectPair2.Item1.Value + level * effectPair2.Item2.Value;
			}
			static float infoFunctionUsages(int level)
			{
				QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = quantumDisruptorConfiguration.GetEffectPair(1);
				return effectPair.Item1.Value + level * effectPair.Item2.Value;
			}
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			switch (CurrentMode)
			{
			case UpgradeModes.SlowdownTime:
				return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Decreases the landed moon's rotation force (time passing) by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.PurchaseMode));
			case UpgradeModes.RevertTime:
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(GetQuantumDisruptorRevertInfo(1, initialPrice));
				for (int i = 0; i < maxLevels; i++)
				{
					stringBuilder.Append(GetQuantumDisruptorRevertInfo(i + 2, incrementalPrices[i]));
				}
				return stringBuilder.ToString();
			}
			default:
				return string.Empty;
			}
			static float infoFunction(int level)
			{
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.GetEffectPair(0);
				return effectPair.Item1.Value + level * effectPair.Item2.Value;
			}
		}

		internal (bool, string) CanRevertTime()
		{
			if (CurrentMode != UpgradeModes.RevertTime)
			{
				return (false, "This command is not available for selected '" + overridenUpgradeName + "' upgrade.\n");
			}
			if (StartOfRound.Instance.inShipPhase)
			{
				return (false, "Cannot execute this command while in orbit.\n");
			}
			if (!StartOfRound.Instance.shipHasLanded)
			{
				return (false, "Cannot execute this command while landing on a moon.\n");
			}
			if (!TimeOfDay.Instance.currentDayTimeStarted)
			{
				return (false, "Cannot execute this command during a time freeze.\n");
			}
			float globalTime = TimeOfDay.Instance.globalTime;
			globalTime -= TimeOfDay.Instance.lengthOfHours * (float)hoursToReduce;
			if (globalTime < 0f)
			{
				return (false, "This command cannot be executed due to the new time being before you started landing on the moon (Leads to negative time).\n");
			}
			string text = string.Empty;
			switch (CurrentResetMode)
			{
			case ResetModes.MoonLanding:
				text = "Come back to orbit";
				break;
			case ResetModes.MoonRerouting:
				text = "Route to a different moon";
				break;
			case ResetModes.NewQuota:
				text = "Finish your current quota";
				break;
			}
			return (currentUsages < availableUsages, "Reached maximum amount of usages during this moon trip. " + text + " to recharge the disruptor.\n");
		}

		internal void TryResetValues(ResetModes requestedMode)
		{
			if (CurrentMode == UpgradeModes.RevertTime && CurrentResetMode == requestedMode)
			{
				ResetUsageCounterClientRpc();
			}
		}

		internal static void TryResetQuantum(ResetModes mode)
		{
			QuantumDisruptorUpgradeConfiguration quantumDisruptorConfiguration = BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration;
			if (SyncedEntry<bool>.op_Implicit(quantumDisruptorConfiguration.Enabled) && ((NetworkBehaviour)Instance).IsHost)
			{
				Instance.TryResetValues(mode);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void RevertTimeServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(211342570u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 211342570u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					RevertTimeClientRpc();
				}
			}
		}

		[ClientRpc]
		internal void RevertTimeClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3272842575u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3272842575u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					RevertTime();
				}
			}
		}

		internal void RevertTime()
		{
			float num = TimeOfDay.Instance.lengthOfHours * (float)hoursToReduce;
			TimeOfDay instance = TimeOfDay.Instance;
			instance.globalTime -= num;
			TimeOfDay instance2 = TimeOfDay.Instance;
			instance2.timeUntilDeadline += num;
			currentUsages++;
		}

		[ClientRpc]
		internal void ResetUsageCounterClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2403649136u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2403649136u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ResetUsageCounter();
				}
			}
		}

		internal void ResetUsageCounter()
		{
			currentUsages = 0;
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Quantum Disruptor", BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<QuantumDisruptor>("Quantum Disruptor");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Quantum Disruptor", BaseUpgrade.GetConfiguration().QuantumDisruptorConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(211342570u, new RpcReceiveHandler(__rpc_handler_211342570), "RevertTimeServerRpc");
			((NetworkBehaviour)this).__registerRpc(3272842575u, new RpcReceiveHandler(__rpc_handler_3272842575), "RevertTimeClientRpc");
			((NetworkBehaviour)this).__registerRpc(2403649136u, new RpcReceiveHandler(__rpc_handler_2403649136), "ResetUsageCounterClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_211342570(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((QuantumDisruptor)(object)target).RevertTimeServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3272842575(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((QuantumDisruptor)(object)target).RevertTimeClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2403649136(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((QuantumDisruptor)(object)target).ResetUsageCounterClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "QuantumDisruptor";
		}
	}
	internal class ScavengerInstincts : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Scavenger Instincts";

		internal const string DEFAULT_PRICES = "800,800,1000,1200,1400";

		internal const string WORLD_BUILDING_TEXT = "\n\nAfter spending a lot of time in the facility, you begin to notice certain patterns in the location of valuable objects. Your department's output increases, but the implications are disturbing.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> scavengerInstictsConfiguration = BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration;
				string[] array = scavengerInstictsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nAfter spending a lot of time in the facility, you begin to notice certain patterns in the location of valuable objects. Your department's output increases, but the implications are disturbing.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Scavenger Instincts";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration.OverrideName);
		}

		public static int IncreaseScrapAmount(int defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> scavengerInstictsConfiguration = BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(scavengerInstictsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Scavenger Instincts"))
			{
				return defaultValue;
			}
			int num = scavengerInstictsConfiguration.InitialEffect.Value + BaseUpgrade.GetUpgradeLevel("Scavenger Instincts") * scavengerInstictsConfiguration.IncrementalEffect.Value;
			return Mathf.Clamp(defaultValue + Mathf.CeilToInt((float)num / RoundManager.Instance.scrapAmountMultiplier), defaultValue, int.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the average amount of scrap spawns by {2} additional items.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> scavengerInstictsConfiguration = BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration;
				return scavengerInstictsConfiguration.InitialEffect.Value + level * scavengerInstictsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Scavenger Instincts", BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ScavengerInstincts>("Scavenger Instincts");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Scavenger Instincts", BaseUpgrade.GetConfiguration().ScavengerInstictsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ScavengerInstincts";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Player
{
	internal class BetterScanner : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Better Scanner";

		internal const string WORLD_BUILDING_TEXT = "\n\nSubscription to 'Stuff Finders' magazine, which comes in three tiers; 'Basic Subscription', 'Pro Package', and 'Diamond Membership'. The magazine comes every week, but the contents of it are always the same, even the ads. Some departments use unwanted issuances of 'Stuff Finders' as toilet paper.\n\n";

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.Price.Value <= 0 && BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.SecondPrice.Value <= 0 && BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.ThirdPrice.Value <= 0;

		internal override void Start()
		{
			upgradeName = "Better Scanner";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.OverrideName);
			base.Start();
		}

		public override void Load()
		{
			base.Load();
			if (GoodItemScanCompat.Enabled)
			{
				BetterScannerUpgradeConfiguration betterScannerUpgradeConfiguration = BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration;
				GoodItemScanCompat.IncreaseScanDistance((int)SyncedEntry<float>.op_Implicit(betterScannerUpgradeConfiguration.NodeRangeIncrease));
				GoodItemScanCompat.IncreaseEnemyScanDistance((int)SyncedEntry<float>.op_Implicit(betterScannerUpgradeConfiguration.NodeRangeIncrease));
				int upgradeLevel = BaseUpgrade.GetUpgradeLevel("Better Scanner");
				if (upgradeLevel == 2)
				{
					GoodItemScanCompat.ToggleScanThroughWalls(scanThroughWalls: true);
				}
			}
		}

		public override void Increment()
		{
			base.Increment();
			if (GoodItemScanCompat.Enabled)
			{
				int upgradeLevel = BaseUpgrade.GetUpgradeLevel("Better Scanner");
				if (upgradeLevel == 2)
				{
					GoodItemScanCompat.ToggleScanThroughWalls(scanThroughWalls: true);
				}
			}
		}

		public static void AddScannerNodeToValve(ref SteamValveHazard steamValveHazard)
		{
			if (BaseUpgrade.GetActiveUpgrade("Better Scanner"))
			{
				LguScanNodeProperties.AddGeneralScanNode(((Component)steamValveHazard).gameObject, "Bursted Steam Valve", "Fix it to get rid of the steam", -1, 3);
			}
		}

		public static void AddScannerNodeToEntrance(ref EntranceTeleport entrance)
		{
			if (BaseUpgrade.GetActiveUpgrade("Better Scanner") && entrance.isEntranceToBuilding)
			{
				LguScanNodeProperties.AddGeneralScanNode(((Component)entrance).gameObject, "Entrance Point", "", -1, 0, Mathf.CeilToInt(UpgradeBus.Instance.PluginConfiguration.BetterScannerUpgradeConfiguration.OutsideNodesRangeIncrease.Value), requiresLineOfSight: false);
			}
		}

		public static void RemoveScannerNodeFromValve(ref SteamValveHazard steamValveHazard)
		{
			LguScanNodeProperties.RemoveScanNode(((Component)steamValveHazard).gameObject);
		}

		public static int GetAdditionalMaximumScanNodeRange(int defaultValue, ScanNodeProperties scanNode)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Better Scanner"))
			{
				return defaultValue;
			}
			string text = scanNode.headerText.ToLower().Trim();
			string text2 = text;
			float num = ((!(text2 == "main entrance") && !(text2 == "ship")) ? SyncedEntry<float>.op_Implicit(BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.NodeRangeIncrease) : SyncedEntry<float>.op_Implicit(BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.OutsideNodesRangeIncrease));
			return Mathf.CeilToInt((float)defaultValue + num);
		}

		public static bool CanSeeScrapThroughWall(ScanNodeProperties scanNode)
		{
			return BaseUpgrade.GetActiveUpgrade("Better Scanner") && BaseUpgrade.GetUpgradeLevel("Better Scanner") == 2 && scanNode.nodeType == 2;
		}

		public static bool CanSeeEnemiesThroughWall(ScanNodeProperties scanNode)
		{
			return BaseUpgrade.GetActiveUpgrade("Better Scanner") && BaseUpgrade.GetUpgradeLevel("Better Scanner") == 2 && scanNode.nodeType == 1 && SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.SeeEnemiesThroughWalls);
		}

		public static string GetBetterScannerInfo(int level, int price)
		{
			BetterScannerUpgradeConfiguration betterScannerUpgradeConfiguration = BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration;
			switch (level)
			{
			case 1:
				return string.Format(AssetBundleHandler.GetInfoFromJSON("Better Scanner1"), level, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(betterScannerUpgradeConfiguration.PurchaseMode)), betterScannerUpgradeConfiguration.NodeRangeIncrease.Value, betterScannerUpgradeConfiguration.OutsideNodesRangeIncrease.Value);
			case 2:
				return string.Format(AssetBundleHandler.GetInfoFromJSON("Better Scanner2"), level, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(betterScannerUpgradeConfiguration.PurchaseMode)));
			case 3:
			{
				string text = string.Format(AssetBundleHandler.GetInfoFromJSON("Better Scanner3"), level, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(betterScannerUpgradeConfiguration.PurchaseMode)), betterScannerUpgradeConfiguration.SeeEnemiesThroughWalls.Value ? " and enemies" : "");
				return text + "hives and scrap command display the location of the most valuable hives and scrap on the map.\n";
			}
			default:
				return "";
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSubscription to 'Stuff Finders' magazine, which comes in three tiers; 'Basic Subscription', 'Pro Package', and 'Diamond Membership'. The magazine comes every week, but the contents of it are always the same, even the ads. Some departments use unwanted issuances of 'Stuff Finders' as toilet paper.\n\n";
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetBetterScannerInfo(1, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetBetterScannerInfo(i + 2, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<BetterScanner>("Better Scanner");
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Better Scanner", BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			BetterScannerUpgradeConfiguration betterScannerUpgradeConfiguration = BaseUpgrade.GetConfiguration().BetterScannerUpgradeConfiguration;
			PurchaseMode purchaseMode = SyncedEntry<PurchaseMode>.op_Implicit(SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().AlternativeCurrencyConfiguration.EnableGlobalPurchase) ? BaseUpgrade.GetConfiguration().AlternativeCurrencyConfiguration.GlobalPurchaseMode : betterScannerUpgradeConfiguration.PurchaseMode);
			bool refundable = SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().REFUND_UPGRADES) || SyncedEntry<bool>.op_Implicit(betterScannerUpgradeConfiguration.Refundable);
			float refundPercentage = (float)SyncedEntry<int>.op_Implicit(betterScannerUpgradeConfiguration.RefundPercentage) / 100f;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Better Scanner", BaseUpgrade.GetConfiguration().SHARED_UPGRADES.Value || !betterScannerUpgradeConfiguration.Individual.Value, betterScannerUpgradeConfiguration.Enabled.Value, betterScannerUpgradeConfiguration.Price.Value, new int[2]
			{
				betterScannerUpgradeConfiguration.SecondPrice.Value,
				betterScannerUpgradeConfiguration.ThirdPrice.Value
			}, SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(betterScannerUpgradeConfiguration.OverrideName) : "", CurrencyManager.Enabled, purchaseMode, refundable, refundPercentage);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BetterScanner";
		}
	}
	internal class CarbonKneejoints : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Carbon Kneejoints";

		internal const string DEFAULT_PRICES = "100,50,100,150";

		internal const string WORLD_BUILDING_TEXT = "\n\nSpecial kneebrace & lower body harness system that supports your joints. Makes you feel prepared to sneak around. Also makes your butt look amazing.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration carbonKneejointsConfiguration = BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration;
				string[] array = carbonKneejointsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Carbon Kneejoints";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration.OverrideName);
		}

		public static float CalculateDecreaseMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> carbonKneejointsConfiguration = BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(carbonKneejointsConfiguration.Enabled) || !BaseUpgrade.GetActiveUpgrade("Carbon Kneejoints"))
			{
				return 0f;
			}
			return (float)(SyncedEntry<int>.op_Implicit(carbonKneejointsConfiguration.InitialEffect) + SyncedEntry<int>.op_Implicit(carbonKneejointsConfiguration.IncrementalEffect) * BaseUpgrade.GetUpgradeLevel("Carbon Kneejoints")) / 100f;
		}

		public static float ReduceCrouchMovementSpeedDebuff(float defaultValue)
		{
			float num = CalculateDecreaseMultiplier();
			float num2 = 1f - defaultValue;
			return defaultValue - Mathf.Clamp(1f - num, 0f, 1f) * num2;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces the movement speed loss while crouching by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> carbonKneejointsConfiguration = BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration;
				return carbonKneejointsConfiguration.InitialEffect.Value + level * carbonKneejointsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Carbon Kneejoints", BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Carbon Kneejoints");
			val.AddComponent<CarbonKneejoints>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Carbon Kneejoints"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Carbon Kneejoints", BaseUpgrade.GetConfiguration().CarbonKneejointsConfiguration, Plugin.networkPrefabs["Carbon Kneejoints"]);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSpecial kneebrace & lower body harness system that supports your joints. Makes you feel prepared to sneak around. Also makes your butt look amazing.\n\n";
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "CarbonKneejoints";
		}
	}
	internal class DeepPockets : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Deeper Pockets";

		internal const string DEFAULT_PRICES = "500,750";

		internal const string WORLD_BUILDING_TEXT = "In the 'GEAR' section of the Company Catalogue, in the middle of the second page, there is an advert for this. It's basically just a requisition of carabiners and bungee cords, but it's being marketed aggressively as a life-changing solution for hauling scrap.";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration deeperPocketsConfiguration = BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration;
				string[] array = deeperPocketsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "In the 'GEAR' section of the Company Catalogue, in the middle of the second page, there is an advert for this. It's basically just a requisition of carabiners and bungee cords, but it's being marketed aggressively as a life-changing solution for hauling scrap.";
		}

		internal override void Start()
		{
			upgradeName = "Deeper Pockets";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the two handed carry capacity of the player by {2}\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				DeeperPocketsUpgradeConfiguration deeperPocketsConfiguration = BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration;
				return deeperPocketsConfiguration.InitialEffect.Value + level * deeperPocketsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Deeper Pockets", BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<DeepPockets>("Deeper Pockets");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Deeper Pockets", BaseUpgrade.GetConfiguration().DeeperPocketsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "DeepPockets";
		}
	}
	internal class EffectiveBandaids : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Effective Bandaids";

		internal const string DEFAULT_PRICES = "250,300,400,550";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration effectiveBandaidsConfiguration = BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration;
				string[] array = effectiveBandaidsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Effective Bandaids";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the amount of health regenerated by {2}\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> effectiveBandaidsConfiguration = BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration;
				return effectiveBandaidsConfiguration.InitialEffect.Value + level * effectiveBandaidsConfiguration.IncrementalEffect.Value;
			}
		}

		public static int GetIncreasedHealthRegenerated(int defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> effectiveBandaidsConfiguration = BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(effectiveBandaidsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Effective Bandaids"))
			{
				return defaultValue;
			}
			int num = SyncedEntry<int>.op_Implicit(effectiveBandaidsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Effective Bandaids") * SyncedEntry<int>.op_Implicit(effectiveBandaidsConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, Stimpack.CheckForAdditionalHealth(100));
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Effective Bandaids", BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Effective Bandaids");
			val.AddComponent<EffectiveBandaids>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Effective Bandaids"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Effective Bandaids", BaseUpgrade.GetConfiguration().EffectiveBandaidsConfiguration, Plugin.networkPrefabs["Effective Bandaids"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "EffectiveBandaids";
		}
	}
	internal class HikingBoots : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Hiking Boots";

		internal const string PRICES_DEFAULT = "75,100,150,175";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the 'GEAR' section of the Company Catalogue, the very last ad on the thirtieth page is for this product. It's a requisition of calf-length boots made of flexible synthetic fiber. Supports your ankles while walking on inclines, allowing your gait to adjust more effortlessly.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration hikingBootsConfiguration = BaseUpgrade.GetConfiguration().HikingBootsConfiguration;
				string[] array = hikingBootsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the 'GEAR' section of the Company Catalogue, the very last ad on the thirtieth page is for this product. It's a requisition of calf-length boots made of flexible synthetic fiber. Supports your ankles while walking on inclines, allowing your gait to adjust more effortlessly.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Hiking Boots";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().HikingBootsConfiguration.OverrideName);
		}

		private static float ComputeUphillSlopeDebuffMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> hikingBootsConfiguration = BaseUpgrade.GetConfiguration().HikingBootsConfiguration;
			return 1f - (float)(SyncedEntry<int>.op_Implicit(hikingBootsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Hiking Boots") * SyncedEntry<int>.op_Implicit(hikingBootsConfiguration.IncrementalEffect)) / 100f;
		}

		public static float ReduceUphillSlopeDebuff(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().HikingBootsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Hiking Boots"))
			{
				return defaultValue;
			}
			float num = ComputeUphillSlopeDebuffMultiplier();
			return Mathf.Clamp(defaultValue * num, 0f, defaultValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces the movement speed change when going through slopes by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().HikingBootsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> hikingBootsConfiguration = BaseUpgrade.GetConfiguration().HikingBootsConfiguration;
				return hikingBootsConfiguration.InitialEffect.Value + level * hikingBootsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Hiking Boots", BaseUpgrade.GetConfiguration().HikingBootsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<HikingBoots>("Hiking Boots");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Hiking Boots", BaseUpgrade.GetConfiguration().HikingBootsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "HikingBoots";
		}
	}
	internal class MechanicalArms : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Mechanical Arms";

		internal const string PRICES_DEFAULT = "300,400,600,800";

		internal const string WORLD_BUILDING_TEXT = "\n\nYou were pricked by a weirdly sharp metal fragment in the facility one day. You fell ill and collapsed for twenty minutes and awoke feeling bizarre. Ever since then, for some reason, you've been able to grab items and open doors from further away.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<float> mechanicalArmsConfiguration = BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration;
				string[] array = mechanicalArmsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nYou were pricked by a weirdly sharp metal fragment in the facility one day. You fell ill and collapsed for twenty minutes and awoke feeling bizarre. Ever since then, for some reason, you've been able to grab items and open doors from further away.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Mechanical Arms";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration.OverrideName);
			base.Start();
		}

		public static float GetIncreasedGrabDistance(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<float> mechanicalArmsConfiguration = BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(mechanicalArmsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Mechanical Arms"))
			{
				return defaultValue;
			}
			float num = SyncedEntry<float>.op_Implicit(mechanicalArmsConfiguration.InitialEffect) + (float)BaseUpgrade.GetUpgradeLevel("Mechanical Arms") * SyncedEntry<float>.op_Implicit(mechanicalArmsConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the player's interaction range by {2} units.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<float> mechanicalArmsConfiguration = BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration;
				return mechanicalArmsConfiguration.InitialEffect.Value + (float)level * mechanicalArmsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Mechanical Arms", BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<MechanicalArms>("Mechanical Arms");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Mechanical Arms", BaseUpgrade.GetConfiguration().MechanicalArmsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "MechanicalArms";
		}
	}
	internal class MedicalNanobots : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Medical Nanobots";

		internal const string DEFAULT_PRICES = "300,400,500,750";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration medicalNanobotsConfiguration = BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration;
				string[] array = medicalNanobotsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Medical Nanobots";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the player's health regeneration cap by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> medicalNanobotsConfiguration = BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration;
				return medicalNanobotsConfiguration.InitialEffect.Value + level * medicalNanobotsConfiguration.IncrementalEffect.Value;
			}
		}

		public static int GetIncreasedHealthRegeneration(int defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> medicalNanobotsConfiguration = BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(medicalNanobotsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Medical Nanobots"))
			{
				return defaultValue;
			}
			float num = (float)(SyncedEntry<int>.op_Implicit(medicalNanobotsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Medical Nanobots") * SyncedEntry<int>.op_Implicit(medicalNanobotsConfiguration.IncrementalEffect)) / 100f;
			return Mathf.Clamp(defaultValue + (int)((float)defaultValue * num), defaultValue, Stimpack.CheckForAdditionalHealth(100));
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Medical Nanobots", BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Medical Nanobots");
			val.AddComponent<MedicalNanobots>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Medical Nanobots"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Medical Nanobots", BaseUpgrade.GetConfiguration().MedicalNanobotsConfiguration, Plugin.networkPrefabs["Medical Nanobots"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "MedicalNanobots";
		}
	}
	internal class NightVision : TierUpgrade, IPlayerSync, IUpgradeWorldBuilding
	{
		[CompilerGenerated]
		private sealed class <BatteryRecovery>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NightVision <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration.ExhaustTime.Value);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.batteryExhaustion = false;
					return false;
				}
			}

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

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

		private float nightBattery;

		private PlayerControllerB client;

		public bool batteryExhaustion;

		internal GameObject nightVisionPrefab;

		internal bool nightVisionActive = false;

		internal float nightVisRange;

		internal float nightVisIntensity;

		internal Color nightVisColor;

		public const string SIMPLE_UPGRADE_NAME = "Night Vision";

		public const string UPGRADE_NAME = "NV Headset Batteries";

		public const string PRICES_DEFAULT = "300,400,500";

		internal const string WORLD_BUILDING_TEXT = "\n\nService package for your crew's Night Vision Headset that optimizes the function of its capacitor, leading to improved uptime and shorter recharge period.\n\n";

		private static readonly LguLogger logger = new LguLogger("NV Headset Batteries");

		public static NightVision Instance { get; internal set; }

		public override bool CanInitializeOnStart
		{
			get
			{
				NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
				string[] array = nightVisionUpgradeConfiguration.Prices.Value.Split(',');
				return nightVisionUpgradeConfiguration.ItemPrice.Value <= 0 && array.Length == 1 && (array[0].Length == 0 || array[0] == "0");
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nService package for your crew's Night Vision Headset that optimizes the function of its capacitor, leading to improved uptime and shorter recharge period.\n\n";
		}

		private void Awake()
		{
			Instance = this;
			upgradeName = "NV Headset Batteries";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration.OverrideName);
			nightVisionPrefab = AssetBundleHandler.GetItemObject("Night Vision").spawnPrefab;
		}

		internal override void Start()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			((Graphic)((Component)((Component)this).transform.GetChild(0).GetChild(0)).GetComponent<Image>()).color = Tools.ConvertValueToColor(nightVisionUpgradeConfiguration.BarColour.LocalValue, Color.green);
			((Graphic)((Component)((Component)this).transform.GetChild(0).GetChild(1)).GetComponent<Text>()).color = Tools.ConvertValueToColor(nightVisionUpgradeConfiguration.TextColour.LocalValue, Color.white);
			((Graphic)((Component)((Component)this).transform.GetChild(0).GetChild(2)).GetComponent<Image>()).color = Tools.ConvertValueToColor(nightVisionUpgradeConfiguration.BarColour.LocalValue, Color.green);
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(false);
		}

		private void LateUpdate()
		{
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)client == (Object)null)
			{
				return;
			}
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			float num = nightVisionUpgradeConfiguration.InitialEffects[0].Value + (float)(BaseUpgrade.GetUpgradeLevel("NV Headset Batteries") + 1) * nightVisionUpgradeConfiguration.IncrementalEffects[0].Value;
			if (nightVisionActive)
			{
				nightBattery -= Time.deltaTime * (nightVisionUpgradeConfiguration.InitialEffects[2].Value - (float)(BaseUpgrade.GetUpgradeLevel("NV Headset Batteries") + 1) * nightVisionUpgradeConfiguration.IncrementalEffects[2].Value);
				nightBattery = Mathf.Clamp(nightBattery, 0f, num);
				((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(true);
				if (nightBattery <= 0f)
				{
					TurnOff(exhaust: true);
				}
			}
			else if (!batteryExhaustion)
			{
				nightBattery += Time.deltaTime * (nightVisionUpgradeConfiguration.InitialEffects[1].Value + (float)(BaseUpgrade.GetUpgradeLevel("NV Headset Batteries") + 1) * nightVisionUpgradeConfiguration.IncrementalEffects[1].Value);
				nightBattery = Mathf.Clamp(nightBattery, 0f, num);
				if (nightBattery >= num)
				{
					((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(false);
				}
				else
				{
					((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(true);
				}
			}
			((Behaviour)client.nightVision).enabled = client.isInsideFactory || nightVisionActive;
			float num2 = nightBattery / num;
			((Component)this).transform.GetChild(0).GetChild(0).localScale = new Vector3(num2, 1f, 1f);
		}

		public void Toggle()
		{
			if (BaseUpgrade.GetActiveUpgrade("Night Vision") && !UpgradeBus.Instance.GetLocalPlayer().inTerminalMenu)
			{
				nightVisionActive = !nightVisionActive;
				if ((Object)(object)client == (Object)null)
				{
					client = GameNetworkManager.Instance.localPlayerController;
				}
				if (nightVisionActive)
				{
					TurnOn();
				}
				else
				{
					TurnOff();
				}
			}
		}

		private void TurnOff(bool exhaust = false)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			nightVisionActive = false;
			client.nightVision.color = nightVisColor;
			client.nightVision.range = nightVisRange;
			client.nightVision.intensity = nightVisIntensity;
			if (exhaust)
			{
				batteryExhaustion = true;
				((MonoBehaviour)this).StartCoroutine(BatteryRecovery());
			}
		}

		private void TurnOn()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			nightVisColor = client.nightVision.color;
			nightVisRange = client.nightVision.range;
			nightVisIntensity = client.nightVision.intensity;
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			client.nightVision.color = Tools.ConvertValueToColor(nightVisionUpgradeConfiguration.LightColour.LocalValue, Color.green);
			client.nightVision.range = nightVisionUpgradeConfiguration.InitialEffects[3].Value + (float)BaseUpgrade.GetUpgradeLevel("NV Headset Batteries") * nightVisionUpgradeConfiguration.IncrementalEffects[3].Value;
			client.nightVision.intensity = nightVisionUpgradeConfiguration.InitialEffects[4].Value + (float)BaseUpgrade.GetUpgradeLevel("NV Headset Batteries") * nightVisionUpgradeConfiguration.IncrementalEffects[4].Value;
			nightBattery -= nightVisionUpgradeConfiguration.StartupPercentage.Value;
		}

		[IteratorStateMachine(typeof(<BatteryRecovery>d__24))]
		private IEnumerator BatteryRecovery()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BatteryRecovery>d__24(0)
			{
				<>4__this = this
			};
		}

		public override void Load()
		{
			base.Load();
			if (BaseUpgrade.GetActiveUpgrade("Night Vision"))
			{
				EnableOnClient();
			}
		}

		public override void Unwind()
		{
			base.Unwind();
			if (BaseUpgrade.GetActiveUpgrade("Night Vision"))
			{
				DisableOnClient();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EnableNightVisionServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(369455900u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 369455900u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					logger.LogDebug("Enabling night vision for all clients...");
					EnableNightVisionClientRpc();
				}
			}
		}

		[ClientRpc]
		private void EnableNightVisionClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2005067157u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2005067157u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					logger.LogDebug("Request to enable night vision on this client received.");
					EnableOnClient();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnNightVisionItemOnDeathServerRpc(Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1636884937u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1636884937u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = Object.Instantiate<GameObject>(nightVisionPrefab, position + Vector3.up, Quaternion.identity);
					val3.GetComponent<NetworkObject>().Spawn(false);
					logger.LogInfo("Request to spawn night vision goggles received.");
				}
			}
		}

		public void EnableOnClient()
		{
			if ((Object)(object)client == (Object)null)
			{
				client = GameNetworkManager.Instance.localPlayerController;
			}
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(true);
			UpgradeBus.Instance.activeUpgrades["Night Vision"] = true;
			TextMeshProUGUI chatText = HUDManager.Instance.chatText;
			((TMP_Text)chatText).text = ((TMP_Text)chatText).text + "\n<color=#FF0000>Press " + InputActionRebindingExtensions.GetBindingDisplayString(Keybinds.NvgAction, (DisplayStringOptions)0, (string)null) + " to toggle Night Vision!!!</color>";
		}

		public void DisableOnClient()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			nightVisionActive = false;
			if ((Object)(object)client != (Object)null && (Object)(object)client.nightVision != (Object)null)
			{
				client.nightVision.color = nightVisColor;
				client.nightVision.range = nightVisRange;
				client.nightVision.intensity = nightVisIntensity;
			}
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(false);
			UpgradeBus.Instance.activeUpgrades["Night Vision"] = false;
			client = null;
		}

		public static string GetNightVisionInfo(int level, int price)
		{
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			float num = Mathf.Clamp(nightVisionUpgradeConfiguration.InitialEffects[1].Value + nightVisionUpgradeConfiguration.IncrementalEffects[1].Value * (float)level, 0f, 1000f);
			float num2 = Mathf.Clamp(nightVisionUpgradeConfiguration.InitialEffects[2].Value - nightVisionUpgradeConfiguration.IncrementalEffects[2].Value * (float)level, 0f, 1000f);
			float num3 = nightVisionUpgradeConfiguration.InitialEffects[0].Value + nightVisionUpgradeConfiguration.IncrementalEffects[0].Value * (float)level;
			string text = "infinite";
			if (num2 != 0f)
			{
				text = ((num3 - num3 * nightVisionUpgradeConfiguration.StartupPercentage.Value) / num2).ToString("F2");
			}
			string text2 = "infinite";
			if (num != 0f)
			{
				text2 = (num3 / num).ToString("F2");
			}
			return string.Format(AssetBundleHandler.GetInfoFromJSON("NV Headset Batteries"), level, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(nightVisionUpgradeConfiguration.PurchaseMode)), text, text2);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			float num = (nightVisionUpgradeConfiguration.InitialEffects[0].Value - nightVisionUpgradeConfiguration.IncrementalEffects[0].Value * nightVisionUpgradeConfiguration.StartupPercentage.Value) / nightVisionUpgradeConfiguration.InitialEffects[2].Value;
			float num2 = nightVisionUpgradeConfiguration.InitialEffects[0].Value / nightVisionUpgradeConfiguration.InitialEffects[1].Value;
			stringBuilder.Append($"The affected item (Night vision Googles) has a base drain time to empty of {num} seconds and regeneration time to full of {num2} seconds.\n\n");
			stringBuilder.Append(GetNightVisionInfo(1, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetNightVisionInfo(i + 2, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("NV Headset Batteries", BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<NightVision>("NV Headset Batteries");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			NightVisionUpgradeConfiguration nightVisionUpgradeConfiguration = BaseUpgrade.GetConfiguration().NightVisionUpgradeConfiguration;
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("NV Headset Batteries", nightVisionUpgradeConfiguration);
		}

		public void ResetPlayerAttribute()
		{
			if (!((Object)(object)client == (Object)null))
			{
				DisableOnClient();
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(369455900u, new RpcReceiveHandler(__rpc_handler_369455900), "EnableNightVisionServerRpc");
			((NetworkBehaviour)this).__registerRpc(2005067157u, new RpcReceiveHandler(__rpc_handler_2005067157), "EnableNightVisionClientRpc");
			((NetworkBehaviour)this).__registerRpc(1636884937u, new RpcReceiveHandler(__rpc_handler_1636884937), "SpawnNightVisionItemOnDeathServerRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_369455900(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((NightVision)(object)target).EnableNightVisionServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2005067157(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((NightVision)(object)target).EnableNightVisionClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1636884937(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((NightVision)(object)target).SpawnNightVisionItemOnDeathServerRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "NightVision";
		}
	}
	public class OxygenCanisters : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Oxygen Canisters";

		internal const string DEFAULT_PRICES = "100,100,200,400";

		internal const string WORLD_BUILDING_TEXT = "\n\nPremium Condensed Air Tanks from OxyCo that come in a variety of flavors.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> oxygenCanistersConfiguration = BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration;
				string[] array = oxygenCanistersConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nPremium Condensed Air Tanks from OxyCo that come in a variety of flavors.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Oxygen Canisters";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration.OverrideName);
		}

		public static float CalculateDecreaseMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> oxygenCanistersConfiguration = BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(oxygenCanistersConfiguration.Enabled) || !BaseUpgrade.GetActiveUpgrade("Oxygen Canisters"))
			{
				return 0f;
			}
			return (float)(SyncedEntry<int>.op_Implicit(oxygenCanistersConfiguration.InitialEffect) + SyncedEntry<int>.op_Implicit(oxygenCanistersConfiguration.IncrementalEffect) * BaseUpgrade.GetUpgradeLevel("Oxygen Canisters")) / 100f;
		}

		public static float ReduceOxygenConsumption(float defaultValue)
		{
			float num = CalculateDecreaseMultiplier();
			return Mathf.Clamp(1f - num, 0f, 1f) * defaultValue;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces oxygen consumption rate by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> oxygenCanistersConfiguration = BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration;
				return oxygenCanistersConfiguration.InitialEffect.Value + level * oxygenCanistersConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Oxygen Canisters", BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Oxygen Canisters");
			val.AddComponent<OxygenCanisters>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Oxygen Canisters"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Oxygen Canisters", BaseUpgrade.GetConfiguration().OxygenCanistersConfiguration, Plugin.networkPrefabs["Oxygen Canisters"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "OxygenCanisters";
		}
	}
	internal class QuickHands : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Quick Hands";

		internal const string DEFAULT_PRICES = "100,100,150,200,250";

		internal const string WORLD_BUILDING_TEXT = "\n\nThe 'Intern Tremble' is a known reoccuring phenomena among contractors in this field. Employees get nervous while exploring the Ruins and it manifests as a constant shaking in the wrists. In the back of a magazine you found an advert for 'Stress Management Lozenges' and decided to take it up. Your wrists don't shake anymore.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> quickHandsConfiguration = BaseUpgrade.GetConfiguration().QuickHandsConfiguration;
				string[] array = quickHandsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nThe 'Intern Tremble' is a known reoccuring phenomena among contractors in this field. Employees get nervous while exploring the Ruins and it manifests as a constant shaking in the wrists. In the back of a magazine you found an advert for 'Stress Management Lozenges' and decided to take it up. Your wrists don't shake anymore.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Quick Hands";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().QuickHandsConfiguration.OverrideName);
		}

		public static float GetIncreasedInteractionSpeedMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> quickHandsConfiguration = BaseUpgrade.GetConfiguration().QuickHandsConfiguration;
			return (float)(SyncedEntry<int>.op_Implicit(quickHandsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Quick Hands") * SyncedEntry<int>.op_Implicit(quickHandsConfiguration.IncrementalEffect)) / 100f;
		}

		public static float IncreaseInteractionSpeed(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().QuickHandsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Quick Hands"))
			{
				return defaultValue;
			}
			float increasedInteractionSpeedMultiplier = GetIncreasedInteractionSpeedMultiplier();
			return (int)Mathf.Clamp(defaultValue + defaultValue * increasedInteractionSpeedMultiplier, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases interaction speed of the player by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().QuickHandsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> quickHandsConfiguration = BaseUpgrade.GetConfiguration().QuickHandsConfiguration;
				return quickHandsConfiguration.InitialEffect.Value + level * quickHandsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Quick Hands", BaseUpgrade.GetConfiguration().QuickHandsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Quick Hands");
			val.AddComponent<QuickHands>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Quick Hands"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Quick Hands", BaseUpgrade.GetConfiguration().QuickHandsConfiguration, Plugin.networkPrefabs["Quick Hands"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "QuickHands";
		}
	}
	internal class ReinforcedBoots : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Reinforced Boots";

		internal const string DEFAULT_PRICES = "250,200,300,400,500";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the 'GEAR' section of the Company Catalogue, the third ad on the first page is for this product. They're Premium High-Impact Shock Absorbent Heel & Toe Pads for your crew's boots. The rhetoric of the advertisement promised a 19% increase in your departent's overall safety when traversing outdoors.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration reinforcedBootsConfiguration = BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration;
				string[] array = reinforcedBootsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the 'GEAR' section of the Company Catalogue, the third ad on the first page is for this product. They're Premium High-Impact Shock Absorbent Heel & Toe Pads for your crew's boots. The rhetoric of the advertisement promised a 19% increase in your departent's overall safety when traversing outdoors.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Reinforced Boots";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration.OverrideName);
		}

		public static int ReduceFallDamage(int defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> reinforcedBootsConfiguration = BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(reinforcedBootsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Reinforced Boots"))
			{
				return defaultValue;
			}
			float num = 1f - (float)(SyncedEntry<int>.op_Implicit(reinforcedBootsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Reinforced Boots") * SyncedEntry<int>.op_Implicit(reinforcedBootsConfiguration.IncrementalEffect)) / 100f;
			return (int)Mathf.Clamp((float)defaultValue * num, 0f, (float)defaultValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces fall damage by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> reinforcedBootsConfiguration = BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration;
				return reinforcedBootsConfiguration.InitialEffect.Value + level * reinforcedBootsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Reinforced Boots", BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ReinforcedBoots>("Reinforced Boots");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Reinforced Boots", BaseUpgrade.GetConfiguration().ReinforcedBootsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ReinforcedBoots";
		}
	}
	public class RubberBoots : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Rubber Boots";

		internal const string DEFAULT_PRICES = "50,50,100,200";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the 'GEAR' section of the Company Catalogue, the twelfth ad on the fourth page is for this product. It's a knee-high boot of rubbery synthetic material that fits over your standard footwear. The boots are flexible enough to be folded for compact storage in a pouch or hip bag.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> rubberBootsConfiguration = BaseUpgrade.GetConfiguration().RubberBootsConfiguration;
				string[] array = rubberBootsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the 'GEAR' section of the Company Catalogue, the twelfth ad on the fourth page is for this product. It's a knee-high boot of rubbery synthetic material that fits over your standard footwear. The boots are flexible enough to be folded for compact storage in a pouch or hip bag.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Rubber Boots";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().RubberBootsConfiguration.OverrideName);
		}

		public static float CalculateDecreaseMultiplier()
		{
			ITierEffectUpgradeConfiguration<int> rubberBootsConfiguration = BaseUpgrade.GetConfiguration().RubberBootsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(rubberBootsConfiguration.Enabled) || !BaseUpgrade.GetActiveUpgrade("Rubber Boots"))
			{
				return 0f;
			}
			return (float)(SyncedEntry<int>.op_Implicit(rubberBootsConfiguration.InitialEffect) + SyncedEntry<int>.op_Implicit(rubberBootsConfiguration.IncrementalEffect) * BaseUpgrade.GetUpgradeLevel("Rubber Boots")) / 100f;
		}

		public static int ClearMovementHinderance(int defaultValue)
		{
			if (CalculateDecreaseMultiplier() >= 1f)
			{
				return 0;
			}
			return defaultValue;
		}

		public static float ReduceMovementHinderance(float defaultValue)
		{
			float num = CalculateDecreaseMultiplier();
			return Mathf.Clamp(Mathf.Clamp(1f - num, 0f, 1f) * defaultValue, 1f, 100f);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Reduces the movement debuff when walking on water surfaces by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().RubberBootsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> rubberBootsConfiguration = BaseUpgrade.GetConfiguration().RubberBootsConfiguration;
				return rubberBootsConfiguration.InitialEffect.Value + level * rubberBootsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Rubber Boots", BaseUpgrade.GetConfiguration().RubberBootsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Rubber Boots");
			val.AddComponent<RubberBoots>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Rubber Boots"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Rubber Boots", BaseUpgrade.GetConfiguration().RubberBootsConfiguration, Plugin.networkPrefabs["Rubber Boots"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "RubberBoots";
		}
	}
	internal class RunningShoes : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Running Shoes";

		public const string PRICES_DEFAULT = "650,500,750,1000";

		internal const string WORLD_BUILDING_TEXT = "\n\nA new pair of boots {0} a whole new lease on life. In this instance, it might also result in fewer wet sock incidents and consequent trenchfoot. After all, who knows how many people have walked in {1} shoes?\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierMultipleEffectUpgradeConfiguration<float> runningShoesConfiguration = BaseUpgrade.GetConfiguration().RunningShoesConfiguration;
				string[] array = runningShoesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Running Shoes";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().RunningShoesConfiguration.OverrideName);
		}

		public static float ApplyPossibleReducedNoiseRange(float defaultValue)
		{
			ITierMultipleEffectUpgradeConfiguration<float> runningShoesConfiguration = BaseUpgrade.GetConfiguration().RunningShoesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(runningShoesConfiguration.Enabled) || !BaseUpgrade.GetActiveUpgrade("Running Shoes") || BaseUpgrade.GetUpgradeLevel("Running Shoes") != runningShoesConfiguration.Prices.Value.Split(',').Length)
			{
				return defaultValue;
			}
			return Mathf.Clamp(defaultValue - runningShoesConfiguration.GetEffectPair(1).Item1.Value, 0f, defaultValue);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nA new pair of boots {0} a whole new lease on life. In this instance, it might also result in fewer wet sock incidents and consequent trenchfoot. After all, who knows how many people have walked in {1} shoes?\n\n", shareStatus ? "could give your crew" : "can give you", shareStatus ? "y'all's" : "your");
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Running Shoes");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().RunningShoesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<float> runningShoesConfiguration = BaseUpgrade.GetConfiguration().RunningShoesConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) effectPair = runningShoesConfiguration.GetEffectPair(0);
				return effectPair.Item1.Value + (float)level * effectPair.Item2.Value;
			}
		}

		public static float GetAdditionalMovementSpeed(float defaultValue)
		{
			ITierMultipleEffectUpgradeConfiguration<float> runningShoesConfiguration = BaseUpgrade.GetConfiguration().RunningShoesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(runningShoesConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Running Shoes"))
			{
				return defaultValue;
			}
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = runningShoesConfiguration.GetEffectPair(0);
			float num = SyncedEntry<float>.op_Implicit(effectPair.Item1) + (float)BaseUpgrade.GetUpgradeLevel("Running Shoes") * SyncedEntry<float>.op_Implicit(effectPair.Item2);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Running Shoes", BaseUpgrade.GetConfiguration().RunningShoesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<RunningShoes>("Running Shoes");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Running Shoes", BaseUpgrade.GetConfiguration().RunningShoesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "RunningShoes";
		}
	}
	internal class StrongLegs : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Strong Legs";

		public const string PRICES_DEFAULT = "300,150,190,250";

		internal const string WORLD_BUILDING_TEXT = "\n\nOne-time issuance of {0}. Comes with a vague list of opt-in maintenance procedures offered by The Company, which includes such gems as 'actuation optimization', 'weight & balance personalization', and similar nigh-meaningless corpo-tech jargon. All of it is expensive.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<float> strongLegsConfiguration = BaseUpgrade.GetConfiguration().StrongLegsConfiguration;
				string[] array = strongLegsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Strong Legs";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().StrongLegsConfiguration.OverrideName);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nOne-time issuance of {0}. Comes with a vague list of opt-in maintenance procedures offered by The Company, which includes such gems as 'actuation optimization', 'weight & balance personalization', and similar nigh-meaningless corpo-tech jargon. All of it is expensive.\n\n", shareStatus ? "proprietary pressure-assisted kneebraces to your crew" : "a proprietary pressure-assisted kneebrace");
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Strong Legs");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().StrongLegsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<float> strongLegsConfiguration = BaseUpgrade.GetConfiguration().StrongLegsConfiguration;
				return strongLegsConfiguration.InitialEffect.Value + (float)level * strongLegsConfiguration.IncrementalEffect.Value;
			}
		}

		public static float GetAdditionalJumpForce(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<float> strongLegsConfiguration = BaseUpgrade.GetConfiguration().StrongLegsConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(strongLegsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Strong Legs"))
			{
				return defaultValue;
			}
			float num = SyncedEntry<float>.op_Implicit(strongLegsConfiguration.InitialEffect) + (float)BaseUpgrade.GetUpgradeLevel("Strong Legs") * SyncedEntry<float>.op_Implicit(strongLegsConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Strong Legs", BaseUpgrade.GetConfiguration().StrongLegsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<StrongLegs>("Strong Legs");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Strong Legs", BaseUpgrade.GetConfiguration().StrongLegsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "StrongLegs";
		}
	}
	internal class TractionBoots : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Traction Boots";

		internal const string PRICES_DEFAULT = "100,100,150,250";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the 'GEAR' section of the Company Catalogue, the first ad on the first page is for these. They're magnetic cleats that hook onto the Proprietary Steel Toe & Heel Reinforcements on your boots. These things have been known to hook into grated metal flooring and come off without the wearer's notice, so be careful.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> tractionBootsConfiguration = BaseUpgrade.GetConfiguration().TractionBootsConfiguration;
				string[] array = tractionBootsConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the 'GEAR' section of the Company Catalogue, the first ad on the first page is for these. They're magnetic cleats that hook onto the Proprietary Steel Toe & Heel Reinforcements on your boots. These things have been known to hook into grated metal flooring and come off without the wearer's notice, so be careful.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Traction Boots";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().TractionBootsConfiguration.OverrideName);
			base.Start();
		}

		public static float ComputeAdditionalTractionForce()
		{
			ITierEffectUpgradeConfiguration<int> tractionBootsConfiguration = BaseUpgrade.GetConfiguration().TractionBootsConfiguration;
			return 1f + (float)(SyncedEntry<int>.op_Implicit(tractionBootsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Traction Boots") * SyncedEntry<int>.op_Implicit(tractionBootsConfiguration.IncrementalEffect)) / 100f;
		}

		public static float GetAdditionalTractionForce(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().TractionBootsConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Traction Boots"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalTractionForce();
			return Mathf.Clamp(num * defaultValue, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Increases the player's traction to the ground by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().TractionBootsConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> tractionBootsConfiguration = BaseUpgrade.GetConfiguration().TractionBootsConfiguration;
				return tractionBootsConfiguration.InitialEffect.Value + level * tractionBootsConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Traction Boots", BaseUpgrade.GetConfiguration().TractionBootsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<TractionBoots>("Traction Boots");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Traction Boots", BaseUpgrade.GetConfiguration().TractionBootsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "TractionBoots";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.AttributeUpgrades
{
	public class BackMuscles : TierUpgrade, IUpgradeWorldBuilding
	{
		public enum UpgradeMode
		{
			ReduceWeight,
			ReduceCarryInfluence,
			ReduceCarryStrain
		}

		internal float alteredWeight = 1f;

		internal static BackMuscles Instance;

		public const string UPGRADE_NAME = "Back Muscles";

		public const string PRICES_DEFAULT = "715,600,700,800";

		internal const string WORLD_BUILDING_TEXT = "\n\nCompany-issued hydraulic girdles which are only awarded to high-performing {0} who can afford to opt in. Highly valued by all employees of The Company for their combination of miraculous health-preserving benefits and artificial, intentionally-implemented scarcity. Sardonically called the 'Back Muscles Upgrade' by some. Comes with a user manual, which mostly contains minimalistic ads for girdle maintenance contractors. Most of the phone numbers don't work anymore.\n\n";

		public static UpgradeMode CurrentUpgradeMode => SyncedEntry<UpgradeMode>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.AlternativeMode);

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierAlternativeEffectUpgradeConfiguration<float, UpgradeMode> backMusclesConfiguration = BaseUpgrade.GetConfiguration().BackMusclesConfiguration;
				string[] array = backMusclesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			upgradeName = "Back Muscles";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.OverrideName);
			Instance = this;
		}

		public override void Increment()
		{
			base.Increment();
			UpdatePlayerWeight();
		}

		public override void Load()
		{
			base.Load();
			UpdatePlayerWeight();
		}

		public override void Unwind()
		{
			base.Unwind();
			UpdatePlayerWeight();
		}

		public static float DecreaseStrain(float defaultWeight)
		{
			return DecreaseValue(defaultWeight, SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.Enabled), UpgradeMode.ReduceCarryStrain, 1f);
		}

		public static float DecreaseCarryLoss(float defaultWeight)
		{
			return DecreaseValue(defaultWeight, SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.Enabled), UpgradeMode.ReduceCarryInfluence, 1f);
		}

		public static float DecreasePossibleWeight(float defaultWeight)
		{
			return DecreaseValue(defaultWeight, SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.Enabled), UpgradeMode.ReduceWeight, 0f);
		}

		public static float DecreaseValue(float defaultWeight, bool enabled, UpgradeMode intendedMode, float lowerBound)
		{
			if (!enabled)
			{
				return defaultWeight;
			}
			if (CurrentUpgradeMode != intendedMode)
			{
				return defaultWeight;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Back Muscles"))
			{
				return defaultWeight;
			}
			ITierAlternativeEffectUpgradeConfiguration<float, UpgradeMode> backMusclesConfiguration = BaseUpgrade.GetConfiguration().BackMusclesConfiguration;
			return Mathf.Max(defaultWeight * (backMusclesConfiguration.InitialEffect.Value - (float)BaseUpgrade.GetUpgradeLevel("Back Muscles") * backMusclesConfiguration.IncrementalEffect.Value), lowerBound);
		}

		public static void UpdatePlayerWeight()
		{
			if (CurrentUpgradeMode != 0)
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (localPlayerController.ItemSlots.Length == 0)
			{
				return;
			}
			Instance.alteredWeight = 1f;
			for (int i = 0; i < localPlayerController.ItemSlots.Length; i++)
			{
				GrabbableObject val = localPlayerController.ItemSlots[i];
				if (!((Object)(object)val == (Object)null))
				{
					Instance.alteredWeight += Mathf.Clamp(DecreasePossibleWeight(val.itemProperties.weight - 1f), 0f, 10f);
				}
			}
			localPlayerController.carryWeight = Instance.alteredWeight;
			if (localPlayerController.carryWeight < 1f)
			{
				localPlayerController.carryWeight = 1f;
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nCompany-issued hydraulic girdles which are only awarded to high-performing {0} who can afford to opt in. Highly valued by all employees of The Company for their combination of miraculous health-preserving benefits and artificial, intentionally-implemented scarcity. Sardonically called the 'Back Muscles Upgrade' by some. Comes with a user manual, which mostly contains minimalistic ads for girdle maintenance contractors. Most of the phone numbers don't work anymore.\n\n", shareStatus ? "departments" : "employees");
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade(CurrentUpgradeMode switch
			{
				UpgradeMode.ReduceWeight => AssetBundleHandler.GetInfoFromJSON("Back Muscles"), 
				UpgradeMode.ReduceCarryInfluence => "LVL {0} - {1} - Reduces the weight's influence on player's running speed by {2}%\n", 
				UpgradeMode.ReduceCarryStrain => "LVL {0} - {1} - Reduces the weight's influence on player's stamina consumption while running by {2}%\n", 
				_ => "Undefined", 
			}, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().BackMusclesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierAlternativeEffectUpgradeConfiguration<float, UpgradeMode> backMusclesConfiguration = BaseUpgrade.GetConfiguration().BackMusclesConfiguration;
				return (backMusclesConfiguration.InitialEffect.Value - (float)level * backMusclesConfiguration.IncrementalEffect.Value) * 100f;
			}
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<BackMuscles>("Back Muscles");
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Back Muscles", BaseUpgrade.GetConfiguration().BackMusclesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Back Muscles", BaseUpgrade.GetConfiguration().BackMusclesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BackMuscles";
		}
	}
	internal class Stimpack : GameAttributeTierUpgrade, IUpgradeWorldBuilding
	{
		internal Dictionary<ulong, int> playerHealthLevels = new Dictionary<ulong, int>();

		internal static Stimpack Instance;

		public const string UPGRADE_NAME = "Stimpack";

		internal const string WORLD_BUILDING_TEXT = "\n\nAn experimental Company-offered 'health treatment' program advertised only on old, peeling Ship posters, which are themselves only present in about 40% of all Company-issued Ships. Some Ships even have multiple. Nothing is known from the outside about how it works, and in order to be eligible for the program, {0} must sign an NDA.\n\n";

		public const string ENABLED_SECTION = "Enable Stimpack Upgrade";

		public const bool ENABLED_DEFAULT = true;

		public const string ENABLED_DESCRIPTION = "Increases player's health.";

		public const string PRICE_SECTION = "Stimpack Price";

		public const int PRICE_DEFAULT = 600;

		public const string PRICES_DEFAULT = "600,300, 450, 600";

		public const string ADDITIONAL_HEALTH_UNLOCK_SECTION = "Initial health boost";

		public const int ADDITIONAL_HEALTH_UNLOCK_DEFAULT = 20;

		public const string ADDITIONAL_HEALTH_UNLOCK_DESCRIPTION = "Amount of health gained when unlocking the upgrade";

		public const string ADDITIONAL_HEALTH_INCREMENT_SECTION = "Additional health boost";

		public const int ADDITIONAL_HEALTH_INCREMENT_DEFAULT = 20;

		public const string ADDITIONAL_HEALTH_INCREMENT_DESCRIPTION = "Every time Stimpack is upgraded this value will be added to the value above.";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration stimpackConfiguration = BaseUpgrade.GetConfiguration().StimpackConfiguration;
				string[] array = stimpackConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		private void Awake()
		{
			ITierEffectUpgradeConfiguration<int> stimpackConfiguration = BaseUpgrade.GetConfiguration().StimpackConfiguration;
			upgradeName = "Stimpack";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(stimpackConfiguration.OverrideName);
			logger = new LguLogger("Stimpack");
			Instance = this;
			changingAttribute = GameAttribute.PLAYER_HEALTH;
			initialValue = stimpackConfiguration.InitialEffect.Value;
			incrementalValue = stimpackConfiguration.IncrementalEffect.Value;
		}

		public override void Load()
		{
			base.Load();
			UpdatePlayerHealthLevel();
		}

		public override void Increment()
		{
			base.Increment();
			UpdatePlayerHealthLevel();
		}

		private void UpdatePlayerHealthLevel()
		{
			PlayerControllerB localPlayer = UpgradeBus.Instance.GetLocalPlayer();
			PlayerHealthUpdateLevelServerRpc(localPlayer.playerSteamId, BaseUpgrade.GetUpgradeLevel("Stimpack"));
		}

		public override void Unwind()
		{
			base.Unwind();
			PlayerControllerB localPlayer = UpgradeBus.Instance.GetLocalPlayer();
			PlayerHealthUpdateLevelServerRpc(localPlayer.playerSteamId, -1);
		}

		public static int CheckForAdditionalHealth(int health)
		{
			ITierEffectUpgradeConfiguration<int> stimpackConfiguration = BaseUpgrade.GetConfiguration().StimpackConfiguration;
			if (!stimpackConfiguration.Enabled.Value)
			{
				return health;
			}
			PlayerControllerB localPlayer = UpgradeBus.Instance.GetLocalPlayer();
			if (!Instance.playerHealthLevels.ContainsKey(localPlayer.playerSteamId))
			{
				return health;
			}
			int num = Instance.playerHealthLevels[localPlayer.playerSteamId];
			return health + stimpackConfiguration.InitialEffect.Value + num * stimpackConfiguration.IncrementalEffect.Value;
		}

		public static int GetHealthFromPlayer(int health, ulong steamId)
		{
			int num = Instance.playerHealthLevels[steamId];
			ITierEffectUpgradeConfiguration<int> stimpackConfiguration = BaseUpgrade.GetConfiguration().StimpackConfiguration;
			return health + stimpackConfiguration.InitialEffect.Value + num * stimpackConfiguration.IncrementalEffect.Value;
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nAn experimental Company-offered 'health treatment' program advertised only on old, peeling Ship posters, which are themselves only present in about 40% of all Company-issued Ships. Some Ships even have multiple. Nothing is known from the outside about how it works, and in order to be eligible for the program, {0} must sign an NDA.\n\n", shareStatus ? "your crew" : "you");
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			string infoFromJSON = AssetBundleHandler.GetInfoFromJSON("Stimpack");
			return Tools.GenerateInfoForUpgrade(infoFromJSON, initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().StimpackConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> stimpackConfiguration = BaseUpgrade.GetConfiguration().StimpackConfiguration;
				return stimpackConfiguration.InitialEffect.Value + level * stimpackConfiguration.IncrementalEffect.Value;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayerHealthUpdateLevelServerRpc(ulong id, int level)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(237193921u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					BytePacker.WriteValueBitPacked(val2, level);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 237193921u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					logger.LogInfo("Request to update player max healths received. Calling ClientRpc...");
					PlayerHealthUpdateLevelClientRpc(id, level);
				}
			}
		}

		[ClientRpc]
		private void PlayerHealthUpdateLevelClientRpc(ulong id, int level)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(50592250u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				BytePacker.WriteValueBitPacked(val2, level);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 50592250u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				logger.LogInfo($"Setting max health level for player {id} to {level}");
				if (level == -1)
				{
					Instance.playerHealthLevels.Remove(id);
				}
				else
				{
					Instance.playerHealthLevels[id] = level;
				}
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Stimpack", BaseUpgrade.GetConfiguration().StimpackConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<Stimpack>("Stimpack");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Stimpack", BaseUpgrade.GetConfiguration().StimpackConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(237193921u, new RpcReceiveHandler(__rpc_handler_237193921), "PlayerHealthUpdateLevelServerRpc");
			((NetworkBehaviour)this).__registerRpc(50592250u, new RpcReceiveHandler(__rpc_handler_50592250), "PlayerHealthUpdateLevelClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_237193921(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				int level = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref level);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Stimpack)(object)target).PlayerHealthUpdateLevelServerRpc(id, level);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_50592250(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				int level = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref level);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Stimpack)(object)target).PlayerHealthUpdateLevelClientRpc(id, level);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Stimpack";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items
{
	internal class ItemDuplicator : TierUpgrade
	{
		public const string UPGRADE_NAME = "Item Duplicator";

		internal const string PRICES_DEFAULT = "250,350,500,750";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> itemDuplicatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration;
				string[] array = itemDuplicatorUpgradeConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Item Duplicator";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration.OverrideName);
			base.Start();
		}

		public static float GetChanceForDuplication()
		{
			ITierEffectUpgradeConfiguration<int> itemDuplicatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(itemDuplicatorUpgradeConfiguration.Enabled))
			{
				return 0f;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Item Duplicator"))
			{
				return 0f;
			}
			return (float)(SyncedEntry<int>.op_Implicit(itemDuplicatorUpgradeConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Item Duplicator") * SyncedEntry<int>.op_Implicit(itemDuplicatorUpgradeConfiguration.IncrementalEffect)) / 100f;
		}

		public static void AttemptDuplication(ref List<int> itemsToDeliver)
		{
			List<int> list = itemsToDeliver.ToList();
			float chanceForDuplication = GetChanceForDuplication();
			for (int i = 0; i < itemsToDeliver.Count; i++)
			{
				if (Random.Range(0f, 1f) < chanceForDuplication)
				{
					list.Add(itemsToDeliver[i]);
				}
			}
			itemsToDeliver = list;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Whenever purchasing an item from the Company store, it has {2}% chance of being duplicated when dropped (without occupying space).\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, BaseUpgrade.GetConfiguration().ClayGlassesConfiguration.PurchaseMode.Value);
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> itemDuplicatorUpgradeConfiguration = BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration;
				return itemDuplicatorUpgradeConfiguration.InitialEffect.Value + level * itemDuplicatorUpgradeConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Item Duplicator", BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Item Duplicator");
			val.AddComponent<ItemDuplicator>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Item Duplicator"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Item Duplicator", BaseUpgrade.GetConfiguration().ItemDuplicatorUpgradeConfiguration, Plugin.networkPrefabs["Item Duplicator"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ItemDuplicator";
		}
	}
	internal class LithiumBatteries : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Lithium Batteries";

		internal const string PRICES_DEFAULT = "100,150, 200, 250, 300";

		internal const string WORLD_BUILDING_TEXT = "\n\nHobby-grade rechargeable batteries for your crew-portable electronic equipment. There is no battery recollection program offered by the Company, so there's no need to hold onto the old batteries. Just throw them in the ocean.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> lithiumBatteriesConfiguration = BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration;
				string[] array = lithiumBatteriesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nHobby-grade rechargeable batteries for your crew-portable electronic equipment. There is no battery recollection program offered by the Company, so there's no need to hold onto the old batteries. Just throw them in the ocean.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Lithium Batteries";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration.OverrideName);
			base.Start();
		}

		public static float GetChargeRateMultiplier(float defaultChargeRate)
		{
			ITierEffectUpgradeConfiguration<int> lithiumBatteriesConfiguration = BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(lithiumBatteriesConfiguration.Enabled))
			{
				return defaultChargeRate;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Lithium Batteries"))
			{
				return defaultChargeRate;
			}
			float num = lithiumBatteriesConfiguration.InitialEffect.Value;
			num += (float)(BaseUpgrade.GetUpgradeLevel("Lithium Batteries") * lithiumBatteriesConfiguration.IncrementalEffect.Value);
			num = (100f - num) / 100f;
			return defaultChargeRate * num;
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Decreases the rate of battery used on the items by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> lithiumBatteriesConfiguration = BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration;
				return lithiumBatteriesConfiguration.InitialEffect.Value + level * lithiumBatteriesConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Lithium Batteries", BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<LithiumBatteries>("Lithium Batteries");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Lithium Batteries", BaseUpgrade.GetConfiguration().LithiumBatteriesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LithiumBatteries";
		}
	}
	public class ScrapKeeper : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Scrap Keeper";

		internal const string PRICES_DEFAULT = "1000,1000,1500,3000";

		internal const string WORLD_BUILDING_TEXT = "\n\nIn the race to the bottom of all possible operating costs, The Company has made many compromises. Some of these compromises end up being pretty questionable, and it's up to individual departments to handle these problems on their own. There is a design flaw in the standard-issue Company Ship that causes it to empty its contents when it's forced to leave a moon and there is no-one onboard to ensure the doors close at the right time. You'd think this would be a simple fix, but for so many reasons it'd be a waste of both our time to describe, no. No, it very much isn't.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration scrapKeeperConfiguration = BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration;
				string[] array = scrapKeeperConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIn the race to the bottom of all possible operating costs, The Company has made many compromises. Some of these compromises end up being pretty questionable, and it's up to individual departments to handle these problems on their own. There is a design flaw in the standard-issue Company Ship that causes it to empty its contents when it's forced to leave a moon and there is no-one onboard to ensure the doors close at the right time. You'd think this would be a simple fix, but for so many reasons it'd be a waste of both our time to describe, no. No, it very much isn't.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Scrap Keeper";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - In case of a full team wipe, each scrap present in the ship has a {2}% chance of not being discarded.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> scrapKeeperConfiguration = BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration;
				return scrapKeeperConfiguration.InitialEffect.Value + level * scrapKeeperConfiguration.IncrementalEffect.Value;
			}
		}

		public static float ComputeScrapKeeperKeepScrapChance()
		{
			ITierEffectUpgradeConfiguration<int> scrapKeeperConfiguration = BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration;
			int num = SyncedEntry<int>.op_Implicit(scrapKeeperConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Scrap Keeper") * SyncedEntry<int>.op_Implicit(scrapKeeperConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static bool CanKeepScrapBasedOnChance(GrabbableObject item)
		{
			ScrapKeeperUpgradeConfiguration scrapKeeperConfiguration = BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(scrapKeeperConfiguration.Enabled))
			{
				return false;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Scrap Keeper"))
			{
				return false;
			}
			if (SyncedEntry<bool>.op_Implicit(scrapKeeperConfiguration.OnlyKeepItemsInShip) && !item.scrapPersistedThroughRounds)
			{
				return false;
			}
			float num = Mathf.Clamp(ComputeScrapKeeperKeepScrapChance(), 0f, 1f);
			return Random.Range(0f, 1f) <= num;
		}

		public static bool CheckIfKeptScrap()
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration.Enabled))
			{
				return false;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Scrap Keeper"))
			{
				return false;
			}
			return true;
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Scrap Keeper", BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Scrap Keeper");
			val.AddComponent<ScrapKeeper>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Scrap Keeper"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Scrap Keeper", BaseUpgrade.GetConfiguration().ScrapKeeperConfiguration, Plugin.networkPrefabs["Scrap Keeper"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ScrapKeeper";
		}
	}
	internal class SmarterLockpick : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Smarter Lockpick";

		internal const string PRICES_DEFAULT = "200,300,350,450";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration smarterLockpickUpgradeConfiguration = BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration;
				string[] array = smarterLockpickUpgradeConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Smarter Lockpick";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The lockpicker item is {2}% more efficient (faster) at opening up locked doors.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> smarterLockpickUpgradeConfiguration = BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration;
				return smarterLockpickUpgradeConfiguration.InitialEffect.Value + level * smarterLockpickUpgradeConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Smarter Lockpick", BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Smarter Lockpick");
			val.AddComponent<SmarterLockpick>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Smarter Lockpick"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Smarter Lockpick", BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration, Plugin.networkPrefabs["Smarter Lockpick"]);
		}

		public static float IncreaseLockpickEfficiency(float defaultAmount)
		{
			ITierEffectUpgradeConfiguration<int> smarterLockpickUpgradeConfiguration = BaseUpgrade.GetConfiguration().SmarterLockpickUpgradeConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(smarterLockpickUpgradeConfiguration.Enabled))
			{
				return defaultAmount;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Smarter Lockpick"))
			{
				return defaultAmount;
			}
			float num = (float)(SyncedEntry<int>.op_Implicit(smarterLockpickUpgradeConfiguration.InitialEffect) + SyncedEntry<int>.op_Implicit(smarterLockpickUpgradeConfiguration.IncrementalEffect) * BaseUpgrade.GetUpgradeLevel("Smarter Lockpick")) / 100f;
			num = Mathf.Clamp(num, 1f, float.MaxValue);
			return defaultAmount + defaultAmount * num;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "SmarterLockpick";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Zapgun
{
	internal class AluminiumCoils : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Aluminium Coils";

		internal const string DEFAULT_PRICES = "750,600, 800, 1000";

		internal const string WORLD_BUILDING_TEXT = "\n\nOn-the-job training package that instructs your crew on how to more safely and efficiently wield the Zap Gun.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
				string[] array = aluminiumCoilConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Aluminium Coils";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration.OverrideName);
			base.Start();
		}

		public static float ApplyDifficultyDecrease(float defaultDifficulty)
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(aluminiumCoilConfiguration.Enabled))
			{
				return defaultDifficulty;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Aluminium Coils"))
			{
				return defaultDifficulty;
			}
			(SyncedEntry<int>, SyncedEntry<int>) effectPair = aluminiumCoilConfiguration.GetEffectPair(0);
			float num = 1f - (float)(effectPair.Item1.Value + BaseUpgrade.GetUpgradeLevel("Aluminium Coils") * effectPair.Item2.Value) / 100f;
			return Mathf.Clamp(defaultDifficulty * num, 0f, defaultDifficulty);
		}

		public static float ApplyCooldownDecrease(float defaultCooldown)
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(aluminiumCoilConfiguration.Enabled))
			{
				return defaultCooldown;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Aluminium Coils"))
			{
				return defaultCooldown;
			}
			(SyncedEntry<int>, SyncedEntry<int>) effectPair = aluminiumCoilConfiguration.GetEffectPair(1);
			float num = 1f - (float)(effectPair.Item1.Value + BaseUpgrade.GetUpgradeLevel("Aluminium Coils") * effectPair.Item2.Value) / 100f;
			return Mathf.Clamp(defaultCooldown * num, 0f, defaultCooldown);
		}

		public static float ApplyIncreasedStunTimer(float defaultStunTimer)
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(aluminiumCoilConfiguration.Enabled))
			{
				return defaultStunTimer;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Aluminium Coils"))
			{
				return defaultStunTimer;
			}
			(SyncedEntry<float>, SyncedEntry<float>) secondEffectPair = aluminiumCoilConfiguration.GetSecondEffectPair(0);
			float num = secondEffectPair.Item1.Value + (float)BaseUpgrade.GetUpgradeLevel("Aluminium Coils") * secondEffectPair.Item2.Value;
			return defaultStunTimer + num;
		}

		public static float ApplyIncreasedStunRange(float defaultRange)
		{
			ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(aluminiumCoilConfiguration.Enabled))
			{
				return defaultRange;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Aluminium Coils"))
			{
				return defaultRange;
			}
			(SyncedEntry<float>, SyncedEntry<float>) secondEffectPair = aluminiumCoilConfiguration.GetSecondEffectPair(1);
			float num = secondEffectPair.Item1.Value + (float)BaseUpgrade.GetUpgradeLevel("Aluminium Coils") * secondEffectPair.Item2.Value;
			return defaultRange + num;
		}

		private string GetAluminiumCoilsInfo(int level, int price)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append($"LVL {level} - {BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration.PurchaseMode))}: Upgrades to zap gun:\n");
			stringBuilder.Append($"- Increases zap gun's range by {rangeInfo(level - 1) / 13f * 100f:F0}%\n");
			stringBuilder.Append($"- Stun time increased by {stunTimerInfo(level - 1)} seconds\n");
			stringBuilder.Append($"- Decreases the minigame's difficulty by {difficultyInfo(level - 1):F0}%\n");
			stringBuilder.Append($"- Decreases the zap gun's cooldown by {cooldownInfo(level - 1):F0}%\n");
			stringBuilder.Append('\n');
			return stringBuilder.ToString();
			static float cooldownInfo(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair = aluminiumCoilConfiguration.GetEffectPair(1);
				return effectPair.Item1.Value + level * effectPair.Item2.Value;
			}
			static float difficultyInfo(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration2 = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
				(SyncedEntry<int>, SyncedEntry<int>) effectPair2 = aluminiumCoilConfiguration2.GetEffectPair(0);
				return effectPair2.Item1.Value + level * effectPair2.Item2.Value;
			}
			static float rangeInfo(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration4 = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) secondEffectPair2 = aluminiumCoilConfiguration4.GetSecondEffectPair(1);
				return secondEffectPair2.Item1.Value + (float)level * secondEffectPair2.Item2.Value;
			}
			static float stunTimerInfo(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<int, float> aluminiumCoilConfiguration3 = BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration;
				(SyncedEntry<float>, SyncedEntry<float>) secondEffectPair = aluminiumCoilConfiguration3.GetSecondEffectPair(0);
				return secondEffectPair.Item1.Value + (float)level * secondEffectPair.Item2.Value;
			}
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetAluminiumCoilsInfo(1, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetAluminiumCoilsInfo(i + 2, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<AluminiumCoils>("Aluminium Coils");
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Aluminium Coils", BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Aluminium Coils", BaseUpgrade.GetConfiguration().AluminiumCoilConfiguration);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOn-the-job training package that instructs your crew on how to more safely and efficiently wield the Zap Gun.\n\n";
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "AluminiumCoils";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.WeedKiller
{
	internal class WeedGeneticManipulation : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Weed Genetic Manipulation";

		internal const string PRICES_DEFAULT = "100,100,150,200";

		internal const string WORLD_BUILDING_TEXT = "\n\nYou figured out that pissing into the Weed Killer makes it more effective. The cost of this upgrade comes from extra portable water requisitions your department needs to order to make the project happen.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> weedGeneticManipulationConfiguration = BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration;
				string[] array = weedGeneticManipulationConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nYou figured out that pissing into the Weed Killer makes it more effective. The cost of this upgrade comes from extra portable water requisitions your department needs to order to make the project happen.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Weed Genetic Manipulation";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration.OverrideName);
			base.Start();
		}

		public static float ComputeWeedKillerEffectiveness()
		{
			ITierEffectUpgradeConfiguration<int> weedGeneticManipulationConfiguration = BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration;
			int num = SyncedEntry<int>.op_Implicit(weedGeneticManipulationConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Weed Genetic Manipulation") * SyncedEntry<int>.op_Implicit(weedGeneticManipulationConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static float GetWeedKillerEffectiveness(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Weed Genetic Manipulation"))
			{
				return defaultValue;
			}
			float num = ComputeWeedKillerEffectiveness();
			return Mathf.Clamp(defaultValue * num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Effectiveness of the Weed Killer item in eradicating plants is increased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> weedGeneticManipulationConfiguration = BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration;
				return weedGeneticManipulationConfiguration.InitialEffect.Value + level * weedGeneticManipulationConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Weed Genetic Manipulation", BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<WeedGeneticManipulation>("Weed Genetic Manipulation");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Weed Genetic Manipulation", BaseUpgrade.GetConfiguration().WeedGeneticManipulationConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "WeedGeneticManipulation";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Shotgun
{
	public class HollowPoint : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Hollow Point";

		internal const string DEFAULT_PRICES = "800,1000";

		internal const string WORLD_BUILDING_TEXT = "\n\nBy trading expedition notes and a few ration tickets with another crew during sale, you have acquired a set of instructions on how to make something called 'Cruelty Slugs'. The Company really shouldn't know about these... please keep this to yourselves.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration hollowPointConfiguration = BaseUpgrade.GetConfiguration().HollowPointConfiguration;
				string[] array = hollowPointConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nBy trading expedition notes and a few ration tickets with another crew during sale, you have acquired a set of instructions on how to make something called 'Cruelty Slugs'. The Company really shouldn't know about these... please keep this to yourselves.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Hollow Point";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().HollowPointConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Damage dealt by the shotgun is increased by {2}\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().HollowPointConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> hollowPointConfiguration = BaseUpgrade.GetConfiguration().HollowPointConfiguration;
				return hollowPointConfiguration.InitialEffect.Value + level * hollowPointConfiguration.IncrementalEffect.Value;
			}
		}

		public static int ComputeHollowPointDamageBoost()
		{
			ITierEffectUpgradeConfiguration<int> hollowPointConfiguration = BaseUpgrade.GetConfiguration().HollowPointConfiguration;
			return SyncedEntry<int>.op_Implicit(hollowPointConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Hollow Point") * SyncedEntry<int>.op_Implicit(hollowPointConfiguration.IncrementalEffect);
		}

		public static int GetHollowPointDamageBoost(int defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().HollowPointConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Hollow Point"))
			{
				return defaultValue;
			}
			int num = ComputeHollowPointDamageBoost();
			return defaultValue + num;
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Hollow Point", BaseUpgrade.GetConfiguration().HollowPointConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Hollow Point");
			val.AddComponent<HollowPoint>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Hollow Point"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Hollow Point", BaseUpgrade.GetConfiguration().HollowPointConfiguration, Plugin.networkPrefabs["Hollow Point"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "HollowPoint";
		}
	}
	internal class LongBarrel : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Long Barrel";

		internal const string DEFAULT_PRICES = "500,500,750";

		internal const string WORLD_BUILDING_TEXT = "\n\nThe shotguns Nutcrackers are issued with break a lot of common gunsmithing conventions. For one thing, the barrels are overly short, and sometimes one tube is longer than the other. You got some help from a friend prying a few sections of spare pipe off the walls of the Factory. The parts appear capable of baring pressure, and the kind of adhesive you need is available in the Company Catalogue, but it's expensive...\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration longBarrelConfiguration = BaseUpgrade.GetConfiguration().LongBarrelConfiguration;
				string[] array = longBarrelConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nThe shotguns Nutcrackers are issued with break a lot of common gunsmithing conventions. For one thing, the barrels are overly short, and sometimes one tube is longer than the other. You got some help from a friend prying a few sections of spare pipe off the walls of the Factory. The parts appear capable of baring pressure, and the kind of adhesive you need is available in the Company Catalogue, but it's expensive...\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Long Barrel";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LongBarrelConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Shotgun's range and its effective damage ranges are increased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LongBarrelConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> longBarrelConfiguration = BaseUpgrade.GetConfiguration().LongBarrelConfiguration;
				return longBarrelConfiguration.InitialEffect.Value + level * longBarrelConfiguration.IncrementalEffect.Value;
			}
		}

		public static float ComputeLongBarrelRangeBoost()
		{
			ITierEffectUpgradeConfiguration<int> longBarrelConfiguration = BaseUpgrade.GetConfiguration().LongBarrelConfiguration;
			int num = SyncedEntry<int>.op_Implicit(longBarrelConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Long Barrel") * SyncedEntry<int>.op_Implicit(longBarrelConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static float GetLongBarrelRangeBoost(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().LongBarrelConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Long Barrel"))
			{
				return defaultValue;
			}
			float num = ComputeLongBarrelRangeBoost();
			return defaultValue + Mathf.Clamp(defaultValue * num, 0f, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Long Barrel", BaseUpgrade.GetConfiguration().LongBarrelConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Long Barrel");
			val.AddComponent<LongBarrel>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Long Barrel"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Long Barrel", BaseUpgrade.GetConfiguration().LongBarrelConfiguration, Plugin.networkPrefabs["Long Barrel"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LongBarrel";
		}
	}
	internal class SleightOfHand : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Sleight of Hand";

		internal const string PRICES_DEFAULT = "100,150,200,250";

		internal const string WORLD_BUILDING_TEXT = "\n\nOn-the-job training package detailing the safe & efficient handling and application of firearms.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> sleightOfHandConfiguration = BaseUpgrade.GetConfiguration().SleightOfHandConfiguration;
				string[] array = sleightOfHandConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOn-the-job training package detailing the safe & efficient handling and application of firearms.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Sleight of Hand";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().SleightOfHandConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The reload speed of weaponry is increased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().SleightOfHandConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> sleightOfHandConfiguration = BaseUpgrade.GetConfiguration().SleightOfHandConfiguration;
				return sleightOfHandConfiguration.InitialEffect.Value + level * sleightOfHandConfiguration.IncrementalEffect.Value;
			}
		}

		public static float ComputeSleightOfHandSpeedBoost()
		{
			ITierEffectUpgradeConfiguration<int> sleightOfHandConfiguration = BaseUpgrade.GetConfiguration().SleightOfHandConfiguration;
			int num = SyncedEntry<int>.op_Implicit(sleightOfHandConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Sleight of Hand") * SyncedEntry<int>.op_Implicit(sleightOfHandConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static float GetSleightOfHandSpeedBoost(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().SleightOfHandConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sleight of Hand"))
			{
				return defaultValue;
			}
			float num = ComputeSleightOfHandSpeedBoost() / 2f;
			return Mathf.Clamp(defaultValue * (1f - num), 0f, defaultValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Sleight of Hand", BaseUpgrade.GetConfiguration().SleightOfHandConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<SleightOfHand>("Sleight of Hand");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Sleight of Hand", BaseUpgrade.GetConfiguration().SleightOfHandConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "SleightOfHand";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.RadarBooster
{
	internal class ChargingBooster : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Charging Booster";

		internal const string WORLD_BUILDING_TEXT = "Terminal hyperlink that leads to an old, decaying section of the Company Portal. The design of the page is bare and archaic, and all text is written in caps. There is a barely-labeled transaction window with your payment credentials autofilled. Clicking 'ACCEPT' causes a hissing noise to emanate from your nearby Radar Booster.";

		internal float chargeCooldown;

		internal static ChargingBooster Instance { get; private set; }

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierMultipleEffectUpgradeConfiguration<float, int> chargingBoosterConfiguration = BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration;
				string[] array = chargingBoosterConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "Terminal hyperlink that leads to an old, decaying section of the Company Portal. The design of the page is bare and archaic, and all text is written in caps. There is a barely-labeled transaction window with your payment credentials autofilled. Clicking 'ACCEPT' causes a hissing noise to emanate from your nearby Radar Booster.";
		}

		private void Awake()
		{
			Instance = this;
		}

		internal override void Start()
		{
			upgradeName = "Charging Booster";
			ITierMultipleEffectUpgradeConfiguration<float, int> chargingBoosterConfiguration = BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration;
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(chargingBoosterConfiguration.OverrideName);
			chargeCooldown = SyncedEntry<float>.op_Implicit(chargingBoosterConfiguration.GetEffectPair(0).Item1);
			base.Start();
		}

		public override void Load()
		{
			base.Load();
			RadarBoosterItem[] array = Object.FindObjectsOfType<RadarBoosterItem>();
			foreach (RadarBoosterItem val in array)
			{
				if (!((Object)(object)((Component)val).GetComponent<ChargingStationManager>() != (Object)null))
				{
					((Component)val).gameObject.AddComponent<ChargingStationManager>();
				}
			}
		}

		public override void Increment()
		{
			base.Increment();
			ITierMultipleEffectUpgradeConfiguration<float, int> chargingBoosterConfiguration = BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration;
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = chargingBoosterConfiguration.GetEffectPair(0);
			chargeCooldown = Mathf.Clamp(chargeCooldown - effectPair.Item2.Value, 0f, effectPair.Item1.Value);
		}

		[ServerRpc(RequireOwnership = false)]
		internal void UpdateCooldownServerRpc(NetworkBehaviourReference radarBooster)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2189107060u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref radarBooster, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2189107060u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateCooldownClientRpc(radarBooster);
				}
			}
		}

		[ClientRpc]
		private void UpdateCooldownClientRpc(NetworkBehaviourReference radarBooster)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2898446694u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref radarBooster, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2898446694u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			RadarBoosterItem val3 = default(RadarBoosterItem);
			((NetworkBehaviourReference)(ref radarBooster)).TryGet<RadarBoosterItem>(ref val3, (NetworkManager)null);
			if (!((Object)(object)val3 == (Object)null))
			{
				ChargingStationManager component = ((Component)val3).GetComponent<ChargingStationManager>();
				if (!((Object)(object)component == (Object)null))
				{
					component.cooldown = chargeCooldown;
				}
			}
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			ITierMultipleEffectUpgradeConfiguration<float, int> chargingBoosterConfiguration = BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration;
			(SyncedEntry<float>, SyncedEntry<float>) effectPair = chargingBoosterConfiguration.GetEffectPair(0);
			return $"LVL 1 - {BaseUpgrade.GetUpgradePrice(initialPrice, SyncedEntry<PurchaseMode>.op_Implicit(chargingBoosterConfiguration.PurchaseMode))} -  Provides charging stations to the radar boosters. After used, goes on cooldown for {effectPair.Item1.Value} seconds\n" + Tools.GenerateInfoForUpgrade("LVL {0} - {1} - Radar boosters will have a recharge cooldown of {2} seconds.\n", 0, incrementalPrices, infoFunction, skipFirst: true, SyncedEntry<PurchaseMode>.op_Implicit(chargingBoosterConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierMultipleEffectUpgradeConfiguration<float, int> chargingBoosterConfiguration2 = BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration;
				return chargingBoosterConfiguration2.GetEffectPair(0).Item1.Value - (float)level * chargingBoosterConfiguration2.GetEffectPair(0).Item2.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Charging Booster", BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ChargingBooster>("Charging Booster");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Charging Booster", BaseUpgrade.GetConfiguration().ChargingBoosterConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2189107060u, new RpcReceiveHandler(__rpc_handler_2189107060), "UpdateCooldownServerRpc");
			((NetworkBehaviour)this).__registerRpc(2898446694u, new RpcReceiveHandler(__rpc_handler_2898446694), "UpdateCooldownClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_2189107060(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference radarBooster = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref radarBooster, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ChargingBooster)(object)target).UpdateCooldownServerRpc(radarBooster);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2898446694(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference radarBooster = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref radarBooster, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ChargingBooster)(object)target).UpdateCooldownClientRpc(radarBooster);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ChargingBooster";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Items.Jetpack
{
	internal class JetFuel : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Jet Fuel";

		internal const string DEFAULT_PRICES = "400,200,400,500";

		internal const string WORLD_BUILDING_TEXT = "\n\nOptimization procedure for your jetpack's fuel injector that results in a cleaner and more efficient detonation of the propellant.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration jetFuelConfiguration = BaseUpgrade.GetConfiguration().JetFuelConfiguration;
				string[] array = jetFuelConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOptimization procedure for your jetpack's fuel injector that results in a cleaner and more efficient detonation of the propellant.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Jet Fuel";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().JetFuelConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The acceleration of the jetpack during flight is increased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().JetFuelConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> jetFuelConfiguration = BaseUpgrade.GetConfiguration().JetFuelConfiguration;
				return jetFuelConfiguration.InitialEffect.Value + level * jetFuelConfiguration.IncrementalEffect.Value;
			}
		}

		public static float GetIncreasedAcceleration()
		{
			ITierEffectUpgradeConfiguration<int> jetFuelConfiguration = BaseUpgrade.GetConfiguration().JetFuelConfiguration;
			int num = SyncedEntry<int>.op_Implicit(jetFuelConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Jet Fuel") * SyncedEntry<int>.op_Implicit(jetFuelConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static float IncreaseJetpackAcceleration(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().JetFuelConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Jet Fuel"))
			{
				return defaultValue;
			}
			float increasedAcceleration = GetIncreasedAcceleration();
			return Mathf.Clamp(defaultValue + defaultValue * increasedAcceleration, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Jet Fuel", BaseUpgrade.GetConfiguration().JetFuelConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Jet Fuel");
			val.AddComponent<JetFuel>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Jet Fuel"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Jet Fuel", BaseUpgrade.GetConfiguration().JetFuelConfiguration, Plugin.networkPrefabs["Jet Fuel"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "JetFuel";
		}
	}
	internal class JetpackThrusters : TierUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Jetpack Thrusters";

		internal const string DEFAULT_PRICES = "300,150,300,400";

		internal const string WORLD_BUILDING_TEXT = "\n\nOptimization procedure for your jetpack's thrust nozzles that results in a higher terminal velocity at maximum thrust.\n\n";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration jetpackThrustersConfiguration = BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration;
				string[] array = jetpackThrustersConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOptimization procedure for your jetpack's thrust nozzles that results in a higher terminal velocity at maximum thrust.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Jetpack Thrusters";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration.OverrideName);
			base.Start();
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The maximum speed of the jetpack during flight is increased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration.PurchaseMode));
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> jetpackThrustersConfiguration = BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration;
				return jetpackThrustersConfiguration.InitialEffect.Value + level * jetpackThrustersConfiguration.IncrementalEffect.Value;
			}
		}

		public static float GetIncreasedMaximumPower()
		{
			ITierEffectUpgradeConfiguration<int> jetpackThrustersConfiguration = BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration;
			int num = SyncedEntry<int>.op_Implicit(jetpackThrustersConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Jetpack Thrusters") * SyncedEntry<int>.op_Implicit(jetpackThrustersConfiguration.IncrementalEffect);
			return (float)num / 100f;
		}

		public static float IncreaseJetpackMaximumPower(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Jetpack Thrusters"))
			{
				return defaultValue;
			}
			float increasedMaximumPower = GetIncreasedMaximumPower();
			return Mathf.Clamp(defaultValue + defaultValue * increasedMaximumPower, defaultValue, float.MaxValue);
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Jetpack Thrusters", BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Jetpack Thrusters");
			val.AddComponent<JetpackThrusters>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Jetpack Thrusters"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Jetpack Thrusters", BaseUpgrade.GetConfiguration().JetpackThrustersConfiguration, Plugin.networkPrefabs["Jetpack Thrusters"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "JetpackThrusters";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.TierUpgrades.Enemies
{
	public class BabyPacifier : TierUpgrade
	{
		public const string UPGRADE_NAME = "Baby Pacifier";

		internal const string PRICES_DEFAULT = "100,100,200,200,400";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<int> babyPacifierUpgradeConfiguration = BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration;
				string[] array = babyPacifierUpgradeConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		internal override void Start()
		{
			upgradeName = "Baby Pacifier";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration.OverrideName);
			base.Start();
		}

		public static float GetDecreasedGrowthRate(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<int> babyPacifierUpgradeConfiguration = BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(babyPacifierUpgradeConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Baby Pacifier"))
			{
				return defaultValue;
			}
			float num = (float)(SyncedEntry<int>.op_Implicit(babyPacifierUpgradeConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Baby Pacifier") * SyncedEntry<int>.op_Implicit(babyPacifierUpgradeConfiguration.IncrementalEffect)) / 100f;
			return Mathf.Clamp(defaultValue - defaultValue * num, 0f, defaultValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The amount of growth increase when the maneater is crying is decreased by {2}%\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, BaseUpgrade.GetConfiguration().ClayGlassesConfiguration.PurchaseMode.Value);
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<int> babyPacifierUpgradeConfiguration = BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration;
				return babyPacifierUpgradeConfiguration.InitialEffect.Value + level * babyPacifierUpgradeConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Baby Pacifier", BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Baby Pacifier");
			val.AddComponent<BabyPacifier>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Baby Pacifier"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Baby Pacifier", BaseUpgrade.GetConfiguration().BabyPacifierUpgradeConfiguration, Plugin.networkPrefabs["Baby Pacifier"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BabyPacifier";
		}
	}
	public class ClayGlasses : TierUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Clay Glasses";

		internal const string WORLD_BUILDING_TEXT = "\n\nSubscription to 'Prestidigitation Press' magazine. Comes every week. The magazines are full of supposed-eyewitness testimony of supernatural occurences. Most of the content of the magazine appears blatantly fake to you, but the fact that the Clay Surgeon is mentioned and described in exacting detail sends a shiver down your spine.\n\n";

		internal const string PRICES_DEFAULT = "200,300,400,500,600";

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierEffectUpgradeConfiguration<float> clayGlassesConfiguration = BaseUpgrade.GetConfiguration().ClayGlassesConfiguration;
				string[] array = clayGlassesConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSubscription to 'Prestidigitation Press' magazine. Comes every week. The magazines are full of supposed-eyewitness testimony of supernatural occurences. Most of the content of the magazine appears blatantly fake to you, but the fact that the Clay Surgeon is mentioned and described in exacting detail sends a shiver down your spine.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Clay Glasses";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().ClayGlassesConfiguration.OverrideName);
			base.Start();
		}

		public static float GetAdditionalMaximumDistance(float defaultValue)
		{
			ITierEffectUpgradeConfiguration<float> clayGlassesConfiguration = BaseUpgrade.GetConfiguration().ClayGlassesConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(clayGlassesConfiguration.Enabled))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Clay Glasses"))
			{
				return defaultValue;
			}
			float num = SyncedEntry<float>.op_Implicit(clayGlassesConfiguration.InitialEffect) + (float)BaseUpgrade.GetUpgradeLevel("Clay Glasses") * SyncedEntry<float>.op_Implicit(clayGlassesConfiguration.IncrementalEffect);
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - {1} - The maximum distance to spot a \"Clay Surgeon\" entity is increased by {2} additional units.\n", initialPrice, incrementalPrices, infoFunction, skipFirst: false, BaseUpgrade.GetConfiguration().ClayGlassesConfiguration.PurchaseMode.Value);
			static float infoFunction(int level)
			{
				ITierEffectUpgradeConfiguration<float> clayGlassesConfiguration = BaseUpgrade.GetConfiguration().ClayGlassesConfiguration;
				return clayGlassesConfiguration.InitialEffect.Value + (float)level * clayGlassesConfiguration.IncrementalEffect.Value;
			}
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Clay Glasses", BaseUpgrade.GetConfiguration().ClayGlassesConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<ClayGlasses>("Clay Glasses");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Clay Glasses", BaseUpgrade.GetConfiguration().ClayGlassesConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ClayGlasses";
		}
	}
	internal class Hunter : TierUpgrade, IUpgradeWorldBuilding
	{
		private static readonly LguLogger logger = new LguLogger("Hunter");

		internal static Hunter Instance;

		public const string UPGRADE_NAME = "Hunter";

		public const string PRICES_DEFAULT = "500,600,700";

		internal const string WORLD_BUILDING_TEXT = "\n\nOn-the-job training program that teaches your crew how to properly collect lab-ready samples of blood, skin, and organ tissue from entities found within the facility. These samples are valuable to The Company. Used to be a part of the standard onboarding procedure, but was made opt-in only in 2005 to cut onboarding costs.\n\n";

		private static readonly Dictionary<string, string> monsterNames = new Dictionary<string, string>
		{
			{ "hoarding", "Hoarding Bug" },
			{ "hoarding bug", "Hoarding Bug" },
			{ "snare", "Snare Flea" },
			{ "flea", "Snare Flea" },
			{ "snare flea", "Snare Flea" },
			{ "centipede", "Snare Flea" },
			{ "bunker spider", "Bunker Spider" },
			{ "bunker", "Bunker Spider" },
			{ "bunk", "Bunker Spider" },
			{ "spider", "Bunker Spider" },
			{ "baboon hawk", "Baboon Hawk" },
			{ "baboon", "Baboon Hawk" },
			{ "hawk", "Baboon Hawk" },
			{ "flowerman", "Bracken" },
			{ "bracken", "Bracken" },
			{ "crawler", "Half/Thumper" },
			{ "half", "Half/Thumper" },
			{ "thumper", "Half/Thumper" },
			{ "mouthdog", "Eyeless Dog" },
			{ "eyeless dog", "Eyeless Dog" },
			{ "eyeless", "Eyeless Dog" },
			{ "dog", "Eyeless Dog" },
			{ "tulip snake", "Tulip Snake" },
			{ "slowersnake", "Tulip Snake" },
			{ "flower snake", "Tulip Snake" },
			{ "snake", "Tulip Snake" },
			{ "forest giant", "Forest Giant" },
			{ "forest keeper", "Forest Giant" },
			{ "forestgiant", "Forest Giant" },
			{ "forestkeeper", "Forest Giant" },
			{ "manticoil", "Manticoil" },
			{ "manti coil", "Manticoil" },
			{ "bird", "Manticoil" },
			{ "puffer", "Spore Lizard" },
			{ "sporelizard", "Spore Lizard" },
			{ "spore lizard", "Spore Lizard" },
			{ "lizard", "Spore Lizard" },
			{ "fox", "Kidnapper Fox" },
			{ "kidnapper fox", "Kidnapper Fox" },
			{ "kidnapperfox", "Kidnapper Fox" },
			{ "bush wolf", "Kidnapper Fox" },
			{ "bushwolf", "Kidnapper Fox" },
			{ "wolf", "Kidnapper Fox" },
			{ "maneater", "Maneater" },
			{ "cave dweller", "Maneater" },
			{ "cavedweller", "Maneater" },
			{ "baby", "Maneater" },
			{ "babyeater", "Maneater" },
			{ "giant sapsucker", "Giant Kiwi" },
			{ "giant kiwi", "Giant Kiwi" },
			{ "woodpecker", "Giant Kiwi" },
			{ "giantkiwi", "Giant Kiwi" }
		};

		private static Dictionary<string, int> levels;

		public override bool CanInitializeOnStart
		{
			get
			{
				ITierUpgradeConfiguration hunterConfiguration = BaseUpgrade.GetConfiguration().HunterConfiguration;
				string[] array = hunterConfiguration.Prices.Value.Split(',');
				return array.Length == 0 || (array.Length == 1 && (array[0].Length == 0 || array[0] == "0"));
			}
		}

		public static void SetupLevels()
		{
			levels = new Dictionary<string, int>();
			string[] array = BaseUpgrade.GetConfiguration().HunterConfiguration.TierCollection.Value.ToLower().Split('-');
			for (int i = 0; i < array.Length; i++)
			{
				foreach (string item in from x in array[i].Split(',')
					select x.Trim().ToLower())
				{
					if (monsterNames.TryGetValue(item, out var value))
					{
						if (levels.ContainsKey(value))
						{
							logger.LogError(value + " appears twice in samples config! Appearing now as " + item);
							continue;
						}
						logger.LogInfo($"{value} set to be harvestable at level {i + 1}");
						levels[value] = i;
					}
					else
					{
						logger.LogError("Unrecognized enemy name: " + item);
					}
				}
			}
			foreach (string key in HunterSamples.moddedLevels.Keys)
			{
				levels[key] = HunterSamples.moddedLevels[key];
				monsterNames[key.ToLower()] = key;
			}
		}

		public static bool CanHarvest(string shortName)
		{
			if (!monsterNames.TryGetValue(shortName.ToLower(), out var value))
			{
				logger.LogDebug(shortName + " is not harvestable");
				return false;
			}
			if (levels.TryGetValue(value, out var value2))
			{
				logger.LogDebug($"{value} can be harvested at level {value2 + 1}");
				return value2 <= BaseUpgrade.GetUpgradeLevel("Hunter");
			}
			logger.LogDebug(value + " cannot be harvested at any level");
			return false;
		}

		private void Awake()
		{
			upgradeName = "Hunter";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().HunterConfiguration.OverrideName);
			Instance = this;
		}

		public static string GetHunterInfo(int level, int price)
		{
			string arg = string.Join(", ", from item in levels
				where item.Value == level
				select item.Key);
			return string.Format(AssetBundleHandler.GetInfoFromJSON("Hunter"), level + 1, BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().HunterConfiguration.PurchaseMode)), arg);
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nOn-the-job training program that teaches your crew how to properly collect lab-ready samples of blood, skin, and organ tissue from entities found within the facility. These samples are valuable to The Company. Used to be a part of the standard onboarding procedure, but was made opt-in only in 2005 to cut onboarding costs.\n\n";
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(GetHunterInfo(0, initialPrice));
			for (int i = 0; i < maxLevels; i++)
			{
				stringBuilder.Append(GetHunterInfo(i + 1, incrementalPrices[i]));
			}
			return stringBuilder.ToString();
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Hunter", BaseUpgrade.GetConfiguration().HunterConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<Hunter>("Hunter");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			SetupLevels();
			return UpgradeBus.Instance.SetupMultiplePurchaseableTerminalNode("Hunter", BaseUpgrade.GetConfiguration().HunterConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "Hunter";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades
{
	public class LightningRod : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public enum UpgradeMode
		{
			EffectiveRange,
			AlwaysRerouteItem,
			AlwaysRerouteRandom,
			AlwaysRerouteAll
		}

		public const string UPGRADE_NAME = "Lightning Rod";

		internal const string WORLD_BUILDING_TEXT = "\n\nService key for the Ship's terminal which allows your crew to legally use the Ship's 'Static Attraction Field' module. Comes with a list of opt-in maintenance procedures that promise to optimize the module's function and field of influence. This Company-issued document is saddled with the uniquely-awkward task of having to ransom a safety feature back to the employee in text while not also admitting to the existence of an occupational hazard that was previously denied in court.\n\n";

		public static LightningRod instance;

		private StormyWeather StormyWeather;

		public const string ENABLED_SECTION = "Enable Lightning Rod Upgrade";

		public const bool ENABLED_DEFAULT = true;

		public const string ENABLED_DESCRIPTION = "A device which redirects lightning bolts to the ship.";

		public const string PRICE_SECTION = "Lightning Rod Price";

		public const int PRICE_DEFAULT = 1000;

		public const string ACTIVE_SECTION = "Active on Purchase";

		public const bool ACTIVE_DEFAULT = true;

		public const string ACTIVE_DESCRIPTION = "If true: Lightning Rod will be active on purchase.";

		public const string ACCESS_DENIED_MESSAGE = "You don't have access to this command yet. Purchase the 'Lightning Rod'.\n";

		public const string TOGGLE_ON_MESSAGE = "Lightning Rod has been enabled. Lightning bolts will now be redirected to the ship.\n";

		public const string TOGGLE_OFF_MESSAGE = "Lightning Rod has been disabled. Lightning bolts will no longer be redirected to the ship.\n";

		public const string DIST_SECTION = "Effective Distance of Lightning Rod.";

		public const float DIST_DEFAULT = 175f;

		public const string DIST_DESCRIPTION = "The closer you are the more likely the rod will reroute lightning.";

		public const string UPGRADE_MODE_SECTION = "Current Upgrade Mode for Lightning Rod";

		public const UpgradeMode UPGRADE_MODE_DEFAULT = UpgradeMode.EffectiveRange;

		public const string UPGRADE_MODE_DESCRIPTION = "Supported Values:\nEffectiveRange: The closer the item is to the ship, the more likely the lightning directed to it will be redirected to the ship instead.\nAlwaysRerouteItem: Whenever an item is picked to be hit by lightning, the bolt will be redirected to the ship instead.\nAlwaysRerouteRandom: Whenever a random lightning bolt (not the one used to target items) is produced, the bolt will be redirected to the ship instead.\nAlwaysRerouteAll: Whenever any kind of lightning bolt is produced, the bolt will be redirected to the ship instead.\n";

		public static UpgradeMode CurrentUpgradeMode => SyncedEntry<UpgradeMode>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.AlternativeMode);

		public bool LightningIntercepted { get; internal set; }

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().LightningRodConfiguration.Price.Value <= 0;

		private void Awake()
		{
			instance = this;
			upgradeName = "Lightning Rod";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.OverrideName);
		}

		public static void TryInterceptLightning(ref StormyWeather __instance, ref GrabbableObject ___targetingMetalObject)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			switch (CurrentUpgradeMode)
			{
			case UpgradeMode.EffectiveRange:
			{
				if ((Object)(object)___targetingMetalObject == (Object)null)
				{
					flag = false;
					break;
				}
				Terminal terminal = UpgradeBus.Instance.GetTerminal();
				float num = Vector3.Distance(((Component)___targetingMetalObject).transform.position, ((Component)terminal).transform.position);
				if (num > BaseUpgrade.GetConfiguration().LightningRodConfiguration.Effect.Value)
				{
					return;
				}
				num /= BaseUpgrade.GetConfiguration().LightningRodConfiguration.Effect.Value;
				float num2 = 1f - num;
				float value = Random.value;
				flag = value < num2;
				break;
			}
			case UpgradeMode.AlwaysRerouteItem:
				flag = (Object)(object)___targetingMetalObject != (Object)null;
				break;
			case UpgradeMode.AlwaysRerouteRandom:
				flag = (Object)(object)___targetingMetalObject == (Object)null;
				break;
			case UpgradeMode.AlwaysRerouteAll:
				flag = true;
				break;
			}
			if (flag)
			{
				__instance.staticElectricityParticle.Stop();
				instance.LightningIntercepted = true;
				instance.CoordinateInterceptionClientRpc();
			}
		}

		public static void RerouteLightningBolt(ref Vector3 strikePosition, ref StormyWeather __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Terminal terminal = UpgradeBus.Instance.GetTerminal();
			strikePosition = ((Component)terminal).transform.position;
			instance.LightningIntercepted = false;
			((Component)__instance.staticElectricityParticle).gameObject.SetActive(true);
		}

		[ClientRpc]
		public void CoordinateInterceptionClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1440413900u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1440413900u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				LightningIntercepted = true;
				if ((Object)(object)StormyWeather == (Object)null)
				{
					StormyWeather = Object.FindObjectOfType<StormyWeather>(true);
				}
				((Component)StormyWeather.staticElectricityParticle).gameObject.SetActive(false);
			}
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nService key for the Ship's terminal which allows your crew to legally use the Ship's 'Static Attraction Field' module. Comes with a list of opt-in maintenance procedures that promise to optimize the module's function and field of influence. This Company-issued document is saddled with the uniquely-awkward task of having to ransom a safety feature back to the employee in text while not also admitting to the existence of an occupational hazard that was previously denied in court.\n\n";
		}

		public override string GetDisplayInfo(int price = -1)
		{
			UpgradeMode currentUpgradeMode = CurrentUpgradeMode;
			if (1 == 0)
			{
			}
			string result = currentUpgradeMode switch
			{
				UpgradeMode.EffectiveRange => string.Format(AssetBundleHandler.GetInfoFromJSON("Lightning Rod"), BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.PurchaseMode)), BaseUpgrade.GetConfiguration().LightningRodConfiguration.Effect.Value), 
				UpgradeMode.AlwaysRerouteItem => "$" + BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.PurchaseMode)) + " - Reroutes all lightning bolts directed to metallic objects to the ship's lightning rod.", 
				UpgradeMode.AlwaysRerouteRandom => "$" + BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.PurchaseMode)) + " - Reroutes all non-targetting lightning bolts to the ship's lightning rod.", 
				UpgradeMode.AlwaysRerouteAll => "$" + BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LightningRodConfiguration.PurchaseMode)) + " - Reroutes all kind of lightning bolts to the ship's lightning rod", 
				_ => string.Empty, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Lightning Rod", BaseUpgrade.GetConfiguration().LightningRodConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<LightningRod>("Lightning Rod");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Lightning Rod", BaseUpgrade.GetConfiguration().LightningRodConfiguration);
		}

		internal void ResetValues()
		{
			StormyWeather = null;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1440413900u, new RpcReceiveHandler(__rpc_handler_1440413900), "CoordinateInterceptionClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_1440413900(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LightningRod)(object)target).CoordinateInterceptionClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LightningRod";
		}
	}
	internal class MalwareBroadcaster : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Malware Broadcaster";

		internal const string WORLD_BUILDING_TEXT = "\n\nIt used to be, back before the War, there was this rumor spread around about a 'failsafe equation' you could use to dispel forgotten landmines when you were exploring the Ruins. This string of logic has been hollered down dark stone hallways, been hurriedly punched into keypads, and been etched into peoples' mailboxes & doorjambs all over the Solar System for a century. The Company is selling your own cultural memories back to you.\n\n";

		public static MalwareBroadcaster instance;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nIt used to be, back before the War, there was this rumor spread around about a 'failsafe equation' you could use to dispel forgotten landmines when you were exploring the Ruins. This string of logic has been hollered down dark stone hallways, been hurriedly punched into keypads, and been etched into peoples' mailboxes & doorjambs all over the Solar System for a century. The Company is selling your own cultural memories back to you.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Malware Broadcaster";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.OverrideName);
			instance = this;
		}

		[ServerRpc(RequireOwnership = false)]
		public void ReqDestroyObjectServerRpc(NetworkObjectReference go)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(457311902u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref go, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 457311902u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			((NetworkObjectReference)(ref go)).TryGet(ref val3, (NetworkManager)null);
			if ((Object)(object)val3 == (Object)null)
			{
				HUDManager.Instance.AddTextToChatOnServer("Can't retrieve obj", 0);
				return;
			}
			if (BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.ExplodeTraps.Value)
			{
				SpawnExplosionClientRpc(((Component)val3).gameObject.transform.position);
			}
			val3.Despawn(true);
		}

		internal static bool IsMapHazard(ref TerminalAccessibleObject possibleHazard)
		{
			if (((Component)possibleHazard).gameObject.layer == LayerMask.NameToLayer("MapHazards"))
			{
				return true;
			}
			if ((Object)(object)((Component)possibleHazard).transform.parent != (Object)null && ((Component)((Component)possibleHazard).transform.parent).gameObject.layer == LayerMask.NameToLayer("MapHazards"))
			{
				return true;
			}
			if (IsLandmine(ref possibleHazard))
			{
				return true;
			}
			if (IsTurret(ref possibleHazard))
			{
				return true;
			}
			if (MissileTurretsCompat.Enabled && MissileTurretsCompat.IsMissileTurret(ref possibleHazard))
			{
				return true;
			}
			return IsSpikeRoofTrap(ref possibleHazard);
		}

		internal static bool IsLandmine(ref TerminalAccessibleObject possibleHazard)
		{
			return (Object)(object)((Component)possibleHazard).GetComponent<Landmine>() != (Object)null;
		}

		internal static bool IsTurret(ref TerminalAccessibleObject possibleHazard)
		{
			return (Object)(object)((Component)possibleHazard).GetComponent<Turret>() != (Object)null;
		}

		internal static bool IsSpikeRoofTrap(ref TerminalAccessibleObject possibleHazard)
		{
			Transform parent = ((Component)possibleHazard).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return false;
			}
			Transform val = parent.Find("AnimContainer");
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)val).GetComponentInChildren<SpikeRoofTrap>() != (Object)null;
		}

		[ClientRpc]
		private void SpawnExplosionClientRpc(Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2073079289u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2073079289u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.ExplodeTraps.Value)
				{
					Tools.SpawnExplosion(position + Vector3.up, spawnExplosionEffect: true, 5.7f, 6.4f);
				}
			}
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return string.Concat(str2: (!BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.DestroyTraps.Value) ? $"Broadcasted codes now disable map hazards for {BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.DisarmTime.Value} seconds." : ((!BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.ExplodeTraps.Value) ? "Broadcasted codes now destroy map hazards." : "Broadcasted codes now explode map hazards."), str0: BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.PurchaseMode)), str1: " - ");
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Malware Broadcaster", BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<MalwareBroadcaster>("Malware Broadcaster");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Malware Broadcaster", BaseUpgrade.GetConfiguration().MalwareBroadcasterUpgradeConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(457311902u, new RpcReceiveHandler(__rpc_handler_457311902), "ReqDestroyObjectServerRpc");
			((NetworkBehaviour)this).__registerRpc(2073079289u, new RpcReceiveHandler(__rpc_handler_2073079289), "SpawnExplosionClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_457311902(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference go = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref go, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((MalwareBroadcaster)(object)target).ReqDestroyObjectServerRpc(go);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2073079289(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((MalwareBroadcaster)(object)target).SpawnExplosionClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "MalwareBroadcaster";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Store
{
	internal class FasterDropPod : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Drop Pod Thrusters";

		internal const string WORLD_BUILDING_TEXT = "\n\nPlaces your department on the 'Priority Shipping List'; your purchases should arrive ~30 minutes faster than before. It's estimated that for every department that signs up for this package, every department on the standard shipping list has their orders delayed by roughly 1.7 seconds.\n\n";

		public static FasterDropPod Instance;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nPlaces your department on the 'Priority Shipping List'; your purchases should arrive ~30 minutes faster than before. It's estimated that for every department that signs up for this package, every department on the standard shipping list has their orders delayed by roughly 1.7 seconds.\n\n";
		}

		internal override void Start()
		{
			upgradeName = "Drop Pod Thrusters";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration.OverrideName);
			base.Start();
		}

		private void Awake()
		{
			Instance = this;
		}

		public static float GetFirstOrderTimer(float defaultValue)
		{
			DropPodThrustersUpgradeConfiguration dropPodThrustersConfiguration = BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration;
			if (!dropPodThrustersConfiguration.Enabled.Value)
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Drop Pod Thrusters"))
			{
				return defaultValue;
			}
			return Mathf.Clamp(defaultValue + dropPodThrustersConfiguration.InitialTimer.Value, defaultValue, defaultValue + dropPodThrustersConfiguration.Timer.Value);
		}

		public static float GetUpgradedTimer(float defaultValue)
		{
			DropPodThrustersUpgradeConfiguration dropPodThrustersConfiguration = BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration;
			if (!dropPodThrustersConfiguration.Enabled.Value)
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Drop Pod Thrusters"))
			{
				return defaultValue;
			}
			return Mathf.Clamp(defaultValue - dropPodThrustersConfiguration.Timer.Value, 0f, defaultValue);
		}

		public static bool CanLeaveEarly(float shipTimer)
		{
			return shipTimer > BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration.ExitTimer.Value;
		}

		public static bool IsUpgradeActive()
		{
			return BaseUpgrade.GetActiveUpgrade("Drop Pod Thrusters");
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return "$" + BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration.PurchaseMode)) + " - Make the Drop Pod, the ship that deliver items bought on the terminal, land faster.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Drop Pod Thrusters", BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<FasterDropPod>("Drop Pod Thrusters");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Drop Pod Thrusters", BaseUpgrade.GetConfiguration().DropPodThrustersConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "FasterDropPod";
		}
	}
	internal class LethalDeals : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Lethal Deals";

		internal const string WORLD_BUILDING_TEXT = "\n\nThe Company Store Loyalty Rewards Program. For a small fee and all of your personally-identifying information, you will be made eligible for one GUARANTEED random discount each Store rotation. Comes with a little plastic card for your keychain. There's a barcode on it, but the Terminal has nothing to scan the barcode with, so who knows what it's really for.\n\n";

		private const int GUARANTEED_ITEMS_AMOUNT = 1;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().LethalDealsConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nThe Company Store Loyalty Rewards Program. For a small fee and all of your personally-identifying information, you will be made eligible for one GUARANTEED random discount each Store rotation. Comes with a little plastic card for your keychain. There's a barcode on it, but the Terminal has nothing to scan the barcode with, so who knows what it's really for.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Lethal Deals";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LethalDealsConfiguration.OverrideName);
		}

		public static int GetLethalDealsGuaranteedItems(int amount)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Lethal Deals"))
			{
				return amount;
			}
			return 1;
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return "$" + BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LethalDealsConfiguration.PurchaseMode)) + " - Guarantees at least one item will be on sale in the store.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Lethal Deals", BaseUpgrade.GetConfiguration().LethalDealsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<LethalDeals>("Lethal Deals");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Lethal Deals", BaseUpgrade.GetConfiguration().LethalDealsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LethalDeals";
		}
	}
	public class Sigurd : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public enum FunctionModes
		{
			LastDay,
			AllDays
		}

		public const string UPGRADE_NAME = "Sigurd Access";

		internal const string WORLD_BUILDING_TEXT = "\n\nSigurd always laughed at Desmond when he remembered the stories about The Company paying 120% of the value of the scrap. Before disappearing, Sigurd found a module for the ship's terminal. After installing this mysterious module, the last scrap sale that Sigurd made was recorded at a value above normal.";

		public static Sigurd Instance;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().SigurdAccessConfiguration.Enabled.Value && BaseUpgrade.GetConfiguration().SigurdAccessConfiguration.Price.Value <= 0;

		internal override void Start()
		{
			upgradeName = "Sigurd Access";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().SigurdAccessConfiguration.OverrideName);
			base.Start();
		}

		private void Awake()
		{
			Instance = this;
		}

		public static float GetBuyingRate(float defaultValue)
		{
			SigurdAccessUpgradeConfiguration sigurdAccessConfiguration = BaseUpgrade.GetConfiguration().SigurdAccessConfiguration;
			if (!sigurdAccessConfiguration.Enabled.Value)
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sigurd Access"))
			{
				return defaultValue;
			}
			switch (sigurdAccessConfiguration.AlternativeMode.Value)
			{
			case FunctionModes.LastDay:
				if (TimeOfDay.Instance.daysUntilDeadline != 0)
				{
					return defaultValue;
				}
				break;
			}
			Random random = new Random(StartOfRound.Instance.randomMapSeed);
			if ((float)random.Next(0, 100) < Mathf.Clamp(sigurdAccessConfiguration.Chance.Value, 0f, 100f))
			{
				return defaultValue + sigurdAccessConfiguration.Effect.Value / 100f;
			}
			return defaultValue;
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().SigurdAccessConfiguration.PurchaseMode)) + " - There's a chance that the company will pay more.";
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSigurd always laughed at Desmond when he remembered the stories about The Company paying 120% of the value of the scrap. Before disappearing, Sigurd found a module for the ship's terminal. After installing this mysterious module, the last scrap sale that Sigurd made was recorded at a value above normal.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Sigurd Access", BaseUpgrade.GetConfiguration().SigurdAccessConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<Sigurd>("Sigurd Access");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Sigurd Access", BaseUpgrade.GetConfiguration().SigurdAccessConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "Sigurd";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Ship
{
	internal class FastEncryption : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Fast Encryption";

		internal const string WORLD_BUILDING_TEXT = "\n\nA small tweak for the signal translator that optimizes the way it compresses text over the Proprietary Network. Don't forget that the Company keeps records of all department transmissions for training purposes, and that your on-the-job conversations may be subject to playback and review by your Employer.\n\n";

		public static FastEncryption instance;

		private const float TRANSMIT_MULTIPLIER = 0.2f;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().FastEncryptionConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nA small tweak for the signal translator that optimizes the way it compresses text over the Proprietary Network. Don't forget that the Company keeps records of all department transmissions for training purposes, and that your on-the-job conversations may be subject to playback and review by your Employer.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Fast Encryption";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().FastEncryptionConfiguration.OverrideName);
			instance = this;
		}

		public static int GetLimitOfCharactersTransmit(int defaultLimit, string message)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Fast Encryption"))
			{
				return defaultLimit;
			}
			return message.Length;
		}

		public static float GetMultiplierOnSignalTextTimer(float defaultMultiplier)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Fast Encryption"))
			{
				return defaultMultiplier;
			}
			return defaultMultiplier * 0.2f;
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().FastEncryptionConfiguration.PurchaseMode)) + " - The transmitter will write the letters faster and the restriction of characters will be lifted.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Fast Encryption", BaseUpgrade.GetConfiguration().FastEncryptionConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<FastEncryption>("Fast Encryption");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Fast Encryption", BaseUpgrade.GetConfiguration().FastEncryptionConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "FastEncryption";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Player
{
	internal class LockSmith : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		[CompilerGenerated]
		private sealed class <CommunicateOrder>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<int> lst;

			public LockSmith <>4__this;

			private int <i>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.75f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<i>5__1 = 0;
					break;
				case 2:
					<>1__state = -1;
					((Graphic)<>4__this.pins[lst[<i>5__1]].GetComponent<Image>()).color = Color.white;
					<i>5__1++;
					break;
				}
				if (<i>5__1 < lst.Count)
				{
					((Graphic)<>4__this.pins[lst[<i>5__1]].GetComponent<Image>()).color = Color.green;
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 2;
					return true;
				}
				<>4__this.canPick = 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 const string UPGRADE_NAME = "Locksmith";

		internal const string WORLD_BUILDING_TEXT = "\n\nOn-the-job training package that supplies {0} with proprietary knowledge of the 'Ram, Scan, Bump' technique for bypassing The Company's proprietary Low-Tech Manual Security Doors' security system. Comes with an 'all-nines-notched' key, a rubber gasket, and a plastic handle on a metal rod {1}.\n\n";

		public static LockSmith instance;

		private List<GameObject> pins;

		private readonly List<int> order = new List<int>(5) { 0, 1, 2, 3, 4 };

		private int currentPin;

		public DoorLock currentDoor;

		private bool canPick;

		public int timesStruck;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().LocksmithConfiguration.Price.Value <= 0;

		private void Awake()
		{
			upgradeName = "Locksmith";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().LocksmithConfiguration.OverrideName);
			instance = this;
		}

		internal override void Start()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			base.Start();
			Transform child = ((Component)this).transform.GetChild(0).GetChild(0).GetChild(0);
			GameObject gameObject = ((Component)child.GetChild(0)).gameObject;
			GameObject gameObject2 = ((Component)child.GetChild(1)).gameObject;
			GameObject gameObject3 = ((Component)child.GetChild(2)).gameObject;
			GameObject gameObject4 = ((Component)child.GetChild(3)).gameObject;
			GameObject gameObject5 = ((Component)child.GetChild(4)).gameObject;
			((UnityEvent)((Component)gameObject.transform.GetChild(0)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				StrikePin(0);
			});
			((UnityEvent)((Component)gameObject2.transform.GetChild(0)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				StrikePin(1);
			});
			((UnityEvent)((Component)gameObject3.transform.GetChild(0)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				StrikePin(2);
			});
			((UnityEvent)((Component)gameObject4.transform.GetChild(0)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				StrikePin(3);
			});
			((UnityEvent)((Component)gameObject5.transform.GetChild(0)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				StrikePin(4);
			});
			pins = new List<GameObject>(5) { gameObject, gameObject2, gameObject3, gameObject4, gameObject5 };
		}

		private void Update()
		{
			if (((ButtonControl)Keyboard.current[(Key)60]).wasPressedThisFrame && ((Component)((Component)this).transform.GetChild(0)).gameObject.activeInHierarchy)
			{
				ToggleLocksmithUI(toggle: false);
			}
		}

		public void BeginLockPick(DoorLock door)
		{
			currentDoor = door;
			timesStruck = 0;
			ToggleLocksmithUI(toggle: true);
			SelectMinigame();
		}

		private void ToggleLocksmithUI(bool toggle)
		{
			if (toggle)
			{
				Cursor.lockState = (CursorLockMode)0;
			}
			else
			{
				Cursor.lockState = (CursorLockMode)1;
			}
			Cursor.visible = toggle;
			((Component)((Component)this).transform.GetChild(0)).gameObject.SetActive(toggle);
			GameNetworkManager.Instance.localPlayerController.quickMenuManager.isMenuOpen = toggle;
		}

		private void SelectMinigame()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			canPick = false;
			currentPin = 0;
			for (int i = 0; i < pins.Count; i++)
			{
				float num = Random.Range(40f, 90f);
				pins[i].transform.localPosition = new Vector3(pins[i].transform.localPosition.x, num, pins[i].transform.localPosition.z);
			}
			RandomizeListOrder(order);
			((MonoBehaviour)this).StartCoroutine(CommunicateOrder(order));
		}

		public void StrikePin(int i)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (!canPick)
			{
				return;
			}
			timesStruck++;
			if (i != order[currentPin])
			{
				SelectMinigame();
				RoundManager.Instance.PlayAudibleNoise(((Component)currentDoor).transform.position, 30f, 0.65f, timesStruck, false, 0);
				return;
			}
			currentPin++;
			pins[i].transform.localPosition = new Vector3(pins[i].transform.localPosition.x, 35f, pins[i].transform.localPosition.z);
			if (currentPin == 5)
			{
				ToggleLocksmithUI(toggle: false);
				currentDoor.UnlockDoorSyncWithServer();
			}
			RoundManager.Instance.PlayAudibleNoise(((Component)currentDoor).transform.position, 10f, 0.65f, timesStruck, false, 0);
		}

		private void RandomizeListOrder<T>(List<T> list)
		{
			int num = list.Count;
			Random random = new Random();
			while (num > 1)
			{
				num--;
				int num2 = random.Next(num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
		}

		[IteratorStateMachine(typeof(<CommunicateOrder>d__19))]
		private IEnumerator CommunicateOrder(List<int> lst)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CommunicateOrder>d__19(0)
			{
				<>4__this = this,
				lst = lst
			};
		}

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nOn-the-job training package that supplies {0} with proprietary knowledge of the 'Ram, Scan, Bump' technique for bypassing The Company's proprietary Low-Tech Manual Security Doors' security system. Comes with an 'all-nines-notched' key, a rubber gasket, and a plastic handle on a metal rod {1}.\n\n", shareStatus ? "your crew" : "you", shareStatus ? "for each of your coworkers" : "");
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().LocksmithConfiguration.PurchaseMode)) + " - Allows you to pick door locks by completing a minigame.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Locksmith", BaseUpgrade.GetConfiguration().LocksmithConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<LockSmith>("Locksmith");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Locksmith", BaseUpgrade.GetConfiguration().LocksmithConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LockSmith";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Items
{
	internal class SickBeats : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		internal List<BoomboxItem> boomBoxes = new List<BoomboxItem>();

		internal List<VehicleController> vehicleControllers = new List<VehicleController>();

		internal float staminaDrainCoefficient = 1f;

		internal float incomingDamageCoefficient = 1f;

		internal int damageBoost;

		internal GameObject BoomboxIcon;

		internal bool EffectsActive;

		public const string UPGRADE_NAME = "Sick Beats";

		internal const string WORLD_BUILDING_TEXT = "\n\nYou negotiated a trade for a cassette that has music on it you actually enjoy, improving your department's morale by a tangible amount. Ship-to-Ship trading with other contractors is difficult and expensive. This cassette costed your department 6 TZP Inhalers and a Lockpicker. You left it for them to pick up on Vow, and the next day you collected your cassette from Experimentation on top of the pipe.\n\n";

		internal static SickBeats Instance;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nYou negotiated a trade for a cassette that has music on it you actually enjoy, improving your department's morale by a tangible amount. Ship-to-Ship trading with other contractors is difficult and expensive. This cassette costed your department 6 TZP Inhalers and a Lockpicker. You left it for them to pick up on Vow, and the next day you collected your cassette from Experimentation on top of the pipe.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Sick Beats";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.OverrideName);
			Instance = this;
		}

		internal override void Start()
		{
			base.Start();
			BoomboxIcon = ((Component)((Component)this).transform.GetChild(0).GetChild(0)).gameObject;
		}

		public override void Unwind()
		{
			base.Unwind();
			Instance.BoomboxIcon.SetActive(false);
		}

		public static void HandlePlayerEffects(PlayerControllerB player)
		{
			SickBeatsUpgradeConfiguration sickBeatsUpgradeConfiguration = BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration;
			Instance.BoomboxIcon.SetActive(Instance.EffectsActive);
			if (Instance.EffectsActive)
			{
				if (sickBeatsUpgradeConfiguration.EnableSpeed.Value)
				{
					player.movementSpeed += sickBeatsUpgradeConfiguration.SpeedBoost.Value;
				}
				if (sickBeatsUpgradeConfiguration.EnableStaminaRegen.Value)
				{
					Instance.staminaDrainCoefficient = sickBeatsUpgradeConfiguration.StaminaRegenBoost.Value;
				}
				if (sickBeatsUpgradeConfiguration.EnableDefense.Value)
				{
					Instance.incomingDamageCoefficient = sickBeatsUpgradeConfiguration.DefenseBoost.Value;
				}
				if (sickBeatsUpgradeConfiguration.EnableDamage.Value)
				{
					Instance.damageBoost = sickBeatsUpgradeConfiguration.DamageBoost.Value;
				}
			}
			else
			{
				if (sickBeatsUpgradeConfiguration.EnableSpeed.Value)
				{
					player.movementSpeed -= sickBeatsUpgradeConfiguration.SpeedBoost.Value;
				}
				Instance.staminaDrainCoefficient = 1f;
				Instance.incomingDamageCoefficient = 1f;
				Instance.damageBoost = 0;
			}
		}

		public static float MuteBoomboxToEnemies(float defaultRange)
		{
			SickBeatsUpgradeConfiguration sickBeatsUpgradeConfiguration = BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(sickBeatsUpgradeConfiguration.Enabled))
			{
				return defaultRange;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sick Beats"))
			{
				return defaultRange;
			}
			if (SyncedEntry<bool>.op_Implicit(sickBeatsUpgradeConfiguration.BoomboxAttract))
			{
				return defaultRange;
			}
			return 0f;
		}

		public static float ApplyPossibleIncreasedStaminaRegen(float regenValue)
		{
			if (!BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.Enabled.Value)
			{
				return regenValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sick Beats"))
			{
				return regenValue;
			}
			return regenValue * Instance.staminaDrainCoefficient;
		}

		public static float ApplyPossibleDecreasedStaminaDrain(float drainValue)
		{
			SickBeatsUpgradeConfiguration sickBeatsUpgradeConfiguration = BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration;
			if (!sickBeatsUpgradeConfiguration.Enabled.Value)
			{
				return drainValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sick Beats"))
			{
				return drainValue;
			}
			if (!SyncedEntry<bool>.op_Implicit(sickBeatsUpgradeConfiguration.ApplyStaminaDuringConsumption))
			{
				return drainValue;
			}
			return drainValue * (1f - Mathf.Clamp(Instance.staminaDrainCoefficient - 1f, 0f, 1f));
		}

		public static int GetShovelHitForce(int force)
		{
			if (!BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.Enabled.Value)
			{
				return force;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sick Beats"))
			{
				return force;
			}
			return force + Instance.damageBoost;
		}

		public static int CalculateDefense(int dmg)
		{
			if (!BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.Enabled.Value)
			{
				return dmg;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Sick Beats") || dmg < 0)
			{
				return dmg;
			}
			return (int)((float)dmg * Instance.incomingDamageCoefficient);
		}

		public override string GetDisplayInfo(int price = -1)
		{
			SickBeatsUpgradeConfiguration sickBeatsUpgradeConfiguration = BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration;
			string text = $"Sick Beats - {BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(sickBeatsUpgradeConfiguration.PurchaseMode))}\nPlayers within a {sickBeatsUpgradeConfiguration.Radius.Value} unit radius from an active boombox will have the following effects:\n\n";
			if (sickBeatsUpgradeConfiguration.EnableSpeed.Value)
			{
				text += $"Movement speed increased by {sickBeatsUpgradeConfiguration.SpeedBoost.Value}\n";
			}
			if (sickBeatsUpgradeConfiguration.EnableDamage.Value)
			{
				text += $"Damage inflicted increased by {sickBeatsUpgradeConfiguration.DamageBoost.Value}\n";
			}
			if (sickBeatsUpgradeConfiguration.EnableDefense.Value)
			{
				text += $"Incoming Damage multiplied by {sickBeatsUpgradeConfiguration.DefenseBoost.Value}\n";
			}
			if (sickBeatsUpgradeConfiguration.EnableStaminaRegen.Value)
			{
				text += $"Stamina Regeneration multiplied by {sickBeatsUpgradeConfiguration.StaminaRegenBoost.Value}\n";
				if (SyncedEntry<bool>.op_Implicit(sickBeatsUpgradeConfiguration.ApplyStaminaDuringConsumption))
				{
					text += $"Also applies on stamina drain overtime (with the multiplier value of {Mathf.Clamp(SyncedEntry<float>.op_Implicit(sickBeatsUpgradeConfiguration.StaminaRegenBoost) - 1f, 0f, 1f)})\n";
				}
			}
			return text;
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Sick Beats", BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<SickBeats>("Sick Beats");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Sick Beats", BaseUpgrade.GetConfiguration().SickBeatsUpgradeConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "SickBeats";
		}
	}
	internal class WalkieGPS : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Walkie GPS";

		internal const string WORLD_BUILDING_TEXT = "\n\nAnother department was in the shipyard at the same time as yours and they swapped you a handwritten guide on jailbreaking the Company-issued walkie-talkies for 5 TZP Inhalers & 2 Pro Flashlights. Using their method, you figured out how to get your walkie-talkie to print debug information that's normally hidden from view, the two most useful readouts being Magnetically-Determined Local Time and Sattelite-Estimated Relative Location.\n\n";

		public static WalkieGPS instance;

		private bool walkieUIActive;

		private GameObject canvas;

		private Text x;

		private Text y;

		private Text z;

		private Text time;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().WalkieGpsConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nAnother department was in the shipyard at the same time as yours and they swapped you a handwritten guide on jailbreaking the Company-issued walkie-talkies for 5 TZP Inhalers & 2 Pro Flashlights. Using their method, you figured out how to get your walkie-talkie to print debug information that's normally hidden from view, the two most useful readouts being Magnetically-Determined Local Time and Sattelite-Estimated Relative Location.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Walkie GPS";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().WalkieGpsConfiguration.OverrideName);
			instance = this;
		}

		internal override void Start()
		{
			base.Start();
			canvas = ((Component)((Component)this).transform.GetChild(0)).gameObject;
			x = ((Component)canvas.transform.GetChild(0)).GetComponent<Text>();
			y = ((Component)canvas.transform.GetChild(1)).GetComponent<Text>();
			z = ((Component)canvas.transform.GetChild(2)).GetComponent<Text>();
			time = ((Component)canvas.transform.GetChild(3)).GetComponent<Text>();
		}

		public void Update()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (walkieUIActive)
			{
				Vector3 position = ((Component)GameNetworkManager.Instance.localPlayerController).transform.position;
				x.text = $"X: {position.x:F1}";
				y.text = $"Y: {position.y:F1}";
				z.text = $"Z: {position.z:F1}";
				int num = (int)(TimeOfDay.Instance.normalizedTimeOfDay * (60f * (float)TimeOfDay.Instance.numberOfHours)) + 360;
				int num2 = (int)Mathf.Floor((float)num / 60f);
				string text = "AM";
				if (num2 > 12)
				{
					text = "PM";
				}
				if (num2 > 12)
				{
					num2 %= 12;
				}
				int num3 = num % 60;
				string text2 = $"{num2:00}:{num3:00}".TrimStart('0') + text;
				time.text = text2;
			}
		}

		public void WalkieActive()
		{
			if (!canvas.activeInHierarchy)
			{
				walkieUIActive = true;
				canvas.SetActive(true);
			}
		}

		public void WalkieDeactivate()
		{
			walkieUIActive = false;
			canvas.SetActive(false);
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().WalkieGpsConfiguration.PurchaseMode)) + " - Displays your location and time when holding a walkie talkie.\nEspecially useful for fog.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Walkie GPS", BaseUpgrade.GetConfiguration().WalkieGpsConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<WalkieGPS>("Walkie GPS");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Walkie GPS", BaseUpgrade.GetConfiguration().WalkieGpsConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "WalkieGPS";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.OneTimeUpgrades.Enemies
{
	internal class FedoraSuit : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		internal const string UPGRADE_NAME = "Fedora Suit";

		internal const string WORLD_BUILDING_TEXT = "\n\nValid and more-recent Staff lanyards for {0}, indicating to any current and former Company Staff that you are permitted to be within the facility. Doesn't work on turrets, as those are... newer.\n\n";

		internal static FedoraSuit instance;

		internal Dictionary<ulong, bool> wearingFedora;

		public override bool CanInitializeOnStart => BaseUpgrade.GetConfiguration().FedoraSuitConfiguration.Price.Value <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return string.Format("\n\nValid and more-recent Staff lanyards for {0}, indicating to any current and former Company Staff that you are permitted to be within the facility. Doesn't work on turrets, as those are... newer.\n\n", shareStatus ? "your crew" : "you");
		}

		private void Awake()
		{
			upgradeName = "Fedora Suit";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().FedoraSuitConfiguration.OverrideName);
			wearingFedora = new Dictionary<ulong, bool>();
			instance = this;
		}

		public override void Load()
		{
			base.Load();
			ulong actualClientId = GameNetworkManager.Instance.localPlayerController.actualClientId;
			if (((NetworkBehaviour)this).IsServer)
			{
				ToggleFedoraToPlayerClientRpc(actualClientId, fedora: true);
			}
			else
			{
				ToggleFedoraToPlayerServerRpc(actualClientId, fedora: true);
			}
		}

		public override void Unwind()
		{
			base.Unwind();
			ulong actualClientId = GameNetworkManager.Instance.localPlayerController.actualClientId;
			if (((NetworkBehaviour)this).IsServer)
			{
				ToggleFedoraToPlayerClientRpc(actualClientId, fedora: false);
			}
			else
			{
				ToggleFedoraToPlayerServerRpc(actualClientId, fedora: false);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void ToggleFedoraToPlayerServerRpc(ulong clientId, bool fedora)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3685349357u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref fedora, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3685349357u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ToggleFedoraToPlayerClientRpc(clientId, fedora);
				}
			}
		}

		[ClientRpc]
		internal void ToggleFedoraToPlayerClientRpc(ulong clientId, bool fedora)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3924203862u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref fedora, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3924203862u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					wearingFedora[clientId] = fedora;
				}
			}
		}

		public static int IsWearingFedoraSuitInt(PlayerControllerB spottedPlayer)
		{
			return IsWearingFedoraSuit(spottedPlayer) ? 1 : 0;
		}

		public static bool IsWearingFedoraSuit(PlayerControllerB spottedPlayer)
		{
			if (!SyncedEntry<bool>.op_Implicit(BaseUpgrade.GetConfiguration().FedoraSuitConfiguration.Enabled))
			{
				return false;
			}
			ulong actualClientId = spottedPlayer.actualClientId;
			return instance.wearingFedora.GetValueOrDefault(actualClientId, defaultValue: false);
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().FedoraSuitConfiguration.PurchaseMode)) + " - Butlers will not feel the urge of stabbing you due to your sophisticated taste in clothes.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Fedora Suit", BaseUpgrade.GetConfiguration().FedoraSuitConfiguration.ItemProgressionItems.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			BaseUpgrade.SetupGenericPerk<FedoraSuit>("Fedora Suit");
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Fedora Suit", BaseUpgrade.GetConfiguration().FedoraSuitConfiguration);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3685349357u, new RpcReceiveHandler(__rpc_handler_3685349357), "ToggleFedoraToPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(3924203862u, new RpcReceiveHandler(__rpc_handler_3924203862), "ToggleFedoraToPlayerClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_3685349357(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				bool fedora = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fedora, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((FedoraSuit)(object)target).ToggleFedoraToPlayerServerRpc(clientId, fedora);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3924203862(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				bool fedora = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fedora, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((FedoraSuit)(object)target).ToggleFedoraToPlayerClientRpc(clientId, fedora);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "FedoraSuit";
		}
	}
	internal class SilverBullets : OneTimeUpgrade, IUpgradeWorldBuilding
	{
		public const string UPGRADE_NAME = "Silver Bullets";

		internal const string WORLD_BUILDING_TEXT = "\n\nSome things are better left unexplained.\n\n";

		public override bool CanInitializeOnStart => SyncedEntry<int>.op_Implicit(BaseUpgrade.GetConfiguration().SilverBulletsConfiguration.Price) <= 0;

		public string GetWorldBuildingText(bool shareStatus = false)
		{
			return "\n\nSome things are better left unexplained.\n\n";
		}

		private void Awake()
		{
			upgradeName = "Silver Bullets";
			overridenUpgradeName = SyncedEntry<string>.op_Implicit(BaseUpgrade.GetConfiguration().SilverBulletsConfiguration.OverrideName);
		}

		public override string GetDisplayInfo(int price = -1)
		{
			return BaseUpgrade.GetUpgradePrice(price, SyncedEntry<PurchaseMode>.op_Implicit(BaseUpgrade.GetConfiguration().SilverBulletsConfiguration.PurchaseMode)) + " - The pellets in the shotgun are replaced with silver, allowing you to cleanse some paranormal activity if necessary.";
		}

		public new static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Silver Bullets", BaseUpgrade.GetConfiguration().SilverBulletsConfiguration.OverrideName.Value.Split(","));
		}

		public new static void RegisterUpgrade()
		{
			GameObject val = ItemManager.CreateNetworkPrefab("Silver Bullets");
			val.AddComponent<SilverBullets>();
			ItemManager.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Silver Bullets"] = val;
		}

		public new static CustomTerminalNode RegisterTerminalNode()
		{
			return UpgradeBus.Instance.SetupOneTimeTerminalNode("Silver Bullets", BaseUpgrade.GetConfiguration().SilverBulletsConfiguration, Plugin.networkPrefabs["Silver Bullets"]);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "SilverBullets";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items
{
	public abstract class LategameItem : GrabbableObject
	{
		protected abstract bool KeepScanNode { get; }

		public static void LoadItem()
		{
			throw new NotImplementedException();
		}

		public override void Start()
		{
			((GrabbableObject)this).Start();
			if (!KeepScanNode)
			{
				LguScanNodeProperties.RemoveScanNode(((Component)this).gameObject);
			}
		}

		protected override void __initializeVariables()
		{
			((GrabbableObject)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((GrabbableObject)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "LategameItem";
		}
	}
	internal class Medkit : LategameItem, IDisplayInfo
	{
		internal const string ITEM_NAME = "Medkit";

		public AudioClip error;

		public AudioClip use;

		private AudioSource audio;

		private HUDManager hudManager;

		private int uses = 0;

		protected int maximumUses;

		protected int healAmount;

		protected override bool KeepScanNode => SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.MEDKIT_SCAN_NODE);

		public override void Start()
		{
			base.Start();
			audio = ((Component)this).GetComponent<AudioSource>();
			hudManager = HUDManager.Instance;
			maximumUses = UpgradeBus.Instance.PluginConfiguration.MEDKIT_USES.Value;
			healAmount = UpgradeBus.Instance.PluginConfiguration.MEDKIT_HEAL_VALUE.Value;
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).playerHeldBy.activatingItem = false;
			((GrabbableObject)this).DiscardItem();
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			AttemptToHealPlayer();
		}

		private void AttemptToHealPlayer()
		{
			int num = 100;
			if (UpgradeBus.Instance.PluginConfiguration.StimpackConfiguration.Enabled.Value)
			{
				num = (Stimpack.Instance.playerHealthLevels.ContainsKey(((GrabbableObject)this).playerHeldBy.playerSteamId) ? Stimpack.GetHealthFromPlayer(100, ((GrabbableObject)this).playerHeldBy.playerSteamId) : num);
			}
			if (CanUseMedkit(num))
			{
				UseMedkit(num);
			}
		}

		private void UseMedkit(int maximumHealth)
		{
			audio.PlayOneShot(use);
			int num = healAmount;
			int num2 = ((GrabbableObject)this).playerHeldBy.health + num;
			if (num2 > maximumHealth)
			{
				num -= num2 - maximumHealth;
			}
			PlayerControllerB playerHeldBy = ((GrabbableObject)this).playerHeldBy;
			playerHeldBy.health += num;
			hudManager.UpdateHealthUI(((GrabbableObject)this).playerHeldBy.health, false);
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				UpdateMedkitUsesClientRpc();
			}
			else
			{
				UpdateMedkitUsesServerRpc();
			}
			if (((GrabbableObject)this).playerHeldBy.health >= 20)
			{
				((GrabbableObject)this).playerHeldBy.MakeCriticallyInjured(false);
			}
		}

		private bool CanUseMedkit(int maximumHealth)
		{
			if (((GrabbableObject)this).itemUsedUp)
			{
				hudManager.DisplayTip("NO MORE USES!", "This medkit doesn't have anymore supplies!", true, false, "LC_Tip1");
				return false;
			}
			if (!Mouse.current.leftButton.isPressed)
			{
				return false;
			}
			if (((GrabbableObject)this).playerHeldBy.health >= maximumHealth)
			{
				audio.PlayOneShot(error);
				return false;
			}
			return true;
		}

		[ServerRpc]
		private void UpdateMedkitUsesServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4132677228u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4132677228u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				UpdateMedkitUsesClientRpc();
			}
		}

		[ClientRpc]
		private void UpdateMedkitUsesClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(300397343u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 300397343u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateMedkitUsagesLocal();
				}
			}
		}

		private void UpdateMedkitUsagesLocal()
		{
			uses++;
			if (uses >= maximumUses)
			{
				((GrabbableObject)this).itemUsedUp = true;
				if ((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)(object)UpgradeBus.Instance.GetLocalPlayer())
				{
					hudManager.DisplayTip("NO MORE USES!", "This medkit doesn't have anymore supplies!", true, false, "LC_Tip1");
				}
			}
		}

		public string GetDisplayInfo()
		{
			return $"MEDKIT - ${UpgradeBus.Instance.PluginConfiguration.MEDKIT_PRICE.Value}\n\n" + $"Left click to heal yourself for {UpgradeBus.Instance.PluginConfiguration.MEDKIT_HEAL_VALUE.Value} health.\n" + $"Can be used {UpgradeBus.Instance.PluginConfiguration.MEDKIT_USES.Value} times.";
		}

		public new static void LoadItem()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			AudioClip audioClip = AssetBundleHandler.GetAudioClip("Error");
			AudioClip audioClip2 = AssetBundleHandler.GetAudioClip("Button Press");
			Item itemObject = AssetBundleHandler.GetItemObject("Medkit");
			if (!((Object)(object)itemObject == (Object)null))
			{
				AnimationCurve curve = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0f, (float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.AmountMedkits.Value),
					new Keyframe(1f, (float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.AmountMedkits.Value)
				});
				itemObject.creditsWorth = UpgradeBus.Instance.PluginConfiguration.MEDKIT_PRICE.Value;
				itemObject.itemId = 492016;
				itemObject.itemName = "Medic Bag";
				Medkit medkit = itemObject.spawnPrefab.AddComponent<Medkit>();
				((GrabbableObject)medkit).itemProperties = itemObject;
				((GrabbableObject)medkit).grabbable = true;
				((GrabbableObject)medkit).useCooldown = 2f;
				((GrabbableObject)medkit).grabbableToEnemies = true;
				medkit.error = audioClip;
				medkit.use = audioClip2;
				ItemManager.SetupStoreItem(itemObject);
				Item itemObject2 = AssetBundleHandler.GetItemObject("MedkitMapItem");
				if (!((Object)(object)itemObject2 == (Object)null))
				{
					Medkit medkit2 = itemObject2.spawnPrefab.AddComponent<Medkit>();
					itemObject2.spawnPrefab.AddComponent<ExtractionContract>();
					itemObject2.itemName = "Medic Bag";
					((GrabbableObject)medkit2).itemProperties = itemObject2;
					((GrabbableObject)medkit2).grabbable = true;
					((GrabbableObject)medkit2).useCooldown = 2f;
					((GrabbableObject)medkit2).grabbableToEnemies = true;
					medkit2.error = audioClip;
					medkit2.use = audioClip2;
					ItemManager.RegisterNetworkPrefab(itemObject2.spawnPrefab);
					ItemManager.SetupMapObject(itemObject2, curve);
					UpgradeBus.Instance.ItemsToSync.Add("Medkit", itemObject);
				}
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(4132677228u, new RpcReceiveHandler(__rpc_handler_4132677228), "UpdateMedkitUsesServerRpc");
			((NetworkBehaviour)this).__registerRpc(300397343u, new RpcReceiveHandler(__rpc_handler_300397343), "UpdateMedkitUsesClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_4132677228(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Medkit)(object)target).UpdateMedkitUsesServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_300397343(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Medkit)(object)target).UpdateMedkitUsesClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Medkit";
		}
	}
	internal class MonsterSample : LategameItem
	{
		private static int usedMapSeed = -1;

		private static Random random = null;

		private ParticleSystem particles;

		protected override bool KeepScanNode => true;

		public override void Start()
		{
			base.Start();
			if (usedMapSeed < 0 || random == null || usedMapSeed != StartOfRound.Instance.randomMapSeed)
			{
				usedMapSeed = StartOfRound.Instance.randomMapSeed;
				random = new Random(usedMapSeed + 105);
			}
			int num = random.Next(((GrabbableObject)this).itemProperties.minValue, ((GrabbableObject)this).itemProperties.maxValue);
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.AffectSamples))
			{
				Plugin.mls.LogDebug((object)$"Midas Touch affecting samples is enabled, increasing the original scrap value ({num})...");
				num = MidasTouch.IncreaseScrapValueInteger(num);
				Plugin.mls.LogDebug((object)$"Set the sample scrap value to {num}...");
			}
			((Component)this).GetComponent<ScrapValueSyncer>().SetScrapValue(num);
			particles = ((Component)this).GetComponentInChildren<ParticleSystem>();
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
			ToggleParticles(toggle: true);
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).DiscardItem();
			ToggleParticles(toggle: false);
		}

		public override void PocketItem()
		{
			((GrabbableObject)this).PocketItem();
			ToggleParticles(toggle: false);
		}

		private void ToggleParticles(bool toggle)
		{
			if (toggle)
			{
				particles.Play(true);
			}
			else
			{
				particles.Stop(true, (ParticleSystemStopBehavior)0);
			}
		}

		public new static void LoadItem()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>
			{
				{
					"centipede",
					UpgradeBus.Instance.PluginConfiguration.SNARE_FLEA_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"bunker spider",
					UpgradeBus.Instance.PluginConfiguration.BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"hoarding bug",
					UpgradeBus.Instance.PluginConfiguration.HOARDING_BUG_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"flowerman",
					UpgradeBus.Instance.PluginConfiguration.BRACKEN_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"mouthdog",
					UpgradeBus.Instance.PluginConfiguration.EYELESS_DOG_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"baboon hawk",
					UpgradeBus.Instance.PluginConfiguration.BABOON_HAWK_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"crawler",
					UpgradeBus.Instance.PluginConfiguration.THUMPER_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"forestgiant",
					UpgradeBus.Instance.PluginConfiguration.FOREST_KEEPER_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"manticoil",
					UpgradeBus.Instance.PluginConfiguration.MANTICOIL_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"tulip snake",
					UpgradeBus.Instance.PluginConfiguration.TULIP_SNAKE_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"bush wolf",
					UpgradeBus.Instance.PluginConfiguration.KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"puffer",
					UpgradeBus.Instance.PluginConfiguration.SPORE_LIZARD_SAMPLE_MINIMUM_VALUE.Value
				},
				{
					"maneater",
					SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.MANEATER_SAMPLE_MINIMUM_VALUE)
				},
				{
					"giantkiwi",
					SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE)
				}
			};
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>
			{
				{
					"centipede",
					UpgradeBus.Instance.PluginConfiguration.SNARE_FLEA_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"bunker spider",
					UpgradeBus.Instance.PluginConfiguration.BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"hoarding bug",
					UpgradeBus.Instance.PluginConfiguration.HOARDING_BUG_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"flowerman",
					UpgradeBus.Instance.PluginConfiguration.BRACKEN_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"mouthdog",
					UpgradeBus.Instance.PluginConfiguration.EYELESS_DOG_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"baboon hawk",
					UpgradeBus.Instance.PluginConfiguration.BABOON_HAWK_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"crawler",
					UpgradeBus.Instance.PluginConfiguration.THUMPER_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"forestgiant",
					UpgradeBus.Instance.PluginConfiguration.FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"manticoil",
					UpgradeBus.Instance.PluginConfiguration.MANTICOIL_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"tulip snake",
					UpgradeBus.Instance.PluginConfiguration.TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"bush wolf",
					UpgradeBus.Instance.PluginConfiguration.KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"puffer",
					UpgradeBus.Instance.PluginConfiguration.SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE.Value
				},
				{
					"maneater",
					SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.MANEATER_SAMPLE_MAXIMUM_VALUE)
				},
				{
					"giantkiwi",
					SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE)
				}
			};
			foreach (string key in AssetBundleHandler.samplePaths.Keys)
			{
				Item itemObject = AssetBundleHandler.GetItemObject(key);
				itemObject.minValue = dictionary[key];
				itemObject.maxValue = dictionary2[key];
				HunterSamples.RegisterSampleItem(itemObject, key, registerNetworkPrefab: true);
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "MonsterSample";
		}
	}
	internal class NightVisionGoggles : LategameItem, IItemWorldBuilding, IDisplayInfo
	{
		internal const string ITEM_NAME = "Night Vision Goggles";

		internal const string WORLD_BUILDING_TEXT = "Very old military surplus phosphor lens modules, retrofitted for compatibility with modern Company-issued helmets and offered to employees of The Company on a subscription plan. The base package comes with cheap batteries, but premium subscriptions offer regular issuances of higher-quality energy solutions, ranging from hobby grade to industrial application power banks. The modules also come with DRM that prevents the user from improvising with other kinds of batteries.";

		protected override bool KeepScanNode => true;

		public string GetDisplayInfo()
		{
			string arg = ((UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.Individual.Value || !UpgradeBus.Instance.PluginConfiguration.SHARED_UPGRADES.Value) ? "one" : "all");
			string arg2 = (UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.LoseOnDeath.Value ? "be" : "not be");
			return string.Format(AssetBundleHandler.GetInfoFromJSON("Night Vision"), arg, arg2);
		}

		public string GetWorldBuildingText()
		{
			return "Very old military surplus phosphor lens modules, retrofitted for compatibility with modern Company-issued helmets and offered to employees of The Company on a subscription plan. The base package comes with cheap batteries, but premium subscriptions offer regular issuances of higher-quality energy solutions, ranging from hobby grade to industrial application power banks. The modules also come with DRM that prevents the user from improvising with other kinds of batteries.";
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (!buttonDown || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.Enabled))
			{
				return;
			}
			if (BaseUpgrade.GetActiveUpgrade("Night Vision"))
			{
				TextMeshProUGUI chatText = HUDManager.Instance.chatText;
				((TMP_Text)chatText).text = ((TMP_Text)chatText).text + "<color=#FF0000>Night vision is already active!</color>";
				return;
			}
			if (UpgradeBus.GetUpgradeNodes().First((CustomTerminalNode x) => x.OriginalName == "NV Headset Batteries").SharedUpgrade)
			{
				NightVision.Instance.EnableNightVisionServerRpc();
			}
			else
			{
				UpgradeBus.Instance.UpgradeObjects["NV Headset Batteries"].GetComponent<NightVision>().EnableOnClient();
			}
			((GrabbableObject)this).playerHeldBy.DespawnHeldObject();
			LguStore.Instance.SaveInfo = new SaveInfo();
			LguStore.Instance.UpdateLGUSaveServerRpc(LguStore.Instance.playerID, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)LguStore.Instance.SaveInfo)), saveFile: true);
		}

		public new static void LoadItem()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Item itemObject = AssetBundleHandler.GetItemObject("Night Vision");
			if (!((Object)(object)itemObject == (Object)null))
			{
				itemObject.creditsWorth = UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.ItemPrice.Value;
				itemObject.spawnPrefab.transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
				itemObject.itemId = 492014;
				NightVisionGoggles nightVisionGoggles = itemObject.spawnPrefab.AddComponent<NightVisionGoggles>();
				((GrabbableObject)nightVisionGoggles).itemProperties = itemObject;
				((GrabbableObject)nightVisionGoggles).grabbable = true;
				((GrabbableObject)nightVisionGoggles).useCooldown = 2f;
				((GrabbableObject)nightVisionGoggles).grabbableToEnemies = true;
				ItemManager.RegisterNetworkPrefab(itemObject.spawnPrefab);
				UpgradeBus.Instance.ItemsToSync.Add("Night Vision Goggles", itemObject);
				ItemManager.SetupStoreItem(itemObject);
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "NightVisionGoggles";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.RadarBooster
{
	internal class ChargingStationManager : MonoBehaviour
	{
		private InteractTrigger interactComponent;

		internal float cooldown = 0f;

		private void Start()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			GameObject chargeStation = Object.Instantiate<GameObject>(GameObject.CreatePrimitive((PrimitiveType)3), ((Component)this).transform.position, Quaternion.Euler(Vector3.zero), ((Component)this).transform);
			chargeStation.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
			chargeStation.tag = "InteractTrigger";
			chargeStation.layer = LayerMask.NameToLayer("Props");
			((Object)chargeStation).name = "Charging Station";
			((Collider)chargeStation.GetComponent<BoxCollider>()).isTrigger = true;
			InitializeInteractTrigger(ref chargeStation);
		}

		private void InitializeInteractTrigger(ref GameObject chargeStation)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			InteractTrigger val = chargeStation.AddComponent<InteractTrigger>();
			val.interactable = true;
			val.holdInteraction = true;
			val.timeToHold = 2f;
			val.holdingInteractEvent = new InteractEventFloat();
			val.onInteractEarly = new InteractEvent();
			val.onStopInteract = new InteractEvent();
			val.onInteract = new InteractEvent();
			((UnityEvent<PlayerControllerB>)(object)val.onInteract).AddListener((UnityAction<PlayerControllerB>)OnChargeInteract);
			val.hoverIcon = ((GrabbableObject)((Component)this).GetComponent<RadarBoosterItem>()).itemProperties.itemIcon;
			val.disabledHoverIcon = ((GrabbableObject)((Component)this).GetComponent<RadarBoosterItem>()).itemProperties.itemIcon;
			interactComponent = val;
		}

		private void Update()
		{
			PlayerControllerB localPlayer = UpgradeBus.Instance.GetLocalPlayer();
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			if (cooldown > 0f)
			{
				SetInteractable(interact: false, $"On cooldown... [{(int)cooldown}s]");
				cooldown -= Time.deltaTime;
				return;
			}
			if (!localPlayer.isHoldingObject)
			{
				SetInteractable(interact: false, "Not holding an item to charge up...");
				return;
			}
			GrabbableObject currentlyHeldObjectServer = localPlayer.currentlyHeldObjectServer;
			if (!currentlyHeldObjectServer.itemProperties.requiresBattery)
			{
				SetInteractable(interact: false, "This item cannot be charged...");
			}
			else
			{
				SetInteractable(interact: true, "Charge item: [LMB]");
			}
		}

		private void SetInteractable(bool interact, string text)
		{
			interactComponent.interactable = interact;
			if (interact)
			{
				interactComponent.hoverTip = text;
			}
			else
			{
				interactComponent.disabledHoverTip = text;
			}
		}

		private void OnChargeInteract(PlayerControllerB interactingPlayer)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject currentlyHeldObjectServer = interactingPlayer.currentlyHeldObjectServer;
			currentlyHeldObjectServer.insertedBattery.charge = Mathf.Clamp(currentlyHeldObjectServer.insertedBattery.charge + (float)UpgradeBus.Instance.PluginConfiguration.ChargingBoosterConfiguration.GetSecondEffectPair(0).Item1.Value / 100f, 0f, 1f);
			cooldown = ChargingBooster.Instance.chargeCooldown;
			ChargingBooster.Instance.UpdateCooldownServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)((Component)this).GetComponent<RadarBoosterItem>()));
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.Contracts.Extraction
{
	internal class ExtractPlayerScript : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <AudioStream>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ExtractPlayerScript <>4__this;

			private float <TimeToWait>5__1;

			private string <soundType>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<TimeToWait>5__1 = Random.Range(25f, 45f);
					if (((GrabbableObject)<>4__this.prop).isInShipRoom)
					{
						<TimeToWait>5__1 *= 3f;
					}
					<>2__current = (object)new WaitForSeconds(<TimeToWait>5__1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((GrabbableObject)<>4__this.prop).isHeld)
					{
						<soundType>5__2 = "held";
					}
					else if (((GrabbableObject)<>4__this.prop).isInShipRoom)
					{
						<soundType>5__2 = "safe";
					}
					else
					{
						<soundType>5__2 = "lost";
					}
					<>4__this.PlayAudioClientRpc(Random.Range(0, clipDict[<soundType>5__2].Length), "lost");
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.AudioStream());
					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();
			}
		}

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

			private object <>2__current;

			public ExtractPlayerScript <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Collider)((Component)<>4__this).GetComponent<BoxCollider>()).enabled = true;
					return false;
				}
			}

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

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

		private AudioSource audio;

		private PhysicsProp prop;

		internal static readonly Dictionary<string, AudioClip[]> clipDict = new Dictionary<string, AudioClip[]>();

		private bool hurtState;

		private InteractTrigger trig;

		private Animator anim;

		private void Start()
		{
			prop = ((Component)this).GetComponent<PhysicsProp>();
			((Component)this).GetComponent<ScrapValueSyncer>().SetScrapValue(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.RewardValue.Value + (int)((float)TimeOfDay.Instance.profitQuota * Mathf.Clamp((float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RewardQuotaMultiplier.Value / 100f, 0f, 1f)));
			audio = ((Component)this).GetComponent<AudioSource>();
			trig = ((Component)this).GetComponentInChildren<InteractTrigger>();
			((UnityEvent<PlayerControllerB>)(object)trig.onInteract).AddListener((UnityAction<PlayerControllerB>)InteractComplete);
			anim = ((Component)this).GetComponent<Animator>();
			if (((NetworkBehaviour)this).IsHost)
			{
				((MonoBehaviour)this).StartCoroutine(AudioStream());
			}
		}

		private void Update()
		{
			if (((GrabbableObject)prop).isHeld)
			{
				anim.SetInteger("holdStatus", 1);
			}
			else
			{
				anim.SetInteger("holdStatus", 0);
			}
			if (!hurtState)
			{
				trig.interactable = EvalMedKit();
			}
		}

		private bool EvalMedKit()
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				return false;
			}
			if ((Object)(object)localPlayerController.currentlyHeldObjectServer == (Object)null)
			{
				return false;
			}
			if (localPlayerController.currentlyHeldObjectServer.itemProperties.itemName == "Medic Bag")
			{
				return true;
			}
			return false;
		}

		private void InteractComplete(PlayerControllerB player)
		{
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				HealScavClientRpc();
			}
			else
			{
				ReqHealScavServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ReqHealScavServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(711752951u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 711752951u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HealScavClientRpc();
				}
			}
		}

		[ClientRpc]
		private void HealScavClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2040945765u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2040945765u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HealScavenger();
				}
			}
		}

		private void HealScavenger()
		{
			((Collider)((Component)trig).GetComponent<BoxCollider>()).enabled = false;
			audio.PlayOneShot(clipDict["heal"][0], UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.ScavengerVolume.Value);
			anim.SetTrigger("heal");
			hurtState = false;
			((MonoBehaviour)this).StartCoroutine(WaitForHealAnim());
			((Behaviour)((Component)this).GetComponent<PhysicsProp>()).enabled = true;
		}

		[IteratorStateMachine(typeof(<WaitForHealAnim>d__13))]
		private IEnumerator WaitForHealAnim()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForHealAnim>d__13(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<AudioStream>d__14))]
		private IEnumerator AudioStream()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AudioStream>d__14(0)
			{
				<>4__this = this
			};
		}

		[ClientRpc]
		private void PlayAudioClientRpc(int index, string soundType)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(584503947u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, index);
				bool flag = soundType != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(soundType, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 584503947u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayAudioLocal(index, soundType);
			}
		}

		private void PlayAudioLocal(int index, string soundType)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			audio.PlayOneShot(clipDict[soundType][index], UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.ScavengerVolume.Value);
			RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 30f, 0.9f, 0, ((GrabbableObject)prop).isInShipRoom, 5);
		}

		internal void MakeScavengerGrabbable()
		{
			trig = ((Component)this).GetComponentInChildren<InteractTrigger>();
			((Collider)((Component)trig).GetComponent<BoxCollider>()).enabled = false;
			anim = ((Component)this).GetComponent<Animator>();
			anim.SetTrigger("heal");
			hurtState = false;
			((MonoBehaviour)this).StartCoroutine(WaitForHealAnim());
			((Behaviour)((Component)this).GetComponent<PhysicsProp>()).enabled = true;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(711752951u, new RpcReceiveHandler(__rpc_handler_711752951), "ReqHealScavServerRpc");
			((NetworkBehaviour)this).__registerRpc(2040945765u, new RpcReceiveHandler(__rpc_handler_2040945765), "HealScavClientRpc");
			((NetworkBehaviour)this).__registerRpc(584503947u, new RpcReceiveHandler(__rpc_handler_584503947), "PlayAudioClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_711752951(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ExtractPlayerScript)(object)target).ReqHealScavServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2040945765(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ExtractPlayerScript)(object)target).HealScavClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_584503947(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string soundType = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref soundType, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ExtractPlayerScript)(object)target).PlayAudioClientRpc(index, soundType);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ExtractPlayerScript";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.Contracts.Exterminator
{
	internal class BugNestScript : NetworkBehaviour
	{
		private Animator anim;

		public GameObject loot;

		private InteractTrigger trig;

		private int cleaning = 0;

		private void Awake()
		{
			trig = ((Component)this).GetComponent<InteractTrigger>();
			((UnityEvent<PlayerControllerB>)(object)trig.onInteract).AddListener((UnityAction<PlayerControllerB>)CleanMess);
			((UnityEvent<PlayerControllerB>)(object)trig.onStopInteract).AddListener((UnityAction<PlayerControllerB>)StopMess);
			((UnityEvent<PlayerControllerB>)(object)trig.onInteractEarly).AddListener((UnityAction<PlayerControllerB>)PlayMess);
			anim = ((Component)this).GetComponentInChildren<Animator>();
		}

		private void Update()
		{
			anim.SetInteger("CleanStatus", cleaning);
		}

		[ServerRpc(RequireOwnership = false)]
		private void SpawnLootServerRpc(Vector3 pos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(762018903u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 762018903u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SpawnLoot(pos);
				}
			}
		}

		private void SpawnLoot(Vector3 position)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(loot, position + Vector3.up, Quaternion.identity);
			val.GetComponent<ScrapValueSyncer>().SetScrapValue(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExterminationConfiguration.RewardValue.Value + (int)((float)TimeOfDay.Instance.profitQuota * Mathf.Clamp((float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RewardQuotaMultiplier.Value / 100f, 0f, 1f)));
			val.GetComponent<NetworkObject>().Spawn(false);
			DisableNestClientRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)this).NetworkObject));
		}

		[ClientRpc]
		private void DisableNestClientRpc(NetworkObjectReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1057964526u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref netRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1057964526u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				((NetworkObjectReference)(ref netRef)).TryGet(ref val3, (NetworkManager)null);
				if ((Object)(object)val3 != (Object)null)
				{
					val3.Despawn(true);
				}
			}
		}

		private void CleanMess(PlayerControllerB player)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)this).transform.position + Vector3.up;
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				SpawnLoot(val);
			}
			else
			{
				SpawnLootServerRpc(val);
			}
		}

		private void StopMess(PlayerControllerB player)
		{
			cleaning = 0;
		}

		private void PlayMess(PlayerControllerB player)
		{
			cleaning = 1;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(762018903u, new RpcReceiveHandler(__rpc_handler_762018903), "SpawnLootServerRpc");
			((NetworkBehaviour)this).__registerRpc(1057964526u, new RpcReceiveHandler(__rpc_handler_1057964526), "DisableNestClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_762018903(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BugNestScript)(object)target).SpawnLootServerRpc(pos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1057964526(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference netRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BugNestScript)(object)target).DisableNestClientRpc(netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BugNestScript";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.Contracts.Exorcism
{
	internal class PentagramScript : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <WaitALittleToStopParticlesGaming>d__22 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PentagramScript <>4__this;

			private ParticleSystem <sys>5__1;

			private GameObject <go>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sys>5__1 = null;
				<go>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//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_00c0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<sys>5__1 = ((Component)((Component)<>4__this).transform.GetChild(3)).GetComponent<ParticleSystem>();
					<sys>5__1.Stop();
					if (((NetworkBehaviour)<>4__this).IsHost || ((NetworkBehaviour)<>4__this).IsServer)
					{
						<go>5__2 = Object.Instantiate<GameObject>(<>4__this.loot, ((Component)<>4__this).transform.position + new Vector3(0f, 0.1f, 0f), Quaternion.identity);
						<go>5__2.GetComponent<ScrapValueSyncer>().SetScrapValue(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExorcismConfiguration.RewardValue.Value + (int)((float)TimeOfDay.Instance.profitQuota * Mathf.Clamp((float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RewardQuotaMultiplier.Value / 100f, 0f, 1f)));
						<go>5__2.GetComponent<NetworkObject>().Spawn(false);
						<go>5__2 = null;
					}
					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();
			}
		}

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

			private object <>2__current;

			public PentagramScript <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Expected O, but got Unknown
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Tools.SpawnExplosion(((Component)<>4__this).transform.position + new Vector3(0f, 0.2f, 0f), spawnExplosionEffect: true, 10f, 20f);
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (((NetworkBehaviour)<>4__this).IsHost && !Tools.SpawnMob("Girl", ((Component)<>4__this).transform.position + new Vector3(0f, 0.15f, 0f), UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExorcismConfiguration.AmountSpawnsOnFail.Value))
					{
						Tools.SpawnMob("Crawler", ((Component)<>4__this).transform.position + new Vector3(0f, 0.15f, 0f), UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExorcismConfiguration.AmountSpawnsOnFail.Value);
					}
					if (UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExorcismConfiguration.AmountSpawnsOnFail.Value > 0)
					{
						HUDManager.Instance.DisplayTip("RUN", "YOU HAVE ANGERED THE SPIRIT WORLD!", false, false, "LC_Tip1");
					}
					return false;
				}
			}

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

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

		private InteractTrigger trig;

		private bool placed = false;

		private Animator anim;

		public GameObject loot;

		private BoxCollider collider;

		private PlaceableObjectsSurface place;

		private LguLogger logger = new LguLogger("PentagramScript");

		public static readonly Dictionary<string, string[]> DemonInstructions = new Dictionary<string, string[]>
		{
			{
				"POLTERGEIST",
				new string[3] { "Heart", "Bones", "Crucifix" }
			},
			{
				"PHANTOM",
				new string[3] { "Heart", "Bones", "Candelabra" }
			},
			{
				"WRAITH",
				new string[3] { "Heart", "Bones", "Teddy Bear" }
			},
			{
				"BANSHEE",
				new string[3] { "Heart", "Crucifix", "Candelabra" }
			},
			{
				"JINN",
				new string[3] { "Heart", "Crucifix", "Teddy Bear" }
			},
			{
				"HANTU",
				new string[3] { "Heart", "Candelabra", "Teddy Bear" }
			},
			{
				"MOROI",
				new string[3] { "Bones", "Crucifix", "Candelabra" }
			},
			{
				"MYLING",
				new string[3] { "Bones", "Crucifix", "Teddy Bear" }
			},
			{
				"GORYO",
				new string[3] { "Bones", "Candelabra", "Teddy Bear" }
			},
			{
				"DE OGEN",
				new string[3] { "Crucifix", "Candelabra", "Teddy Bear" }
			}
		};

		private List<string> currentRitual = new List<string>();

		public AudioClip chant;

		public AudioClip portal;

		private AudioSource audio;

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			place = ((Component)this).GetComponent<PlaceableObjectsSurface>();
			audio = ((Component)this).GetComponent<AudioSource>();
			trig = ((Component)this).GetComponent<InteractTrigger>();
			((UnityEvent<PlayerControllerB>)(object)trig.onInteract).AddListener((UnityAction<PlayerControllerB>)Interact);
			anim = ((Component)this).GetComponent<Animator>();
			collider = ((Component)this).GetComponent<BoxCollider>();
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				SyncAltarClientRpc(Random.Range(0, DemonInstructions.Count));
			}
		}

		[ClientRpc]
		private void SyncAltarClientRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1161562103u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, index);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1161562103u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				currentRitual = DemonInstructions[DemonInstructions.Keys.ElementAt(index)].ToList();
				string text = DemonInstructions.Keys.ElementAt(index);
				if ((Object)(object)trig == (Object)null)
				{
					trig = ((Component)this).GetComponent<InteractTrigger>();
				}
				trig.disabledHoverTip = text + " ALTAR";
			}
		}

		private void Interact(PlayerControllerB player)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			DisableGrabbableServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)player.currentlyHeldObjectServer));
			if (currentRitual.Contains(player.currentlyHeldObjectServer.itemProperties.itemName))
			{
				if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
				{
					SyncCurrentRitualClientRpc(player.currentlyHeldObjectServer.itemProperties.itemName);
				}
				else
				{
					SyncCurrentRitualServerRpc(player.currentlyHeldObjectServer.itemProperties.itemName);
				}
			}
			else
			{
				FailRitualServerRpc();
			}
			place.PlaceObject(player);
		}

		[ServerRpc(RequireOwnership = false)]
		private void SyncCurrentRitualServerRpc(string toRemove)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1035147740u, val, (RpcDelivery)0);
				bool flag = toRemove != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(toRemove, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1035147740u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SyncCurrentRitualClientRpc(toRemove);
			}
		}

		[ClientRpc]
		private void SyncCurrentRitualClientRpc(string toRemove)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3557057854u, val, (RpcDelivery)0);
				bool flag = toRemove != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(toRemove, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3557057854u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				logger.LogInfo("Removing " + toRemove + " from currentRitual...");
				if (currentRitual.Contains(toRemove))
				{
					currentRitual.Remove(toRemove);
				}
				else
				{
					logger.LogWarning(toRemove + " was not found in currentRitual!");
				}
				if (currentRitual.Count <= 0)
				{
					logger.LogInfo("Ritual starting...");
					placed = true;
					((Collider)collider).enabled = false;
					anim.SetTrigger("Ritual");
					((Component)this).GetComponentInChildren<ParticleSystem>().Play();
					((MonoBehaviour)this).StartCoroutine(WaitALittleToStopParticlesGaming());
					audio.Stop();
					audio.PlayOneShot(portal);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void DisableGrabbableServerRpc(NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(740226654u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 740226654u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					DisableGrabbableClientRpc(netRef);
				}
			}
		}

		[ClientRpc]
		private void DisableGrabbableClientRpc(NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1472006783u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1472006783u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				GrabbableObject val3 = default(GrabbableObject);
				((NetworkBehaviourReference)(ref netRef)).TryGet<GrabbableObject>(ref val3, (NetworkManager)null);
				if (!((Object)(object)val3 == (Object)null))
				{
					Object.Destroy((Object)(object)((Component)val3).GetComponent<BoxCollider>());
					val3.grabbable = false;
					val3.grabbableToEnemies = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void FailRitualServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2707826424u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2707826424u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FailRitualClientRpc();
				}
			}
		}

		[ClientRpc]
		private void FailRitualClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1200018192u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1200018192u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					placed = true;
					((Collider)collider).enabled = false;
					audio.Stop();
					audio.PlayOneShot(chant);
					((MonoBehaviour)this).StartCoroutine(WaitToExplode());
				}
			}
		}

		[IteratorStateMachine(typeof(<WaitToExplode>d__21))]
		private IEnumerator WaitToExplode()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitToExplode>d__21(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<WaitALittleToStopParticlesGaming>d__22))]
		private IEnumerator WaitALittleToStopParticlesGaming()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitALittleToStopParticlesGaming>d__22(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (!placed)
			{
				trig.interactable = EvalHeldItem();
			}
		}

		private bool EvalHeldItem()
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null)
			{
				return false;
			}
			if ((Object)(object)localPlayerController.currentlyHeldObjectServer == (Object)null)
			{
				return false;
			}
			ExorcismContract component = ((Component)localPlayerController.currentlyHeldObjectServer).GetComponent<ExorcismContract>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			return true;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1161562103u, new RpcReceiveHandler(__rpc_handler_1161562103), "SyncAltarClientRpc");
			((NetworkBehaviour)this).__registerRpc(1035147740u, new RpcReceiveHandler(__rpc_handler_1035147740), "SyncCurrentRitualServerRpc");
			((NetworkBehaviour)this).__registerRpc(3557057854u, new RpcReceiveHandler(__rpc_handler_3557057854), "SyncCurrentRitualClientRpc");
			((NetworkBehaviour)this).__registerRpc(740226654u, new RpcReceiveHandler(__rpc_handler_740226654), "DisableGrabbableServerRpc");
			((NetworkBehaviour)this).__registerRpc(1472006783u, new RpcReceiveHandler(__rpc_handler_1472006783), "DisableGrabbableClientRpc");
			((NetworkBehaviour)this).__registerRpc(2707826424u, new RpcReceiveHandler(__rpc_handler_2707826424), "FailRitualServerRpc");
			((NetworkBehaviour)this).__registerRpc(1200018192u, new RpcReceiveHandler(__rpc_handler_1200018192), "FailRitualClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1161562103(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).SyncAltarClientRpc(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1035147740(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string toRemove = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref toRemove, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).SyncCurrentRitualServerRpc(toRemove);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3557057854(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string toRemove = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref toRemove, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).SyncCurrentRitualClientRpc(toRemove);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_740226654(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).DisableGrabbableServerRpc(netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1472006783(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).DisableGrabbableClientRpc(netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2707826424(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).FailRitualServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1200018192(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PentagramScript)(object)target).FailRitualClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "PentagramScript";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.Contracts.DataRetrieval
{
	internal class DataPCScript : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <MoveCaret>d__39 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DataPCScript <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.gameField.caretPosition = <>4__this.gameField.text.Length;
					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();
			}
		}

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

			private object <>2__current;

			public string text;

			public DataPCScript <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!text.Contains(<>4__this.defaultText))
					{
						<>4__this.gameField.text = <>4__this.defaultText;
						<>4__this.gameField.caretPosition = <>4__this.defaultText.Length;
					}
					return false;
				}
			}

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

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

		private static LguLogger logger = new LguLogger("DataPCScript");

		private GameObject root;

		public GameObject loot;

		public AudioClip error;

		public AudioClip startup;

		private AudioSource audio;

		private InteractTrigger trig;

		private Text IPText;

		private InputField userField;

		private InputField passField;

		private InputField gameField;

		private string user;

		private string pass;

		private string defaultText;

		private string dir = "C:\\WINDOWS";

		private static string rootDir = "C:\\WINDOWS";

		private readonly List<string> dirs = new List<string>
		{
			rootDir + "\\Documents",
			rootDir + "\\Downloads",
			rootDir + "\\TopSecret",
			rootDir + "\\ImportantFiles",
			rootDir + "\\CatPhotos",
			rootDir + "\\ReallyImportantFiles",
			rootDir + "\\NotImportantFiles",
			rootDir + "\\Data",
			rootDir + "\\Fortnite",
			rootDir + "\\Goobers",
			rootDir + "\\Games",
			rootDir + "\\Recipes",
			rootDir + "\\PicsThatGoHard",
			rootDir + "\\Files",
			rootDir + "\\Surveys"
		};

		private readonly List<string> fileDirs = new List<string>();

		private readonly string[] files = new string[21]
		{
			"minecraft.exe", "MoreRam.dll", "why_mustard_is_better_than_ketchup.txt", "cursed_cat_photo.png", "slightly_less_cursed_cat_photo.jpg", "singles_in_your_area.exe", "silly_goofy_file.dll", "orange.png", "apple.png", "free_robux.exe",
			"free_vbux.exe", "unlock_every_fortnite_skin.exe", "how_to_exorcize_ghosts.txt", "benefits_of_eating_microplastics.txt", "me_eating_microplastics.mp4", "how_to_season_microplastics.mp4", "amogus.dll", "best_frogs_compilation.mp4", "scariest_frogs_compilation.mp4", "minecraft_mobs_irl.mp4",
			"drinking_and_driving_tutorial.mp4"
		};

		private bool interactable = true;

		private PlayerControllerB interactingPlayer;

		private void Start()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			root = ((Component)((Component)this).transform.GetChild(2)).gameObject;
			root.SetActive(false);
			IPText = ((Component)root.transform.GetChild(0).GetChild(2).GetChild(0)).GetComponent<Text>();
			userField = ((Component)root.transform.GetChild(0).GetChild(1).GetChild(0)).GetComponent<InputField>();
			passField = ((Component)root.transform.GetChild(0).GetChild(1).GetChild(1)).GetComponent<InputField>();
			gameField = ((Component)root.transform.GetChild(0).GetChild(3).GetChild(0)).GetComponent<InputField>();
			((UnityEvent)((Component)root.transform.GetChild(0).GetChild(1).GetChild(2)).GetComponent<Button>().onClick).AddListener(new UnityAction(Login));
			((UnityEvent<PlayerControllerB>)(object)((Component)this).GetComponent<InteractTrigger>().onInteract).AddListener((UnityAction<PlayerControllerB>)Interact);
			defaultText = gameField.text;
			((UnityEvent<string>)(object)gameField.onValueChanged).AddListener((UnityAction<string>)OnChange);
			trig = ((Component)this).GetComponent<InteractTrigger>();
			audio = ((Component)this).GetComponent<AudioSource>();
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				string text = $"{Random.Range(0, 213)}.{Random.Range(0, 99)}.{Random.Range(0, 99)}.{Random.Range(0, 255)}";
				IPText.text = IPText.text.Replace("[IP]", text);
				user = RandomString();
				pass = RandomString();
				SyncGameDetailsClientRpc(text, user, pass);
			}
			AddFiles();
		}

		private void OnChange(string text)
		{
			((MonoBehaviour)this).StartCoroutine(PreserveDefaultText(text));
		}

		private void Interact(PlayerControllerB player)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (interactable)
			{
				interactingPlayer = player;
				root.SetActive(true);
				if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
				{
					InitiateGameClientRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this));
				}
				else
				{
					InitiateGameServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this));
				}
				SetPlayerInputs(enable: false);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void InitiateGameServerRpc(NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1872074367u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1872074367u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					InitiateGameClientRpc(netRef);
				}
			}
		}

		[ClientRpc]
		private void SyncGameDetailsClientRpc(string Key, string user, string pass)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2131233339u, val, (RpcDelivery)0);
				bool flag = Key != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(Key, false);
				}
				bool flag2 = user != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(user, false);
				}
				bool flag3 = pass != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(pass, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2131233339u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				logger.LogInfo("Received Broadcasted minigame info!\nKey: " + Key + "\nuser: " + user + "\npassword: " + pass);
				ContractManager.Instance.DataMinigameKey = Key;
				ContractManager.Instance.DataMinigameUser = user;
				ContractManager.Instance.DataMinigamePass = pass;
				this.user = user;
				this.pass = pass;
				if ((Object)(object)IPText == (Object)null)
				{
					IPText = ((Component)((Component)this).transform.GetChild(2).GetChild(0).GetChild(2)
						.GetChild(0)).GetComponent<Text>();
				}
				IPText.text = IPText.text.Replace("[IP]", Key);
			}
		}

		[ClientRpc]
		private void InitiateGameClientRpc(NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3225194558u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3225194558u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				DataPCScript dataPCScript = default(DataPCScript);
				((NetworkBehaviourReference)(ref netRef)).TryGet<DataPCScript>(ref dataPCScript, (NetworkManager)null);
				if ((Object)(object)dataPCScript != (Object)null)
				{
					dataPCScript.interactable = false;
					dataPCScript.trig.interactable = false;
					dataPCScript.audio.PlayOneShot(startup);
				}
				else
				{
					logger.LogError("Unable to resolve netRef!");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ExitGameServerRpc(NetworkBehaviourReference netRef, bool succeeded)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3223316248u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref succeeded, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3223316248u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ExitGameClientRpc(netRef, succeeded);
				}
			}
		}

		[ClientRpc]
		private void ExitGameClientRpc(NetworkBehaviourReference netRef, bool succeeded)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1495716314u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref succeeded, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1495716314u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if ((((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer) && succeeded)
			{
				GameObject val3 = Object.Instantiate<GameObject>(loot, ((Component)this).transform.position + Vector3.up, Quaternion.identity);
				val3.GetComponent<ScrapValueSyncer>().SetScrapValue(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.DataConfiguration.RewardValue.Value + (int)((float)TimeOfDay.Instance.profitQuota * Mathf.Clamp((float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RewardQuotaMultiplier.Value / 100f, 0f, 1f)));
				val3.GetComponent<NetworkObject>().Spawn(false);
				logger.LogInfo("Loot successfully spawned");
			}
			DataPCScript dataPCScript = default(DataPCScript);
			((NetworkBehaviourReference)(ref netRef)).TryGet<DataPCScript>(ref dataPCScript, (NetworkManager)null);
			if ((Object)(object)dataPCScript == (Object)null)
			{
				logger.LogError("Unable to resolve netRef!");
				root.SetActive(false);
				return;
			}
			if (succeeded)
			{
				Object.Destroy((Object)(object)((Component)dataPCScript).GetComponent<BoxCollider>());
			}
			else
			{
				dataPCScript.trig.interactable = true;
				interactable = true;
			}
			interactingPlayer = null;
			root.SetActive(false);
		}

		public void HandleInput(string input)
		{
			string text = dir + ">";
			int num = input.IndexOf(text);
			string text2 = ((num != -1) ? input.Substring(num + text.Length) : "");
			string[] array = text2.Trim().Split(' ');
			string text3 = array[0].ToLower();
			string text4 = "";
			if (array.Length > 1)
			{
				text4 = array[1];
			}
			switch (text3)
			{
			case "ls":
				ExecuteLsCommand();
				break;
			case "cd":
				ExecuteCdCommand(text4);
				break;
			case "mv":
				ExecuteMvCommand(text4);
				break;
			default:
				UnknownCommand(text3, text4);
				break;
			}
		}

		private void SetGameFieldText(string text)
		{
			gameField.text = text;
			defaultText = gameField.text;
		}

		private void UnknownCommand(string firstWord, string secondWord)
		{
			SetGameFieldText(firstWord + " " + secondWord + " WAS NOT RECOGNIZED AS A COMMAND\n\nCOMMANDS ARE :\nLS\nCD\nMV\n\n" + dir + "> ");
		}

		private void ExecuteLsCommand()
		{
			if (dir == rootDir)
			{
				SetGameFieldText(string.Join("\n", dirs) + "\n\n" + dir + "> ");
				return;
			}
			SetGameFieldText(string.Join("\n", fileDirs.Where((string x) => x.Contains(dir))) + "\n\n" + dir + "> ");
		}

		private void ExecuteCdCommand(string input)
		{
			if (input.Length == 0)
			{
				SetGameFieldText("YOU MUST PROVIDE A VALID DIRECTORY TO SWITCH TO\n\n" + dir);
			}
			else if (input == ".." || input == "~")
			{
				if (dir == rootDir)
				{
					SetGameFieldText("YOU ARE ALREADY IN THE ROOT DIRECTORY\n\n" + dir + "> ");
					return;
				}
				dir = rootDir;
				SetGameFieldText(dir + "> ");
			}
			else if (dirs.Contains(dir + "\\" + input))
			{
				dir = dir + "\\" + input;
				SetGameFieldText(dir + "> ");
			}
			else
			{
				SetGameFieldText(dir + "\\" + input + " IS NOT A VALID DIRECTORY\n\nENTER LS TO VIEW DIRECTORIES\n\n" + dir + "> ");
			}
		}

		private void ExecuteMvCommand(string input)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (input == "")
			{
				SetGameFieldText("YOU MUST PROVIDE A VALID FILE TO MOVE\n\n" + dir);
			}
			else if (input == "survey.db")
			{
				if (fileDirs.Contains(dir + "\\survey.db"))
				{
					logger.LogInfo("Minigame completed, spawning loot and exiting...");
					SetPlayerInputs(enable: true);
					if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
					{
						ExitGameClientRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this), succeeded: true);
					}
					else
					{
						ExitGameServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this), succeeded: true);
					}
				}
				else
				{
					SetGameFieldText(dir + "\\survey.db does not exist\n\n" + dir + "> ");
				}
			}
			else if (fileDirs.Contains(dir + "\\" + input))
			{
				SetGameFieldText(dir + "\\" + input + " IS NOT A FILE OF INTEREST\n\n" + dir + "> ");
			}
			else
			{
				SetGameFieldText(dir + "\\" + input + " IS NOT A VALID FILE\n\nENTER LS TO VIEW FILES\n\n" + dir + "> ");
			}
		}

		public void Login()
		{
			logger.LogInfo("Submitted user: " + userField.text + "\nTrue user: " + user + "\nSubmitted password: " + passField.text + "\nTrue password: " + pass);
			if (userField.text == user && passField.text == pass)
			{
				((Component)((Component)gameField).transform.parent).gameObject.SetActive(true);
				((Component)((Component)userField).transform.parent).gameObject.SetActive(false);
			}
			else
			{
				audio.PlayOneShot(error);
				userField.text = "";
				passField.text = "";
			}
		}

		private static string RandomString()
		{
			int num = Random.Range(5, 9);
			char[] array = new char[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"[Random.Range(0, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".Length)];
			}
			return new string(array);
		}

		private void AddFiles()
		{
			int num = Random.Range(3, 7);
			while (dirs.Count > num)
			{
				dirs.Remove(dirs[Random.Range(0, dirs.Count)]);
			}
			foreach (string dir in dirs)
			{
				int num2 = Random.Range(1, 4);
				for (int i = 0; i < num2; i++)
				{
					fileDirs.Add(dir + "\\" + files[Random.Range(0, files.Length)]);
				}
			}
			fileDirs.Add(dirs[Random.Range(0, dirs.Count)] + "\\survey.db");
		}

		private void Update()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)(object)interactingPlayer)
			{
				return;
			}
			if (((ButtonControl)Keyboard.current.enterKey).wasReleasedThisFrame)
			{
				HandleInput(gameField.text);
				((MonoBehaviour)this).StartCoroutine(MoveCaret());
			}
			else if (((ButtonControl)Keyboard.current.escapeKey).wasReleasedThisFrame)
			{
				interactable = true;
				SetPlayerInputs(enable: true);
				if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
				{
					ExitGameClientRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this), succeeded: false);
				}
				else
				{
					ExitGameServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)this), succeeded: false);
				}
			}
		}

		[IteratorStateMachine(typeof(<MoveCaret>d__39))]
		private IEnumerator MoveCaret()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MoveCaret>d__39(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<PreserveDefaultText>d__40))]
		private IEnumerator PreserveDefaultText(string text)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PreserveDefaultText>d__40(0)
			{
				<>4__this = this,
				text = text
			};
		}

		private void SetPlayerInputs(bool enable)
		{
			Cursor.visible = !enable;
			Cursor.lockState = (CursorLockMode)(enable ? 1 : 0);
			interactingPlayer.quickMenuManager.isMenuOpen = !enable;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1872074367u, new RpcReceiveHandler(__rpc_handler_1872074367), "InitiateGameServerRpc");
			((NetworkBehaviour)this).__registerRpc(2131233339u, new RpcReceiveHandler(__rpc_handler_2131233339), "SyncGameDetailsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3225194558u, new RpcReceiveHandler(__rpc_handler_3225194558), "InitiateGameClientRpc");
			((NetworkBehaviour)this).__registerRpc(3223316248u, new RpcReceiveHandler(__rpc_handler_3223316248), "ExitGameServerRpc");
			((NetworkBehaviour)this).__registerRpc(1495716314u, new RpcReceiveHandler(__rpc_handler_1495716314), "ExitGameClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1872074367(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DataPCScript)(object)target).InitiateGameServerRpc(netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2131233339(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string key = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref key, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string text = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text, false);
				}
				bool flag3 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag3, default(ForPrimitives));
				string text2 = null;
				if (flag3)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text2, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DataPCScript)(object)target).SyncGameDetailsClientRpc(key, text, text2);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3225194558(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DataPCScript)(object)target).InitiateGameClientRpc(netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3223316248(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				bool succeeded = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref succeeded, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DataPCScript)(object)target).ExitGameServerRpc(netRef, succeeded);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1495716314(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				bool succeeded = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref succeeded, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DataPCScript)(object)target).ExitGameClientRpc(netRef, succeeded);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "DataPCScript";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Items.Contracts.BombDefusal
{
	internal class BombDefusalScript : NetworkBehaviour
	{
		private static LguLogger logger = new LguLogger("BombDefusalScript");

		private AudioSource audio;

		private readonly Dictionary<string, GameObject> wires = new Dictionary<string, GameObject>
		{
			{ "red", null },
			{ "green", null },
			{ "blue", null }
		};

		private readonly Dictionary<string, GameObject> cutWires = new Dictionary<string, GameObject>
		{
			{ "red", null },
			{ "green", null },
			{ "blue", null }
		};

		private readonly Dictionary<string, InteractTrigger[]> trigs = new Dictionary<string, InteractTrigger[]>
		{
			{ "red", null },
			{ "green", null },
			{ "blue", null }
		};

		internal AudioClip tick;

		internal AudioClip snip;

		private BoxCollider grabBox;

		private TextMesh serialNumberMesh;

		private TextMesh countdown;

		private float BombTimer = 300f;

		private bool armed = true;

		private const string allowedLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

		private const string allowedNums = "0123456789";

		private void Start()
		{
			InitializeFields();
			((Component)this).GetComponent<ScrapValueSyncer>().SetScrapValue(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.DefusalConfiguration.RewardValue.Value + (int)((float)TimeOfDay.Instance.profitQuota * Mathf.Clamp((float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RewardQuotaMultiplier.Value / 100f, 0f, 1f)));
			audio.clip = tick;
			audio.Play();
			InteractTrigger[] array = trigs["red"];
			foreach (InteractTrigger val in array)
			{
				((UnityEvent<PlayerControllerB>)(object)val.onInteract).AddListener((UnityAction<PlayerControllerB>)CutRed);
			}
			InteractTrigger[] array2 = trigs["blue"];
			foreach (InteractTrigger val2 in array2)
			{
				((UnityEvent<PlayerControllerB>)(object)val2.onInteract).AddListener((UnityAction<PlayerControllerB>)CutBlue);
			}
			InteractTrigger[] array3 = trigs["green"];
			foreach (InteractTrigger val3 in array3)
			{
				((UnityEvent<PlayerControllerB>)(object)val3.onInteract).AddListener((UnityAction<PlayerControllerB>)CutGreen);
			}
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				char[] value = new char[6]
				{
					"ABCDEFGHIJKLMNOPQRSTUVWXYZ"[Random.Range(0, "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Length)],
					"ABCDEFGHIJKLMNOPQRSTUVWXYZ"[Random.Range(0, "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Length)],
					'-',
					"0123456789"[Random.Range(0, "0123456789".Length)],
					"0123456789"[Random.Range(0, "0123456789".Length)],
					"0123456789"[Random.Range(0, "0123456789".Length)]
				};
				ContractManager.Instance.bombOrder = new List<string> { "red", "green", "blue" };
				Tools.ShuffleList(ContractManager.Instance.bombOrder);
				string newOrder = string.Join(",", ContractManager.Instance.bombOrder);
				SyncBombDetailsClientRpc(new string(value), newOrder);
			}
		}

		private void Update()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (armed)
			{
				BombTimer -= Time.deltaTime;
				int num = (int)(BombTimer / 60f);
				int num2 = (int)(BombTimer % 60f);
				string arg = ((num2 > 9) ? num2.ToString() : ("0" + num2));
				countdown.text = $"0{num} {arg}";
				if (BombTimer <= 0f)
				{
					armed = false;
					Tools.SpawnExplosion(((Component)this).transform.position, spawnExplosionEffect: true, 20f, 10f);
					((Component)this).gameObject.SetActive(false);
					((Behaviour)this).enabled = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ReqBombStateChangeServerRpc(string wire)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3042118480u, val, (RpcDelivery)0);
				bool flag = wire != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(wire, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3042118480u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				BombStateChangeClientRpc(wire);
			}
		}

		[ClientRpc]
		private void BombStateChangeClientRpc(string wire)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(961392946u, val, (RpcDelivery)0);
				bool flag = wire != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(wire, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 961392946u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			audio.PlayOneShot(snip);
			if (ContractManager.Instance.bombOrder[0] == wire)
			{
				ContractManager.Instance.bombOrder.Remove(wire);
				audio.PlayOneShot(snip);
				wires[wire].SetActive(false);
				cutWires[wire].SetActive(true);
				InteractTrigger[] array = trigs[wire];
				foreach (InteractTrigger val3 in array)
				{
					((Behaviour)val3).enabled = false;
					((Collider)((Component)val3).GetComponent<BoxCollider>()).enabled = false;
				}
				if (ContractManager.Instance.bombOrder.Count == 0)
				{
					armed = false;
					((Collider)grabBox).enabled = true;
					audio.Stop();
					((Behaviour)this).enabled = false;
					((Behaviour)((Component)this).GetComponent<PhysicsProp>()).enabled = true;
				}
			}
			else
			{
				armed = false;
				Tools.SpawnExplosion(((Component)this).transform.position, spawnExplosionEffect: true, 20f, 10f);
				((Component)this).gameObject.SetActive(false);
				((Behaviour)this).enabled = false;
			}
		}

		private void CutRed(PlayerControllerB player)
		{
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				BombStateChangeClientRpc("red");
			}
			else
			{
				ReqBombStateChangeServerRpc("red");
			}
		}

		private void CutBlue(PlayerControllerB player)
		{
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				BombStateChangeClientRpc("blue");
			}
			else
			{
				ReqBombStateChangeServerRpc("blue");
			}
		}

		private void CutGreen(PlayerControllerB player)
		{
			if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
			{
				BombStateChangeClientRpc("green");
			}
			else
			{
				ReqBombStateChangeServerRpc("green");
			}
		}

		[ClientRpc]
		private void SyncBombDetailsClientRpc(string serial, string newOrder)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(386075860u, val, (RpcDelivery)0);
				bool flag = serial != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(serial, false);
				}
				bool flag2 = newOrder != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(newOrder, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 386075860u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if ((Object)(object)serialNumberMesh == (Object)null)
				{
					serialNumberMesh = ((Component)((Component)this).transform.GetChild(0).GetChild(2)).GetComponent<TextMesh>();
				}
				ContractManager.Instance.SerialNumber = serial;
				ContractManager.Instance.bombOrder = newOrder.Split(",").ToList();
				serialNumberMesh.text = serial;
				InteractTrigger component = ((Component)((Component)this).transform.Find("LGUBomb").Find("SerialDisplay")).GetComponent<InteractTrigger>();
				component.disabledHoverTip = "Serial: [" + serial + "]";
			}
		}

		private void InitializeFields()
		{
			grabBox = ((Component)this).GetComponent<BoxCollider>();
			audio = ((Component)this).GetComponent<AudioSource>();
			Transform child = ((Component)this).transform.GetChild(0).GetChild(0);
			wires["blue"] = ((Component)child.GetChild(0)).gameObject;
			wires["green"] = ((Component)child.GetChild(1)).gameObject;
			wires["red"] = ((Component)child.GetChild(2)).gameObject;
			Transform child2 = ((Component)this).transform.GetChild(0).GetChild(1);
			cutWires["blue"] = ((Component)child2.GetChild(0)).gameObject;
			cutWires["green"] = ((Component)child2.GetChild(1)).gameObject;
			cutWires["red"] = ((Component)child2.GetChild(2)).gameObject;
			trigs["red"] = ((Component)((Component)this).transform.Find("LGUBomb").Find("InteractWires").Find("Red")).GetComponentsInChildren<InteractTrigger>();
			trigs["blue"] = ((Component)((Component)this).transform.Find("LGUBomb").Find("InteractWires").Find("Blue")).GetComponentsInChildren<InteractTrigger>();
			trigs["green"] = ((Component)((Component)this).transform.Find("LGUBomb").Find("InteractWires").Find("Green")).GetComponentsInChildren<InteractTrigger>();
			serialNumberMesh = ((Component)((Component)this).transform.GetChild(0).GetChild(2)).GetComponent<TextMesh>();
			if ((Object)(object)serialNumberMesh == (Object)null)
			{
				logger.LogError("FAILED TO GET SERIAL NUMBER MESH");
			}
			countdown = ((Component)((Component)this).transform.GetChild(0).GetChild(3)).GetComponent<TextMesh>();
		}

		internal void MakeBombGrabbable()
		{
			InitializeFields();
			armed = false;
			((Collider)grabBox).enabled = true;
			audio.Stop();
			((Behaviour)this).enabled = false;
			foreach (string key in wires.Keys)
			{
				wires[key].SetActive(false);
				cutWires[key].SetActive(true);
				InteractTrigger[] array = trigs[key];
				foreach (InteractTrigger val in array)
				{
					((Behaviour)val).enabled = false;
					((Collider)((Component)val).GetComponent<BoxCollider>()).enabled = false;
				}
			}
			((Behaviour)((Component)this).GetComponent<PhysicsProp>()).enabled = true;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3042118480u, new RpcReceiveHandler(__rpc_handler_3042118480), "ReqBombStateChangeServerRpc");
			((NetworkBehaviour)this).__registerRpc(961392946u, new RpcReceiveHandler(__rpc_handler_961392946), "BombStateChangeClientRpc");
			((NetworkBehaviour)this).__registerRpc(386075860u, new RpcReceiveHandler(__rpc_handler_386075860), "SyncBombDetailsClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3042118480(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string wire = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref wire, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BombDefusalScript)(object)target).ReqBombStateChangeServerRpc(wire);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_961392946(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string wire = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref wire, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BombDefusalScript)(object)target).BombStateChangeClientRpc(wire);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_386075860(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string serial = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref serial, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string newOrder = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref newOrder, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BombDefusalScript)(object)target).SyncBombDetailsClientRpc(serial, newOrder);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BombDefusalScript";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Interfaces
{
	internal interface IDisplayInfo
	{
		string GetDisplayInfo();
	}
	internal interface IItemWorldBuilding
	{
		string GetWorldBuildingText();
	}
	internal interface IPlayerSync
	{
		void ResetPlayerAttribute();
	}
	internal interface IUpgradeWorldBuilding
	{
		string GetWorldBuildingText(bool shareStatus = false);
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Contracts
{
	internal class ContractObject : NetworkBehaviour
	{
		protected string contractType = null;

		public bool SetPosition = false;

		public virtual void Start()
		{
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			if (ContractManager.Instance.contractType != contractType || StartOfRound.Instance.currentLevel.PlanetName != ContractManager.Instance.contractLevel)
			{
				((Component)this).gameObject.GetComponent<NetworkObject>().Despawn(true);
				return;
			}
			if (SetPosition)
			{
				List<EntranceTeleport> mainDoors = (from obj in Object.FindObjectsOfType<EntranceTeleport>()
					where ((Component)obj).gameObject.transform.position.y <= -170f
					select obj).ToList();
				EnemyVent[] array = Object.FindObjectsOfType<EnemyVent>();
				EnemyVent val = null;
				val = ((!UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.FurthestSpawnPossible.Value) ? array[Random.Range(0, array.Length)] : array.OrderByDescending((EnemyVent vent) => Vector3.Distance(((Component)mainDoors[0]).transform.position, vent.floorNode.position)).First());
				Vector3 val2 = Quaternion.Euler(0f, val.floorNode.eulerAngles.y, 0f) * Vector3.forward;
				Vector3 position = val.floorNode.position + val2;
				((Component)this).transform.position = position;
			}
			if (!(contractType != "Exterminator"))
			{
				Tools.SpawnMob("Hoarding bug", ((Component)this).transform.position, UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExterminationConfiguration.AmountSpawns.Value);
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ContractObject";
		}
	}
	internal class DataRetrievalContract : ContractObject
	{
		public override void Start()
		{
			contractType = "Data";
			base.Start();
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "DataRetrievalContract";
		}
	}
	internal class DefusalContract : ContractObject
	{
		public override void Start()
		{
			contractType = "Defusal";
			if (((GrabbableObject)((Component)this).GetComponent<PhysicsProp>()).isInShipRoom || ((GrabbableObject)((Component)this).GetComponent<PhysicsProp>()).isInElevator)
			{
				BombDefusalScript component = ((Component)this).GetComponent<BombDefusalScript>();
				component.MakeBombGrabbable();
			}
			else
			{
				base.Start();
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "DefusalContract";
		}
	}
	internal class ExorcismContract : ContractObject
	{
		public override void Start()
		{
			contractType = "Exorcism";
			base.Start();
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ExorcismContract";
		}
	}
	internal class ExterminatorContract : ContractObject
	{
		public override void Start()
		{
			contractType = "Exterminator";
			base.Start();
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ExterminatorContract";
		}
	}
	internal class ExtractionContract : ContractObject
	{
		public override void Start()
		{
			contractType = "Extraction";
			if ((Object)(object)((Component)this).GetComponent<Medkit>() == (Object)null && (((Component)this).GetComponent<GrabbableObject>().isInShipRoom || ((Component)this).GetComponent<GrabbableObject>().isInElevator))
			{
				ExtractPlayerScript component = ((Component)this).GetComponent<ExtractPlayerScript>();
				component.MakeScavengerGrabbable();
			}
			else
			{
				base.Start();
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ExtractionContract";
		}
	}
}
namespace MoreShipUpgrades.UpgradeComponents.Commands
{
	public class Interns : BaseCommand
	{
		public enum TeleportRestriction
		{
			None,
			ExitBuilding,
			EnterShip
		}

		internal const string NAME = "Interns";

		public static Interns instance;

		private List<PlayerControllerB> recentlyInterned;

		internal string[] internNames;

		internal string[] internInterests;

		internal int currentUsages;

		internal float revivalTimer;

		internal float delayReviveTimer;

		internal PlayerControllerB delayedRevivePlayer;

		private void Start()
		{
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			instance = this;
			recentlyInterned = new List<PlayerControllerB>();
			internNames = AssetBundleHandler.GetInfoFromJSON("InternNames").Split(",");
			internInterests = AssetBundleHandler.GetInfoFromJSON("InternInterests").Split(",");
			currentUsages = 0;
			revivalTimer = 0f;
			delayReviveTimer = 0f;
			delayedRevivePlayer = null;
		}

		private void Update()
		{
			if (revivalTimer > 0f)
			{
				revivalTimer -= Time.deltaTime;
			}
			if (delayReviveTimer > 0f)
			{
				delayReviveTimer -= Time.deltaTime;
			}
			if (delayReviveTimer <= 0f && (Object)(object)delayedRevivePlayer != (Object)null)
			{
				ReviveDelayedPlayer();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ReviveTargetedPlayerServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3098261166u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3098261166u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERNS_DELAY_BEFORE_REVIVE) > 0f)
				{
					SetDelayedReviveClientRpc(SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERNS_DELAY_BEFORE_REVIVE), new NetworkBehaviourReference((NetworkBehaviour)(object)StartOfRound.Instance.mapScreen.targetedPlayer));
					return;
				}
				ReviveTargetedPlayerClientRpc();
				Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length)].transform.position;
				position = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((NetworkBehaviourReference)(ref netRef))..ctor((NetworkBehaviour)(object)StartOfRound.Instance.mapScreen.targetedPlayer);
				TelePlayerClientRpc(position, netRef);
			}
		}

		[ClientRpc]
		private void SetDelayedReviveClientRpc(float delayedRevive, NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(559280491u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref delayedRevive, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 559280491u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SetDelayedRevive(delayedRevive, netRef);
				}
			}
		}

		private void SetDelayedRevive(float delayedTimer, NetworkBehaviourReference netRef)
		{
			PlayerControllerB val = default(PlayerControllerB);
			((NetworkBehaviourReference)(ref netRef)).TryGet<PlayerControllerB>(ref val, (NetworkManager)null);
			if ((Object)(object)val != (Object)null)
			{
				delayReviveTimer = delayedTimer;
				delayedRevivePlayer = val;
			}
		}

		public void ReviveDelayedPlayer()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkBehaviourReference val = default(NetworkBehaviourReference);
			((NetworkBehaviourReference)(ref val))..ctor((NetworkBehaviour)(object)delayedRevivePlayer);
			delayedRevivePlayer = null;
			if (((NetworkBehaviour)this).IsServer && ((NetworkBehaviour)this).IsHost)
			{
				ReviveTargetedPlayerClientRpc(val);
				Vector3 position = RoundManager.Instance.insideAINodes[Random.Range(0, RoundManager.Instance.insideAINodes.Length)].transform.position;
				position = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				TelePlayerClientRpc(position, val);
			}
		}

		[ClientRpc]
		private void TelePlayerClientRpc(Vector3 vector, NetworkBehaviourReference netRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(424913975u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref vector);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 424913975u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NetworkBehaviour val3 = default(NetworkBehaviour);
				((NetworkBehaviourReference)(ref netRef)).TryGet(ref val3, (NetworkManager)null);
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)((Component)val3).transform).GetComponent<PlayerControllerB>().TeleportPlayer(vector, false, 0f, false, true);
				}
			}
		}

		[ClientRpc]
		private void ReviveTargetedPlayerClientRpc(NetworkBehaviourReference playerRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1018108951u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref playerRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1018108951u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val3 = default(PlayerControllerB);
				((NetworkBehaviourReference)(ref playerRef)).TryGet<PlayerControllerB>(ref val3, (NetworkManager)null);
				if (!((Object)(object)val3 == (Object)null))
				{
					ReviveTargetedPlayer(val3);
				}
			}
		}

		[ClientRpc]
		private void ReviveTargetedPlayerClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(185636199u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 185636199u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
					ReviveTargetedPlayer(targetedPlayer);
				}
			}
		}

		private void ReviveTargetedPlayer(PlayerControllerB player)
		{
			currentUsages++;
			revivalTimer = SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERNS_INTERVAL_BETWEEN_REVIVES);
			int num = 100;
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.StimpackConfiguration.Enabled))
			{
				num = (Stimpack.Instance.playerHealthLevels.ContainsKey(player.playerSteamId) ? Stimpack.GetHealthFromPlayer(100, player.playerSteamId) : 100);
			}
			player.ResetPlayerBloodObjects(player.isPlayerDead);
			if (player.isPlayerDead || player.isPlayerControlled)
			{
				player.isClimbingLadder = false;
				player.inVehicleAnimation = false;
				player.ResetZAndXRotation();
				((Collider)player.thisController).enabled = true;
				player.health = num;
				player.disableLookInput = false;
				if (player.isPlayerDead)
				{
					player.isPlayerDead = false;
					player.isPlayerControlled = true;
					player.isInElevator = false;
					player.isInHangarShipRoom = false;
					player.isInsideFactory = true;
					StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
					player.setPositionOfDeadPlayer = false;
					((Behaviour)player.helmetLight).enabled = false;
					player.Crouch(false);
					player.criticallyInjured = false;
					if ((Object)(object)player.playerBodyAnimator != (Object)null)
					{
						player.playerBodyAnimator.SetBool("Limp", false);
					}
					player.bleedingHeavily = false;
					player.activatingItem = false;
					player.twoHanded = false;
					player.inSpecialInteractAnimation = false;
					player.disableSyncInAnimation = false;
					player.inAnimationWithEnemy = null;
					player.holdingWalkieTalkie = false;
					player.speakingToWalkieTalkie = false;
					player.isSinking = false;
					player.isUnderwater = false;
					player.sinkingValue = 0f;
					player.statusEffectAudio.Stop();
					player.DisableJetpackControlsLocally();
					player.health = num;
					player.mapRadarDotAnimator.SetBool("dead", false);
					player.deadBody = null;
					if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
					{
						HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
						player.hasBegunSpectating = false;
						HUDManager.Instance.RemoveSpectateUI();
						HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
						player.hinderedMultiplier = 1f;
						player.isMovementHindered = 0;
						player.sourcesCausingSinking = 0;
						HUDManager.Instance.HideHUD(false);
					}
				}
				SoundManager.Instance.earsRingingTimer = 0f;
				player.voiceMuffledByEnemy = false;
				if ((Object)(object)player.currentVoiceChatIngameSettings == (Object)null)
				{
					StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
				}
				if ((Object)(object)player.currentVoiceChatIngameSettings != (Object)null)
				{
					if ((Object)(object)player.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						player.currentVoiceChatIngameSettings.InitializeComponents();
					}
					if ((Object)(object)player.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						return;
					}
					((Component)player.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
			}
			StartOfRound obj = StartOfRound.Instance;
			obj.livingPlayers++;
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)player)
			{
				player.bleedingHeavily = false;
				player.criticallyInjured = false;
				player.playerBodyAnimator.SetBool("Limp", false);
				player.health = num;
				HUDManager.Instance.UpdateHealthUI(num, false);
				player.spectatedPlayerScript = null;
				((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
				StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, player);
				TimeOfDay.Instance.DisableAllWeather(false);
				StartOfRound.Instance.UpdatePlayerVoiceEffects();
				((Renderer)player.thisPlayerModel).enabled = true;
			}
			else
			{
				((Renderer)player.thisPlayerModel).enabled = true;
				((Renderer)player.thisPlayerModelLOD1).enabled = true;
				((Renderer)player.thisPlayerModelLOD2).enabled = true;
			}
			if (StartOfRound.Instance.currentLevel.spawnEnemiesAndScrap)
			{
				recentlyInterned.Add(player);
			}
		}

		internal void RemoveRecentlyInterned(PlayerControllerB player)
		{
			if (ContainsRecentlyInterned(player))
			{
				recentlyInterned.Remove(player);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void RemoveRecentlyInternedServerRpc(NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1514856847u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1514856847u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					RemoveRecentlyInternedClientRpc(player);
				}
			}
		}

		[ClientRpc]
		internal void RemoveRecentlyInternedClientRpc(NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4239227032u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4239227032u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player2 = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref player2, (NetworkManager)null))
				{
					RemoveRecentlyInterned(player2);
				}
			}
		}

		internal void ResetRecentlyInterned()
		{
			recentlyInterned.Clear();
		}

		internal bool ContainsRecentlyInterned(PlayerControllerB player)
		{
			return recentlyInterned.Contains(player);
		}

		internal void AddRecentlyInterned(PlayerControllerB player)
		{
			if (!ContainsRecentlyInterned(player))
			{
				recentlyInterned.Remove(player);
			}
		}

		public new static void RegisterCommand()
		{
			BaseCommand.SetupGenericCommand<Interns>("Interns");
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3098261166u, new RpcReceiveHandler(__rpc_handler_3098261166), "ReviveTargetedPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(559280491u, new RpcReceiveHandler(__rpc_handler_559280491), "SetDelayedReviveClientRpc");
			((NetworkBehaviour)this).__registerRpc(424913975u, new RpcReceiveHandler(__rpc_handler_424913975), "TelePlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(1018108951u, new RpcReceiveHandler(__rpc_handler_1018108951), "ReviveTargetedPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(185636199u, new RpcReceiveHandler(__rpc_handler_185636199), "ReviveTargetedPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(1514856847u, new RpcReceiveHandler(__rpc_handler_1514856847), "RemoveRecentlyInternedServerRpc");
			((NetworkBehaviour)this).__registerRpc(4239227032u, new RpcReceiveHandler(__rpc_handler_4239227032), "RemoveRecentlyInternedClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_3098261166(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).ReviveTargetedPlayerServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_559280491(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float delayedRevive = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref delayedRevive, default(ForPrimitives));
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).SetDelayedReviveClientRpc(delayedRevive, netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_424913975(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 vector = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref vector);
				NetworkBehaviourReference netRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref netRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).TelePlayerClientRpc(vector, netRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1018108951(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference playerRef = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref playerRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).ReviveTargetedPlayerClientRpc(playerRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_185636199(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).ReviveTargetedPlayerClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1514856847(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).RemoveRecentlyInternedServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4239227032(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Interns)(object)target).RemoveRecentlyInternedClientRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Interns";
		}
	}
}
namespace MoreShipUpgrades.UI.TerminalNodes
{
	public enum PurchaseMode
	{
		AlternateCurrency,
		CompanyCredits,
		Both
	}
	public abstract class CustomTerminalNode : IComparable
	{
		public string Name { get; set; }

		public string OriginalName { get; set; }

		public int[] Prices { get; set; }

		public int UnlockPrice { get; set; }

		public string Description { get; set; }

		public GameObject Prefab { get; set; }

		public bool Unlocked { get; set; }

		public int MaxUpgrade { get; set; }

		public int CurrentUpgrade { get; set; }

		public bool SharedUpgrade { get; set; }

		public float SalePercentage { get; set; } = 1f;


		public bool Visible { get; set; }

		public bool AlternateCurrency { get; set; }

		public PurchaseMode PurchaseMode { get; set; }

		public bool Refundable { get; set; }

		public float RefundPercentage { get; set; }

		protected CustomTerminalNode(string name, int unlockPrice, string description, GameObject prefab, int[] prices = null, int maxUpgrade = 0, string originalName = "", bool sharedUpgrade = false, bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = false, float refundPercentage = 1f)
		{
			if (prices == null)
			{
				prices = Array.Empty<int>();
			}
			Name = name;
			Prices = prices;
			Description = description;
			Prefab = prefab;
			MaxUpgrade = maxUpgrade;
			UnlockPrice = unlockPrice;
			OriginalName = originalName;
			SharedUpgrade = sharedUpgrade;
			Visible = true;
			AlternateCurrency = alternateCurrency;
			PurchaseMode = purchaseMode;
			Refundable = refundable;
			RefundPercentage = refundPercentage;
		}

		public int CompareTo(object obj)
		{
			if (obj == null)
			{
				return -1;
			}
			if (!(obj is CustomTerminalNode))
			{
				return -1;
			}
			CustomTerminalNode customTerminalNode = obj as CustomTerminalNode;
			return Name.CompareTo(customTerminalNode.Name);
		}

		public int GetCurrentPrice()
		{
			if (!Unlocked)
			{
				return (int)((float)(UnlockPrice - ItemProgressionManager.GetCurrentContribution(this)) * SalePercentage);
			}
			if (CurrentUpgrade >= MaxUpgrade)
			{
				return int.MaxValue;
			}
			return (int)((float)(Prices[CurrentUpgrade] - ItemProgressionManager.GetCurrentContribution(this)) * SalePercentage);
		}

		public int GetPreviousPrice()
		{
			if (!Unlocked)
			{
				return 0;
			}
			if (CurrentUpgrade > MaxUpgrade)
			{
				return int.MaxValue;
			}
			return (CurrentUpgrade > 0) ? ((int)((float)(Prices[CurrentUpgrade - 1] - ItemProgressionManager.GetCurrentContribution(this)) * SalePercentage)) : UnlockPrice;
		}

		public int GetCurrentLevel()
		{
			if (!Unlocked)
			{
				return 0;
			}
			return Mathf.Clamp(CurrentUpgrade, 0, MaxUpgrade) + 1;
		}

		public int GetRemainingLevels()
		{
			int num = ((!Unlocked) ? 1 : 0);
			return num + ((MaxUpgrade != 0) ? Mathf.Max(0, MaxUpgrade - CurrentUpgrade) : 0);
		}
	}
	internal static class HelpTerminalNode
	{
		private static bool addedHelp;

		private const string TRADING_HELP_COMMAND = ">LGU TRADE / TRADE PLAYER CREDITS / TRADE\n Allows trading Player Credits between players.\n\n";

		private const string CONVERT_HELP_COMMAND = ">CONVERT / PC\nAllows converting Company Credits to Player Credits and vice versa.\n\n";

		private const string INTERNS_HELP_COMMAND = ">INTERNS / INTERN\nRevives the selected player in radar with a new employee. Consumes {0} credits for each revive.\n\n";

		private const string CONTRACT_HELP_COMMAND = ">CONTRACT [moon]\nGives you a random contract for a scrap item with considerable value and lasts til you leave from assigned planet.\nConsumes {0} credits for each contract and will be unable to get another contract til current has expired.\nIf a moon is specified, it will generate a contract for that moon for the cost of {1} Company credits instead.\n\n";

		private const string ATK_HELP_COMMAND = ">ATK / INITATTACK\nStuns nearby enemies for a set period of time. Only applicable when Discombobulator has been purchased\n\n";

		private const string CD_HELP_COMMAND = ">CD / COOLDOWN\nShows the current cooldown of the ship stun ability. Only applicable when Discombobulator has been purchased\n\n";

		private const string INFO_CONTRACT_HELP_COMMAND = ">CONTRACT INFO\nDisplays all information related to each contract and how to complete it.\n\n";

		internal static void SetupLGUHelpCommand(TerminalNode helpNode = null)
		{
			if ((Object)(object)helpNode == (Object)null)
			{
				helpNode = LguTerminalNode.GetHelpTerminalNode();
			}
			if (!addedHelp)
			{
				TerminalNode obj = helpNode;
				obj.displayText += ">LATEGAME\nDisplays information related with Lategame-Upgrades mod\n\n";
				addedHelp = true;
			}
		}

		public static string HandleHelpDiscombobulator()
		{
			if (UpgradeBus.Instance.PluginConfiguration.DiscombobulatorUpgradeConfiguration.Enabled.Value)
			{
				return ">ATK / INITATTACK\nStuns nearby enemies for a set period of time. Only applicable when Discombobulator has been purchased\n\n>CD / COOLDOWN\nShows the current cooldown of the ship stun ability. Only applicable when Discombobulator has been purchased\n\n";
			}
			return "";
		}

		public static string HandleHelpContract()
		{
			if (UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				return $">CONTRACT [moon]\nGives you a random contract for a scrap item with considerable value and lasts til you leave from assigned planet.\nConsumes {UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value} credits for each contract and will be unable to get another contract til current has expired.\nIf a moon is specified, it will generate a contract for that moon for the cost of {UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.SpecifyPrice.Value} Company credits instead.\n\n>CONTRACT INFO\nDisplays all information related to each contract and how to complete it.\n\n";
			}
			return "";
		}

		public static string HandleHelpInterns()
		{
			if (UpgradeBus.Instance.PluginConfiguration.INTERN_ENABLED.Value)
			{
				return $">INTERNS / INTERN\nRevives the selected player in radar with a new employee. Consumes {UpgradeBus.Instance.PluginConfiguration.INTERN_PRICE.Value} credits for each revive.\n\n";
			}
			return "";
		}

		internal static string HandleAlternateCurrency()
		{
			if (CurrencyManager.Enabled)
			{
				return ">CONVERT / PC\nAllows converting Company Credits to Player Credits and vice versa.\n\n>LGU TRADE / TRADE PLAYER CREDITS / TRADE\n Allows trading Player Credits between players.\n\n";
			}
			return "";
		}
	}
	internal static class LguTerminalNode
	{
		private static Terminal terminal;

		private static readonly LguLogger logger = new LguLogger("LguTerminalNode");

		private static readonly Dictionary<string, TerminalNode> retrievedTerminalNodes = new Dictionary<string, TerminalNode>();

		private const string HELP_NOUN = "help";

		public static Terminal GetTerminal()
		{
			if ((Object)(object)terminal == (Object)null)
			{
				terminal = UpgradeBus.Instance.GetTerminal();
			}
			return terminal;
		}

		internal static TerminalKeyword FindTerminalKeyword(string word)
		{
			TerminalKeyword val = GetTerminal().CheckForExactSentences(word);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("Couldn't find terminal node for the word \"" + word + "\"");
			}
			return val;
		}

		internal static TerminalNode GetSpecialTerminalNodeByWord(string word)
		{
			TerminalNode valueOrDefault = retrievedTerminalNodes.GetValueOrDefault(word, null);
			if ((Object)(object)valueOrDefault != (Object)null)
			{
				return valueOrDefault;
			}
			valueOrDefault = FindTerminalKeyword(word).specialKeywordResult;
			if (!retrievedTerminalNodes.ContainsKey(word))
			{
				retrievedTerminalNodes[word] = valueOrDefault;
			}
			return valueOrDefault;
		}

		internal static TerminalNode GetHelpTerminalNode()
		{
			return GetSpecialTerminalNodeByWord("help");
		}
	}
	internal class OneTimeTerminalNode : CustomTerminalNode
	{
		public OneTimeTerminalNode(string name, int unlockPrice, string description, GameObject prefab, string originalName = "", bool sharedUpgrade = false, bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = false, float refundPercentage = 1f)
			: base(name, unlockPrice, description, prefab, null, 0, originalName, sharedUpgrade, alternateCurrency, purchaseMode, refundable, refundPercentage)
		{
		}
	}
	internal class TierTerminalNode : CustomTerminalNode
	{
		public TierTerminalNode(string name, int unlockPrice, string description, GameObject prefab, int[] prices, int maxUpgrade, string originalName = "", bool sharedUpgrade = false, bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = false, float refundPercentage = 1f)
			: base(name, unlockPrice, description, prefab, prices, maxUpgrade, originalName, sharedUpgrade, alternateCurrency, purchaseMode, refundable, refundPercentage)
		{
		}
	}
}
namespace MoreShipUpgrades.UI.Cursor
{
	internal class UpgradeCursorElement : CursorElement
	{
		internal CustomTerminalNode Node { get; set; }

		public override string GetText(int availableLength)
		{
			StringBuilder sb = new StringBuilder();
			sb.Append(new string(' ', 2));
			string value = ((Node.Name.Length > 17) ? Node.Name.Substring(0, 17) : (Node.Name + new string(' ', Mathf.Max(0, 17 - Node.Name.Length))));
			if (!((CursorElement)this).Active((CursorElement)(object)this))
			{
				if (Node.Unlocked && Node.CurrentUpgrade >= Node.MaxUpgrade)
				{
					sb.Append(string.Format("<color={0}>", "#026440"));
				}
				else
				{
					sb.Append(string.Format("<color={0}>", "#666666"));
				}
			}
			sb.Append(value);
			int currentLevel = Node.GetCurrentLevel();
			int remainingLevels = Node.GetRemainingLevels();
			string value2 = new string('●', currentLevel) + new string('○', remainingLevels) + new string(' ', Mathf.Max(0, 7 - currentLevel - remainingLevels));
			sb.Append(' ');
			sb.Append(value2);
			sb.Append(' ');
			if (remainingLevels > 0)
			{
				AppendPriceText(ref sb);
				AppendSaleText(ref sb);
			}
			else
			{
				sb.Append("Maxed!");
			}
			if (!((CursorElement)this).Active((CursorElement)(object)this))
			{
				sb.Append("</color>");
			}
			return sb.ToString();
		}

		private void AppendPriceText(ref StringBuilder sb)
		{
			int currentPrice = Node.GetCurrentPrice();
			if (!Node.AlternateCurrency || Node.PurchaseMode != 0)
			{
				int groupCredits = UpgradeBus.Instance.GetTerminal().groupCredits;
				if (currentPrice <= groupCredits)
				{
					sb.Append(currentPrice);
					sb.Append("$");
				}
				else
				{
					sb.Append(string.Format("<color={0}>", "#8B0000"));
					sb.Append(currentPrice);
					sb.Append("$");
					sb.Append("</color>");
				}
			}
			if (Node.AlternateCurrency && Node.PurchaseMode != PurchaseMode.CompanyCredits)
			{
				if (Node.PurchaseMode != 0)
				{
					sb.Append("/");
				}
				int currencyAmountFromCredits = CurrencyManager.Instance.GetCurrencyAmountFromCredits(currentPrice);
				int currencyAmount = CurrencyManager.Instance.CurrencyAmount;
				if (currencyAmountFromCredits <= currencyAmount)
				{
					sb.Append(currencyAmountFromCredits);
					sb.Append(' ');
					sb.Append("PC");
				}
				else
				{
					sb.Append(string.Format("<color={0}>", "#8B0000"));
					sb.Append(currencyAmountFromCredits);
					sb.Append(' ');
					sb.Append("PC");
					sb.Append("</color>");
				}
			}
		}

		private void AppendSaleText(ref StringBuilder sb)
		{
			if (Node.SalePercentage < 1f)
			{
				sb.Append(' ');
				sb.Append($"({(1f - Node.SalePercentage) * 100f:F0}% OFF)");
			}
		}
	}
}
namespace MoreShipUpgrades.UI.Application
{
	internal class ContractApplication : InteractiveTerminalApplication<CursorElement>
	{
		private const string MAIN_MENU_TITLE = "Contracts";

		private const string CONTRACT_INFO_CURSOR_ELEMENT = "Contract Info";

		private const string PICK_CONTRACT_CURSOR_ELEMENT = "Pick a Contract";

		private const string CURRENT_CONTRACT_CURSOR_ELEMENT = "Current Contract";

		private const string RANDOM_MOON_CURSOR_ELEMENT = "Random Moon";

		private const string SPECIFIED_MOON_CURSOR_ELEMENT = "Specified Moon";

		private static readonly string[] MAIN_MENU_CURSOR_ELEMENTS = new string[3] { "Contract Info", "Pick a Contract", "Current Contract" };

		private IScreen mainScreen;

		private CursorMenu<CursorElement> mainCursorMenu;

		public override void Initialization()
		{
			CursorElement[] array = (CursorElement[])(object)new CursorElement[MAIN_MENU_CURSOR_ELEMENTS.Length];
			array[0] = CursorElement.Create(MAIN_MENU_CURSOR_ELEMENTS[0], "", (Action)ShowContractInformation, (Func<CursorElement, bool>)((CursorElement _) => true), false);
			array[1] = CursorElement.Create(MAIN_MENU_CURSOR_ELEMENTS[1], "", (Action)PickContract, (Func<CursorElement, bool>)((CursorElement _) => ContractManager.Instance.contractType == "None"), true);
			array[2] = CursorElement.Create(MAIN_MENU_CURSOR_ELEMENTS[2], "", (Action)ShowCurrentContract, (Func<CursorElement, bool>)((CursorElement _) => ContractManager.Instance.contractType != "None"), true);
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create("Select a prompt to execute contract related actions."),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen currentScreen = (IScreen)(object)BoxedScreen.Create("Contracts", array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorElement>)(object)val;
			((TerminalApplication)this).currentScreen = currentScreen;
			mainScreen = currentScreen;
			mainCursorMenu = val;
		}

		private void ShowContractInformation()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			CursorElement[] array = (CursorElement[])(object)new CursorElement[CommandParser.contractInfos.Count + 1];
			for (int i = 0; i < CommandParser.contracts.Count; i++)
			{
				int counter = i;
				array[i] = CursorElement.Create(CommandParser.contracts[counter], string.Empty, (Action)delegate
				{
					ShowContractInformation(CommandParser.contracts[counter], CommandParser.contractInfos[counter]);
				}, (Func<CursorElement, bool>)((CursorElement _) => true), false);
			}
			array[CommandParser.contractInfos.Count] = CursorElement.Create("Back", string.Empty, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, (Func<CursorElement, bool>)((CursorElement _) => true), true);
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create("Select a prompt to know the information of the contract from."),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create("Contracts", array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, true);
		}

		private void ShowContractInformation(string contractType, string information)
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			CursorElement[] array = (CursorElement[])(object)new CursorElement[1] { CursorElement.Create("Back", string.Empty, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, (Func<CursorElement, bool>)((CursorElement _) => true), true) };
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create(information),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(contractType, array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, true);
		}

		private void PickContract()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			if (ContractManager.Instance.contractType != "None")
			{
				base.ErrorMessage("Contracts", (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, "You still have an ongoing contract to finish.");
				return;
			}
			CursorElement[] array = (CursorElement[])(object)new CursorElement[3]
			{
				CursorElement.Create("Random Moon", string.Empty, (Action)ConfirmRandomMoonContract, (Func<CursorElement, bool>)((CursorElement _) => ((TerminalApplication)this).terminal.groupCredits >= SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice)), true),
				CursorElement.Create("Specified Moon", string.Empty, (Action)PickSpecifiedMoonContract, (Func<CursorElement, bool>)((CursorElement _) => ((TerminalApplication)this).terminal.groupCredits >= SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.SpecifyPrice)), true),
				CursorElement.Create("Back", string.Empty, (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, (Func<CursorElement, bool>)((CursorElement _) => true), true)
			};
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create("Select a prompt to specify where you want to get the contract on."),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create("Contracts", array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, true);
		}

		private void PickSpecifiedMoonContract()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			if (((TerminalApplication)this).terminal.groupCredits < SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.SpecifyPrice))
			{
				base.ErrorMessage("Contracts", (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, "Not enough credits to purchase a specified moon contract.");
				return;
			}
			SelectableLevel[] levels = StartOfRound.Instance.levels.Where((SelectableLevel x) => !x.PlanetName.Contains("Gordion")).ToArray();
			if (LethalLevelLoaderCompat.Enabled)
			{
				LethalLevelLoaderCompat.GrabAllAvailableLevels(ref levels);
			}
			CursorElement[] array = (CursorElement[])(object)new CursorElement[levels.Length + 1];
			for (int i = 0; i < levels.Length; i++)
			{
				int counter = i;
				array[i] = CursorElement.Create(levels[counter].PlanetName, string.Empty, (Action)delegate
				{
					ConfirmSpecifiedMoonContract(levels[counter]);
				}, (Func<CursorElement, bool>)((CursorElement _) => true), false);
			}
			array[levels.Length] = CursorElement.Create("Back", string.Empty, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, (Func<CursorElement, bool>)((CursorElement _) => true), true);
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create("Select the moon you wish to get a contract on."),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create("Contracts", array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, true);
		}

		private void ConfirmSpecifiedMoonContract(SelectableLevel level)
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			base.Confirm("Contracts", $"Do you wish to purchase a contract on {level.PlanetName} for a price of {UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.SpecifyPrice.Value} Company credits?", (Action)delegate
			{
				PurchaseSpecifiedMoonContract(level, delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(mainScreen, (BaseCursorMenu<CursorElement>)(object)mainCursorMenu, true);
				});
			}, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, "");
		}

		private void PurchaseSpecifiedMoonContract(SelectableLevel level, Action backAction)
		{
			((TerminalApplication)this).terminal.BuyItemsServerRpc(Array.Empty<int>(), ((TerminalApplication)this).terminal.groupCredits - UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.SpecifyPrice.Value, ((TerminalApplication)this).terminal.numberOfItemsInDropship);
			int num = Random.Range(0, CommandParser.contracts.Count);
			if (CommandParser.contracts.Count > 1)
			{
				while (num == ContractManager.Instance.lastContractIndex)
				{
					num = Random.Range(0, CommandParser.contracts.Count);
				}
			}
			ContractManager.Instance.contractType = CommandParser.contracts[num];
			ContractManager.Instance.contractLevel = level.PlanetName;
			if (((NetworkBehaviour)((TerminalApplication)this).terminal).IsHost || ((NetworkBehaviour)((TerminalApplication)this).terminal).IsServer)
			{
				ContractManager.Instance.SyncContractDetailsClientRpc(ContractManager.Instance.contractLevel, num);
			}
			else
			{
				ContractManager.Instance.ReqSyncContractDetailsServerRpc(ContractManager.Instance.contractLevel, num);
			}
			base.ErrorMessage("Contracts", backAction, "A " + ContractManager.Instance.contractType + " contract has been accepted on the moon " + ContractManager.Instance.contractLevel + "! " + CommandParser.contractInfos[num]);
		}

		private void ConfirmRandomMoonContract()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			if (((TerminalApplication)this).terminal.groupCredits < SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice))
			{
				base.ErrorMessage("Contracts", (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, "Not enough credits to purchase a randomized moon contract.");
				return;
			}
			base.Confirm("Contracts", $"Do you wish to purchase a randomized moon contract for a price of {UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value} Company credits?", (Action)delegate
			{
				PurchaseRandomMoonContract(delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(mainScreen, (BaseCursorMenu<CursorElement>)(object)mainCursorMenu, true);
				});
			}, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, "");
		}

		private void PurchaseRandomMoonContract(Action backAction)
		{
			((TerminalApplication)this).terminal.BuyItemsServerRpc(Array.Empty<int>(), ((TerminalApplication)this).terminal.groupCredits - UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value, ((TerminalApplication)this).terminal.numberOfItemsInDropship);
			int num = Random.Range(0, CommandParser.contracts.Count);
			if (CommandParser.contracts.Count > 1)
			{
				while (num == ContractManager.Instance.lastContractIndex)
				{
					num = Random.Range(0, CommandParser.contracts.Count);
				}
			}
			ContractManager.Instance.contractType = CommandParser.contracts[num];
			ContractManager.RandomLevel();
			if (((NetworkBehaviour)((TerminalApplication)this).terminal).IsHost || ((NetworkBehaviour)((TerminalApplication)this).terminal).IsServer)
			{
				ContractManager.Instance.SyncContractDetailsClientRpc(ContractManager.Instance.contractLevel, num);
			}
			else
			{
				ContractManager.Instance.ReqSyncContractDetailsServerRpc(ContractManager.Instance.contractLevel, num);
			}
			base.ErrorMessage("Contracts", backAction, "A " + ContractManager.Instance.contractType + " contract has been accepted on the moon " + ContractManager.Instance.contractLevel + "! " + CommandParser.contractInfos[num]);
		}

		private void ShowCurrentContract()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			if (ContractManager.Instance.contractType == "None")
			{
				base.ErrorMessage("Contracts", (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, "You currently do not have an assigned contract.");
				return;
			}
			CursorElement[] array = (CursorElement[])(object)new CursorElement[2]
			{
				CursorElement.Create("Cancel Current Contract", string.Empty, (Action)ConfirmCancelContract, (Func<CursorElement, bool>)((CursorElement _) => true), true),
				CursorElement.Create("Back", string.Empty, (Action)delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
				}, (Func<CursorElement, bool>)((CursorElement _) => true), true)
			};
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create(CommandParser.contractInfos[CommandParser.contracts.IndexOf(ContractManager.Instance.contractType)]),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(ContractManager.Instance.contractType + " - " + ContractManager.Instance.contractLevel, array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, true);
		}

		private void ConfirmCancelContract()
		{
			IScreen previousScreen = ((TerminalApplication)this).currentScreen;
			BaseCursorMenu<CursorElement> previousCursorMenu = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu;
			base.Confirm("Contracts", "Do you wish to cancel the current contract?", (Action)delegate
			{
				CancelContract(delegate
				{
					((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(mainScreen, (BaseCursorMenu<CursorElement>)(object)mainCursorMenu, true);
				});
			}, (Action)delegate
			{
				((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(previousScreen, previousCursorMenu, true);
			}, "");
		}

		private void CancelContract(Action backAction)
		{
			if (((NetworkBehaviour)((TerminalApplication)this).terminal).IsHost || ((NetworkBehaviour)((TerminalApplication)this).terminal).IsServer)
			{
				ContractManager.Instance.SyncContractDetailsClientRpc();
			}
			else
			{
				ContractManager.Instance.ReqSyncContractDetailsServerRpc("None", -1);
			}
			base.ErrorMessage("Contracts", backAction, "Cancelling contract...\n\n");
		}
	}
	internal class ConvertPlayerCreditApplication : InteractiveCounterApplication<CursorCounterElement>
	{
		private const string TITLE = "Player Credits Conversion";

		private const int MINIMUM_PC = 1;

		public override void Initialization()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_00f6: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			CursorCounterElement[] array = (CursorCounterElement[])(object)new CursorCounterElement[3];
			CursorMenu<CursorCounterElement> cursorCounterMenu = CursorMenu<CursorCounterElement>.Create(array.Length - 1, '>', array, (Func<CursorCounterElement, CursorCounterElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)new TextElement
				{
					Text = "What operation of conversion do you wish to execute?"
				},
				(ITextElement)new TextElement
				{
					Text = ""
				},
				(ITextElement)cursorCounterMenu
			};
			IScreen screen = (IScreen)(object)BoxedScreen.Create("Player Credits Conversion", array2);
			array[0] = new CursorCounterElement
			{
				Action = delegate
				{
					ConvertCreditsToPCsScreen(delegate
					{
						((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(screen, (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu, true);
					});
				},
				Active = (CursorElement _) => HasEnoughCreditsToConvert(),
				Name = "Convert Credits to Player Credits (PCs)",
				SelectInactive = false
			};
			array[1] = new CursorCounterElement
			{
				Action = delegate
				{
					ConvertPCsToCreditsScreen(delegate
					{
						((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(screen, (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu, true);
					});
				},
				Active = (CursorElement _) => HasEnoughPCsToConvert(),
				Name = "Convert Player Credits (PCs) to Credits",
				SelectInactive = false
			};
			array[2] = new CursorCounterElement
			{
				Action = delegate
				{
					Object.Destroy((Object)(object)((Component)InteractiveTerminalManager.Instance).gameObject);
				},
				Active = (CursorElement _) => true,
				Name = "Back",
				SelectInactive = false
			};
			((BaseInteractiveApplication<CursorCounterElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu;
			((TerminalApplication)this).currentScreen = screen;
		}

		private void ConvertPCsToCreditsScreen(Action backAction)
		{
			CursorOutputElement<string>[] cursorCounterElements = new CursorOutputElement<string>[2];
			Func<int, string>[] array = new Func<int, string>[1]
			{
				(int x) => $"{x} PCs"
			};
			int num = cursorCounterElements.Length - 1;
			CursorCounterElement[] array2 = (CursorCounterElement[])(object)cursorCounterElements;
			CursorMenu<CursorCounterElement> cursorCounterMenu = CursorMenu<CursorCounterElement>.Create(num, '>', array2, (Func<CursorCounterElement, CursorCounterElement, int>[])null);
			IScreen screen = (IScreen)(object)BoxedOutputScreen<string, string>.Create("Player Credits Conversion", (ITextElement[])(object)new ITextElement[1] { (ITextElement)cursorCounterMenu }, (Func<string>)(() => $"${CurrencyManager.Instance.GetCreditsFromCurrencyAmountConversion(((CursorCounterElement)cursorCounterElements[0]).Counter)}"), (Func<string, string>)((string x) => x));
			CursorOutputElement<string>[] array3 = cursorCounterElements;
			CursorOutputElement<string> obj = new CursorOutputElement<string>();
			((CursorElement)obj).Action = delegate
			{
				TryConvertPCsToCredits(cursorCounterElements[0], delegate
				{
					((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(screen, (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu, true);
				});
			};
			((CursorElement)obj).Active = (CursorElement x) => HasEnoughPCsToConvert(((CursorCounterElement)x).Counter);
			((CursorElement)obj).Name = "Amount of PCs to convert";
			((CursorElement)obj).SelectInactive = true;
			obj.Func = array[0];
			array3[0] = obj;
			CursorOutputElement<string>[] array4 = cursorCounterElements;
			CursorOutputElement<string> obj2 = new CursorOutputElement<string>();
			((CursorElement)obj2).Action = backAction;
			((CursorElement)obj2).Active = (CursorElement _) => true;
			((CursorElement)obj2).Name = "Back";
			((CursorElement)obj2).SelectInactive = false;
			obj2.Func = (int _) => "";
			array4[1] = obj2;
			((BaseInteractiveApplication<CursorCounterElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu;
			((TerminalApplication)this).currentScreen = screen;
		}

		private void TryConvertPCsToCredits(CursorOutputElement<string> cursorOutputElement, Action backAction)
		{
			int counter = ((CursorCounterElement)cursorOutputElement).Counter;
			if (CurrencyManager.Instance.CurrencyAmount < counter)
			{
				ErrorMessage("Player Credits Conversion", "", backAction, "Not enough PCs to perform conversion.");
				return;
			}
			LguStore.Instance.SyncCreditsServerRpc(((TerminalApplication)this).terminal.groupCredits + CurrencyManager.Instance.GetCreditsFromCurrencyAmountConversion(counter));
			CurrencyManager.Instance.RemoveCurrencyAmount(counter);
			backAction();
		}

		private void TryConvertCreditsToPCs(CursorOutputElement<string> cursorOutputElement, Action backAction)
		{
			int counter = ((CursorCounterElement)cursorOutputElement).Counter;
			if (CurrencyManager.Instance.BlockExceedOperations(counter))
			{
				ErrorMessage("Player Credits Conversion", "", backAction, "Solicited amount exceeds the configurated maximum cap of alternative currency units.");
				return;
			}
			int requiredCreditsFromCurrencyConversion = CurrencyManager.Instance.GetRequiredCreditsFromCurrencyConversion(counter);
			if (((TerminalApplication)this).terminal.groupCredits < requiredCreditsFromCurrencyConversion)
			{
				ErrorMessage("Player Credits Conversion", "", backAction, "Not enough Company Credits to perform conversion.");
				return;
			}
			LguStore.Instance.SyncCreditsServerRpc(((TerminalApplication)this).terminal.groupCredits - requiredCreditsFromCurrencyConversion);
			CurrencyManager.Instance.AddCurrencyAmount(counter);
			backAction();
		}

		private bool HasEnoughCreditsToConvert(int amount = 1)
		{
			if (CurrencyManager.Instance.BlockExceedOperations(amount))
			{
				return false;
			}
			return ((TerminalApplication)this).terminal.groupCredits >= CurrencyManager.Instance.GetRequiredCreditsFromCurrencyConversion(amount);
		}

		private bool HasEnoughPCsToConvert(int amount = 0)
		{
			return CurrencyManager.Instance.CurrencyAmount != 0 && CurrencyManager.Instance.CurrencyAmount >= amount;
		}

		private void ConvertCreditsToPCsScreen(Action backAction)
		{
			CursorOutputElement<string>[] cursorCounterElements = new CursorOutputElement<string>[2];
			Func<int, string>[] array = new Func<int, string>[1]
			{
				(int x) => $"${CurrencyManager.Instance.GetRequiredCreditsFromCurrencyConversion(((CursorCounterElement)cursorCounterElements[0]).Counter)}"
			};
			int num = cursorCounterElements.Length - 1;
			CursorCounterElement[] array2 = (CursorCounterElement[])(object)cursorCounterElements;
			CursorMenu<CursorCounterElement> cursorCounterMenu = CursorMenu<CursorCounterElement>.Create(num, '>', array2, (Func<CursorCounterElement, CursorCounterElement, int>[])null);
			IScreen screen = (IScreen)(object)BoxedOutputScreen<string, string>.Create("Player Credits Conversion", (ITextElement[])(object)new ITextElement[1] { (ITextElement)cursorCounterMenu }, (Func<string>)(() => $"{((CursorCounterElement)cursorCounterElements[0]).Counter} PC"), (Func<string, string>)((string x) => x));
			CursorOutputElement<string>[] array3 = cursorCounterElements;
			CursorOutputElement<string> obj = new CursorOutputElement<string>();
			((CursorElement)obj).Action = delegate
			{
				TryConvertCreditsToPCs(cursorCounterElements[0], delegate
				{
					((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(screen, (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu, true);
				});
			};
			((CursorElement)obj).Active = (CursorElement x) => HasEnoughCreditsToConvert(((CursorCounterElement)x).Counter);
			((CursorElement)obj).Name = "Amount of credits to convert";
			((CursorElement)obj).SelectInactive = true;
			obj.Func = array[0];
			array3[0] = obj;
			CursorOutputElement<string>[] array4 = cursorCounterElements;
			CursorOutputElement<string> obj2 = new CursorOutputElement<string>();
			((CursorElement)obj2).Action = backAction;
			((CursorElement)obj2).Active = (CursorElement _) => true;
			((CursorElement)obj2).Name = "Back";
			((CursorElement)obj2).SelectInactive = false;
			obj2.Func = (int _) => "";
			array4[1] = obj2;
			((BaseInteractiveApplication<CursorCounterElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorCounterElement>)(object)cursorCounterMenu;
			((TerminalApplication)this).currentScreen = screen;
		}

		protected void Confirm(string title, string description, Action confirmAction, Action declineAction, string additionalMessage = "")
		{
			CursorCounterElement[] array = (CursorCounterElement[])(object)new CursorCounterElement[2]
			{
				CursorCounterElement.Create("Confirm", "", confirmAction, 0, (Func<CursorElement, bool>)null, true, false),
				CursorCounterElement.Create("Abort", "", declineAction, 0, (Func<CursorElement, bool>)null, true, false)
			};
			CursorMenu<CursorCounterElement> val = CursorMenu<CursorCounterElement>.Create(0, '>', array, (Func<CursorCounterElement, CursorCounterElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[4]
			{
				(ITextElement)TextElement.Create(description),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)TextElement.Create(additionalMessage),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(title, array2);
			((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorCounterElement>)(object)val, false);
		}

		protected void ErrorMessage(string title, string description, Action backAction, string error)
		{
			CursorCounterElement[] array = (CursorCounterElement[])(object)new CursorCounterElement[1] { CursorCounterElement.Create("Back", "", backAction, 0, (Func<CursorElement, bool>)null, true, false) };
			CursorMenu<CursorCounterElement> val = CursorMenu<CursorCounterElement>.Create(0, '>', array, (Func<CursorCounterElement, CursorCounterElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[5]
			{
				(ITextElement)TextElement.Create(description),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)TextElement.Create(error),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(title, array2);
			((BaseInteractiveApplication<CursorCounterElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorCounterElement>)(object)val, false);
		}
	}
	internal class TradePlayerCreditsApplication : PageApplication<CursorElement>
	{
		private const string MAIN_SCREEN_TITLE = "Player Credits Trading";

		private const string NO_PLAYERS_TO_TRADE_TEXT = "There are no players you can trade your player credits with.";

		private const string NO_PLAYER_CREDITS_TO_TRADE_TEXT = "You currently don't possess any player credit to trade with.";

		private const string TRADE_PLAYER_TEXT = "How many player credits do you wish to provide for selected player?";

		private const string TRADE_CREDITS_INFO_TEXT = "Select the player you wish to provide player credits to:";

		private const string CONFIRM_TRADE_PLAYER_TEXT = "Do you wish to trade {0} player credits to {1}?";

		public override void Initialization()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//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_00c8: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			PlayerControllerB[] array = StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB x) => (x.isPlayerControlled || x.isPlayerDead) && (Object)(object)x != (Object)(object)GameNetworkManager.Instance.localPlayerController).ToArray();
			if (array.Length == 0)
			{
				CursorElement[] array2 = (CursorElement[])(object)new CursorElement[1] { CursorElement.Create("Leave", "", (Action)delegate
				{
					Object.Destroy((Object)(object)InteractiveTerminalManager.Instance);
				}, (Func<CursorElement, bool>)null, true) };
				CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array2, (Func<CursorElement, CursorElement, int>[])null);
				BoxedScreen val2 = new BoxedScreen();
				val2.Title = "Player Credits Trading";
				val2.elements = (ITextElement[])(object)new ITextElement[3]
				{
					(ITextElement)new TextElement
					{
						Text = "There are no players you can trade your player credits with."
					},
					(ITextElement)new TextElement
					{
						Text = " "
					},
					(ITextElement)val
				};
				IScreen val3 = (IScreen)(object)val2;
				base.currentPage = PageCursorElement<CursorElement>.Create(0, (IScreen[])(object)new IScreen[1] { val3 }, new BaseCursorMenu<CursorElement>[1] { (BaseCursorMenu<CursorElement>)(object)val });
				((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorElement>)(object)val;
				((TerminalApplication)this).currentScreen = val3;
				return;
			}
			if (CurrencyManager.Instance.CurrencyAmount <= 0)
			{
				CursorElement[] array3 = (CursorElement[])(object)new CursorElement[1] { CursorElement.Create("Leave", "", (Action)delegate
				{
					Object.Destroy((Object)(object)InteractiveTerminalManager.Instance);
				}, (Func<CursorElement, bool>)null, true) };
				CursorMenu<CursorElement> val4 = CursorMenu<CursorElement>.Create(0, '>', array3, (Func<CursorElement, CursorElement, int>[])null);
				BoxedScreen val2 = new BoxedScreen();
				val2.Title = "Player Credits Trading";
				val2.elements = (ITextElement[])(object)new ITextElement[3]
				{
					(ITextElement)new TextElement
					{
						Text = "You currently don't possess any player credit to trade with."
					},
					(ITextElement)new TextElement
					{
						Text = " "
					},
					(ITextElement)val4
				};
				IScreen val5 = (IScreen)(object)val2;
				base.currentPage = PageCursorElement<CursorElement>.Create(0, (IScreen[])(object)new IScreen[1] { val5 }, new BaseCursorMenu<CursorElement>[1] { (BaseCursorMenu<CursorElement>)(object)val4 });
				((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorElement>)(object)val4;
				((TerminalApplication)this).currentScreen = val5;
				return;
			}
			(PlayerControllerB[][], BaseCursorMenu<CursorElement>[], IScreen[]) pageEntries = base.GetPageEntries<PlayerControllerB>(array);
			PlayerControllerB[][] item = pageEntries.Item1;
			BaseCursorMenu<CursorElement>[] item2 = pageEntries.Item2;
			IScreen[] item3 = pageEntries.Item3;
			PageCursorElement<CursorElement> page = null;
			for (int i = 0; i < item.Length; i++)
			{
				PlayerControllerB[] array4 = item[i];
				CursorElement[] array5 = (CursorElement[])(object)new CursorElement[array4.Length];
				item2[i] = (BaseCursorMenu<CursorElement>)(object)CursorMenu<CursorElement>.Create(0, '>', array5, (Func<CursorElement, CursorElement, int>[])null);
				BaseCursorMenu<CursorElement> val6 = item2[i];
				int num = i;
				BoxedScreen val2 = new BoxedScreen();
				val2.Title = "Player Credits Trading";
				val2.elements = (ITextElement[])(object)new ITextElement[3]
				{
					(ITextElement)new TextElement
					{
						Text = "Select the player you wish to provide player credits to:"
					},
					(ITextElement)new TextElement
					{
						Text = " "
					},
					(ITextElement)val6
				};
				item3[num] = (IScreen)(object)val2;
				for (int j = 0; j < array4.Length; j++)
				{
					PlayerControllerB player = array4[j];
					if ((Object)(object)player == (Object)null)
					{
						continue;
					}
					array5[j] = new CursorElement
					{
						Name = player.playerUsername,
						Action = delegate
						{
							TradePlayerCredits(player, delegate
							{
								base.SwitchScreen(page, true);
							});
						}
					};
				}
			}
			page = PageCursorElement<CursorElement>.Create(0, item3, item2);
			base.initialPage = page;
			base.currentPage = base.initialPage;
			((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = base.currentPage.GetCurrentCursorMenu();
			((TerminalApplication)this).currentScreen = ((PageElement)base.currentPage).GetCurrentScreen();
		}

		private void TradePlayerCredits(PlayerControllerB tradingPlayer, Action backAction)
		{
			int playerCredits = CurrencyManager.Instance.CurrencyAmount;
			CursorElement[] array = (CursorElement[])(object)new CursorElement[4]
			{
				CursorElement.Create("Give 1 Player Credit", "", (Action)delegate
				{
					ConfirmTradePlayerCredits(tradingPlayer, 1, backAction);
				}, (Func<CursorElement, bool>)null, false),
				CursorElement.Create("Give 5 Player Credits", "", (Action)delegate
				{
					ConfirmTradePlayerCredits(tradingPlayer, 5, backAction);
				}, (Func<CursorElement, bool>)((CursorElement _) => playerCredits >= 5), false),
				CursorElement.Create("Give All Player Credits", "", (Action)delegate
				{
					ConfirmTradePlayerCredits(tradingPlayer, playerCredits, backAction);
				}, (Func<CursorElement, bool>)null, false),
				CursorElement.Create("Cancel", "", backAction, (Func<CursorElement, bool>)null, true)
			};
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create("How many player credits do you wish to provide for selected player?"),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(tradingPlayer.playerUsername, array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, false);
		}

		private void ConfirmTradePlayerCredits(PlayerControllerB tradingPlayer, int playerCreditAmount, Action backAction)
		{
			((InteractiveTerminalApplication<CursorElement>)(object)this).Confirm(tradingPlayer.playerUsername, $"Do you wish to trade {playerCreditAmount} player credits to {tradingPlayer.playerUsername}?", (Action)delegate
			{
				ExecuteTrade(tradingPlayer, playerCreditAmount, backAction);
			}, backAction, "");
		}

		private void ExecuteTrade(PlayerControllerB tradingPlayer, int playerCreditAmount, Action backAction)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			CurrencyManager.Instance.RemoveCurrencyAmount(playerCreditAmount);
			CurrencyManager.Instance.TradePlayerCreditsServerRpc(tradingPlayer.actualClientId, playerCreditAmount);
			if (CurrencyManager.Instance.CurrencyAmount <= 0)
			{
				Object.Destroy((Object)(object)InteractiveTerminalManager.Instance);
			}
			else
			{
				backAction();
			}
		}
	}
	internal class UpgradeStoreApplication : PageApplication<CursorElement>
	{
		private const int UPGRADES_PER_PAGE = 12;

		protected override int GetEntriesPerPage<T>(T[] entries)
		{
			return 12;
		}

		public override void Initialization()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			CustomTerminalNode[] nodes = UpgradeApi.GetPurchaseableUpgradeNodes().ToArray();
			if (nodes.Length == 0)
			{
				CursorElement[] array = (CursorElement[])(object)new CursorElement[1] { CursorElement.Create("Leave", "", (Action)delegate
				{
					Object.Destroy((Object)(object)InteractiveTerminalManager.Instance);
				}, (Func<CursorElement, bool>)null, true) };
				CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(0, '>', array, (Func<CursorElement, CursorElement, int>[])null);
				BoxedScreen val2 = new BoxedScreen();
				val2.Title = "Lategame Upgrades";
				val2.elements = (ITextElement[])(object)new ITextElement[3]
				{
					(ITextElement)new TextElement
					{
						Text = "There are no upgrades for purchase."
					},
					(ITextElement)new TextElement
					{
						Text = " "
					},
					(ITextElement)val
				};
				IScreen val3 = (IScreen)(object)val2;
				base.currentPage = PageCursorElement<CursorElement>.Create(0, (IScreen[])(object)new IScreen[1] { val3 }, new BaseCursorMenu<CursorElement>[1] { (BaseCursorMenu<CursorElement>)(object)val });
				((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = (BaseCursorMenu<CursorElement>)(object)val;
				((TerminalApplication)this).currentScreen = val3;
				return;
			}
			List<CursorElement> list = new List<CursorElement>();
			PageCursorElement<CursorElement> filteredUpgradeNodes = GetFilteredUpgradeNodes(ref nodes, ref list, (CustomTerminalNode x) => x.SharedUpgrade, "Lategame Upgrades", "Shared Upgrades");
			PageCursorElement<CursorElement> filteredUpgradeNodes2 = GetFilteredUpgradeNodes(ref nodes, ref list, (CustomTerminalNode x) => !x.SharedUpgrade && (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ShowLockedUpgrades) || !UpgradeBus.Instance.lockedUpgrades.Keys.Contains(x)), "Lategame Upgrades", "Individual Upgrades");
			if (list.Count > 1)
			{
				CursorElement[] array2 = list.ToArray();
				CursorMenu<CursorElement> val4 = CursorMenu<CursorElement>.Create(0, '>', array2, (Func<CursorElement, CursorElement, int>[])null);
				BoxedScreen val2 = new BoxedScreen();
				val2.Title = "Lategame Upgrades";
				val2.elements = (ITextElement[])(object)new ITextElement[1] { (ITextElement)val4 };
				IScreen val5 = (IScreen)(object)val2;
				base.initialPage = PageCursorElement<CursorElement>.Create(0, (IScreen[])(object)new IScreen[1] { val5 }, new BaseCursorMenu<CursorElement>[1] { (BaseCursorMenu<CursorElement>)(object)val4 });
			}
			else if (filteredUpgradeNodes == null)
			{
				base.initialPage = filteredUpgradeNodes2;
			}
			else
			{
				base.initialPage = filteredUpgradeNodes;
			}
			base.currentPage = base.initialPage;
			((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = base.currentPage.GetCurrentCursorMenu();
			((TerminalApplication)this).currentScreen = ((PageElement)base.currentPage).GetCurrentScreen();
		}

		private PageCursorElement<CursorElement> GetFilteredUpgradeNodes(ref CustomTerminalNode[] nodes, ref List<CursorElement> list, Func<CustomTerminalNode, bool> predicate, string pageTitle, string cursorName)
		{
			PageCursorElement<CursorElement> page = null;
			CustomTerminalNode[] array = nodes.Where(predicate).ToArray();
			if (array.Length != 0)
			{
				page = BuildUpgradePage(array, pageTitle);
				list.Add(CursorElement.Create(cursorName, "", (Action)delegate
				{
					SwitchToUpgradeScreen(page, previous: true);
				}, (Func<CursorElement, bool>)null, true));
			}
			return page;
		}

		private void SwitchToUpgradeScreen(PageCursorElement<CursorElement> page, bool previous)
		{
			InputUtils_Compat.CursorExitKey.performed -= ((TerminalApplication)this).OnScreenExit;
			InputUtils_Compat.CursorExitKey.performed += OnUpgradeStoreExit;
			base.SwitchScreen(page, previous);
		}

		private void OnUpgradeStoreExit(CallbackContext context)
		{
			base.ResetScreen();
			InputUtils_Compat.CursorExitKey.performed += ((TerminalApplication)this).OnScreenExit;
			InputUtils_Compat.CursorExitKey.performed -= OnUpgradeStoreExit;
		}

		private PageCursorElement<CursorElement> BuildUpgradePage(CustomTerminalNode[] nodes, string title)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			(CustomTerminalNode[][], BaseCursorMenu<CursorElement>[], IScreen[]) pageEntries = base.GetPageEntries<CustomTerminalNode>(nodes);
			CustomTerminalNode[][] item = pageEntries.Item1;
			BaseCursorMenu<CursorElement>[] item2 = pageEntries.Item2;
			IScreen[] item3 = pageEntries.Item3;
			PageCursorElement<CursorElement> page = null;
			for (int i = 0; i < item.Length; i++)
			{
				CustomTerminalNode[] array = item[i];
				CursorElement[] array2 = (CursorElement[])(object)new CursorElement[array.Length];
				item2[i] = (BaseCursorMenu<CursorElement>)(object)CursorMenu<CursorElement>.Create(0, '>', array2, new Func<CursorElement, CursorElement, int>[3] { CompareName, CompareCurrentPrice, CompareCurrentPriceReversed });
				BaseCursorMenu<CursorElement> val = item2[i];
				item3[i] = (IScreen)(object)new BoxedOutputScreen<string, string>
				{
					Title = title,
					elements = (ITextElement[])(object)new ITextElement[3]
					{
						(ITextElement)new TextElement
						{
							Text = "Select an upgrade to purchase:"
						},
						(ITextElement)new TextElement
						{
							Text = " "
						},
						(ITextElement)val
					},
					Output = (string x) => x,
					Input = GetCurrentSort
				};
				for (int j = 0; j < array.Length; j++)
				{
					CustomTerminalNode upgrade = array[j];
					if (upgrade == null)
					{
						continue;
					}
					int num = j;
					UpgradeCursorElement obj = new UpgradeCursorElement
					{
						Node = upgrade
					};
					((CursorElement)obj).Action = delegate
					{
						BuyUpgrade(upgrade, delegate
						{
							base.SwitchScreen(page, true);
						});
					};
					((CursorElement)obj).Active = (CursorElement x) => CanBuyUpgrade(((UpgradeCursorElement)(object)x).Node);
					array2[num] = (CursorElement)(object)obj;
				}
			}
			page = PageCursorElement<CursorElement>.Create(0, item3, item2);
			return page;
		}

		private string GetCurrentSort()
		{
			int sortingIndex = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu.sortingIndex;
			if (1 == 0)
			{
			}
			string result = sortingIndex switch
			{
				0 => "Sorted by: Alphabetical [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				1 => "Sorted by: Price (Ascending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				2 => "Sorted by: Price (Descending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				_ => "", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private int CompareName(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			UpgradeCursorElement upgradeCursorElement = cursor1 as UpgradeCursorElement;
			UpgradeCursorElement upgradeCursorElement2 = cursor2 as UpgradeCursorElement;
			string name = upgradeCursorElement.Node.Name;
			string name2 = upgradeCursorElement2.Node.Name;
			return name.CompareTo(name2);
		}

		private int CompareCurrentPriceReversed(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			UpgradeCursorElement upgradeCursorElement = cursor1 as UpgradeCursorElement;
			UpgradeCursorElement upgradeCursorElement2 = cursor2 as UpgradeCursorElement;
			int value = ((upgradeCursorElement.Node.Unlocked && upgradeCursorElement.Node.CurrentUpgrade >= upgradeCursorElement.Node.MaxUpgrade) ? int.MinValue : upgradeCursorElement.Node.GetCurrentPrice());
			return ((upgradeCursorElement2.Node.Unlocked && upgradeCursorElement2.Node.CurrentUpgrade >= upgradeCursorElement2.Node.MaxUpgrade) ? int.MinValue : upgradeCursorElement2.Node.GetCurrentPrice()).CompareTo(value);
		}

		private int CompareCurrentPrice(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			UpgradeCursorElement upgradeCursorElement = cursor1 as UpgradeCursorElement;
			UpgradeCursorElement upgradeCursorElement2 = cursor2 as UpgradeCursorElement;
			int num = ((upgradeCursorElement.Node.Unlocked && upgradeCursorElement.Node.CurrentUpgrade >= upgradeCursorElement.Node.MaxUpgrade) ? int.MaxValue : upgradeCursorElement.Node.GetCurrentPrice());
			int value = ((upgradeCursorElement2.Node.Unlocked && upgradeCursorElement2.Node.CurrentUpgrade >= upgradeCursorElement2.Node.MaxUpgrade) ? int.MaxValue : upgradeCursorElement2.Node.GetCurrentPrice());
			return num.CompareTo(value);
		}

		private static bool CanBuyUpgrade(CustomTerminalNode node)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_NO_PURCHASE_UPGRADES))
			{
				return false;
			}
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.BuyableUpgradeOnce) && UpgradeBus.Instance.lockedUpgrades.Keys.Contains(node))
			{
				return false;
			}
			if (MaximumIndividualUpgradeCheck(node))
			{
				return false;
			}
			if (node.Refundable && node.Unlocked)
			{
				return true;
			}
			if (node.CurrentUpgrade >= node.MaxUpgrade && node.Unlocked)
			{
				return false;
			}
			int groupCredits = UpgradeBus.Instance.GetTerminal().groupCredits;
			int currentPrice = node.GetCurrentPrice();
			bool flag = groupCredits >= currentPrice;
			if (!node.AlternateCurrency)
			{
				return flag;
			}
			int currencyAmount = CurrencyManager.Instance.CurrencyAmount;
			int currencyAmountFromCredits = CurrencyManager.Instance.GetCurrencyAmountFromCredits(currentPrice);
			bool flag2 = currencyAmount >= currencyAmountFromCredits;
			return node.PurchaseMode switch
			{
				PurchaseMode.Both => flag || flag2, 
				PurchaseMode.CompanyCredits => flag, 
				PurchaseMode.AlternateCurrency => flag2, 
				_ => false, 
			};
		}

		private static bool CanBuyUpgradeWithGroupCredits(CustomTerminalNode node)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_NO_PURCHASE_UPGRADES))
			{
				return true;
			}
			if (node.CurrentUpgrade >= node.MaxUpgrade && node.Unlocked)
			{
				return false;
			}
			int groupCredits = UpgradeBus.Instance.GetTerminal().groupCredits;
			int currentPrice = node.GetCurrentPrice();
			return groupCredits >= currentPrice;
		}

		private static bool MaximumIndividualUpgradeCheck(CustomTerminalNode node)
		{
			return !node.SharedUpgrade && !node.Unlocked && SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.MaximumIndividualUpgrades) > 0 && (from x in UpgradeApi.GetUpgradeNodes()
				where !x.SharedUpgrade && x.Unlocked
				select x).Count() >= SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.MaximumIndividualUpgrades);
		}

		private static bool CanBuyUpgradeWithPlayerCredits(CustomTerminalNode node)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_NO_PURCHASE_UPGRADES))
			{
				return true;
			}
			if (node.CurrentUpgrade >= node.MaxUpgrade && node.Unlocked)
			{
				return false;
			}
			int currentPrice = node.GetCurrentPrice();
			int currencyAmount = CurrencyManager.Instance.CurrencyAmount;
			int currencyAmountFromCredits = CurrencyManager.Instance.GetCurrencyAmountFromCredits(currentPrice);
			return currencyAmount >= currencyAmountFromCredits;
		}

		public void BuyUpgrade(CustomTerminalNode node, Action backAction)
		{
			int groupCredits = UpgradeBus.Instance.GetTerminal().groupCredits;
			StringBuilder stringBuilder = new StringBuilder();
			List<string> discoveredItems = ItemProgressionManager.GetDiscoveredItems(node);
			if (discoveredItems.Count > 0)
			{
				stringBuilder.Append("\n\nDiscovered items: ");
				stringBuilder.Append(string.Join(",", discoveredItems));
			}
			string text = node.Description + stringBuilder;
			if (node.CurrentUpgrade >= node.MaxUpgrade && node.Unlocked && !node.Refundable)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You have reached the maximum level of this upgrade.");
				return;
			}
			int price = node.GetCurrentPrice();
			switch (node.PurchaseMode)
			{
			case PurchaseMode.CompanyCredits:
				if (groupCredits < price && !node.Refundable)
				{
					((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You do not have enough credits to purchase this upgrade.");
					return;
				}
				break;
			case PurchaseMode.AlternateCurrency:
			{
				if (!node.AlternateCurrency && !node.Refundable)
				{
					((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You do not have enough credits to purchase this upgrade.");
					return;
				}
				int currencyAmountFromCredits2 = CurrencyManager.Instance.GetCurrencyAmountFromCredits(price);
				int currencyAmount2 = CurrencyManager.Instance.CurrencyAmount;
				if (currencyAmount2 < currencyAmountFromCredits2 && !node.Refundable)
				{
					((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You do not have enough credits to purchase this upgrade.");
					return;
				}
				break;
			}
			case PurchaseMode.Both:
				if (groupCredits < price)
				{
					if (!node.AlternateCurrency && !node.Refundable)
					{
						((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You do not have enough credits to purchase this upgrade.");
						return;
					}
					int currencyAmountFromCredits = CurrencyManager.Instance.GetCurrencyAmountFromCredits(price);
					int currencyAmount = CurrencyManager.Instance.CurrencyAmount;
					if (currencyAmount < currencyAmountFromCredits && !node.Refundable)
					{
						((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "You do not have enough credits to purchase this upgrade.");
						return;
					}
				}
				break;
			}
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.BuyableUpgradeOnce) && UpgradeBus.Instance.lockedUpgrades.Keys.Contains(node))
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, "This upgrade has been assigned to another crew member.");
				return;
			}
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_NO_PURCHASE_UPGRADES))
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, " ");
				return;
			}
			if (MaximumIndividualUpgradeCheck(node))
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, text, backAction, $"You have surpassed the maximum amount of allowed individual upgrades purchased. ({UpgradeBus.Instance.PluginConfiguration.MaximumIndividualUpgrades.Value})");
				return;
			}
			CursorElement[] array = (CursorElement[])((!node.AlternateCurrency) ? ((Array)new CursorElement[3]
			{
				CursorElement.Create("Purchase with Company Credits", "", (Action)delegate
				{
					ConfirmPurchaseUpgrade(node, price, backAction);
				}, (Func<CursorElement, bool>)((CursorElement _) => CanBuyUpgradeWithGroupCredits(node)), false),
				CursorElement.Create("Refund Upgrade Level", "", (Action)delegate
				{
					ConfirmRefundUpgradeLevel(node, PurchaseMode.CompanyCredits, backAction);
				}, (Func<CursorElement, bool>)((CursorElement _) => CanRefundUpgradeLevel(node)), false),
				CursorElement.Create("Cancel", "", backAction, (Func<CursorElement, bool>)null, true)
			}) : ((Array)(node.PurchaseMode switch
			{
				PurchaseMode.Both => (CursorElement[])(object)new CursorElement[5]
				{
					CursorElement.Create("Purchase with Company Credits", "", (Action)delegate
					{
						ConfirmPurchaseUpgrade(node, price, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanBuyUpgradeWithGroupCredits(node)), false),
					CursorElement.Create("Purchase with Player Credits", "", (Action)delegate
					{
						ConfirmPurchaseUpgradeAlternateCurrency(node, CurrencyManager.Instance.GetCurrencyAmountFromCredits(price), backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanBuyUpgradeWithPlayerCredits(node)), false),
					CursorElement.Create("Refund Upgrade Level for Company Credits", "", (Action)delegate
					{
						ConfirmRefundUpgradeLevel(node, PurchaseMode.CompanyCredits, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanRefundUpgradeLevel(node)), false),
					CursorElement.Create("Refund Upgrade Level for Player Credits", "", (Action)delegate
					{
						ConfirmRefundUpgradeLevel(node, PurchaseMode.AlternateCurrency, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanRefundUpgradeLevel(node)), false),
					CursorElement.Create("Cancel", "", backAction, (Func<CursorElement, bool>)null, true)
				}, 
				PurchaseMode.AlternateCurrency => (CursorElement[])(object)new CursorElement[3]
				{
					CursorElement.Create("Purchase with Player Credits", "", (Action)delegate
					{
						ConfirmPurchaseUpgradeAlternateCurrency(node, CurrencyManager.Instance.GetCurrencyAmountFromCredits(price), backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanBuyUpgradeWithPlayerCredits(node)), false),
					CursorElement.Create("Refund Upgrade Level", "", (Action)delegate
					{
						ConfirmRefundUpgradeLevel(node, node.PurchaseMode, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanRefundUpgradeLevel(node)), false),
					CursorElement.Create("Cancel", "", backAction, (Func<CursorElement, bool>)null, true)
				}, 
				_ => (CursorElement[])(object)new CursorElement[3]
				{
					CursorElement.Create("Purchase with Company Credits", "", (Action)delegate
					{
						ConfirmPurchaseUpgrade(node, price, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanBuyUpgradeWithGroupCredits(node)), false),
					CursorElement.Create("Refund Upgrade Level", "", (Action)delegate
					{
						ConfirmRefundUpgradeLevel(node, node.PurchaseMode, backAction);
					}, (Func<CursorElement, bool>)((CursorElement _) => CanRefundUpgradeLevel(node)), false),
					CursorElement.Create("Cancel", "", backAction, (Func<CursorElement, bool>)null, true)
				}, 
			})));
			CursorMenu<CursorElement> val = CursorMenu<CursorElement>.Create(array.Length - 1, '>', array, (Func<CursorElement, CursorElement, int>[])null);
			ITextElement[] array2 = (ITextElement[])(object)new ITextElement[3]
			{
				(ITextElement)TextElement.Create(text),
				(ITextElement)TextElement.Create(" "),
				(ITextElement)val
			};
			IScreen val2 = (IScreen)(object)BoxedScreen.Create(node.Name, array2);
			((BaseInteractiveApplication<CursorElement>)(object)this).SwitchScreen(val2, (BaseCursorMenu<CursorElement>)(object)val, false);
		}

		private void ConfirmRefundUpgradeLevel(CustomTerminalNode node, PurchaseMode refundMode, Action backAction)
		{
			if (!node.Refundable)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, backAction, "Current configuration does not allow refunding this upgrade.");
				return;
			}
			if (!node.Unlocked)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, backAction, "You can only refund upgrades you have purchased.");
				return;
			}
			((InteractiveTerminalApplication<CursorElement>)(object)this).Confirm(node.Name, "Do you wish to refund a level from this upgrade", (Action)delegate
			{
				RefundUpgrade(node, refundMode, backAction);
			}, backAction, "");
		}

		private void RefundUpgrade(CustomTerminalNode node, PurchaseMode refundMode, Action backAction)
		{
			int previousPrice = node.GetPreviousPrice();
			switch (refundMode)
			{
			case PurchaseMode.CompanyCredits:
				LguStore.Instance.SyncCreditsServerRpc(((TerminalApplication)this).terminal.groupCredits + Mathf.CeilToInt((float)previousPrice * Mathf.Clamp01(node.RefundPercentage)));
				break;
			case PurchaseMode.AlternateCurrency:
			{
				int credits = Mathf.CeilToInt((float)previousPrice * Mathf.Clamp01(node.RefundPercentage));
				int currencyAmountFromCredits = CurrencyManager.Instance.GetCurrencyAmountFromCredits(credits);
				CurrencyManager.Instance.AddCurrencyAmount(currencyAmountFromCredits, trackSpent: true);
				break;
			}
			}
			UpgradeApi.TriggerUpgradeDowngrade(node);
			backAction();
		}

		private bool CanRefundUpgradeLevel(CustomTerminalNode node)
		{
			return node.Refundable && node.Unlocked;
		}

		private void ConfirmPurchaseUpgrade(CustomTerminalNode node, int price, Action backAction)
		{
			int groupCredits = UpgradeBus.Instance.GetTerminal().groupCredits;
			if (groupCredits < price)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, backAction, "You do not have enough credits to purchase this upgrade.");
				return;
			}
			((InteractiveTerminalApplication<CursorElement>)(object)this).Confirm(node.Name, $"Do you wish to purchase this upgrade for {price} credits?", (Action)delegate
			{
				PurchaseUpgrade(node, price, backAction);
			}, backAction, "");
		}

		private void ConfirmPurchaseUpgradeAlternateCurrency(CustomTerminalNode node, int currencyPrice, Action backAction)
		{
			int currencyAmount = CurrencyManager.Instance.CurrencyAmount;
			if (currencyAmount < currencyPrice)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(node.Name, backAction, "You do not have enough credits to purchase this upgrade.");
				return;
			}
			((InteractiveTerminalApplication<CursorElement>)(object)this).Confirm(node.Name, $"Do you wish to purchase this upgrade for {currencyPrice} player credits?", (Action)delegate
			{
				PurchaseUpgradeAlternateCurrency(node, currencyPrice, backAction);
			}, backAction, "");
		}

		private void PurchaseUpgradeAlternateCurrency(CustomTerminalNode node, int currencyPrice, Action backAction)
		{
			CurrencyManager.Instance.RemoveCurrencyAmount(currencyPrice, trackSpent: true);
			if (!node.Unlocked)
			{
				LguStore.Instance.HandleUpgrade(node);
			}
			else if (node.Unlocked && node.MaxUpgrade > node.CurrentUpgrade)
			{
				LguStore.Instance.HandleUpgrade(node, increment: true);
			}
			backAction();
		}

		private void PurchaseUpgrade(CustomTerminalNode node, int price, Action backAction)
		{
			LguStore.Instance.SyncCreditsServerRpc(((TerminalApplication)this).terminal.groupCredits - price);
			LguStore.Instance.AddUpgradeSpentCreditsServerRpc(price);
			UpgradeApi.TriggerUpgradeRankup(node);
			backAction();
		}
	}
}
namespace MoreShipUpgrades.Patches.Weather
{
	[HarmonyPatch(typeof(StormyWeather))]
	internal static class StormyWeatherPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("LightningStrike")]
		private static void CheckIfLightningRodPresent(StormyWeather __instance, ref Vector3 strikePosition, bool useTargetedObject)
		{
			if (!((Object)(object)LightningRod.instance != (Object)null) || !LightningRod.instance.LightningIntercepted)
			{
				return;
			}
			switch (LightningRod.CurrentUpgradeMode)
			{
			case LightningRod.UpgradeMode.EffectiveRange:
			case LightningRod.UpgradeMode.AlwaysRerouteItem:
				if (!useTargetedObject)
				{
					return;
				}
				break;
			case LightningRod.UpgradeMode.AlwaysRerouteRandom:
				if (useTargetedObject)
				{
					return;
				}
				break;
			}
			LightningRod.RerouteLightningBolt(ref strikePosition, ref __instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void InterceptSelectedObject(StormyWeather __instance, GrabbableObject ___targetingMetalObject)
		{
			if (BaseUpgrade.GetActiveUpgrade("Lightning Rod") && ((NetworkBehaviour)LguStore.Instance).IsHost && ((NetworkBehaviour)LguStore.Instance).IsServer)
			{
				LightningRod.TryInterceptLightning(ref __instance, ref ___targetingMetalObject);
			}
		}
	}
}
namespace MoreShipUpgrades.Patches.TerminalComponents
{
	[HarmonyPatch(typeof(TerminalAccessibleObject))]
	internal static class TerminalAccessibleObjectPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("CallFunctionFromTerminal")]
		private static bool DestroyObject(ref TerminalAccessibleObject __instance, ref float ___codeAccessCooldownTimer, ref bool ___inCooldown)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!BaseUpgrade.GetActiveUpgrade("Malware Broadcaster"))
			{
				return true;
			}
			if (!MalwareBroadcaster.IsMapHazard(ref __instance))
			{
				return true;
			}
			if (UpgradeBus.Instance.PluginConfiguration.MalwareBroadcasterUpgradeConfiguration.DestroyTraps.Value)
			{
				MalwareBroadcaster.instance.ReqDestroyObjectServerRpc(new NetworkObjectReference(((Component)__instance).gameObject.GetComponentInParent<NetworkObject>()));
				return false;
			}
			if (!___inCooldown)
			{
				___codeAccessCooldownTimer = UpgradeBus.Instance.PluginConfiguration.MalwareBroadcasterUpgradeConfiguration.DisarmTime.Value;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	internal static class TerminalPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(Terminal __instance)
		{
			HelpTerminalNode.SetupLGUHelpCommand();
			DropPodPatcher.orderedItems = __instance.orderedItemsFromTerminal;
		}

		[HarmonyPostfix]
		[HarmonyPatch("ParsePlayerSentence")]
		private static void CustomParser(ref Terminal __instance, ref TerminalNode __result)
		{
			string fullText = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
			CommandParser.ParseLGUCommands(fullText, ref __instance, ref __result);
		}

		[HarmonyTranspiler]
		[HarmonyPatch("SetItemSales")]
		private static IEnumerable<CodeInstruction> SetItemSalesTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			MethodInfo method = typeof(BargainConnections).GetMethod("GetBargainConnectionsAdditionalItems");
			MethodInfo method2 = typeof(LethalDeals).GetMethod("GetLethalDealsGuaranteedItems");
			MethodInfo method3 = typeof(MarketInfluence).GetMethod("GetGuaranteedPercentageSale");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindInteger(ref index, ref codes, -10, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first negative value representing no sales");
			Tools.FindInteger(ref index, ref codes, 5, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first maximum amount of items to go on sale");
			Tools.FindInteger(ref index, ref codes, -2, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second negative value representing no sales");
			Tools.FindInteger(ref index, ref codes, 9, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second maximum amount of items to go on sale");
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find minimum sale percentage");
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			Tools.FindInteger(ref index, ref codes, 0, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find minimum sale percentage");
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("ParsePlayerSentence")]
		private static IEnumerable<CodeInstruction> ParsePlayerSenteceTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			MethodInfo method = typeof(FastEncryption).GetMethod("GetLimitOfCharactersTransmit");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 10, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 10 value which is used as character limit");
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_S, (object)12));
			return codes;
		}

		[HarmonyPostfix]
		[HarmonyPatch("LoadNewNode")]
		private static void LoadNewNodePostfix(Terminal __instance, TerminalNode node)
		{
			if (node.buyRerouteToMoon == -2 && node.buyVehicleIndex == -1)
			{
				string newValue = EfficientEngines.GetDiscountedMoonPrice(node.itemCost).ToString();
				__instance.screenText.text = __instance.currentText.Replace(node.itemCost.ToString(), newValue);
				__instance.currentText = __instance.screenText.text;
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("LoadNewNodeIfAffordable")]
		private static IEnumerable<CodeInstruction> LoadNewNodeIfAffordableTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(TerminalNode).GetField("itemCost");
			MethodInfo method = typeof(EfficientEngines).GetMethod("GetDiscountedMoonPrice");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the item cost applied to a specific item with index 7");
			Tools.FindField(ref index, ref codes, field, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the item cost used when buying vehicles");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the item cost applied to moon routing");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(CurrencyManager).GetMethod("GetNewCreditFormat");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindString(ref index, ref codes, "${0}", method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the string format for showing credits in the terminal");
			return codes;
		}
	}
}
namespace MoreShipUpgrades.Patches.RoundComponents
{
	[HarmonyPatch(typeof(RoundManager))]
	internal static class RoundManagerPatcher
	{
		[HarmonyPatch("SpawnScrapInLevel")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SpawnScrapInLevelTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(SelectableLevel).GetField("minScrap");
			FieldInfo field2 = typeof(SelectableLevel).GetField("maxScrap");
			FieldInfo field3 = typeof(RoundManager).GetField("scrapValueMultiplier");
			MethodInfo method = typeof(MidasTouch).GetMethod("IncreaseScrapValueInteger");
			MethodInfo method2 = typeof(MidasTouch).GetMethod("IncreaseScrapValue");
			MethodInfo method3 = typeof(ScavengerInstincts).GetMethod("IncreaseScrapAmount");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find level's minimum scrap amount");
			Tools.FindField(ref index, ref codes, field2, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find level's maximum scrap amount");
			Tools.FindField(ref index, ref codes, field3, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the round manager's scrap value multiplier");
			Tools.FindInteger(ref index, ref codes, 50, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum value of scrap value used when same item day happens");
			Tools.FindExplicitInteger(ref index, ref codes, 170, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the maximum value of scrap value used when same item day happens");
			Tools.FindField(ref index, ref codes, field3, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the round manager's scrap value multiplier");
			return codes;
		}

		public static void FinishGeneratingLevelPrefix()
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.Enabled) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectLanding))
			{
				Plugin.mls.LogDebug((object)"Adding speed in FinishGeneratingLevel callback");
				Animator shipAnimator = StartOfRound.Instance.shipAnimator;
				shipAnimator.speed *= LandingThrusters.GetLandingSpeedMultiplier();
			}
		}

		[HarmonyPatch("GenerateNewLevelClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GenerateNewLevelClientRpcTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			FieldInfo field = typeof(SelectableLevel).GetField("spawnEnemiesAndScrap");
			Tools.FindField(ref index, ref codes, field, null, skip: true);
			codes.Insert(index - 2, new CodeInstruction(OpCodes.Call, (object)typeof(RoundManagerPatcher).GetMethod("FinishGeneratingLevelPrefix")));
			return codes;
		}

		[HarmonyPatch("DespawnPropsAtEndOfRound")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DespawnPropsAtEndOfRoundTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			FieldInfo field = typeof(Item).GetField("isScrap");
			MethodInfo method = typeof(ScrapKeeper).GetMethod("CanKeepScrapBasedOnChance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: true, andInstruction: true);
			codes.Insert(index, new CodeInstruction(OpCodes.Ldelem_Ref, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc, (object)9));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			return codes;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatcher
	{
		private static readonly LguLogger logger = new LguLogger("StartOfRoundPatcher");

		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		private static void InitLguStore(StartOfRound __instance)
		{
			logger.LogDebug("Initiating components...");
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(UpgradeBus.Instance.modStorePrefab);
				val.GetComponent<NetworkObject>().Spawn(false);
				logger.LogDebug("LguStore component initiated...");
			}
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdatePostfix()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			LategameConfiguration pluginConfiguration = UpgradeBus.Instance.PluginConfiguration;
			if (SyncedEntry<bool>.op_Implicit(pluginConfiguration.INTERN_ENABLED) && SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) == Interns.TeleportRestriction.EnterShip)
			{
				PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
				if (Interns.instance.ContainsRecentlyInterned(localPlayerController) && (localPlayerController.isInHangarShipRoom || localPlayerController.isInElevator))
				{
					Interns.instance.RemoveRecentlyInternedServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)localPlayerController));
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("LoadShipGrabbableItems")]
		private static void LoadShipGrabbableItemsPrefix(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				ItemProgressionManager.AssignScrapToUpgrades();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("playersFiredGameOver")]
		private static void GameOverResetUpgradeManager(StartOfRound __instance)
		{
			if (!UpgradeBus.Instance.PluginConfiguration.KEEP_UPGRADES_AFTER_FIRED_CUTSCENE.Value)
			{
				logger.LogDebug("Configurations do not wish to keep upgrades, erasing...");
				if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
				{
					LguStore.Instance.PlayersFiredServerRpc();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("PowerSurgeShip")]
		private static bool PowerSurgeShip()
		{
			return !BaseUpgrade.GetActiveUpgrade("Lightning Rod");
		}

		[HarmonyTranspiler]
		[HarmonyPatch("ReviveDeadPlayers")]
		private static IEnumerable<CodeInstruction> ReviveDeadPlayers_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Stimpack).GetMethod("CheckForAdditionalHealth");
			List<CodeInstruction> codes = instructions.ToList();
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 100, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find maximum health on update health UI");
			Tools.FindInteger(ref index, ref codes, 100, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first maximum health on player's health attribute");
			Tools.FindInteger(ref index, ref codes, 100, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second maximum health on player's health attribute");
			Tools.FindInteger(ref index, ref codes, 100, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find third maximum health on player's health attribute");
			return codes.AsEnumerable();
		}

		[HarmonyPatch("ReviveDeadPlayers")]
		[HarmonyPostfix]
		private static void ReviveDeadPlayersPostfix(StartOfRound __instance)
		{
			ResetContract(ref __instance);
			QuantumDisruptor.TryResetQuantum(QuantumDisruptor.ResetModes.MoonLanding);
			RandomizeUpgradeManager.RandomizeUpgrades(RandomizeUpgradeManager.RandomizeUpgradeEvents.PerMoonLanding);
			Interns.instance.currentUsages = 0;
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERN_ENABLED))
			{
				Interns.instance.ResetRecentlyInterned();
			}
		}

		private static void ResetContract(ref StartOfRound __instance)
		{
			if (!(ContractManager.Instance.contractLevel != RoundManager.Instance.currentLevel.PlanetName) && ((NetworkBehaviour)__instance).IsHost)
			{
				ContractManager.Instance.SyncContractDetailsClientRpc();
			}
		}

		[HarmonyPatch("ResetShip")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ResetShip(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Sigurd).GetMethod("GetBuyingRate");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.3f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 0.3 value which is used as buying rate");
			return codes.AsEnumerable();
		}

		[HarmonyPatch("OnPlayerConnectedClientRpc")]
		[HarmonyPostfix]
		private static void ShareSaveShipDataPostfix(StartOfRound __instance)
		{
			if (!((NetworkBehaviour)__instance).IsHost && !((NetworkBehaviour)__instance).IsServer)
			{
				LguStore.Instance.ShareSaveServerRpc();
			}
		}

		[HarmonyPatch("ShipLeave")]
		[HarmonyPrefix]
		private static void ShipLeavePrefix(StartOfRound __instance)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.Enabled))
			{
				if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectLanding) && !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectDeparture))
				{
					Plugin.mls.LogDebug((object)"Removing speed in ShipLeave callback");
					Animator shipAnimator = __instance.shipAnimator;
					shipAnimator.speed /= LandingThrusters.GetLandingSpeedMultiplier();
				}
				else if (!SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectLanding) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectDeparture))
				{
					Plugin.mls.LogDebug((object)"Adding speed in ShipLeave callback");
					Animator shipAnimator2 = __instance.shipAnimator;
					shipAnimator2.speed *= LandingThrusters.GetLandingSpeedMultiplier();
				}
			}
		}

		[HarmonyPatch("EndOfGame")]
		[HarmonyPostfix]
		private static void EndOfGamePostfix(StartOfRound __instance)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.Enabled) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LandingThrustersConfiguration.AffectDeparture))
			{
				Plugin.mls.LogDebug((object)"Removing speed in EndOfGame callback");
				Animator shipAnimator = __instance.shipAnimator;
				shipAnimator.speed /= LandingThrusters.GetLandingSpeedMultiplier();
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpeningDoorsSequenceTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			MethodInfo method = typeof(LandingThrusters).GetMethod("GetInteractMutliplier");
			List<CodeInstruction> codes = instructions.ToList();
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 5f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 5f value used on WaitForSeconds");
			codes.Insert(index + 1, new CodeInstruction(OpCodes.Div, (object)null));
			Tools.FindFloat(ref index, ref codes, 10f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 10f value used on WaitForSeconds");
			codes.Insert(index + 1, new CodeInstruction(OpCodes.Div, (object)null));
			return codes;
		}

		[HarmonyPatch("ChangeLevel")]
		[HarmonyPostfix]
		private static void ChangeLevelPostfix()
		{
			QuantumDisruptor.TryResetQuantum(QuantumDisruptor.ResetModes.MoonRerouting);
			RandomizeUpgradeManager.RandomizeUpgrades(RandomizeUpgradeManager.RandomizeUpgradeEvents.PerMoonRouting);
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal static class TimeOfDayPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("SyncNewProfitQuotaClientRpc")]
		private static void SyncNewProfitQuotaClientRpcPostfix(TimeOfDay __instance)
		{
			GenerateNewSales(ref __instance);
			QuantumDisruptor.TryResetQuantum(QuantumDisruptor.ResetModes.NewQuota);
			RandomizeUpgradeManager.RandomizeUpgrades(RandomizeUpgradeManager.RandomizeUpgradeEvents.PerQuota);
		}

		private static void GenerateNewSales(ref TimeOfDay __instance)
		{
			if (UpgradeBus.Instance.PluginConfiguration.SHARED_UPGRADES.Value && (((NetworkBehaviour)__instance).IsHost || ((NetworkBehaviour)__instance).IsServer))
			{
				int seed = Random.Range(0, 999999);
				LguStore.Instance.GenerateSalesClientRpc(seed);
			}
			else
			{
				LguStore.Instance.GenerateSales();
			}
		}

		[HarmonyPatch("SetBuyingRateForDay")]
		[HarmonyPostfix]
		private static void SetBuyingRateForDayPatch()
		{
			if (UpgradeBus.Instance.PluginConfiguration.SigurdAccessConfiguration.Enabled.Value && BaseUpgrade.GetActiveUpgrade("Sigurd Access") && TimeOfDay.Instance.daysUntilDeadline != 0)
			{
				Random random = new Random(StartOfRound.Instance.randomMapSeed);
				if ((float)random.Next(0, 100) < Mathf.Clamp(UpgradeBus.Instance.PluginConfiguration.SigurdAccessConfiguration.Chance.Value, 0f, 100f))
				{
					StartOfRound instance = StartOfRound.Instance;
					instance.companyBuyingRate += UpgradeBus.Instance.PluginConfiguration.SigurdAccessConfiguration.Effect.Value / 100f;
				}
			}
		}

		[HarmonyPatch("SetNewProfitQuota")]
		[HarmonyPrefix]
		private static void SetNewProfitQuotaPrefix(TimeOfDay __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost)
			{
				if (CurrencyManager.Enabled)
				{
					CurrencyManager.Instance.AddCurrencyAmountFromQuotaClientRpc(__instance.quotaFulfilled);
				}
				ItemProgressionManager.CheckNewQuota(__instance.quotaFulfilled);
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal static class TimeOfDayTranspilerPatcher
	{
		[HarmonyPatch("SetBuyingRateForDay")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetBuyingRateForDayTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Sigurd).GetMethod("GetBuyingRate");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 1f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 1 value which is used as buying rate");
			Tools.FindFloat(ref index, ref codes, 0.3f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 0.3f value which is used as buying rate");
			return codes.AsEnumerable();
		}

		[HarmonyPatch("SyncNewProfitQuotaClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SyncNewProfitQuotaClientRpcTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Sigurd).GetMethod("GetBuyingRate");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.3f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 0.3 value which is used as buying rate");
			return codes.AsEnumerable();
		}

		[HarmonyPatch("MoveGlobalTime")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> MoveGlobalTimeTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(QuantumDisruptor).GetMethod("GetGlobalSpeedMultiplier");
			FieldInfo field = typeof(TimeOfDay).GetField("globalTimeSpeedMultiplier");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find occurence of global speed multiplier field");
			return codes;
		}
	}
}
namespace MoreShipUpgrades.Patches.PlayerController
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerControllerBPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void StartPostfix(PlayerControllerB __instance)
		{
			((Component)__instance).gameObject.AddComponent<PlayerManager>();
		}

		[HarmonyPatch("KillPlayerClientRpc")]
		[HarmonyPostfix]
		private static void KillPlayerClientRpcPostfix(int playerId)
		{
			LategameConfiguration pluginConfiguration = UpgradeBus.Instance.PluginConfiguration;
			if (SyncedEntry<bool>.op_Implicit(pluginConfiguration.INTERN_ENABLED) && SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) != 0)
			{
				PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerId];
				Interns.instance.RemoveRecentlyInterned(player);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("KillPlayer")]
		private static void DisableUpgradesOnDeath(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && !__instance.isPlayerDead && __instance.AllowPlayerDeath())
			{
				if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERN_ENABLED))
				{
					Interns.instance.RemoveRecentlyInterned(__instance);
				}
				LoseNightVisionOnDeath(ref __instance);
			}
		}

		private static void LoseNightVisionOnDeath(ref PlayerControllerB __instance)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.LoseOnDeath.Value && !((Object)(object)__instance != (Object)(object)UpgradeBus.Instance.GetLocalPlayer()) && BaseUpgrade.GetActiveUpgrade("Night Vision"))
			{
				Plugin.mls.LogDebug((object)("Player that died: " + __instance.playerUsername));
				Plugin.mls.LogDebug((object)("Local player we are deactivating to: " + UpgradeBus.Instance.GetLocalPlayer().playerUsername));
				UpgradeBus.Instance.UpgradeObjects["NV Headset Batteries"].GetComponent<NightVision>().DisableOnClient();
				if (UpgradeBus.Instance.PluginConfiguration.NightVisionUpgradeConfiguration.DropOnDeath.Value)
				{
					NightVision.Instance.SpawnNightVisionItemOnDeathServerRpc(((Component)__instance).transform.position);
				}
			}
		}

		[HarmonyPatch("DamagePlayer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DamagePlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			MethodInfo method = typeof(Stimpack).GetMethod("CheckForAdditionalHealth");
			MethodInfo method2 = typeof(SickBeats).GetMethod("CalculateDefense");
			List<CodeInstruction> list = instructions.ToList();
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (flag)
				{
					break;
				}
				if (list[i].opcode == OpCodes.Ldarg_1)
				{
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)method2));
				}
				else if (list[i].opcode == OpCodes.Ldc_I4_S && list[i].operand.ToString() == "100" && list[i + 1] != null && list[i + 1].opcode == OpCodes.Call && list[i + 1].operand.ToString() == "Int32 Clamp(Int32, Int32, Int32)" && list[i + 2] != null && list[i + 2].opcode == OpCodes.Stfld && list[i + 2].operand.ToString() == "System.Int32 health")
				{
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)method));
					flag = true;
				}
			}
			if (!flag)
			{
				Plugin.mls.LogError((object)"Could not find the maximum of Mathf.Clamp that changes the health value");
			}
			return list.AsEnumerable();
		}

		[HarmonyTranspiler]
		[HarmonyPatch("PlayerHitGroundEffects")]
		private static IEnumerable<CodeInstruction> PlayerHitGroundEffectsTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ReinforcedBoots).GetMethod("ReduceFallDamage");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 100, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find 100 fall damage");
			Tools.FindInteger(ref index, ref codes, 80, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find 80 fall damage");
			Tools.FindInteger(ref index, ref codes, 50, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find 50 fall damage");
			Tools.FindInteger(ref index, ref codes, 30, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find 30 fall damage");
			return codes.AsEnumerable();
		}

		[HarmonyPostfix]
		[HarmonyPatch("SwitchToItemSlot")]
		[HarmonyPatch("BeginGrabObject")]
		private static void SwitchToItemSlotPostfix(PlayerControllerB __instance)
		{
			DeepPocketsTwoHandedCheck(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("GrabObjectClientRpc")]
		private static void GrabObjectClientRpcPostfix(PlayerControllerB __instance)
		{
			DeepPocketsTwoHandedCheck(__instance);
		}

		private static void DeepPocketsTwoHandedCheck(PlayerControllerB player)
		{
			if (!player.twoHanded || !BaseUpgrade.GetActiveUpgrade("Deeper Pockets"))
			{
				return;
			}
			if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
			{
				EnemyAI component = ((Component)player.currentlyHeldObjectServer).GetComponent<EnemyAI>();
				if ((Object)(object)component != (Object)null && !component.isEnemyDead)
				{
					return;
				}
			}
			if (CustomItemBehaviourLibraryCompat.Enabled && !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DeeperPocketsConfiguration.AllowWheelbarrows) && CustomItemBehaviourLibraryCompat.CheckForContainers(ref player))
			{
				return;
			}
			int num = 0;
			int num2 = 1 + SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DeeperPocketsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Deeper Pockets") * SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DeeperPocketsConfiguration.IncrementalEffect);
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if (num >= num2)
				{
					break;
				}
				GrabbableObject val = player.ItemSlots[i];
				if (!((Object)(object)val == (Object)null) && val.itemProperties.twoHanded)
				{
					num++;
				}
			}
			if (num < num2)
			{
				player.twoHanded = false;
				((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("BeginGrabObject")]
		[HarmonyPatch("GrabObjectClientRpc")]
		[HarmonyPatch("DestroyItemInSlot")]
		[HarmonyPatch("DespawnHeldObjectOnClient")]
		[HarmonyPatch("SetObjectAsNoLongerHeld")]
		[HarmonyPatch("PlaceGrabbableObject")]
		private static IEnumerable<CodeInstruction> ItemWeightTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			AddBackMusclesCodeInstruction(ref index, ref codes);
			return codes;
		}

		internal static void AddBackMusclesCodeInstruction(ref int index, ref List<CodeInstruction> codes)
		{
			MethodInfo method = typeof(BackMuscles).GetMethod("DecreasePossibleWeight");
			Tools.FindSub(ref index, ref codes, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find item weight");
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void CheckForBoomboxes(PlayerControllerB __instance)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			if (!UpgradeBus.Instance.PluginConfiguration.SickBeatsUpgradeConfiguration.Enabled.Value || !BaseUpgrade.GetActiveUpgrade("Sick Beats") || (Object)(object)__instance != (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				return;
			}
			SickBeats.Instance.boomBoxes.RemoveAll((BoomboxItem b) => (Object)(object)b == (Object)null);
			SickBeats.Instance.vehicleControllers.RemoveAll((VehicleController c) => (Object)(object)c == (Object)null);
			bool flag = false;
			if (__instance.isPlayerDead)
			{
				if (SickBeats.Instance.EffectsActive)
				{
					SickBeats.Instance.EffectsActive = flag;
					SickBeats.HandlePlayerEffects(__instance);
				}
				return;
			}
			foreach (BoomboxItem boomBox in SickBeats.Instance.boomBoxes)
			{
				if (!boomBox.isPlayingMusic || Vector3.Distance(((Component)boomBox).transform.position, ((Component)__instance).transform.position) >= UpgradeBus.Instance.PluginConfiguration.SickBeatsUpgradeConfiguration.Radius.Value)
				{
					continue;
				}
				flag = true;
				break;
			}
			foreach (VehicleController vehicleController in SickBeats.Instance.vehicleControllers)
			{
				if (!vehicleController.radioOn || Vector3.Distance(((Component)vehicleController).transform.position, ((Component)__instance).transform.position) >= UpgradeBus.Instance.PluginConfiguration.SickBeatsUpgradeConfiguration.Radius.Value)
				{
					continue;
				}
				flag = true;
				break;
			}
			if (flag != SickBeats.Instance.EffectsActive)
			{
				SickBeats.Instance.EffectsActive = flag;
				SickBeats.HandlePlayerEffects(__instance);
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("LateUpdate")]
		private static IEnumerable<CodeInstruction> LateUpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			MethodInfo method = typeof(BiggerLungs).GetMethod("ApplyPossibleIncreasedStaminaRegen");
			MethodInfo method2 = typeof(SickBeats).GetMethod("ApplyPossibleIncreasedStaminaRegen");
			MethodInfo method3 = typeof(SickBeats).GetMethod("ApplyPossibleDecreasedStaminaDrain");
			MethodInfo method4 = typeof(BiggerLungs).GetMethod("GetAdditionalStaminaTime");
			MethodInfo method5 = typeof(BackMuscles).GetMethod("DecreaseStrain");
			MethodInfo method6 = typeof(MedicalNanobots).GetMethod("GetIncreasedHealthRegeneration");
			MethodInfo method7 = typeof(EffectiveBandaids).GetMethod("GetIncreasedHealthRegenerated");
			FieldInfo field = typeof(PlayerControllerB).GetField("sprintTime");
			FieldInfo field2 = typeof(PlayerControllerB).GetField("carryWeight");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the first occurence of sprintTime field");
			Tools.FindDiv(ref index, ref codes, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find first mul instruction to include our drain method from Sick Beats");
			Tools.FindField(ref index, ref codes, field2, method5, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the occurence of carryWeight field");
			Tools.FindField(ref index, ref codes, field, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the second occurence of sprintTime field");
			Tools.FindDiv(ref index, ref codes, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find second mul instruction to include our drain method from Sick Beats");
			Tools.FindField(ref index, ref codes, field, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the third occurence of sprintTime field");
			Tools.FindMul(ref index, ref codes, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find first mul instruction to include our regen method from Bigger Lungs");
			codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, (object)method2));
			Tools.FindField(ref index, ref codes, field, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the fourth occurence of sprintTime field");
			Tools.FindMul(ref index, ref codes, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find second mul instruction to include our regen method from Bigger Lungs");
			codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, (object)method2));
			Tools.FindInteger(ref index, ref codes, 20, method6, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the value used to represent the maximum health regenerable");
			Tools.FindInteger(ref index, ref codes, 1, method7, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the value used to increment the player's health");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Jump_performed")]
		private static IEnumerable<CodeInstruction> JumpPerformedTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(BiggerLungs).GetMethod("ApplyPossibleReducedJumpStaminaCost");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.08f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find jump stamina cost");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("PlayFootstepLocal")]
		private static IEnumerable<CodeInstruction> PlayFootstepLocalTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			return AddReduceNoiseRangeFunctionToPlayerFootsteps(instructions);
		}

		[HarmonyTranspiler]
		[HarmonyPatch("PlayFootstepServer")]
		private static IEnumerable<CodeInstruction> PlayFootstepServerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			return AddReduceNoiseRangeFunctionToPlayerFootsteps(instructions);
		}

		private static IEnumerable<CodeInstruction> AddReduceNoiseRangeFunctionToPlayerFootsteps(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(RunningShoes).GetMethod("ApplyPossibleReducedNoiseRange");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 22f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find footstep noise");
			Tools.FindFloat(ref index, ref codes, 17f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find footstep noise");
			return codes.AsEnumerable();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlayerJumpTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(StrongLegs).GetMethod("GetAdditionalJumpForce");
			FieldInfo field = typeof(PlayerControllerB).GetField("jumpForce");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first occurence of jump force field");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second occurence of jump force field");
			return codes;
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(BackMuscles).GetMethod("DecreaseCarryLoss");
			MethodInfo method2 = typeof(RunningShoes).GetMethod("GetAdditionalMovementSpeed");
			MethodInfo method3 = typeof(ClimbingGloves).GetMethod("GetAdditionalClimbingSpeed");
			MethodInfo method4 = typeof(StrongLegs).GetMethod("GetAdditionalJumpForce");
			MethodInfo method5 = typeof(TractionBoots).GetMethod("GetAdditionalTractionForce");
			MethodInfo method6 = typeof(HikingBoots).GetMethod("ReduceUphillSlopeDebuff");
			MethodInfo method7 = typeof(CarbonKneejoints).GetMethod("ReduceCrouchMovementSpeedDebuff");
			MethodInfo method8 = typeof(ReinforcedBoots).GetMethod("ReduceFallDamage");
			FieldInfo field = typeof(PlayerControllerB).GetField("carryWeight");
			FieldInfo field2 = typeof(PlayerControllerB).GetField("movementSpeed");
			FieldInfo field3 = typeof(PlayerControllerB).GetField("climbSpeed");
			FieldInfo field4 = typeof(PlayerControllerB).GetField("jumpForce");
			FieldInfo field5 = typeof(PlayerControllerB).GetField("slopeIntensity");
			FieldInfo field6 = typeof(PlayerControllerB).GetField("slopeModifier", BindingFlags.Instance | BindingFlags.NonPublic);
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field2, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first occurence of movement speed field");
			Tools.FindField(ref index, ref codes, field2, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second occurence of movement speed field");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first carryWeight occurence");
			Tools.FindFloat(ref index, ref codes, 1.5f, method7, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the movement speed loss value while crouching");
			Tools.FindField(ref index, ref codes, field5, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find skip slope Intensity");
			Tools.FindField(ref index, ref codes, field6, method6, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find occurence of slopeModifier");
			Tools.FindFloat(ref index, ref codes, 5f, method5, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the numerator used when sprinting");
			Tools.FindFloat(ref index, ref codes, 10f, method5, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the numerator used when walking");
			Tools.FindField(ref index, ref codes, field4, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find occurence of jump force field");
			Tools.FindInteger(ref index, ref codes, 85, method8, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first occurence of fall damage when using jetpack");
			Tools.FindInteger(ref index, ref codes, 30, method8, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second occurence of fall damage when using jetpack");
			Tools.FindInteger(ref index, ref codes, 30, method8, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find third occurence of fall damage when using jetpack");
			Tools.FindField(ref index, ref codes, field3, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find occurence of climb speed field");
			return codes;
		}

		[HarmonyPatch("BeginGrabObject")]
		[HarmonyPatch("SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetGrabDistanceTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(PlayerControllerB).GetField("grabDistance");
			MethodInfo method = typeof(MechanicalArms).GetMethod("GetIncreasedGrabDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the grab distance field");
			return codes;
		}

		[HarmonyPatch("SetFaceUnderwaterFilters")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetFaceUnderwaterFiltersTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(OxygenCanisters).GetMethod("ReduceOxygenConsumption");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindDiv(ref index, ref codes, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the value used to decrease the drowning timer");
			return codes;
		}

		[HarmonyPatch("ClickHoldInteraction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ClickHoldInteractionTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(InteractTrigger).GetField("timeToHoldSpeedMultiplier");
			MethodInfo method = typeof(QuickHands).GetMethod("IncreaseInteractionSpeed");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the interaction speed multiplier saved in the interact trigger");
			return codes;
		}

		[HarmonyPatch("DropAllHeldItems")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DropAllHeldItemsTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Expected O, but got Unknown
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			MethodInfo method = typeof(FusionMatter).GetMethod("CanHoldItem");
			MethodInfo method2 = typeof(PlayerControllerBExtensions).GetMethod("RemainItemSlotIfTeleporting");
			MethodInfo method3 = typeof(PlayerControllerBExtensions).GetMethod("RemainIsHoldingObjectIfTeleporting");
			MethodInfo method4 = typeof(PlayerControllerBExtensions).GetMethod("RemainActivatingItemIfTeleporting");
			MethodInfo method5 = typeof(PlayerControllerBExtensions).GetMethod("RemainTwoHandedIfTeleporting");
			MethodInfo method6 = typeof(PlayerControllerBExtensions).GetMethod("RemainCarryWeightIfTeleporting");
			MethodInfo method7 = typeof(PlayerControllerBExtensions).GetMethod("RemainCurrentlyHeldObjectServerIfTeleporting");
			FieldInfo field = typeof(PlayerControllerB).GetField("isHoldingObject");
			FieldInfo field2 = typeof(PlayerControllerB).GetField("playerBodyAnimator");
			FieldInfo field3 = typeof(PlayerControllerB).GetField("ItemOnlySlot");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindNull(ref index, ref codes, null, skip: true);
			Tools.FindNull(ref index, ref codes, null, skip: true);
			index++;
			codes.Insert(index, new CodeInstruction(OpCodes.And, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Not, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			Tools.FindArgumentField(ref index, ref codes, 2, null, skip: true);
			Tools.FindArgumentField(ref index, ref codes, 2, null, skip: true);
			codes.Insert(index, new CodeInstruction(OpCodes.Or, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			Tools.FindNull(ref index, ref codes, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: true);
			codes.RemoveAt(index - 1);
			index--;
			codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			Tools.FindNull(ref index, ref codes, null, skip: true);
			index++;
			codes.Insert(index, new CodeInstruction(OpCodes.And, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Not, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldfld, (object)field3));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			Tools.FindField(ref index, ref codes, field, method3, skip: false, notInstruction: true, andInstruction: true, orInstruction: false, requireInstance: true);
			Tools.FindField(ref index, ref codes, field2, null, skip: true);
			Tools.FindInteger(ref index, ref codes, 0, method4, skip: false, notInstruction: false, andInstruction: false, orInstruction: true, requireInstance: true);
			Tools.FindInteger(ref index, ref codes, 0, method5, skip: false, notInstruction: false, andInstruction: false, orInstruction: true, requireInstance: true);
			Tools.FindFloat(ref index, ref codes, 1f, method6, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: true, instanceBefore: true);
			Tools.FindNull(ref index, ref codes, method7, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: true, instanceBefore: true);
			return codes;
		}
	}
}
namespace MoreShipUpgrades.Patches.NetworkManager
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal static class GameNetworkManagerPatcher
	{
		private static LguLogger logger = new LguLogger("GameNetworkManagerPatcher");

		[HarmonyPostfix]
		[HarmonyPatch("Disconnect")]
		private static void ResetUpgradeBus()
		{
			logger.LogDebug("Resetting the Upgrade Bus due to disconnecting...");
			UpgradeBus.Instance.ResetAllValues();
			BaseUpgrade[] array = Object.FindObjectsOfType<BaseUpgrade>();
			BaseUpgrade[] array2 = array;
			foreach (BaseUpgrade baseUpgrade in array2)
			{
				Object.Destroy((Object)(object)((Component)baseUpgrade).gameObject);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SaveGame")]
		private static void SaveGamePostfix(GameNetworkManager __instance)
		{
			if (__instance.isHostingGame)
			{
				if (!StartOfRound.Instance.inShipPhase && PlayerManager.instance.GetUpgradeSpentCredits() > 0)
				{
					int num = ES3.Load<int>("GroupCredits", __instance.currentSaveFileName, 60);
					ES3.Save<int>("GroupCredits", num - PlayerManager.instance.GetUpgradeSpentCredits(), __instance.currentSaveFileName);
				}
				logger.LogDebug("Saving the LGU upgrades unto a json file...");
				LguStore.Instance.ServerSaveFile();
				PlayerManager.instance.ResetUpgradeSpentCredits();
			}
		}
	}
}
namespace MoreShipUpgrades.Patches.Items
{
	[HarmonyPatch(typeof(BeltBagItem))]
	internal static class BeltBagItemPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("ItemInteractLeftRight")]
		public static IEnumerable<CodeInstruction> BeltBagItemInteractTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(MechanicalArms).GetMethod("GetIncreasedGrabDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 4f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find belt bag item's debug pickup distance");
			Tools.FindFloat(ref index, ref codes, 4f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find belt bag item's pickup distance");
			return codes.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(BoomboxItem))]
	internal static class BoomBoxPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("StartMusic")]
		private static void StartMusicPrefix(BoomboxItem __instance)
		{
			if (UpgradeBus.Instance.PluginConfiguration.SickBeatsUpgradeConfiguration.Enabled.Value && !SickBeats.Instance.boomBoxes.Contains(__instance))
			{
				SickBeats.Instance.boomBoxes.Add(__instance);
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(SickBeats).GetMethod("MuteBoomboxToEnemies");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 16f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the sound range to attract nearby enemies");
			return codes;
		}
	}
	[HarmonyPatch(typeof(ItemDropship))]
	internal static class DropPodPatcher
	{
		internal static List<int> orderedItems;

		private const int MAXIMUM_ALLOWED_DELIVERED_ITEMS = 12;

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Expected O, but got Unknown
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Expected O, but got Unknown
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Expected O, but got Unknown
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Expected O, but got Unknown
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			MethodInfo method = typeof(FasterDropPod).GetMethod("GetUpgradedTimer");
			MethodInfo method2 = typeof(FasterDropPod).GetMethod("CanLeaveEarly");
			MethodInfo method3 = typeof(FasterDropPod).GetMethod("GetFirstOrderTimer");
			MethodInfo method4 = typeof(FasterDropPod).GetMethod("IsUpgradeActive");
			FieldInfo field = typeof(ItemDropship).GetField("playersManager", BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field2 = typeof(StartOfRound).GetField("shipHasLanded");
			FieldInfo field3 = typeof(ItemDropship).GetField("shipTimer");
			FieldInfo field4 = typeof(ItemDropship).GetField("shipDoorsOpened");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int i = 0;
			Tools.FindFloat(ref i, ref codes, 20f, method3, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 20 value which is used as first buy ship timer");
			Tools.FindFloat(ref i, ref codes, 40f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 40 value which is used as ship timer");
			bool flag = false;
			for (; i < codes.Count; i++)
			{
				if (codes[i].opcode == OpCodes.Ble_Un)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				codes[i].opcode = OpCodes.Brfalse;
				codes.Insert(i, new CodeInstruction(OpCodes.And, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Or, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Not, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Call, (object)method4));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldfld, (object)field2));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldfld, (object)field));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Cgt, (object)null));
			}
			flag = false;
			for (; i < codes.Count; i++)
			{
				if (codes[i].opcode == OpCodes.Ble_Un && codes[i - 1].opcode == OpCodes.Ldc_R4 && (float)codes[i - 1].operand == 30f)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				codes[i].opcode = OpCodes.Brfalse;
				codes.Insert(i, new CodeInstruction(OpCodes.Or, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.And, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.And, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldfld, (object)field4));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Call, (object)method4));
				codes.Insert(i, new CodeInstruction(OpCodes.Call, (object)method2));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldfld, (object)field3));
				codes.Insert(i, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(i, new CodeInstruction(OpCodes.Cgt, (object)null));
			}
			return codes.AsEnumerable();
		}

		[HarmonyPatch("ShipLandedAnimationEvent")]
		[HarmonyPrefix]
		private static void ShipLandedAnimationEventPrefix(ItemDropship __instance)
		{
			if (BaseUpgrade.GetActiveUpgrade("Drop Pod Thrusters"))
			{
				while (orderedItems.Count > 0 && __instance.itemsToDeliver.Count < 12)
				{
					__instance.itemsToDeliver.Add(orderedItems[0]);
					orderedItems.RemoveAt(0);
				}
			}
		}

		[HarmonyPatch("LandShipOnServer")]
		[HarmonyPostfix]
		private static void LandShipOnServerPostfix(ref List<int> ___itemsToDeliver)
		{
			ItemDuplicator.AttemptDuplication(ref ___itemsToDeliver);
		}
	}
	[HarmonyPatch(typeof(GrabbableObject))]
	internal static class GrabbableObjectPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("UseItemBatteries")]
		private static IEnumerable<CodeInstruction> UseItemBatteriesTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(LithiumBatteries).GetMethod("GetChargeRateMultiplier");
			FieldInfo field = typeof(Item).GetField("batteryUsage");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the field which is used to drain the item's battery on use");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(LithiumBatteries).GetMethod("GetChargeRateMultiplier");
			FieldInfo field = typeof(Item).GetField("batteryUsage");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the field which is used to drain the item's battery passively");
			Tools.FindDiv(ref index, ref codes, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the field which is used to drain the item's battery passively");
			return codes;
		}
	}
	[HarmonyPatch(typeof(JetpackItem))]
	internal static class JetpackItemPatcher
	{
		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(JetpackItem).GetField("jetpackAcceleration");
			MethodInfo method = typeof(JetFuel).GetMethod("IncreaseJetpackAcceleration");
			MethodInfo method2 = typeof(JetpackThrusters).GetMethod("IncreaseJetpackMaximumPower");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the jetpack acceleration field used to increase speed while in flight");
			Tools.FindFloat(ref index, ref codes, 500f, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the maximum power allowed when flying.");
			return codes;
		}
	}
	[HarmonyPatch(typeof(KnifeItem))]
	internal static class KnifePatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("HitKnife")]
		public static IEnumerable<CodeInstruction> HitKnifeTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ProteinPowder).GetMethod("GetShovelHitForce");
			MethodInfo method2 = typeof(SickBeats).GetMethod("GetShovelHitForce");
			FieldInfo field = typeof(KnifeItem).GetField("knifeHitForce");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find shovel hit force field");
			Tools.FindMethod(ref index, ref codes, method, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find our Protein Powder shovel hit force method");
			return codes.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(LungProp))]
	internal static class LungPropPatcher
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(LungProp __instance)
		{
			if (!SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.AffectApparatus))
			{
				Plugin.mls.LogDebug((object)"Midas Touch affecting apparatus is disabled, skipping...");
				return;
			}
			int scrapValue = ((GrabbableObject)__instance).scrapValue;
			Plugin.mls.LogDebug((object)$"Midas Touch affecting apparatus is enabled, increasing the original scrap value of apparatus ({scrapValue})...");
			scrapValue = MidasTouch.IncreaseScrapValueInteger(scrapValue);
			((GrabbableObject)__instance).SetScrapValue(scrapValue);
			Plugin.mls.LogDebug((object)$"Set new scrap value of apparatus to {scrapValue}...");
		}
	}
	[HarmonyPatch(typeof(PatcherTool))]
	internal static class PatchToolPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("BeginShockingAnomalyOnClient")]
		private static IEnumerable<CodeInstruction> BeginShockingAnomalyOnClientTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			return PatchDifficulty(new List<CodeInstruction>(instructions));
		}

		[HarmonyTranspiler]
		[HarmonyPatch("StopShockingAnomalyOnClient")]
		private static IEnumerable<CodeInstruction> StopShockingAnomalyOnClientTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(AluminiumCoils).GetMethod("ApplyCooldownDecrease");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindFloat(ref index, ref codes, 5f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the method call where it retrieves the enemy's difficulty multiplier");
			return codes;
		}

		private static IEnumerable<CodeInstruction> PatchDifficulty(List<CodeInstruction> codes)
		{
			MethodInfo method = typeof(IShockableWithGun).GetMethod("GetDifficultyMultiplier");
			MethodInfo method2 = typeof(AluminiumCoils).GetMethod("ApplyDifficultyDecrease");
			int index = 0;
			Tools.FindMethod(ref index, ref codes, method, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the method call where it retrieves the enemy's difficulty multiplier");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> ScanGunTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(AluminiumCoils).GetMethod("ApplyIncreasedStunRange");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindFloat(ref index, ref codes, 5f, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't skip first occurence of 5f value");
			Tools.FindFloat(ref index, ref codes, 5f, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't skip second occurence of 5f value");
			Tools.FindFloat(ref index, ref codes, 5f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the range used for maximum distance of SphereNonAlloc");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("GunMeetsConditionsToShock")]
		private static IEnumerable<CodeInstruction> GunMeetsConditionsToShockTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(AluminiumCoils).GetMethod("ApplyIncreasedStunRange");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindFloat(ref index, ref codes, 13f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the value used for maximum distance");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("SetCurrentDifficultyValue")]
		private static IEnumerable<CodeInstruction> SetCurrentDifficultyValueTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			return PatchDifficulty(new List<CodeInstruction>(instructions));
		}

		[HarmonyTranspiler]
		[HarmonyPatch("InitialDifficultyValues")]
		private static IEnumerable<CodeInstruction> InitialDifficultyValuesTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(AluminiumCoils).GetMethod("ApplyDifficultyDecrease");
			FieldInfo field = typeof(PatcherTool).GetField("endStrengthCap");
			FieldInfo field2 = typeof(PatcherTool).GetField("endChangeSpeedMultiplier");
			FieldInfo field3 = typeof(PatcherTool).GetField("endPullStrength");
			FieldInfo field4 = typeof(PatcherTool).GetField("endChangePerFrame");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the maximum current end strength cap");
			Tools.FindFloat(ref index, ref codes, 1.4f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum current end strength cap");
			Tools.FindField(ref index, ref codes, field2, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the maximum current end change speed multiplier");
			Tools.FindFloat(ref index, ref codes, 7f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum current end change speed multiplier");
			Tools.FindField(ref index, ref codes, field3, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the maximum current end pull strength multiplier");
			Tools.FindFloat(ref index, ref codes, 0.4f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum current end pull strength multiplier");
			Tools.FindField(ref index, ref codes, field4, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the maximum current end change per frame multiplier");
			Tools.FindFloat(ref index, ref codes, 0.12f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum current end change per frame multiplier");
			return codes;
		}
	}
	[HarmonyPatch(typeof(RadarBoosterItem))]
	internal static class RadarBoosterPatcher
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostifx(RadarBoosterItem __instance)
		{
			if (UpgradeBus.Instance.PluginConfiguration.ChargingBoosterConfiguration.Enabled.Value && BaseUpgrade.GetActiveUpgrade("Charging Booster"))
			{
				((Component)__instance).gameObject.AddComponent<ChargingStationManager>();
			}
		}
	}
	[HarmonyPatch(typeof(ShotgunItem))]
	internal static class ShotgunPatcher
	{
		[HarmonyPatch("ReloadGunEffectsClientRpc")]
		[HarmonyPrefix]
		private static void ReloadGunEffectsClientRpcPrefix(ShotgunItem __instance, bool start)
		{
			if (BaseUpgrade.GetActiveUpgrade("Sleight of Hand"))
			{
				if (start)
				{
					Animator gunAnimator = __instance.gunAnimator;
					gunAnimator.speed *= 1f + SleightOfHand.ComputeSleightOfHandSpeedBoost();
				}
				else
				{
					Animator gunAnimator2 = __instance.gunAnimator;
					gunAnimator2.speed /= 1f + SleightOfHand.ComputeSleightOfHandSpeedBoost();
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> reloadGunAnimationTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(SleightOfHand).GetMethod("GetSleightOfHandSpeedBoost");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.3f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the first value for WaitForSeconds");
			Tools.FindFloat(ref index, ref codes, 0.95f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the second value for WaitForSeconds");
			Tools.FindFloat(ref index, ref codes, 0.95f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the third value for WaitForSeconds");
			Tools.FindFloat(ref index, ref codes, 0.45f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the third value for WaitForSeconds");
			return codes;
		}

		[HarmonyPatch("ShootGun")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShootGunTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(HollowPoint).GetMethod("GetHollowPointDamageBoost");
			MethodInfo method2 = typeof(LongBarrel).GetMethod("GetLongBarrelRangeBoost");
			FieldInfo field = typeof(ShotgunItem).GetField("enemyColliders", BindingFlags.Instance | BindingFlags.NonPublic);
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, null, skip: true);
			Tools.FindFloat(ref index, ref codes, 15f, method2);
			Tools.FindFloat(ref index, ref codes, 3.7f, method2);
			Tools.FindInteger(ref index, ref codes, 5, method);
			Tools.FindFloat(ref index, ref codes, 6f, method2);
			Tools.FindInteger(ref index, ref codes, 3, method);
			Tools.FindInteger(ref index, ref codes, 2, method);
			return codes;
		}
	}
	[HarmonyPatch(typeof(Shovel))]
	internal static class ShovelPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("HitShovel")]
		public static IEnumerable<CodeInstruction> HitShovelTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ProteinPowder).GetMethod("GetShovelHitForce");
			MethodInfo method2 = typeof(SickBeats).GetMethod("GetShovelHitForce");
			FieldInfo field = typeof(Shovel).GetField("shovelHitForce");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find shovel hit force field");
			Tools.FindMethod(ref index, ref codes, method, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find our Protein Powder shovel hit force method");
			return codes.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(SprayPaintItem))]
	internal static class SprayPaintItemPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("LateUpdate")]
		private static IEnumerable<CodeInstruction> LateUpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(WeedGeneticManipulation).GetMethod("GetWeedKillerEffectiveness");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 2.2f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the usage of killWeedSpeed attribute");
			Tools.FindFloat(ref index, ref codes, 1.7f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the usage of killWeedSpeed attribute");
			return codes;
		}
	}
	[HarmonyPatch(typeof(VehicleController))]
	internal static class VehicleControllerPatcher
	{
		[HarmonyPatch("SetRadioOnLocalClient")]
		[HarmonyPrefix]
		private static void SetRadioOnLocalClientPrefix(VehicleController __instance)
		{
			if (UpgradeBus.Instance.PluginConfiguration.SickBeatsUpgradeConfiguration.Enabled.Value && !SickBeats.Instance.vehicleControllers.Contains(__instance))
			{
				SickBeats.Instance.vehicleControllers.Add(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(WalkieTalkie))]
	internal static class WalkiePatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("DiscardItem")]
		private static void DisableHUD(WalkieTalkie __instance)
		{
			if (BaseUpgrade.GetActiveUpgrade("Walkie GPS") && ((NetworkBehaviour)((GrabbableObject)__instance).playerHeldBy).IsOwner)
			{
				PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
				if (!playerHeldBy.ContainsItemOfType<WalkieTalkie>(__instance))
				{
					WalkieGPS.instance.WalkieDeactivate();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("EquipItem")]
		private static void EnableHUD(WalkieTalkie __instance)
		{
			if (BaseUpgrade.GetActiveUpgrade("Walkie GPS") && ((NetworkBehaviour)((GrabbableObject)__instance).playerHeldBy).IsOwner)
			{
				WalkieGPS.instance.WalkieActive();
			}
		}
	}
}
namespace MoreShipUpgrades.Patches.Interactables
{
	[HarmonyPatch(typeof(DepositItemsDesk))]
	internal static class DepositItemsDeskPatcher
	{
		[HarmonyPatch("SellItemsOnServer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SellItemsOnServerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			FieldInfo field = typeof(GrabbableObject).GetField("scrapValue");
			FieldInfo field2 = typeof(DepositItemsDesk).GetField("itemsOnCounter");
			MethodInfo method = typeof(ItemProgressionManager).GetMethod("CheckCollectionScrap");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindField(ref index, ref codes, field, null, skip: true);
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Callvirt, codes[index - 2].operand));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_2, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldfld, (object)field2));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			Tools.FindField(ref index, ref codes, field, null, skip: true);
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Callvirt, codes[index - 2].operand));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_2, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldfld, (object)field2));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			return codes;
		}
	}
	[HarmonyPatch(typeof(DoorLock))]
	internal static class DoorLockPatcher
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix(DoorLock __instance)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.LocksmithConfiguration.Enabled) && BaseUpgrade.GetActiveUpgrade("Locksmith"))
			{
				if (__instance.isLocked && !__instance.isPickingLock)
				{
					__instance.doorTrigger.hoverTip = "Lockpick: [LMB]";
					__instance.doorTrigger.interactable = true;
				}
				else
				{
					__instance.doorTrigger.hoverTip = "Use door : [LMB]";
				}
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			MethodInfo method = typeof(SmarterLockpick).GetMethod("IncreaseLockpickEfficiency");
			MethodInfo getMethod = typeof(Time).GetProperty("deltaTime").GetGetMethod();
			Tools.FindMethod(ref index, ref codes, getMethod, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "DeltaTime not found in DoorLock script");
			Tools.FindMethod(ref index, ref codes, getMethod, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "DeltaTime not found in DoorLock script");
			return codes;
		}

		[HarmonyPatch("OnHoldInteract")]
		[HarmonyPrefix]
		private static bool OnHoldInteractPrefix(DoorLock __instance)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Locksmith"))
			{
				return true;
			}
			if (!__instance.isLocked)
			{
				return true;
			}
			if (((Component)((Component)LockSmith.instance).gameObject.transform.GetChild(0)).gameObject.activeInHierarchy)
			{
				return true;
			}
			LockSmith.instance.BeginLockPick(__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	internal static class EntranceTeleportPatcher
	{
		[HarmonyPatch("TeleportPlayerClientRpc")]
		[HarmonyPostfix]
		private static void TeleportPlayerClientRpcPostfix(int playerObj)
		{
			LategameConfiguration pluginConfiguration = UpgradeBus.Instance.PluginConfiguration;
			if (SyncedEntry<bool>.op_Implicit(pluginConfiguration.INTERN_ENABLED) && SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) == Interns.TeleportRestriction.ExitBuilding)
			{
				PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerObj];
				Interns.instance.RemoveRecentlyInterned(player);
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix(EntranceTeleport __instance)
		{
			BetterScanner.AddScannerNodeToEntrance(ref __instance);
		}
	}
	[HarmonyPatch(typeof(HangarShipDoor))]
	internal static class HangarShipDoorPatcher
	{
		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ShutterBatteries).GetMethod("GetAdditionalDoorTime");
			FieldInfo field = typeof(HangarShipDoor).GetField("doorPowerDuration");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find first occurence of door battery duration field");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find second occurence of door battery duration field");
			return codes;
		}
	}
	[HarmonyPatch(typeof(InteractTrigger))]
	internal static class InteractTriggerPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		private static bool OnTriggerEnterPrefix(InteractTrigger __instance, Collider other)
		{
			if (!BaseUpgrade.GetActiveUpgrade("Locksmith"))
			{
				return true;
			}
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (!((NetworkBehaviour)component).IsOwner)
			{
				return true;
			}
			DoorLock component2 = ((Component)__instance).gameObject.GetComponent<DoorLock>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			if (!component2.isLocked)
			{
				return true;
			}
			if (((Component)((Component)LockSmith.instance).gameObject.transform.GetChild(0)).gameObject.activeInHierarchy)
			{
				return true;
			}
			LockSmith.instance.BeginLockPick(component2);
			return false;
		}
	}
	[HarmonyPatch(typeof(QuicksandTrigger))]
	internal static class QuicksandTriggerPatcher
	{
		[HarmonyPatch("StopSinkingLocalPlayer")]
		[HarmonyPatch("OnTriggerStay")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OnTriggerStayTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(QuicksandTrigger).GetField("movementHinderance");
			MethodInfo method = typeof(RubberBoots).GetMethod("ReduceMovementHinderance");
			MethodInfo method2 = typeof(RubberBoots).GetMethod("ClearMovementHinderance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the movement hinderance debuff when walking on water surface");
			Tools.FindIntegerReverse(ref index, ref codes, 1, method2, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "Couldn't find the int used to tell the player that their movement is hindered");
			return codes;
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	internal static class ShipTeleporterPatcher
	{
		[HarmonyPatch("PressButtonEffects")]
		[HarmonyPostfix]
		private static void PressButtonEffectsPostfix(ShipTeleporter __instance)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ParticleInfuserConfiguration.Enabled))
			{
				Animator teleporterAnimator = __instance.teleporterAnimator;
				teleporterAnimator.speed *= ParticleInfuser.IncreaseTeleportSpeed();
				AudioSource shipTeleporterAudio = __instance.shipTeleporterAudio;
				shipTeleporterAudio.pitch *= ParticleInfuser.IncreaseTeleportSpeed();
				((MonoBehaviour)ParticleInfuser.instance).StartCoroutine(ParticleInfuser.instance.ResetTeleporterSpeed(__instance));
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static bool beamUpPlayerPrefix()
		{
			LategameConfiguration pluginConfiguration = UpgradeBus.Instance.PluginConfiguration;
			if (!SyncedEntry<bool>.op_Implicit(pluginConfiguration.INTERN_ENABLED) || SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) == Interns.TeleportRestriction.None)
			{
				return true;
			}
			PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
			return !Interns.instance.ContainsRecentlyInterned(targetedPlayer);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> beamOutPlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ParticleInfuser).GetMethod("DecreaseTeleportTime");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 1f, method);
			return codes;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> beamUpPlayerTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ParticleInfuser).GetMethod("DecreaseTeleportTime");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 3f, method);
			Tools.FindFloat(ref index, ref codes, 3f, method);
			return codes;
		}

		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TeleportPlayerOutWithInverseTeleporterTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ShipTeleporter).GetMethod("SetPlayerTeleporterId", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method2 = typeof(PlayerControllerB).GetMethod("DropAllHeldItems");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindLocalField(ref index, ref codes, 0, null, skip: true, store: true);
			List<CodeInstruction> list = new List<CodeInstruction>();
			while (index < codes.Count)
			{
				list.Add(codes[index]);
				codes.RemoveAt(index);
				if (list[list.Count - 1].opcode == OpCodes.Call && (MethodInfo)list[list.Count - 1].operand == method)
				{
					break;
				}
			}
			Tools.FindMethod(ref index, ref codes, method2, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, "DropAllHeldItems method went missing.");
			if (index >= codes.Count)
			{
				return instructions;
			}
			codes.InsertRange(index + 1, list);
			return codes;
		}

		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyPrefix]
		private static void TeleportPlayerOutWithInverseTeleporterPrefix(ShipTeleporter __instance, int playerObj)
		{
			if (!StartOfRound.Instance.allPlayerScripts[playerObj].isPlayerDead)
			{
				__instance.SetPlayerTeleporterId(StartOfRound.Instance.allPlayerScripts[playerObj], 2);
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix(ShipTeleporter __instance)
		{
			LategameConfiguration pluginConfiguration = UpgradeBus.Instance.PluginConfiguration;
			if (SyncedEntry<bool>.op_Implicit(pluginConfiguration.INTERN_ENABLED) && SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) != 0 && __instance.buttonTrigger.interactable)
			{
				PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
				InteractTrigger buttonTrigger = __instance.buttonTrigger;
				buttonTrigger.interactable &= !Interns.instance.ContainsRecentlyInterned(targetedPlayer);
				if (!__instance.buttonTrigger.interactable)
				{
					__instance.buttonTrigger.disabledHoverTip = "[Recent intern must " + ((SyncedEntry<Interns.TeleportRestriction>.op_Implicit(pluginConfiguration.INTERNS_TELEPORT_RESTRICTION) == Interns.TeleportRestriction.ExitBuilding) ? "exit the building" : "enter the ship") + " first]";
				}
			}
		}
	}
	[HarmonyPatch(typeof(SteamValveHazard))]
	internal static class SteamValveHazardPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("BurstValve")]
		private static void BurstValvePostFix(ref SteamValveHazard __instance)
		{
			BetterScanner.AddScannerNodeToValve(ref __instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("FixValveLocalClient")]
		private static void FixValvePostFix(ref SteamValveHazard __instance)
		{
			BetterScanner.RemoveScannerNodeFromValve(ref __instance);
		}
	}
}
namespace MoreShipUpgrades.Patches.HUD
{
	[HarmonyPatch(typeof(HUDManager))]
	internal static class HudManagerPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("MeetsScanNodeRequirements")]
		private static IEnumerable<CodeInstruction> MeetsScanNodeRequirementsTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			MethodInfo method = typeof(BetterScanner).GetMethod("GetAdditionalMaximumScanNodeRange");
			MethodInfo method2 = typeof(BetterScanner).GetMethod("CanSeeScrapThroughWall");
			MethodInfo method3 = typeof(BetterScanner).GetMethod("CanSeeEnemiesThroughWall");
			FieldInfo field = typeof(ScanNodeProperties).GetField("maxRange");
			FieldInfo field2 = typeof(ScanNodeProperties).GetField("requiresLineOfSight");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find maximum range of scan node properties");
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			Tools.FindField(ref index, ref codes, field2, method2, skip: false, notInstruction: true, andInstruction: true, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find line of sight requirement of scan node properties");
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			Tools.FindFieldReverse(ref index, ref codes, field2, method3, skip: false, notInstruction: true, andInstruction: true, orInstruction: false, requireInstance: false, "Couldn't find line of sight requirement of scan node properties");
			codes.Insert(index + 2, new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			return codes;
		}

		[HarmonyPatch("UseSignalTranslatorServerRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UseSignalTranslatorServerRpcTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			MethodInfo method = typeof(FastEncryption).GetMethod("GetLimitOfCharactersTransmit");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 12, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 12 value which is used as character limit");
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			return codes;
		}

		[HarmonyPatch("UseSignalTranslatorClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UseSignalTranslatorClientRpcTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			MethodInfo method = typeof(FastEncryption).GetMethod("GetLimitOfCharactersTransmit");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 10, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 10 value which is used as character limit");
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			return codes;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisplaySignalTranslatorMessageTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(FastEncryption).GetMethod("GetMultiplierOnSignalTextTimer");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.5f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 0.5f value which is used in enumerator wait timer");
			Tools.FindFloat(ref index, ref codes, 0.7f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 0.5f value which is used in enumerator wait timer");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("ApplyPenalty")]
		private static IEnumerable<CodeInstruction> ApplyPenaltyTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(LifeInsurance).GetMethod("ReduceCreditCostPercentage");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindFloat(ref index, ref codes, 0.2f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the multiplier used to decrease the amount of Company Credits");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("FillEndGameStats")]
		private static IEnumerable<CodeInstruction> FillEndGameStatsTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(StartOfRound).GetField("allPlayersDead");
			MethodInfo method = typeof(ScrapKeeper).GetMethod("CheckIfKeptScrap");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: true, andInstruction: true);
			return codes;
		}
	}
}
namespace MoreShipUpgrades.Patches.Enemies
{
	[HarmonyPatch(typeof(ButlerBeesEnemyAI))]
	internal static class ButlerBeesPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("OnCollideWithPlayer")]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Beekeeper).GetMethod("CalculateBeeDamage");
			List<CodeInstruction> codes = instructions.ToList();
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 10, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the damage number applied to the player when colliding");
			return codes.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(ButlerEnemyAI))]
	internal static class ButlerEnemyAIPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("CheckLOS")]
		private static IEnumerable<CodeInstruction> CheckLOSTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo field = typeof(PlayerControllerB).GetField("isPlayerControlled");
			FieldInfo field2 = typeof(StartOfRound).GetField("allPlayerScripts");
			MethodInfo method = typeof(FedoraSuit).GetMethod("IsWearingFedoraSuitInt");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the 'isPlayerControlled' field used on Line of Sight check");
			object operand = codes[index - 5].operand;
			Tools.FindAdd(ref index, ref codes, null, skip: true);
			codes.Insert(index, new CodeInstruction(OpCodes.Add, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Call, (object)method));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldelem_Ref, (object)null));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			codes.Insert(index, new CodeInstruction(OpCodes.Ldfld, (object)field2));
			codes.Insert(index, new CodeInstruction(OpCodes.Call, operand));
			return codes;
		}
	}
	[HarmonyPatch(typeof(CaveDwellerAI))]
	internal static class CaveDwellerAIPatcher
	{
		[HarmonyPatch("IncreaseBabyGrowthMeter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> IncreaseBabyGrowthMeterTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			FieldInfo field = typeof(CaveDwellerAI).GetField("growthSpeedMultiplier");
			MethodInfo method = typeof(BabyPacifier).GetMethod("GetDecreasedGrowthRate");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find growth multiplier used to increase the age of maneater");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find growth multiplier used to increase the age of maneater");
			return codes;
		}
	}
	[HarmonyPatch(typeof(ClaySurgeonAI))]
	internal static class ClaySurgeonAIPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("SetVisibility")]
		private static IEnumerable<CodeInstruction> SetVisibilityTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ClayGlasses).GetMethod("GetAdditionalMaximumDistance");
			FieldInfo field = typeof(ClaySurgeonAI).GetField("maxDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the first occurence of maxDistance field");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the second occurence of maxDistance field");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("AnimationEventA")]
		private static IEnumerable<CodeInstruction> AnimationEventATranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(ClayGlasses).GetMethod("GetAdditionalMaximumDistance");
			FieldInfo field = typeof(ClaySurgeonAI).GetField("maxDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the occurence of maxDistance field");
			return codes;
		}
	}
	[HarmonyPatch(typeof(EnemyAICollisionDetect))]
	internal static class EnemyAICollisionDetectPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("IShockableWithGun.ShockWithGun")]
		private static IEnumerable<CodeInstruction> ShockWithGunTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(AluminiumCoils).GetMethod("ApplyIncreasedStunTimer");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindFloat(ref index, ref codes, 0.25f, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the minimum current end strength cap");
			return codes;
		}
	}
	[HarmonyPatch(typeof(EnemyAI))]
	internal static class EnemyAIPatcher
	{
		private static readonly LguLogger logger = new LguLogger("EnemyAIPatcher");

		private static ulong currentEnemy = 0uL;

		[HarmonyPostfix]
		[HarmonyPatch("KillEnemy")]
		private static void SpawnSample(EnemyAI __instance, bool destroy)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!((__instance is DoublewingAI || __instance is FlowerSnakeEnemy) && destroy) && (((NetworkBehaviour)__instance).IsServer || ((NetworkBehaviour)__instance).IsHost) && currentEnemy != ((NetworkBehaviour)__instance).NetworkObject.NetworkObjectId)
			{
				currentEnemy = ((NetworkBehaviour)__instance).NetworkObject.NetworkObjectId;
				string enemyName = __instance.enemyType.enemyName;
				if (BaseUpgrade.GetActiveUpgrade("Hunter") && Hunter.CanHarvest(enemyName))
				{
					logger.LogDebug("Spawning sample for " + enemyName);
					ItemManager.Instance.SpawnSample(enemyName.ToLower(), ((Component)__instance).transform.position);
				}
			}
		}

		[HarmonyPatch("HitEnemy")]
		[HarmonyPostfix]
		private static void HitEnemyPostifx(EnemyAI __instance, int hitID)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.SilverBulletsConfiguration.Enabled) && BaseUpgrade.GetActiveUpgrade("Silver Bullets") && hitID == -1 && __instance is DressGirlAI)
			{
				if (!__instance.enemyType.canBeDestroyed)
				{
					__instance.enemyType.canBeDestroyed = true;
				}
				__instance.KillEnemy(true);
			}
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	internal static class HoarderBugAIPatcher
	{
		[HarmonyPostfix]
		[HarmonyPatch("IsHoarderBugAngry")]
		private static void MakeHoarderBugSwarmAngry(ref bool __result)
		{
			if (!(ContractManager.Instance.contractType != "Exterminator") && ContractManager.Instance.contractLevel == RoundManager.Instance.currentLevel.PlanetName)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(RedLocustBees))]
	internal static class RedLocustBeesPatch
	{
		private static LguLogger logger = new LguLogger(typeof(RedLocustBeesPatch).Name);

		[HarmonyTranspiler]
		[HarmonyPatch("OnCollideWithPlayer")]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(Beekeeper).GetMethod("CalculateBeeDamage");
			List<CodeInstruction> codes = instructions.ToList();
			int index = 0;
			Tools.FindInteger(ref index, ref codes, 10, null, skip: true, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't skip the number used to check the player's health");
			Tools.FindInteger(ref index, ref codes, 10, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the damage number applied to the player when colliding");
			return codes.AsEnumerable();
		}

		[HarmonyTranspiler]
		[HarmonyPatch("SpawnHiveClientRpc")]
		public static IEnumerable<CodeInstruction> SpawnHiveClientRpcTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			MethodInfo method = typeof(Beekeeper).GetMethod("GetHiveScrapValue");
			List<CodeInstruction> list = instructions.ToList();
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (flag)
				{
					break;
				}
				if (!(list[i].opcode != OpCodes.Ldarg_2) && list[i + 1].opcode == OpCodes.Stfld && list[i + 1].operand.ToString() == "System.Int32 scrapValue")
				{
					list.Insert(i + 1, new CodeInstruction(OpCodes.Ldarg_2, (object)null));
					list.Insert(i + 1, new CodeInstruction(OpCodes.Starg, (object)2));
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)method));
					flag = true;
				}
			}
			if (!flag)
			{
				logger.LogError("Did not find the hive scrap value...");
			}
			return list.AsEnumerable();
		}
	}
}
namespace MoreShipUpgrades.Misc
{
	internal static class AssetBundleHandler
	{
		private static readonly LguLogger logger = new LguLogger("AssetBundleHandler");

		private static Dictionary<string, string> infoJSON;

		private const string root = "Assets/ShipUpgrades/";

		private const string upgrades = "Assets/ShipUpgrades/Upgrades/";

		private const string commands = "Assets/ShipUpgrades/Commands/";

		private const string items = "Assets/ShipUpgrades/Items/";

		private const string sampleItems = "Assets/ShipUpgrades/Items/Samples/";

		private const string storeItems = "Assets/ShipUpgrades/Items/Store/";

		private const string contractItems = "Assets/ShipUpgrades/Items/Contracts/";

		private const string extractionItems = "Assets/ShipUpgrades/Items/Contracts/Extraction/";

		private const string defusalItems = "Assets/ShipUpgrades/Items/Contracts/Defusal/";

		private const string dataItems = "Assets/ShipUpgrades/Items/Contracts/Data Retrieval/";

		private const string exorcismItems = "Assets/ShipUpgrades/Items/Contracts/Exorcism/";

		private const string ritualItems = "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/";

		private const string exterminatorItems = "Assets/ShipUpgrades/Items/Contracts/Exterminator/";

		private const string models = "Assets/ShipUpgrades/Models/";

		private const string prefabs = "Assets/ShipUpgrades/Models/Prefabs/";

		private const string SFX = "Assets/ShipUpgrades/Sound Effects/";

		private const string contractSFX = "Assets/ShipUpgrades/Sound Effects/Contracts/";

		private const string defusalSFX = "Assets/ShipUpgrades/Sound Effects/Contracts/Defusal/";

		private const string exorcismSFX = "Assets/ShipUpgrades/Sound Effects/Contracts/Exorcism/";

		private const string extractionSFX = "Assets/ShipUpgrades/Sound Effects/Contracts/Extraction/";

		private const string dataSFX = "Assets/ShipUpgrades/Sound Effects/Contracts/Data Retrieval/";

		private const string DiscombobulatorSFX = "Assets/ShipUpgrades/Sound Effects/Discombobulator/";

		private const string ShoppingCartSFX = "Assets/ShipUpgrades/Sound Effects/Shopping Cart/";

		private const string PortableTeleSFX = "Assets/ShipUpgrades/Sound Effects/Portable Teleporter/";

		internal static readonly Dictionary<string, string> samplePaths = new Dictionary<string, string>
		{
			{ "centipede", "Assets/ShipUpgrades/Items/Samples/SnareFleaSample.asset" },
			{ "bunker spider", "Assets/ShipUpgrades/Items/Samples/BunkerSpiderSample.asset" },
			{ "hoarding bug", "Assets/ShipUpgrades/Items/Samples/HoardingBugSample.asset" },
			{ "flowerman", "Assets/ShipUpgrades/Items/Samples/BrackenSample.asset" },
			{ "mouthdog", "Assets/ShipUpgrades/Items/Samples/EyelessDogSample.asset" },
			{ "baboon hawk", "Assets/ShipUpgrades/Items/Samples/BaboonHawkSample.asset" },
			{ "crawler", "Assets/ShipUpgrades/Items/Samples/ThumperSample.asset" },
			{ "forestgiant", "Assets/ShipUpgrades/Items/Samples/ForestKeeperSample.asset" },
			{ "manticoil", "Assets/ShipUpgrades/Items/Samples/ManticoilSample.asset" },
			{ "tulip snake", "Assets/ShipUpgrades/Items/Samples/TulipSnakeSample.asset" },
			{ "bush wolf", "Assets/ShipUpgrades/Items/Samples/KidnapperFoxSample.asset" },
			{ "puffer", "Assets/ShipUpgrades/Items/Samples/SporeLizardSample.asset" },
			{ "maneater", "Assets/ShipUpgrades/Items/Samples/ManeaterSample.asset" },
			{ "giantkiwi", "Assets/ShipUpgrades/Items/Samples/GiantSapsuckerSample.asset" }
		};

		private static readonly Dictionary<string, string> SFXPaths = new Dictionary<string, string>
		{
			{ "Scrap Wheelbarrow Sound 0", "Assets/ShipUpgrades/Sound Effects/Shopping Cart/Shopping_Cart_Move_1.ogg" },
			{ "Scrap Wheelbarrow Sound 1", "Assets/ShipUpgrades/Sound Effects/Shopping Cart/Shopping_Cart_Move_2.ogg" },
			{ "Scrap Wheelbarrow Sound 2", "Assets/ShipUpgrades/Sound Effects/Shopping Cart/Shopping_Cart_Move_3.ogg" },
			{ "Scrap Wheelbarrow Sound 3", "Assets/ShipUpgrades/Sound Effects/Shopping Cart/Shopping_Cart_Move_4.ogg" },
			{ "Break", "Assets/ShipUpgrades/Sound Effects/Portable Teleporter/break.mp3" },
			{ "Error", "Assets/ShipUpgrades/Sound Effects/Portable Teleporter/error.mp3" },
			{ "Button Press", "Assets/ShipUpgrades/Sound Effects/Portable Teleporter/ButtonPress2.ogg" },
			{ "Flashbang", "Assets/ShipUpgrades/Sound Effects/Discombobulator/flashbangsfx.ogg" },
			{ "Data Startup", "Assets/ShipUpgrades/Sound Effects/Contracts/startup.mp3" },
			{ "Bomb Cut", "Assets/ShipUpgrades/Sound Effects/Contracts/Defusal/scissors.mp3" },
			{ "Bomb Tick", "Assets/ShipUpgrades/Sound Effects/Contracts/Defusal/tick.mp3" },
			{ "Ritual Fail", "Assets/ShipUpgrades/Sound Effects/Contracts/Exorcism/ritualSFX.mp3" },
			{ "Ritual Success", "Assets/ShipUpgrades/Sound Effects/Contracts/Exorcism/portal.mp3" },
			{ "Ritual Idle", "Assets/ShipUpgrades/Sound Effects/Contracts/Exorcism/whisper.mp3" },
			{ "Laptop Error", "Assets/ShipUpgrades/Sound Effects/Contracts/Data Retrieval/winError.mp3" },
			{ "Laptop Start", "Assets/ShipUpgrades/Sound Effects/Contracts/Data Retrieval/startup.mp3" }
		};

		private static readonly Dictionary<string, string> assetPaths = new Dictionary<string, string>
		{
			{ "Beekeeper", "Assets/ShipUpgrades/Upgrades/beekeeper.prefab" },
			{ "Sick Beats", "Assets/ShipUpgrades/Upgrades/SickBeats.prefab" },
			{ "Protein Powder", "Assets/ShipUpgrades/Upgrades/ProteinPowder.prefab" },
			{ "Bigger Lungs", "Assets/ShipUpgrades/Upgrades/BiggerLungs.prefab" },
			{ "Running Shoes", "Assets/ShipUpgrades/Upgrades/runningShoes.prefab" },
			{ "Strong Legs", "Assets/ShipUpgrades/Upgrades/strongLegs.prefab" },
			{ "Malware Broadcaster", "Assets/ShipUpgrades/Upgrades/destructiveCodes.prefab" },
			{ "NV Headset Batteries", "Assets/ShipUpgrades/Upgrades/nightVision.prefab" },
			{ "Discombobulator", "Assets/ShipUpgrades/Upgrades/terminalFlash.prefab" },
			{ "Hunter", "Assets/ShipUpgrades/Upgrades/Hunter.prefab" },
			{ "Better Scanner", "Assets/ShipUpgrades/Upgrades/strongScanner.prefab" },
			{ "Lightning Rod", "Assets/ShipUpgrades/Upgrades/LightningRod.prefab" },
			{ "Walkie GPS", "Assets/ShipUpgrades/Upgrades/walkieUpgrade.prefab" },
			{ "Back Muscles", "Assets/ShipUpgrades/Upgrades/exoskeleton.prefab" },
			{ "Interns", "Assets/ShipUpgrades/Commands/Intern.prefab" },
			{ "Fast Encryption", "Assets/ShipUpgrades/Upgrades/Pager.prefab" },
			{ "Locksmith", "Assets/ShipUpgrades/Upgrades/LockSmith.prefab" },
			{ "Stimpack", "Assets/ShipUpgrades/Upgrades/PlayerHealth.prefab" },
			{ "Shutter Batteries", "Assets/ShipUpgrades/Upgrades/DoorsHydraulicsBattery.prefab" },
			{ "Market Influence", "Assets/ShipUpgrades/Upgrades/MarketInfluence.prefab" },
			{ "Bargain Connections", "Assets/ShipUpgrades/Upgrades/BargainConnections.prefab" },
			{ "Lethal Deals", "Assets/ShipUpgrades/Upgrades/LethalDeals.prefab" },
			{ "Quantum Disruptor", "Assets/ShipUpgrades/Upgrades/QuantumDisruptor.prefab" },
			{ "Charging Booster", "Assets/ShipUpgrades/Upgrades/ChargingBooster.prefab" },
			{ "Drop Pod Thrusters", "Assets/ShipUpgrades/Upgrades/FasterDropPod.prefab" },
			{ "Sigurd Access", "Assets/ShipUpgrades/Upgrades/Sigurd.prefab" },
			{ "Efficient Engines", "Assets/ShipUpgrades/Upgrades/EfficientEngines.prefab" },
			{ "Climbing Gloves", "Assets/ShipUpgrades/Upgrades/ClimbingGloves.prefab" },
			{ "Lithium Batteries", "Assets/ShipUpgrades/Upgrades/LithiumBatteries.prefab" },
			{ "Aluminium Coils", "Assets/ShipUpgrades/Upgrades/AluminiumCoils.prefab" },
			{ "Deeper Pockets", "Assets/ShipUpgrades/Upgrades/DeeperPockets.prefab" },
			{ "Reinforced Boots", "Assets/ShipUpgrades/Upgrades/ReinforcedBoots.prefab" },
			{ "Landing Thrusters", "Assets/ShipUpgrades/Upgrades/LandingThrusters.prefab" },
			{ "Scavenger Instincts", "Assets/ShipUpgrades/Upgrades/ScavengerInstincts.prefab" },
			{ "Mechanical Arms", "Assets/ShipUpgrades/Upgrades/MechanicalArms.prefab" },
			{ "Clay Glasses", "Assets/ShipUpgrades/Upgrades/ClayGlasses.prefab" },
			{ "Weed Genetic Manipulation", "Assets/ShipUpgrades/Upgrades/WeedGeneticManipulation.prefab" },
			{ "Fedora Suit", "Assets/ShipUpgrades/Upgrades/FedoraSuit.prefab" },
			{ "Traction Boots", "Assets/ShipUpgrades/Upgrades/TractionBoots.prefab" },
			{ "Hiking Boots", "Assets/ShipUpgrades/Upgrades/HikingBoots.prefab" },
			{ "Sleight of Hand", "Assets/ShipUpgrades/Upgrades/SleightOfHand.prefab" },
			{ "Advanced Portable Tele", "Assets/ShipUpgrades/Items/Store/TpButtonAdv.asset" },
			{ "Portable Tele", "Assets/ShipUpgrades/Items/Store/TpButton.asset" },
			{ "Medkit", "Assets/ShipUpgrades/Items/Store/MedKitItem.asset" },
			{ "HelmetItem", "Assets/ShipUpgrades/Items/Store/HelmetItem.asset" },
			{ "HelmetModel", "Assets/ShipUpgrades/Models/Prefabs/HelmetModel.prefab" },
			{ "MedkitMapItem", "Assets/ShipUpgrades/Items/Contracts/Extraction/MedKitMapItem.asset" },
			{ "Night Vision", "Assets/ShipUpgrades/Items/Store/NightVisionItem.asset" },
			{ "Scrap Wheelbarrow", "Assets/ShipUpgrades/Items/Wheelbarrow/ScrapWheelbarrowItem.asset" },
			{ "Bomb", "Assets/ShipUpgrades/Items/Contracts/Defusal/BombItem.asset" },
			{ "Demon Tome", "Assets/ShipUpgrades/Items/Contracts/Exorcism/ExorcLootItem.asset" },
			{ "Pentagram", "Assets/ShipUpgrades/Items/Contracts/Exorcism/PentagramItem.asset" },
			{ "RitualItem0", "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/Heart.asset" },
			{ "RitualItem1", "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/Crucifix.asset" },
			{ "RitualItem2", "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/candelabraItem.asset" },
			{ "RitualItem3", "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/Teddy Bear.asset" },
			{ "RitualItem4", "Assets/ShipUpgrades/Items/Contracts/Exorcism/Ritual Items/Bones.asset" },
			{ "HoardingBugEggsLoot", "Assets/ShipUpgrades/Items/Contracts/Exterminator/EggLootItem.asset" },
			{ "HoardingBugEggs", "Assets/ShipUpgrades/Items/Contracts/Exterminator/HoardingEggItem.asset" },
			{ "Scavenger", "Assets/ShipUpgrades/Items/Contracts/Extraction/ScavItem.asset" },
			{ "Scavenger Sounds", "Assets/ShipUpgrades/Sound Effects/Contracts/Extraction/scavSounds/scavAudio.json" },
			{ "Floppy Disk", "Assets/ShipUpgrades/Items/Contracts/Data Retrieval/DiscItem.asset" },
			{ "Laptop", "Assets/ShipUpgrades/Items/Contracts/Data Retrieval/DataPCItem.asset" }
		};

		public static GameObject TryLoadGameObjectAsset(ref AssetBundle bundle, string path)
		{
			GameObject val = bundle.LoadAsset<GameObject>(path);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("An error has occurred trying to load asset from " + path);
			}
			return val;
		}

		public static AudioClip TryLoadAudioClipAsset(ref AssetBundle bundle, string path)
		{
			AudioClip val = bundle.LoadAsset<AudioClip>(path);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("An error has occurred trying to load asset from " + path);
			}
			return val;
		}

		public static T TryLoadOtherAsset<T>(ref AssetBundle bundle, string path) where T : Object
		{
			T val = bundle.LoadAsset<T>(path);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("An error has occurred trying to load asset from " + path);
			}
			return val;
		}

		public static Item TryLoadItemAsset(ref AssetBundle bundle, string path)
		{
			Item val = bundle.LoadAsset<Item>(path);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError("An error has occurred trying to load asset from " + path);
			}
			return val;
		}

		public static Dictionary<string, string> GetInfoJSON(ref AssetBundle bundle)
		{
			if (infoJSON != null)
			{
				return infoJSON;
			}
			TextAsset val = bundle.LoadAsset<TextAsset>("Assets/ShipUpgrades/Upgrades/InfoStrings.json");
			if (!Object.op_Implicit((Object)(object)val))
			{
				logger.LogError("An error has occurred trying to load info strings from the bundle");
				return new Dictionary<string, string>();
			}
			infoJSON = JsonConvert.DeserializeObject<Dictionary<string, string>>(val.text);
			if (infoJSON == null)
			{
				logger.LogError("An error has occurred trying to deserialize info strings into a dictionary");
			}
			return infoJSON;
		}

		public static string GetInfoFromJSON(string key)
		{
			Dictionary<string, string> dictionary = GetInfoJSON(ref UpgradeBus.Instance.UpgradeAssets);
			if (dictionary == null)
			{
				return "";
			}
			if (!dictionary.ContainsKey(key))
			{
				logger.LogError("The key was not present in the info JSON file!");
				return "";
			}
			return dictionary[key];
		}

		public static GameObject GetPerkGameObject(string upgradeName)
		{
			if (!assetPaths.ContainsKey(upgradeName))
			{
				logger.LogError(upgradeName + " was not present in the asset dictionary!");
				return null;
			}
			return TryLoadGameObjectAsset(ref UpgradeBus.Instance.UpgradeAssets, assetPaths[upgradeName]);
		}

		public static Item GetItemObject(string itemName)
		{
			if (assetPaths.ContainsKey(itemName))
			{
				return TryLoadItemAsset(ref UpgradeBus.Instance.UpgradeAssets, assetPaths[itemName]);
			}
			if (samplePaths.ContainsKey(itemName))
			{
				return TryLoadItemAsset(ref UpgradeBus.Instance.UpgradeAssets, samplePaths[itemName]);
			}
			logger.LogError(itemName + " was not present in the asset or sample dictionary!");
			return null;
		}

		public static AudioClip GetAudioClip(string audioName)
		{
			if (!SFXPaths.ContainsKey(audioName))
			{
				logger.LogError(audioName + " was not present in the asset dictionary!");
				return null;
			}
			return TryLoadAudioClipAsset(ref UpgradeBus.Instance.UpgradeAssets, SFXPaths[audioName]);
		}

		public static T GetGenericAsset<T>(string assetName) where T : Object
		{
			if (!assetPaths.ContainsKey(assetName))
			{
				logger.LogError(assetName + " was not present in the asset dictionary!");
				return default(T);
			}
			return TryLoadOtherAsset<T>(ref UpgradeBus.Instance.UpgradeAssets, assetPaths[assetName]);
		}
	}
	internal static class CommandParser
	{
		[CompilerGenerated]
		private sealed class <CountDownChat>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float count;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					((TMP_Text)HUDManager.Instance.chatText).text = "";
					TextMeshProUGUI chatText2 = HUDManager.Instance.chatText;
					((TMP_Text)chatText2).text = ((TMP_Text)chatText2).text + $"<color=#FFFFFF>Stun Duration: {count:F1} seconds.</color>";
					break;
				}
				case 1:
				{
					<>1__state = -1;
					count--;
					((TMP_Text)HUDManager.Instance.chatText).text = "";
					TextMeshProUGUI chatText = HUDManager.Instance.chatText;
					((TMP_Text)chatText).text = ((TMP_Text)chatText).text + $"<color=#FFFFFF>Stun Duration: {count:F1} seconds.</color>";
					break;
				}
				}
				if (count > 0f)
				{
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				((TMP_Text)HUDManager.Instance.chatText).text = "";
				TextMeshProUGUI chatText3 = HUDManager.Instance.chatText;
				((TMP_Text)chatText3).text = ((TMP_Text)chatText3).text + "\n<color=#FF0000>Effected enemies are no longer stunned!</color>";
				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();
			}
		}

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

			private object <>2__current;

			public ulong id;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					HUDManager.Instance.DisplayTip("LOADING SAVE DATA", $"Overwiting local save data with the save under player id: {id}", false, false, "LC_Tip1");
					LguStore.Instance.SaveInfo = LguStore.Instance.LguSave.playerSaves[id];
					LguStore.Instance.UpdateUpgradeBus(UseLocalSteamID: false);
					return false;
				}
			}

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

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

		private static readonly LguLogger logger = new LguLogger("CommandParser");

		private const string LOAD_LGU_COMMAND = "load lgu";

		public static readonly List<string> contracts = new List<string>(5) { "Data", "Exterminator", "Extraction", "Exorcism", "Defusal" };

		public static readonly List<string> contractInfos = new List<string>(5) { "\n\nOur systems have detected an active PC somewhere in the facility.\nFind it, use the bruteforce command on the ship terminal with the devices IP to get login credentials, then use the cd, ls, and mv commands to find the .db file (enter `mv survey.db` in the containing folder).\n\n", "\n\nIt's been reported that the population of hoarder bugs on this moon have skyrocketed and become aggressive. You must destroy their nest at all costs.\n\n", "\n\nCrew number 5339 have reported that one of their operatives was lost on this moon and left behind. You will have to find or bring a medkit to heal and extract the lost operative.\n\n", "\n\nUnusual activity in the spirit world has been reported at this facility.\nFind the ritual site to determine what type of demon it is, enter `demon DemonName` in the terminal to get the ritual instructions. Find ritual items and banish the demon.\n\n", "\n\nAn unknown party has planted a bomb at an integral point in this facility.\nYou must find the bomb and work together to defuse it.\nUse the `Lookup` command with the bombs serial number to get defusal instructions.\n\n" };

		private static TerminalNode DisplayTerminalMessage(string message, bool clearPreviousText = true)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.displayText = message;
			val.clearPreviousText = clearPreviousText;
			return val;
		}

		private static TerminalNode ExecuteDiscombobulatorAttack(ref Terminal terminal)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (!BaseUpgrade.GetActiveUpgrade("Discombobulator"))
			{
				return DisplayTerminalMessage("You don't have access to this command yet. Purchase the 'Discombobulator'.\n\n");
			}
			if (Discombobulator.instance.flashCooldown > 0f)
			{
				return DisplayTerminalMessage($"You can discombobulate again in {Mathf.Round(Discombobulator.instance.flashCooldown)} seconds.\nType 'cooldown' or 'cd' to check discombobulation cooldown.\n\n");
			}
			RoundManager.Instance.PlayAudibleNoise(((Component)terminal).transform.position, 60f, 0.8f, 0, false, 14155);
			Discombobulator.instance.UseDiscombobulatorServerRpc();
			DiscombobulatorUpgradeConfiguration discombobulatorUpgradeConfiguration = UpgradeBus.Instance.PluginConfiguration.DiscombobulatorUpgradeConfiguration;
			Collider[] array = Physics.OverlapSphere(((Component)terminal).transform.position, discombobulatorUpgradeConfiguration.Radius.Value, 524288);
			if (array.Length == 0)
			{
				return DisplayTerminalMessage("No stunned enemies detected.\n\n");
			}
			if (discombobulatorUpgradeConfiguration.NotifyChat.Value)
			{
				((MonoBehaviour)terminal).StartCoroutine(CountDownChat(discombobulatorUpgradeConfiguration.InitialEffect.Value + discombobulatorUpgradeConfiguration.IncrementalEffect.Value * (float)BaseUpgrade.GetUpgradeLevel("Discombobulator")));
			}
			return DisplayTerminalMessage($"Discombobulator hit {array.Length} enemies.\n\n");
		}

		private static TerminalNode ExecuteDiscombobulatorCooldown()
		{
			if (!BaseUpgrade.GetActiveUpgrade("Discombobulator"))
			{
				return DisplayTerminalMessage("You don't have access to this command yet. Purchase the 'Discombobulator'.\n\n");
			}
			if (Discombobulator.instance.flashCooldown > 0f)
			{
				return DisplayTerminalMessage($"You can discombobulate again in {Mathf.Round(Discombobulator.instance.flashCooldown)} seconds.\n\n");
			}
			return DisplayTerminalMessage("Discombobulate is ready, Type 'initattack' or 'atk' to execute.\n\n");
		}

		private static TerminalNode ExecuteModInformation()
		{
			string text = "Late Game Upgrades\n\nType `lategame store` or `lgu` to view upgrades.\n\nMost of the mod is configurable via the config file in `BepInEx/config/com.malco.lethalcompany.moreshipupgrades.cfg`.";
			text += "\n\nType `lategame commands` or 'lgc' to see all commands related to upgrades";
			text += "\n\nTo force wipe an lgu save file type `reset lgu`. (will only wipe the clients save).";
			text += "\n\nTo reapply any upgrades that failed to apply type `load lgu`.";
			text += "\n\nIn the case of credit desync to force an amount of credits type `forceCredits 123`";
			text += "\n\n";
			return DisplayTerminalMessage(text);
		}

		private static TerminalNode ExecuteResetLGUSave()
		{
			if (LguStore.Instance.LguSave.playerSaves.ContainsKey(GameNetworkManager.Instance.localPlayerController.playerSteamId))
			{
				UpgradeBus.Instance.ResetAllValues(wipeObjRefs: false);
				SaveInfo saveInfo = new SaveInfo();
				ulong playerSteamId = GameNetworkManager.Instance.localPlayerController.playerSteamId;
				LguStore.Instance.SaveInfo = saveInfo;
				LguStore.Instance.UpdateLGUSaveServerRpc(playerSteamId, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)saveInfo)));
				return DisplayTerminalMessage("LGU save has been wiped.\n\n");
			}
			logger.LogError("LGU SAVE NOT FOUND in ExecuteResetLGUSave()!");
			return DisplayTerminalMessage("LGU save was not found!\n\n");
		}

		private static TerminalNode ExecuteForceCredits(string creditAmount, ref Terminal terminal)
		{
			if (int.TryParse(creditAmount, out var result))
			{
				if (((NetworkBehaviour)terminal).IsHost || ((NetworkBehaviour)terminal).IsServer)
				{
					terminal.SyncGroupCreditsClientRpc(result, terminal.numberOfItemsInDropship);
					return DisplayTerminalMessage($"All clients should now have ${result}\n\n");
				}
				return DisplayTerminalMessage("Only the host can do this");
			}
			return DisplayTerminalMessage($"Failed to parse value {creditAmount}.\n\n");
		}

		private static TerminalNode ExecuteInternsCommand(ref Terminal terminal, TerminalNode outputNode)
		{
			if (!SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERN_ENABLED))
			{
				return outputNode;
			}
			if (terminal.groupCredits < UpgradeBus.Instance.PluginConfiguration.INTERN_PRICE.Value)
			{
				return DisplayTerminalMessage($"Interns cost {UpgradeBus.Instance.PluginConfiguration.INTERN_PRICE.Value} credits and you have {terminal.groupCredits} credits.\n");
			}
			if (Interns.instance.revivalTimer > 0f)
			{
				return DisplayTerminalMessage(string.Format("We currently cannot provide you with a new intern. Please try again later. ({0} seconds)\n\n", Interns.instance.revivalTimer.ToString("F2")));
			}
			if (SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERNS_USAGES_PER_LANDING) != -1 && Interns.instance.currentUsages >= SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.INTERNS_USAGES_PER_LANDING))
			{
				return DisplayTerminalMessage($"You have depleted your interns for the current moon landing ({Interns.instance.currentUsages} usages). They will be replenished on the next moon landing\n\n");
			}
			if (Interns.instance.delayReviveTimer > 0f)
			{
				return DisplayTerminalMessage(string.Format("An intern is being dispatched to replace " + Interns.instance.delayedRevivePlayer.playerUsername + " in " + Interns.instance.delayReviveTimer.ToString("F2") + " seconds.\n\n"));
			}
			PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
			if (!targetedPlayer.isPlayerDead)
			{
				return DisplayTerminalMessage($"{targetedPlayer.playerUsername} is still alive, they can't be replaced with an intern.\n\n");
			}
			terminal.BuyItemsServerRpc(Array.Empty<int>(), terminal.groupCredits - UpgradeBus.Instance.PluginConfiguration.INTERN_PRICE.Value, terminal.numberOfItemsInDropship);
			Interns.instance.ReviveTargetedPlayerServerRpc();
			string text = Interns.instance.internNames[Random.Range(0, Interns.instance.internNames.Length)];
			string text2 = Interns.instance.internInterests[Random.Range(0, Interns.instance.internInterests.Length)];
			logger.LogInfo("Successfully executed intern command for " + targetedPlayer.playerUsername + "!");
			return DisplayTerminalMessage(targetedPlayer.playerUsername + " has been replaced with:\n\nNAME: " + text + "\n" + $"AGE: {Random.Range(19, 76)}\nIQ: {Random.Range(2, 160)}\n" + "INTERESTS: " + text2 + "\n\n" + text + " HAS BEEN DISPATCHED TO YOUR LOCATION, PLEASE ACQUAINTANCE YOURSELF ACCORDINGLY\n\n");
		}

		private static TerminalNode ExecuteLoadLGUCommand(string text, ref Terminal terminal)
		{
			if (text.ToLower() == "load lgu")
			{
				return DisplayTerminalMessage("Enter the name of the user whos upgrades/save you want to copy. Ex: `load lgu steve`\n");
			}
			PlayerControllerB[] array = Object.FindObjectsOfType<PlayerControllerB>();
			List<string> list = new List<string>();
			int num = text.IndexOf("load lgu") + "load lgu".Length;
			string text2 = text.Substring(num, text.Length - num).Trim();
			PlayerControllerB[] array2 = array;
			foreach (PlayerControllerB val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string playerUsername = val.playerUsername;
				ulong playerSteamId = val.playerSteamId;
				if (playerUsername != null)
				{
					list.Add(playerUsername);
					if (playerUsername.Contains(text2, StringComparison.OrdinalIgnoreCase))
					{
						LguStore.Instance.ShareSaveServerRpc();
						((MonoBehaviour)terminal).StartCoroutine(WaitForSync(playerSteamId));
						logger.LogInfo("Attempting to overwrite local save data with " + playerUsername + "'s save data.");
						return DisplayTerminalMessage($"Attempting to overwrite local save data with {playerUsername}'s save data\nYou should see a popup in 5 seconds...\n.\n");
					}
				}
			}
			string text3 = string.Join(", ", list);
			logger.LogInfo(text2 + " was not found among: " + text3);
			return DisplayTerminalMessage($"The name {text2} was not found. The following names were found:\n{text3}\n");
		}

		private static TerminalNode ExecuteScanHivesCommand()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if (BaseUpgrade.GetUpgradeLevel("Better Scanner") < 1)
			{
				return DisplayTerminalMessage("Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n");
			}
			GrabbableObject[] source = Object.FindObjectsOfType<GrabbableObject>();
			GrabbableObject[] array = source.Where((GrabbableObject scrap) => scrap.itemProperties.itemName == "Hive").ToArray();
			GrabbableObject[] array2 = array.OrderByDescending((GrabbableObject v) => v.scrapValue).ToArray();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"Found {array2.Length} Hives:");
			GrabbableObject[] array3 = array2;
			foreach (GrabbableObject val in array3)
			{
				stringBuilder.AppendLine($"{val.scrapValue} // X: {((Component)val).gameObject.transform.position.x:F1}, Y: {((Component)val).gameObject.transform.position.y:F1}, Z: {((Component)val).gameObject.transform.position.z:F1}");
			}
			stringBuilder.AppendLine("Don't forget your GPS!").AppendLine();
			logger.LogInfo($"Scan Hives command found {array.Length} hives.");
			return DisplayTerminalMessage(stringBuilder.ToString());
		}

		private static TerminalNode ExecuteScanScrapCommand()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (BaseUpgrade.GetUpgradeLevel("Better Scanner") < 1)
			{
				return DisplayTerminalMessage("Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n");
			}
			GrabbableObject[] source = Object.FindObjectsOfType<GrabbableObject>().ToArray();
			GrabbableObject[] array = source.Where((GrabbableObject scrap) => scrap.isInFactory && scrap.itemProperties.isScrap).ToArray();
			GrabbableObject[] array2 = array.OrderByDescending((GrabbableObject v) => v.scrapValue).Take(5).ToArray();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Most valuable items:");
			GrabbableObject[] array3 = array2;
			foreach (GrabbableObject val in array3)
			{
				stringBuilder.AppendLine($"{val.itemProperties.itemName}: ${val.scrapValue}\nX: {Mathf.RoundToInt(((Component)val).gameObject.transform.position.x)}, Y: {Mathf.RoundToInt(((Component)val).gameObject.transform.position.y)}, Z: {Mathf.RoundToInt(((Component)val).gameObject.transform.position.z)}");
			}
			stringBuilder.AppendLine("Don't forget your GPS!").AppendLine();
			logger.LogInfo($"Scan scrap command found {array.Length} valid scrap items.");
			return DisplayTerminalMessage(stringBuilder.ToString());
		}

		private static TerminalNode ExecuteScanPlayerCommand()
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			if (BaseUpgrade.GetUpgradeLevel("Better Scanner") < 1)
			{
				return DisplayTerminalMessage("Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n");
			}
			PlayerControllerB[] source = Object.FindObjectsOfType<PlayerControllerB>().ToArray();
			PlayerControllerB[] source2 = source.Where((PlayerControllerB player) => player.playerSteamId != 0).ToArray();
			PlayerControllerB[] array = source2.Where((PlayerControllerB player) => !player.isPlayerDead).ToArray();
			PlayerControllerB[] array2 = source2.Where((PlayerControllerB player) => player.isPlayerDead).ToArray();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Alive Players:");
			PlayerControllerB[] array3 = array;
			foreach (PlayerControllerB val in array3)
			{
				stringBuilder.AppendLine($"\n{val.playerUsername} - X:{Mathf.RoundToInt(((Component)val).transform.position.x)},Y:{Mathf.RoundToInt(((Component)val).transform.position.y)},Z:{Mathf.RoundToInt(((Component)val).transform.position.z)}");
			}
			stringBuilder.AppendLine("Dead Players:");
			PlayerControllerB[] array4 = array2;
			foreach (PlayerControllerB val2 in array4)
			{
				stringBuilder.AppendLine($"\n{val2.playerUsername} - X:{Mathf.RoundToInt(((Component)val2).transform.position.x)},Y:{Mathf.RoundToInt(((Component)val2).transform.position.y)},Z:{Mathf.RoundToInt(((Component)val2).transform.position.z)}");
			}
			stringBuilder.AppendLine();
			logger.LogInfo($"Scan players command found {array.Length} alive players and {array2.Length} dead players.");
			return DisplayTerminalMessage(stringBuilder.ToString());
		}

		private static TerminalNode ExecuteScanEnemiesCommand()
		{
			if (BaseUpgrade.GetUpgradeLevel("Better Scanner") < 1)
			{
				return DisplayTerminalMessage("Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n");
			}
			EnemyAI[] array = (from enem in Object.FindObjectsOfType<EnemyAI>()
				where !enem.isEnemyDead
				select enem).ToArray();
			if (array.Length == 0)
			{
				return DisplayTerminalMessage("0 enemies detected\n\n");
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			if (!UpgradeBus.Instance.PluginConfiguration.BetterScannerUpgradeConfiguration.VerboseEnemies.Value)
			{
				logger.LogInfo("Scan Enemies: Verbose mode = true");
				dictionary.Add("Outside Enemies", 0);
				dictionary.Add("Inside Enemies", 0);
				EnemyAI[] array2 = array;
				foreach (EnemyAI val in array2)
				{
					if (val.isOutside)
					{
						dictionary["Outside Enemies"]++;
					}
					else
					{
						dictionary["Inside Enemies"]++;
					}
				}
			}
			else
			{
				logger.LogInfo("Scan Enemies: Verbose mode = false");
				EnemyAI[] array3 = array;
				foreach (EnemyAI val2 in array3)
				{
					ScanNodeProperties componentInChildren = ((Component)val2).GetComponentInChildren<ScanNodeProperties>();
					string text = "";
					text = ((!((Object)(object)componentInChildren != (Object)null)) ? "Unknown" : componentInChildren.headerText);
					if (dictionary.ContainsKey(text))
					{
						dictionary[text]++;
					}
					else
					{
						dictionary.Add(text, 1);
					}
				}
			}
			logger.LogInfo($"Scan Enemies found {array.Length} alive enemies.");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"Alive Enemies: {array.Length}");
			foreach (KeyValuePair<string, int> item in dictionary)
			{
				stringBuilder.AppendLine($"{item.Key} - {item.Value}");
			}
			stringBuilder.AppendLine();
			return DisplayTerminalMessage(stringBuilder.ToString());
		}

		private static TerminalNode ExecuteScanDoorsCommand()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			if (BaseUpgrade.GetUpgradeLevel("Better Scanner") < 1)
			{
				return DisplayTerminalMessage("Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n");
			}
			List<GameObject> list = (from obj in Object.FindObjectsOfType<GameObject>()
				where ((Object)obj).name == "SpawnEntranceBTrigger"
				select obj).ToList();
			List<EntranceTeleport> list2 = Object.FindObjectsOfType<EntranceTeleport>().ToList();
			List<EntranceTeleport> list3 = new List<EntranceTeleport>();
			foreach (EntranceTeleport item in list2)
			{
				if (!(((Component)item).gameObject.transform.position.y >= -170f))
				{
					list3.Add(item);
				}
			}
			foreach (EntranceTeleport item2 in list3)
			{
				list2.Remove(item2);
				if (!list.Contains(((Component)item2).gameObject))
				{
					list.Add(((Component)item2).gameObject);
				}
			}
			PlayerControllerB player = StartOfRound.Instance.mapScreen.targetedPlayer;
			StringBuilder stringBuilder = new StringBuilder();
			if (player.isInsideFactory)
			{
				stringBuilder.AppendLine("Closest exits to " + player.playerUsername + " " + $"(X:{Mathf.RoundToInt(((Component)player).transform.position.x)}," + $"Y:{Mathf.RoundToInt(((Component)player).transform.position.y)}," + $"Z:{Mathf.RoundToInt(((Component)player).transform.position.z)}):");
				GameObject[] source = list.OrderBy((GameObject door) => Vector3.Distance(door.transform.position, ((Component)player).transform.position)).Take(3).ToArray();
				foreach (Vector3 item3 in source.Select((GameObject door) => door.transform.position))
				{
					stringBuilder.AppendLine($"X:{Mathf.RoundToInt(item3.x)}," + $"Y:{Mathf.RoundToInt(item3.y)}," + $"Z:{Mathf.RoundToInt(item3.z)} - " + $"{Mathf.RoundToInt(Vector3.Distance(item3, ((Component)player).transform.position))} units away.");
				}
				logger.LogInfo($"Scan Doors, player is inside factory. Found {list.Count} doors.");
			}
			else
			{
				stringBuilder.AppendLine("Entrances for " + player.playerUsername + " " + $"(X:{Mathf.RoundToInt(((Component)player).transform.position.x)}," + $"Y:{Mathf.RoundToInt(((Component)player).transform.position.y)}," + $"Z:{Mathf.RoundToInt(((Component)player).transform.position.z)}):");
				foreach (Vector3 item4 in list2.Select((EntranceTeleport door) => ((Component)door).transform.position))
				{
					stringBuilder.AppendLine($"X:{Mathf.RoundToInt(item4.x)},Y:{Mathf.RoundToInt(item4.y)},Z:{Mathf.RoundToInt(item4.z)} - {Mathf.RoundToInt(Vector3.Distance(item4, ((Component)player).transform.position))} units away.");
				}
				logger.LogInfo($"Scan Doors, player is outside factory. Found {list2.Count} doors.");
			}
			stringBuilder.AppendLine();
			return DisplayTerminalMessage(stringBuilder.ToString());
		}

		private static TerminalNode ExecuteLategameCommands(string secondWord)
		{
			if (1 == 0)
			{
			}
			TerminalNode result = ((!(secondWord == "commands")) ? ExecuteModInformation() : ExecuteLGUCommands());
			if (1 == 0)
			{
			}
			return result;
		}

		private static TerminalNode ExecuteResetCommands(string secondWord, ref TerminalNode outputNode)
		{
			if (1 == 0)
			{
			}
			TerminalNode result = ((!(secondWord == "lgu")) ? outputNode : ExecuteResetLGUSave());
			if (1 == 0)
			{
			}
			return result;
		}

		private static TerminalNode ExecuteLoadCommands(string secondWord, string fullText, ref Terminal terminal, ref TerminalNode outputNode)
		{
			if (1 == 0)
			{
			}
			TerminalNode result = ((!(secondWord == "lgu")) ? outputNode : ExecuteLoadLGUCommand(fullText, ref terminal));
			if (1 == 0)
			{
			}
			return result;
		}

		private static TerminalNode ExecuteScanCommands(string secondWord, ref TerminalNode outputNode)
		{
			if (1 == 0)
			{
			}
			TerminalNode result = (TerminalNode)(secondWord switch
			{
				"hives" => ExecuteScanHivesCommand(), 
				"scrap" => ExecuteScanScrapCommand(), 
				"player" => ExecuteScanPlayerCommand(), 
				"enemies" => ExecuteScanEnemiesCommand(), 
				"doors" => ExecuteScanDoorsCommand(), 
				_ => outputNode, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private static TerminalNode ExecuteBruteForce(string secondWord)
		{
			if (1 == 0)
			{
			}
			TerminalNode result = ((!(secondWord == "")) ? HandleBruteForce(secondWord) : DisplayTerminalMessage("Enter a valid address for a device to connect to!\n\n"));
			if (1 == 0)
			{
			}
			return result;
		}

		public static void ParseLGUCommands(string fullText, ref Terminal terminal, ref TerminalNode outputNode)
		{
			string[] array = fullText.Split();
			string text = array[0].ToLower();
			string text2 = ((array.Length > 1) ? array[1].ToLower() : "");
			string thirdWord = ((array.Length > 2) ? array[2].ToLower() : "");
			switch (text)
			{
			case "demon":
				outputNode = LookupDemon(text2, thirdWord);
				break;
			case "lookup":
				outputNode = DefuseBombCommand(text2);
				break;
			case "bruteforce":
				outputNode = ExecuteBruteForce(text2);
				break;
			case "initattack":
			case "atk":
				outputNode = ExecuteDiscombobulatorAttack(ref terminal);
				break;
			case "cd":
			case "cooldown":
				outputNode = ExecuteDiscombobulatorCooldown();
				break;
			case "lategame":
				outputNode = ExecuteLategameCommands(text2);
				break;
			case "lgc":
				outputNode = ExecuteLGUCommands();
				break;
			case "reset":
				outputNode = ExecuteResetCommands(text2, ref outputNode);
				break;
			case "forcecredits":
				outputNode = ExecuteForceCredits(text2, ref terminal);
				break;
			case "intern":
			case "interns":
				outputNode = ExecuteInternsCommand(ref terminal, outputNode);
				break;
			case "load":
				outputNode = ExecuteLoadCommands(text2, fullText, ref terminal, ref outputNode);
				break;
			case "scan":
				outputNode = ExecuteScanCommands(text2, ref outputNode);
				break;
			case "quantum":
				ExecuteQuantumCommands(ref terminal, ref outputNode);
				break;
			case "contract":
				ExecuteContractCommands(ref terminal, ref outputNode);
				break;
			}
		}

		private static void ExecuteContractCommands(ref Terminal terminal, ref TerminalNode outputNode)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.Enabled) && SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomOnly))
			{
				outputNode = TryGetContract(ref terminal);
			}
		}

		private static TerminalNode TryGetContract(ref Terminal terminal)
		{
			if (contracts.Count == 0)
			{
				return DisplayTerminalMessage("Not possible to provide a contract due to configuration having it disabled.\n\n");
			}
			string text;
			if (ContractManager.Instance.contractLevel != "None")
			{
				text = "You currently have a " + ContractManager.Instance.contractType + " contract on " + ContractManager.Instance.contractLevel + "!\n\n";
				text += string.Format(AssetBundleHandler.GetInfoFromJSON("Contract"), UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value);
				logger.LogInfo("User tried starting a new contract while they still have a " + ContractManager.Instance.contractType + " contract on " + ContractManager.Instance.contractLevel + "!");
				return DisplayTerminalMessage(text);
			}
			if (terminal.groupCredits < UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value)
			{
				text = $"Contracts costs ${UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value} and you have ${terminal.groupCredits}\n\n";
				return DisplayTerminalMessage(text);
			}
			terminal.BuyItemsServerRpc(Array.Empty<int>(), terminal.groupCredits - UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.RandomPrice.Value, terminal.numberOfItemsInDropship);
			int num = Random.Range(0, contracts.Count);
			if (contracts.Count > 1)
			{
				while (num == ContractManager.Instance.lastContractIndex)
				{
					num = Random.Range(0, contracts.Count);
				}
			}
			ContractManager.Instance.contractType = contracts[num];
			text = "A " + contracts[num] + " contract has been accepted for " + ContractManager.RandomLevel() + "!" + contractInfos[num];
			if (((NetworkBehaviour)terminal).IsHost || ((NetworkBehaviour)terminal).IsServer)
			{
				ContractManager.Instance.SyncContractDetailsClientRpc(ContractManager.Instance.contractLevel, num);
			}
			else
			{
				ContractManager.Instance.ReqSyncContractDetailsServerRpc(ContractManager.Instance.contractLevel, num);
			}
			logger.LogInfo("User accepted a " + ContractManager.Instance.contractType + " contract on " + ContractManager.Instance.contractLevel);
			return DisplayTerminalMessage(text);
		}

		private static void ExecuteQuantumCommands(ref Terminal terminal, ref TerminalNode outputNode)
		{
			if (!SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.QuantumDisruptorConfiguration.Enabled))
			{
				return;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Quantum Disruptor"))
			{
				outputNode = DisplayTerminalMessage("You need 'Quantum Disruptor' upgrade active to use this command.\n");
				return;
			}
			(bool, string) tuple = QuantumDisruptor.Instance.CanRevertTime();
			if (!tuple.Item1)
			{
				outputNode = DisplayTerminalMessage(tuple.Item2);
				return;
			}
			if (((NetworkBehaviour)terminal).IsHost || ((NetworkBehaviour)terminal).IsServer)
			{
				QuantumDisruptor.Instance.RevertTimeClientRpc();
			}
			else
			{
				QuantumDisruptor.Instance.RevertTimeServerRpc();
			}
			outputNode = DisplayTerminalMessage($"Successfully reverted back current moon's time by {QuantumDisruptor.Instance.hoursToReduce}. You currently have {QuantumDisruptor.Instance.currentUsages} out of {QuantumDisruptor.Instance.availableUsages} usages.\n");
		}

		private static TerminalNode LookupDemon(string secondWord, string thirdWord)
		{
			string text = secondWord.ToUpper();
			if (text == "DE" && string.Equals(thirdWord, "OGEN", StringComparison.OrdinalIgnoreCase))
			{
				text = text + " " + thirdWord.ToUpper();
			}
			if (PentagramScript.DemonInstructions.ContainsKey(text))
			{
				string[] array = PentagramScript.DemonInstructions[text];
				return DisplayTerminalMessage("To banish this spirit you must assemble the following items:\n\n" + array[0] + "\n" + array[1] + "\n" + array[2] + "\n\n");
			}
			string text2 = string.Join("\n", PentagramScript.DemonInstructions.Keys.ToArray());
			return DisplayTerminalMessage("There is no known data on " + secondWord + ". Known spirits are:\n\n" + text2 + "\n\n");
		}

		private static TerminalNode DefuseBombCommand(string secondWord)
		{
			if (ContractManager.Instance.contractLevel != StartOfRound.Instance.currentLevel.PlanetName || ContractManager.Instance.contractType != "Defusal")
			{
				return DisplayTerminalMessage("YOU MUST BE IN A DEFUSAL CONTRACT TO USE THIS COMMAND!\n\n");
			}
			if (secondWord.Length == 0)
			{
				return DisplayTerminalMessage("YOU MUST ENTER A SERIAL NUMBER TO LOOK UP!\n\n");
			}
			if (string.Equals(secondWord, ContractManager.Instance.SerialNumber, StringComparison.OrdinalIgnoreCase) || string.Equals(secondWord, ContractManager.Instance.SerialNumber.Replace("-", ""), StringComparison.OrdinalIgnoreCase))
			{
				logger.LogInfo("DEFUSAL: user entered correct serial number!");
				return DisplayTerminalMessage(string.Format("CUT THE WIRES IN THE FOLLOWING ORDER:\n\n{0}\n\n", string.Join("\n\n", ContractManager.Instance.bombOrder)));
			}
			logger.LogInfo("DEFUSAL: user entered incorrect serial number! Entered: " + secondWord + ", Expected: " + ContractManager.Instance.SerialNumber + " (case and hyphen insensitive)");
			if (ContractManager.Instance.fakeBombOrders.ContainsKey(secondWord))
			{
				logger.LogInfo("DEFUSAL: Reusing previously generated fake defusal under this key.");
				return DisplayTerminalMessage(string.Format("CUT THE WIRES IN THE FOLLOWING ORDER:\n\n{0}\n\n", string.Join("\n\n", ContractManager.Instance.fakeBombOrders[secondWord])));
			}
			logger.LogInfo("DEFUSAL: Generating new fake defusal under this key.");
			List<string> list = new List<string>(3) { "red", "green", "blue" };
			Tools.ShuffleList(list);
			ContractManager.Instance.fakeBombOrders.Add(secondWord, list);
			return DisplayTerminalMessage(string.Format("CUT THE WIRES IN THE FOLLOWING ORDER:\n\n{0}\n\n", string.Join("\n\n", list)));
		}

		private static TerminalNode HandleBruteForce(string secondWord)
		{
			string dataMinigameKey = ContractManager.Instance.DataMinigameKey;
			string text;
			if (secondWord == dataMinigameKey)
			{
				logger.LogInfo("USER CORRECTLY ENTERED IP ADDRESS, user: " + ContractManager.Instance.DataMinigameUser + ", pass: " + ContractManager.Instance.DataMinigamePass);
				text = "PING " + dataMinigameKey + " (" + dataMinigameKey + "): 56 data bytes\r\n64 bytes from " + dataMinigameKey + ": icmp_seq=0 ttl=64 time=1.234 ms\r\n64 bytes from " + dataMinigameKey + ": icmp_seq=1 ttl=64 time=1.345 ms\r\n64 bytes from " + dataMinigameKey + ": icmp_seq=2 ttl=64 time=1.123 ms\r\n64 bytes from " + dataMinigameKey + ": icmp_seq=3 ttl=64 time=1.456 ms\r\n\r\n--- " + dataMinigameKey + " ping statistics ---\r\n4 packets transmitted, 4 packets received, 0.0% packet loss\r\nround-trip min/avg/max/stddev = 1.123/1.289/1.456/0.123 ms\n\n";
				text = text + "CONNECTION ESTABLISHED --- RETRIEVING CREDENTIALS...\n\nUSER: " + ContractManager.Instance.DataMinigameUser + "\nPASSWORD: " + ContractManager.Instance.DataMinigamePass + "\n";
			}
			else
			{
				logger.LogInfo("USER INCORRECTLY ENTERED IP ADDRESS! submitted: " + secondWord + ", expected: " + dataMinigameKey);
				text = "PING " + secondWord + " (" + secondWord + "): 56 data bytes\r\nRequest timeout for icmp_seq 0\r\nRequest timeout for icmp_seq 1\r\nRequest timeout for icmp_seq 2\r\nRequest timeout for icmp_seq 3\r\n\r\n--- " + secondWord + " ping statistics ---\r\n4 packets transmitted, 0 packets received, 100.0% packet loss\n\n";
				text += "CONNECTION FAILED -- INVALID ADDRESS?\n\n";
			}
			return DisplayTerminalMessage(text);
		}

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

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

		private static TerminalNode ExecuteLGUCommands()
		{
			string text = "Late Game Commands\n\n";
			text += HelpTerminalNode.HandleHelpInterns();
			text += HelpTerminalNode.HandleHelpContract();
			text += HelpTerminalNode.HandleHelpDiscombobulator();
			text += HelpTerminalNode.HandleAlternateCurrency();
			text += "\n\n";
			return DisplayTerminalMessage(text);
		}
	}
	public class LguLogger
	{
		private readonly string moduleName;

		private readonly ManualLogSource logSource;

		public LguLogger(string moduleName)
		{
			this.moduleName = moduleName;
			logSource = Plugin.mls;
			base..ctor();
		}

		public void LogCodeInstruction(CodeInstruction code)
		{
			LogDebug(code.opcode.ToString() + ", " + code.operand);
		}

		public void LogDebug(object message)
		{
			logSource.LogDebug((object)$"[{moduleName}] {message}");
		}

		public void LogMessage(object message)
		{
			logSource.LogMessage((object)$"[{moduleName}] {message}");
		}

		public void LogInfo(object message)
		{
			logSource.LogInfo((object)$"[{moduleName}] {message}");
		}

		public void LogWarning(object message)
		{
			logSource.LogWarning((object)$"[{moduleName}] {message}");
		}

		public void LogError(object message)
		{
			logSource.LogError((object)$"[{moduleName}] {message}");
		}
	}
	internal static class LguScanNodeProperties
	{
		internal enum NodeType
		{
			GENERAL,
			DANGER,
			SCRAP
		}

		public static void UpdateScrapValue(ref GrabbableObject grabbableObject, int scrapValue = -1)
		{
			ScanNodeProperties scanNodeProperties = ((Component)grabbableObject).GetComponentInChildren<ScanNodeProperties>();
			ChangeScanNode(ref scanNodeProperties, (NodeType)scanNodeProperties.nodeType, scanNodeProperties.headerText, $"Value: ${scrapValue}", -1, scrapValue);
		}

		public static void ChangeScanNode(ref ScanNodeProperties scanNodeProperties, NodeType nodeType, string header = "LGU Scan Node", string subText = "Used for LGU stuff", int creatureScanID = -1, int scrapValue = 0, int minRange = 2, int maxRange = 7, bool requiresLineOfSight = true)
		{
			scanNodeProperties.headerText = header;
			scanNodeProperties.subText = subText;
			scanNodeProperties.nodeType = (int)nodeType;
			scanNodeProperties.creatureScanID = creatureScanID;
			scanNodeProperties.scrapValue = scrapValue;
			scanNodeProperties.minRange = minRange;
			scanNodeProperties.maxRange = maxRange;
			scanNodeProperties.requiresLineOfSight = requiresLineOfSight;
		}

		private static GameObject CreateCanvasScanNode(ref GameObject objectToAddScanNode)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(GameObject.CreatePrimitive((PrimitiveType)3), objectToAddScanNode.transform.position, Quaternion.Euler(Vector3.zero), objectToAddScanNode.transform);
			((Object)val).name = "ScanNode";
			val.layer = LayerMask.NameToLayer("ScanNode");
			Object.Destroy((Object)(object)val.GetComponent<MeshRenderer>());
			Object.Destroy((Object)(object)val.GetComponent<MeshFilter>());
			return val;
		}

		private static void AddScanNode(GameObject objectToAddScanNode, NodeType nodeType, string header = "LGU Scan Node", string subText = "Used for LGU stuff", int creatureScanID = -1, int minRange = 2, int maxRange = 7, bool requiresLineOfSight = true)
		{
			GameObject val = CreateCanvasScanNode(ref objectToAddScanNode);
			ScanNodeProperties scanNodeProperties = val.AddComponent<ScanNodeProperties>();
			ChangeScanNode(ref scanNodeProperties, nodeType, header, subText, creatureScanID, 0, minRange, maxRange, requiresLineOfSight);
		}

		public static void AddGeneralScanNode(GameObject objectToAddScanNode, string header = "LGU Scan Node", string subText = "Used for LGU stuff", int creatureScanID = -1, int minRange = 2, int maxRange = 7, bool requiresLineOfSight = true)
		{
			AddScanNode(objectToAddScanNode, NodeType.GENERAL, header, subText, creatureScanID, minRange, maxRange, requiresLineOfSight);
		}

		public static void RemoveScanNode(GameObject objectToRemoveScanNode)
		{
			Object.Destroy((Object)(object)objectToRemoveScanNode.GetComponentInChildren<ScanNodeProperties>());
		}
	}
	internal static class Metadata
	{
		public const string GUID = "com.malco.lethalcompany.moreshipupgrades";

		public const string DAWN_ID = "lategame_upgrades";

		public const string NAME = "More Ship Upgrades";

		public const string VERSION = "3.13.1";
	}
	internal class ScrapValueSyncer : MonoBehaviour
	{
		internal void SetScrapValue(int scrapValue)
		{
			GrabbableObject component = ((Component)this).GetComponent<GrabbableObject>();
			if (component.scrapValue > 0)
			{
				component.SetScrapValue(component.scrapValue);
				return;
			}
			component.SetScrapValue(scrapValue);
			RoundManager instance = RoundManager.Instance;
			instance.totalScrapValueInLevel += (float)scrapValue;
		}
	}
}
namespace MoreShipUpgrades.Misc.Util
{
	internal static class LguConstants
	{
		internal const char WHITE_SPACE = ' ';

		internal const string HEXADECIMAL_RED = "#FF0000";

		internal const string HEXADECIMAL_DARK_RED = "#8B0000";

		internal const string HEXADECIMAL_WHITE = "#FFFFFF";

		internal const string HEXADECIMAL_GREEN = "#00FF00";

		internal const string HEXADECIMAL_DARK_GREEN = "#026440";

		internal const string HEXADECIMAL_GREY = "#666666";

		internal const string DROP_ALL_ITEMS_WHEELBARROW_KEYBIND_NAME = "Drop all items from wheelbarrow";

		internal const string DROP_ALL_ITEMS_WHEELBARROW_DEFAULT_KEYBIND = "<Mouse>/middleButton";

		internal const string TOGGLE_NIGHT_VISION_KEYBIND_NAME = "Toggle NVG";

		internal const string TOGGLE_NIGHT_VISION_DEFAULT_KEYBIND = "<Keyboard>/leftAlt";

		internal const string MOVE_CURSOR_UP_KEYBIND_NAME = "Move Cursor Up in Lategame Upgrades Store";

		internal const string MOVE_CURSOR_UP_DEFAULT_KEYBIND = "<Keyboard>/w";

		internal const string MOVE_CURSOR_DOWN_KEYBIND_NAME = "Move Cursor Down in Lategame Upgrades Store";

		internal const string MOVE_CURSOR_DOWN_DEFAULT_KEYBIND = "<Keyboard>/s";

		internal const string EXIT_STORE_KEYBIND_NAME = "Exit Lategame Upgrades Store";

		internal const string EXIT_STORE_DEFAULT_KEYBIND = "<Keyboard>/escape";

		internal const string NEXT_PAGE_KEYBIND_NAME = "Next Page in Lategame Upgrades Store";

		internal const string NEXT_PAGE_DEFAULT_KEYBIND = "<Keyboard>/d";

		internal const string PREVIOUS_PAGE_KEYBIND_NAME = "Previous Page in Lategame Upgrades Store";

		internal const string PREVIOUS_PAGE_DEFAULT_KEYBIND = "<Keyboard>/a";

		internal const string SUBMIT_PROMPT_KEYBIND_NAME = "Submit Prompt in Lategame Upgrades Store";

		internal const string SUBMIT_PROMPT_DEFAULT_KEYBIND = "<Keyboard>/enter";

		internal const string RANDOMIZE_UPGRADES_SECTION = "_Randomize Upgrades_";

		internal const string RANDOMIZE_UPGRADES_ENABLED_KEY = "Enable Randomize Upgrades";

		internal const bool RANDOMIZE_UPGRADES_ENABLED_DEFAULT = false;

		internal const string RANDOMIZE_UPGRADES_ENABLED_DESCRIPTION = "Upgrades will be randomized per selected event to be allowed purchased on the store.";

		internal const string RANDOMIZE_UPGRADES_AMOUNT_KEY = "Amount of Upgrades";

		internal const int RANDOMIZE_UPGRADES_AMOUNT_DEFAULT = 5;

		internal const string RANDOMIZE_UPGRADES_AMOUNT_DESCRIPTION = "Amount of Upgrades that will always appear in the store (if allowed).";

		internal const string RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED_KEY = "Show purchased upgrades";

		internal const bool RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED_DEFAULT = true;

		internal const string RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED_DESCRIPTION = "Wether purchased upgrades will always show in the store and the specified amount of random upgrades will not include these in the selection.";

		internal const string RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT_KEY = "Randomize Upgrades Event";

		internal const RandomizeUpgradeManager.RandomizeUpgradeEvents RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT_DEFAULT = RandomizeUpgradeManager.RandomizeUpgradeEvents.PerQuota;

		internal const string RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT_DESCRIPTION = "Event which triggers the random upgrades being changed in the store.";

		internal const string ITEM_PROGRESSION_SECTION = "_Item Progression Route_";

		internal const string ALTERNATIVE_ITEM_PROGRESSION_KEY = "Enable Item Progression";

		internal const bool ALTERNATIVE_ITEM_PROGRESSION_DEFAULT = false;

		internal const string ALTERNATIVE_ITEM_PROGRESSION_DESCRIPTION = "Alternative Item Progression\nIf true, items retrieved can be used for ship upgrades.";

		internal const string ITEM_PROGRESSION_MODE_KEY = "Item Progression Mode";

		internal const ItemProgressionManager.CollectionModes ITEM_PROGRESSION_MODE_DEFAULT = ItemProgressionManager.CollectionModes.CustomScrap;

		internal const string ITEM_PROGRESSION_MODE_DESCRIPTION = "Item Progression Mode\nSupported Modes: \nCustomScrap: Specified scrap will contribute towards the level of the associated upgrade.\nUniqueScrap: All scrap (specifications will be ignored) will contribute towards the level of a random assigned upgrade\nNearestValue: At the end of each Quota, grant a random upgrade worth the nearest total scrap collected, rounded down.\nChancePerScrap: For each scrap sold, run a configured chance to receive a random/cheap/lowest tier upgrade.\nApparatice: Always receive an upgrade when an apparatus has been successfully sold.";

		internal const string ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER_KEY = "Item Progression Multiplier";

		internal const float ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER_DEFAULT = 0.85f;

		internal const string ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER_DESCRIPTION = "Item Progression Contribution Multiplier\nThe multiplier for scrap's value contribution towards an upgrade.";

		internal const string SCRAP_UPGRADE_CHANCE_KEY = "Scrap Upgrade Chance";

		internal const float SCRAP_UPGRADE_CHANCE_DEFAULT = 0.05f;

		internal const string SCRAP_UPGRADE_CHANCE_DESCRIPTION = "Upgrade Chance Calculation\nOnly used if Item Progression Mode is set to ChancePerScrap.\nX -> (X * 100) %";

		internal const string SCRAP_UPGRADE_MODE_KEY = "Upgrade Chance Priority";

		internal const ItemProgressionManager.ChancePerScrapModes SCRAP_UPGRADE_MODE_DEFAULT = ItemProgressionManager.ChancePerScrapModes.LowestLevel;

		internal const string SCRAP_UPGRADE_MODE_DESCRIPTION = "Upgrade Chance Priority\nOnly used if Item Progression Mode is set to ChancePerScrap.\nAcceptable Values:\nRandom: Pick a random upgrade to apply.\nCheapest: Pick the cheapest upgrade to apply.\nLowest Tier: Pick the upgrade with the lowest level to apply.";

		internal const string ITEM_PROGRESSION_BLACKLISTED_ITEMS_KEY = "Blacklisted Items";

		internal const string ITEM_PROGRESSION_BLACKLISTED_ITEMS_DEFAULT = "Clipboard";

		internal const string ITEM_PROGRESSION_BLACKLISTED_ITEMS_DESCRIPTION = "Blacklisted items for Item Progression.\nOnly used if Item Progression Mode is set to UniqueScrap. These items will NOT contribute towards ANY upgrade";

		internal const string ITEM_PROGRESSION_BLACKLIST_ITEMS_ENTRY_DELIMITER = ",";

		internal const string ITEM_PROGRESSION_APPARATICE_ITEMS_KEY = "Apparatus Items";

		internal const string ITEM_PROGRESSION_APPARATICE_ITEMS_DEFAULT = "Apparatus@1,ExampleItemName@2";

		internal const string ITEM_PROGRESSION_APPARATICE_ITEMS_DESCRIPTION = "Items that are considered \"Apparatice\" and provide a set amount of upgrades once sold to The Company.\nThe item name is either the one displayed in the scan node or its internal name.\nThis list is only valid if Item Progression Mode is set to Apparatice.";

		internal const string ITEM_PROGRESSION_NO_PURCHASE_UPGRADES_KEY = "Non-Purchaseable Upgrades";

		internal const bool ITEM_PROGRESSION_NO_PURCHASE_UPGRADES_DEFAULT = false;

		internal const string ITEM_PROGRESSION_NO_PURCHASE_UPGRADES_DESCRIPTION = "Prevents the upgrades from being purchaseable in the store to be only used to know how far are they to acquiring one. Only valid if Item Progression mode is toggled on";

		internal const string ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS_KEY = "Always Show Contribution Items";

		internal const bool ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS_DEFAULT = false;

		internal const string ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS_DESCRIPTION = "Shows all the items associated to each upgrade regardless if they were sold before or not.";

		internal const string ITEM_PROGRESSION_APPARATICE_ITEMS_ENTRY_DELIMITER = ",";

		internal const string ITEM_PROGRESSION_APPARATICE_ITEMS_ATTRIBUTE_DELIMITER = "@";

		internal const string ITEM_PROGRESSION_ITEMS_KEY = "Contribution Items";

		internal const string ITEM_PROGRESSION_ITEMS_DEFAULT = "";

		internal const string ITEM_PROGRESSION_ITEMS_DESCRIPTION = "Items that when sold contribute to the purchase of the upgrade. Either the scan node's name or ItemProperties.itemName can be inserted here";

		internal const string MISCELLANEOUS_SECTION = "_Misc_";

		internal const string SHARE_ALL_UPGRADES_KEY = "Convert all upgrades to be shared.";

		internal const bool SHARE_ALL_UPGRADES_DEFAULT = true;

		internal const string SHARE_ALL_UPGRADES_DESCRIPTION = "If true this will ignore the individual shared upgrade option for all other upgrades and set all upgrades to be shared.";

		internal const string SALE_PERCENT_KEY = "Chance of upgrades going on sale";

		internal const float SALE_PERCENT_DEFAULT = 0.85f;

		internal const string SALE_PERCENT_DESCRIPTION = "0.85 = 15% chance of an upgrade going on sale.";

		internal const string KEEP_UPGRADES_AFTER_FIRED_KEY = "Keep upgrades after quota failure";

		internal const bool KEEP_UPGRADES_AFTER_FIRED_DEFAULT = false;

		internal const string KEEP_UPGRADES_AFTER_FIRED_DESCRIPTION = "If true, you will keep your upgrades after being fired by The Company.";

		internal const string SHOW_UPGRADES_CHAT_KEY = "Show upgrades being loaded in chat";

		internal const bool SHOW_UPGRADES_CHAT_DEFAULT = true;

		internal const string SHOW_UPGRADES_CHAT_DESCRIPTION = "If enabled, chat messages will be displayed when loading an upgrade for the first time.";

		internal const string SALE_APPLY_ONCE_KEY = "Apply upgrade sale on one purchase";

		internal const bool SALE_APPLY_ONCE_DEFAULT = false;

		internal const string SALE_APPLY_ONCE_DESCRIPTION = "When an upgrade is on sale, apply the sale only on the first ever purchase of it while on sale. Consecutive purchases will not have the sale applied";

		internal const string SHOW_WORLD_BUILDING_TEXT_KEY = "Show World Building text in Upgrade information";

		internal const bool SHOW_WORLD_BUILDING_TEXT_DEFAULT = true;

		internal const string SHOW_WORLD_BUILDING_TEXT_DESCRIPTION = "When viewing an upgrade's information, wether show world-building text along with pratical information or not.";

		internal const string BUYABLE_UPGRADES_ONCE_KEY = "Limited Buyable Upgrades";

		internal const bool BUYABLE_UPGRADES_ONCE_DEFAULT = false;

		internal const string BUYABLE_UPGRADES_ONCE_DESCRIPTION = "If toggled on, the upgrade bought for the first time will only be buyable after by the purchasing player. This is only relevant to individual upgrades";

		internal const string SHOW_LOCKED_UPGRADES_KEY = "Show Locked Upgrades";

		internal const bool SHOW_LOCKED_UPGRADES_DEFAULT = true;

		internal const string SHOW_LOCKED_UPGRADES_DESCRIPTION = "If toggled off, upgrades which are locked to other crew members for purchase will not appear in the store";

		internal const string OVERRIDE_NAMES_SECTION = "Name Overrides";

		internal const string OVERRIDE_NAMES_ENABLED_KEY = "Override Upgrade Names";

		internal const bool OVERRIDE_NAMES_ENABLED_DEFAULT = false;

		internal const string OVERRIDE_NAMES_ENABLED_DESCRIPTION = "When enabled, replaces the names of each upgrades with the ones defined in this section";

		internal const string OVERRIDE_NAME_KEY_FORMAT = "Alternative name for {0} upgrade";

		internal static readonly string EFFECTIVE_BANDAIDS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Effective Bandaids");

		internal static readonly string MEDICAL_NANOBOTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Medical Nanobots");

		internal static readonly string SCRAP_KEEPER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Scrap Keeper");

		internal static readonly string PARTICLE_INFUSER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Particle Infuser");

		internal static readonly string SILVER_BULLETS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Silver Bullets");

		internal static readonly string FUSION_MATTER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Fusion Matter");

		internal static readonly string LONG_BARREL_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Long Barrel");

		internal static readonly string HOLLOW_POINT_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Hollow Point");

		internal static readonly string JETPACK_THRUSTERS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Jetpack Thrusters");

		internal static readonly string JET_FUEL_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Jet Fuel");

		internal static readonly string QUICK_HANDS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Quick Hands");

		internal static readonly string MIDAS_TOUCH_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Midas Touch");

		internal static readonly string CARBON_KNEEJOINTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Carbon Kneejoints");

		internal static readonly string LIFE_INSURANCE_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Life Insurance");

		internal static readonly string RUBBER_BOOTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Rubber Boots");

		internal static readonly string OXYGEN_CANISTERS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Oxygen Canisters");

		internal static readonly string SLEIGHT_OF_HAND_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Sleight of Hand");

		internal static readonly string HIKING_BOOTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Hiking Boots");

		internal static readonly string TRACTION_BOOTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Traction Boots");

		internal static readonly string FEDORA_SUIT_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Fedora Suit");

		internal static readonly string WEED_GENETIC_MANIPULATION_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Weed Genetic Manipulation");

		internal static readonly string CLAY_GLASSES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Clay Glasses");

		internal static readonly string MECHANICAL_ARMS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Mechanical Arms");

		internal static readonly string SCAVENGER_INSTINCTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Scavenger Instincts");

		internal static readonly string LANDING_THRUSTERS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Landing Thrusters");

		internal static readonly string REINFORCED_BOOTS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Reinforced Boots");

		internal static readonly string DEEPER_POCKETS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Deeper Pockets");

		internal static readonly string ALUMINIUM_COILS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Aluminium Coils");

		internal static readonly string BACK_MUSCLES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Back Muscles");

		internal static readonly string BARGAIN_CONNECTIONS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Bargain Connections");

		internal static readonly string BEEKEEPER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Beekeeper");

		internal static readonly string BETTER_SCANNER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Better Scanner");

		internal static readonly string CHARGING_BOOSTER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Charging Booster");

		internal static readonly string DISCOMBOBULATOR_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Discombobulator");

		internal static readonly string EFFICIENT_ENGINES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Efficient Engines");

		internal static readonly string HUNTER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Hunter");

		internal static readonly string LITHIUM_BATTERIES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Lithium Batteries");

		internal static readonly string MARKET_INFLUENCE_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Market Influence");

		internal static readonly string NIGHT_VISION_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "NV Headset Batteries");

		internal static readonly string PROTEIN_POWDER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Protein Powder");

		internal static readonly string BIGGER_LUNGS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Bigger Lungs");

		internal static readonly string CLIMBING_GLOVES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Climbing Gloves");

		internal static readonly string SHUTTER_BATTERIES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Shutter Batteries");

		internal static readonly string QUANTUM_DISRUPTOR_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Quantum Disruptor");

		internal static readonly string RUNNING_SHOES_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Running Shoes");

		internal static readonly string STIMPACK_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Stimpack");

		internal static readonly string STRONG_LEGS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Strong Legs");

		internal static readonly string FAST_ENCRYPTION_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Fast Encryption");

		internal static readonly string DROP_POD_THRUSTERS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Drop Pod Thrusters");

		internal static readonly string LETHAL_DEALS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Lethal Deals");

		internal static readonly string LIGHTNING_ROD_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Lightning Rod");

		internal static readonly string LOCKSMITH_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Locksmith");

		internal static readonly string MALWARE_BROADCASTER_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Malware Broadcaster");

		internal static readonly string SICK_BEATS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Sick Beats");

		internal static readonly string SIGURD_ACCESS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Sigurd Access");

		internal static readonly string WALKIE_GPS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Walkie GPS");

		internal const string CONTRACTS_SECTION = "Contracts";

		internal const string ENABLE_CONTRACTS_KEY = "Enable the ability to purchase contracts / missions";

		internal const bool ENABLE_CONTRACTS_DEFAULT = true;

		internal const string CONTRACT_PROVIDE_RANDOM_ONLY_KEY = "Random Contract on Keyword";

		internal const bool CONTRACT_PROVIDE_RANDOM_ONLY_DEFAULT = false;

		internal const string CONTRACT_PROVIDE_RANDOM_ONLY_DESCRIPTION = "When enabled, typing contract will automatically assign you a random contract when possible. (Essentialy old behaviour)";

		internal const string CONTRACT_FREE_MOONS_ONLY_KEY = "Random contracts on free moons only";

		internal const bool CONTRACT_FREE_MOONS_ONLY_DEFAULT = true;

		internal const string CONTRACT_FREE_MOONS_ONLY_DESCRIPTION = "If true, \"contract\" command will only generate contracts on free moons.";

		internal const string CONTRACT_PRICE_KEY = "Price of a random contract";

		internal const int CONTRACT_PRICE_DEFAULT = 500;

		internal const string CONTRACT_SPECIFY_PRICE_KEY = "Price of a specified moon contract";

		internal const int CONTRACT_SPECIFY_PRICE_DEFAULT = 750;

		internal const string CONTRACT_BUG_REWARD_KEY = "Value of an exterminator contract reward";

		internal const int CONTRACT_BUG_REWARD_DEFAULT = 500;

		internal const string CONTRACT_EXORCISM_REWARD_KEY = "Value of an exorcism contract reward";

		internal const int CONTRACT_EXORCISM_REWARD_DEFAULT = 500;

		internal const string CONTRACT_DEFUSAL_REWARD_KEY = "Value of an defusal contract reward";

		internal const int CONTRACT_DEFUSAL_REWARD_DEFAULT = 500;

		internal const string CONTRACT_EXTRACTION_REWARD_KEY = "Value of an extraction contract reward";

		internal const int CONTRACT_EXTRACTION_REWARD_DEFAULT = 500;

		internal const string CONTRACT_DATA_REWARD_KEY = "Value of a data contract reward";

		internal const int CONTRACT_DATA_REWARD_DEFAULT = 500;

		internal const string EXTERMINATION_BUG_SPAWNS_KEY = "Hoarder Bug Spawn Number";

		internal const int EXTERMINATION_BUG_SPAWNS_DEFAULT = 20;

		internal const string EXTERMINATION_BUG_SPAWNS_DESCRIPTION = "How many bugs to spawn during exterminator contracts.";

		internal const string EXORCISM_GHOST_SPAWN_KEY = "Dress Girl / Thumper Spawn Number";

		internal const int EXORCISM_GHOST_SPAWN_DEFAULT = 3;

		internal const string EXORCISM_GHOST_SPAWN_DESCRIPTION = "How many ghosts/thumpers to spawn when failing exorcism contracts";

		internal const string EXTRACTION_SCAVENGER_WEIGHT_KEY = "Weight of an extraction human";

		internal const float EXTRACTION_SCAVENGER_WEIGHT_DEFAULT = 2.5f;

		internal const string EXTRACTION_SCAVENGER_WEIGHT_DESCRIPTION = "Subtract 1 and multiply by 100 (2.5 = 150lbs).";

		internal const string EXTRACTION_SCAVENGER_SOUND_VOLUME_KEY = "Volume of the scavenger voice clips";

		internal const float EXTRACTION_SCAVENGER_SOUND_VOLUME_DEFAULT = 0.25f;

		internal const string EXTRACTION_SCAVENGER_SOUND_VOLUME_DESCRIPTION = "0.0 - 1.0";

		internal const string CONTRACT_FAR_FROM_MAIN_KEY = "Spawn main object far away";

		internal const bool CONTRACT_FAR_FROM_MAIN_DEFAULT = true;

		internal const string CONTRACT_FAR_FROM_MAIN_DESCRIPTION = "If true the main object for contracts will try spawn as far away from the main entrance as possible. If false it will spawn at a random location.";

		internal const string EXTRACTION_MEDKIT_AMOUNT_KEY = "Amount of medkits that can spawn in the Extraction contract";

		internal const int EXTRACTION_MEDKIT_AMOUNT_DEFAULT = 3;

		internal const string CONTRACT_DATA_ENABLED_KEY = "Enable the data contract";

		internal const bool CONTRACT_DATA_ENABLED_DEFAULT = true;

		internal const string CONTRACT_DATA_ENABLED_DESCRIPTION = "Make this false if you don't want the data contract";

		internal const string CONTRACT_EXTRACTION_ENABLED_KEY = "Enable the extraction contract";

		internal const bool CONTRACT_EXTRACTION_ENABLED_DEFAULT = true;

		internal const string CONTRACT_EXTRACTION_ENABLED_DESCRIPTION = "Make this false if you don't want the extraction contract";

		internal const string CONTRACT_EXORCISM_ENABLED_KEY = "Enable the exorcism contract";

		internal const bool CONTRACT_EXORCISM_ENABLED_DEFAULT = true;

		internal const string CONTRACT_EXORCISM_ENABLED_DESCRIPTION = "Make this false if you don't want the exorcism contract";

		internal const string CONTRACT_DEFUSAL_ENABLED_KEY = "Enable the defusal contract";

		internal const bool CONTRACT_DEFUSAL_ENABLED_DEFAULT = true;

		internal const string CONTRACT_DEFUSAL_ENABLED_DESCRIPTION = "Make this false if you don't want the defusal contract";

		internal const string CONTRACT_EXTERMINATION_ENABLED_KEY = "Enable the exterminator contract";

		internal const bool CONTRACT_EXTERMINATION_ENABLED_DEFAULT = true;

		internal const string CONTRACT_EXTERMINATION_ENABLED_DESCRIPTION = "Make this false if you don't want the exterminator contract";

		internal const string CONTRACT_QUOTA_MULTIPLIER_KEY = "Multiplier applied to the contract loot items dependant on the current applied quota";

		internal const int CONTRACT_QUOTA_MULTIPLIER_DEFAULT = 25;

		internal const string CONTRACT_QUOTA_MULTIPLIER_DESCRIPTION = "0 = None of the quota value will influence the loot's value.\n100 = The quota value will be added fully to the loot's value.";

		internal const string INTERNS_ENABLED_KEY = "Enable hiring of interns";

		internal const bool INTERNS_ENABLED_DEFAULT = true;

		internal const string INTERNS_ENABLED_DESCRIPTION = "Pay x amount of credits to revive a player.";

		internal const string INTERNS_PRICE_KEY = "Interns Price";

		internal const int INTERNS_PRICE_DEFAULT = 1000;

		internal const string INTERNS_PRICE_DESCRIPTION = "Default price to hire an intern.";

		internal const string ITEM_SCAN_NODE_KEY_FORMAT = "Enable scan node of {0}";

		internal const bool ITEM_SCAN_NODE_DEFAULT = true;

		internal const string ITEM_SCAN_NODE_DESCRIPTION = "Shows a scan node on the item when scanning";

		internal const string MEDKIT_ENABLED_KEY = "Enable the Medkit item";

		internal const bool MEDKIT_ENABLED_DEFAULT = true;

		internal const string MEDKIT_ENABLED_DESCRIPTION = "Allows you to buy a Medkit to heal yourself.";

		internal const string MEDKIT_PRICE_KEY = "Medkit price";

		internal const int MEDKIT_PRICE_DEFAULT = 300;

		internal const string MEDKIT_PRICE_DESCRIPTION = "Default price for Medkit.";

		internal const string MEDKIT_HEAL_AMOUNT_KEY = "Heal Amount";

		internal const int MEDKIT_HEAL_AMOUNT_DEFAULT = 20;

		internal const string MEDKIT_HEAL_AMOUNT_DESCRIPTION = "The amount the Medkit heals you.";

		internal const string MEDKIT_USES_KEY = "Uses";

		internal const int MEDKIT_USES_DEFAULT = 3;

		internal const string MEDKIT_USES_DESCRIPTION = "The amount of times the Medkit can heal you.";

		internal static readonly string MEDKIT_SCAN_NODE_KEY = string.Format("Enable scan node of {0}", "Medkit");

		internal const string ENABLED_FORMAT = "Enable {0} Upgrade";

		internal const string PRICE_FORMAT = "Price of {0} Upgrade";

		internal const string SMARTER_LOCKPICK_ENABLED_DESCRIPTION = "Tier upgrade that increases the efficiency of the lockpicker item, making it faster at opening doors.";

		internal const string SMARTER_LOCKPICK_INITIAL_INCREASE_KEY = "Initial Efficiency Increase";

		internal const int SMARTER_LOCKPICK_INITIAL_INCREASE_DEFAULT = 100;

		internal const string SMARTER_LOCKPICK_INITIAL_INCREASE_DESCRIPTION = "Initial increase (%) of efficiency of the lockpicker item in opening doors, decreasing the required time to be lockpicked";

		internal const string SMARTER_LOCKPICK_INCREMENTAL_INCREASE_KEY = "Incremental Efficiency Increase";

		internal const int SMARTER_LOCKPICK_INCREMENTAL_INCREASE_DEFAULT = 100;

		internal const string SMARTER_LOCKPICK_INCREMENTAL_INCREASE_DESCRIPTION = "Incremental increase (%) of efficiency of the lockpicker item in opening doors, decreasing the required time to be lockpicked";

		internal const string EFFECTIVE_BANDAIDS_ENABLED_KEY = "Enable Effective Bandaids Upgrade";

		internal const bool EFFECTIVE_BANDAIDS_ENABLED_DEFAULT = true;

		internal const string EFFECTIVE_BANDAIDS_ENABLED_DESCRIPTION = "Tier upgrade which increases the amount of health you regain when regenerating.";

		internal const string EFFECTIVE_BANDAIDS_PRICE_KEY = "Price of Effective Bandaids Upgrade";

		internal const int EFFECTIVE_BANDAIDS_PRICE_DEFAULT = 250;

		internal const string EFFECTIVE_BANDAIDS_INITIAL_HEALTH_REGEN_AMOUNT_INCREASE_KEY = "Initial Health Regeneration Amount Increase";

		internal const int EFFECTIVE_BANDAIDS_INITIAL_HEALTH_REGEN_AMOUNT_INCREASE_DEFAULT = 1;

		internal const string EFFECTIVE_BANDAIDS_INITIAL_HEALTH_REGEN_AMOUNT_INCREASE_DESCRIPTION = "Initial health amount increase during health regeneration when first purchasing the upgrade.";

		internal const string EFFECTIVE_BANDAIDS_INCREMENTAL_HEALTH_REGEN_AMOUNT_INCREASE_KEY = "Incremental Health Regeneration Amount Increase";

		internal const int EFFECTIVE_BANDAIDS_INCREMENTAL_HEALTH_REGEN_AMOUNT_INCREASE_DEFAULT = 1;

		internal const string EFFECTIVE_BANDAIDS_INCREMENTAL_HEALTH_REGEN_AMOUNT_INCREASE_DESCRIPTION = "Incremental health amount increase during health regeneration when purchasing further levels of the upgrade";

		internal const string MEDICAL_NANOBOTS_ENABLED_KEY = "Enable Medical Nanobots Upgrade";

		internal const bool MEDICAL_NANOBOTS_ENABLED_DEFAULT = true;

		internal const string MEDICAL_NANOBOTS_ENABLED_DESCRIPTION = "Tier upgrade which increases the health regeneration cap amount.";

		internal const string MEDICAL_NANOBOTS_PRICE_KEY = "Price of Medical Nanobots Upgrade";

		internal const int MEDICAL_NANOBOTS_PRICE_DEFAULT = 300;

		internal const string MEDICAL_NANOBOTS_INITIAL_HEALTH_REGEN_CAP_INCREASE_KEY = "Initial Health Regeneration Cap Increase";

		internal const int MEDICAL_NANOBOTS_INITIAL_HEALTH_REGEN_CAP_INCREASE_DEFAULT = 50;

		internal const string MEDICAL_NANOBOTS_INITIAL_HEALTH_REGEN_CAP_INCREASE_DESCRIPTION = "Initial percentage increase of the health regeneration cap when first purchasing the upgrade.";

		internal const string MEDICAL_NANOBOTS_INCREMENTAL_HEALTH_REGEN_CAP_INCREASE_KEY = "Incremental Health Regeneration Cap Increase";

		internal const int MEDICAL_NANOBOTS_INCREMENTAL_HEALTH_REGEN_CAP_INCREASE_DEFAULT = 50;

		internal const string MEDICAL_NANOBOTS_INCREMENTAL_HEALTH_REGEN_CAP_INCREASE_DESCRIPTION = "Incremental percentage increase of the health regeneration cap when purchasing further levels of the upgrade";

		internal const string SCRAP_KEEPER_ENABLED_KEY = "Enable Scrap Keeper Upgrade";

		internal const bool SCRAP_KEEPER_ENABLED_DEFAULT = true;

		internal const string SCRAP_KEEPER_ENABLED_DESCRIPTION = "Tier upgrade which adds a chance of keeping the scrap item incase of full team wipe.";

		internal const string SCRAP_KEEPER_PRICE_KEY = "Price of Scrap Keeper Upgrade";

		internal const int SCRAP_KEEPER_PRICE_DEFAULT = 1000;

		internal const string SCRAP_KEEPER_INITIAL_KEEP_SCRAP_CHANCE_INCREASE_KEY = "Initial Keep Scrap Chance Increase";

		internal const int SCRAP_KEEPER_INITIAL_KEEP_SCRAP_CHANCE_INCREASE_DEFAULT = 25;

		internal const string SCRAP_KEEPER_INITIAL_KEEP_SCRAP_CHANCE_INCREASE_DESCRIPTION = "Initial percentage chance increase of keeping the scrap item when first purchasing the upgrade";

		internal const string SCRAP_KEEPER_INCREMENTAL_KEEP_SCRAP_CHANCE_INCREASE_KEY = "Incremental Keep Scrap Chance Increase";

		internal const int SCRAP_KEEPER_INCREMENTAL_KEEP_SCRAP_CHANCE_INCREASE_DEFAULT = 25;

		internal const string SCRAP_KEEPER_INCREMENTAL_KEEP_SCRAP_CHANCE_INCREASE_DESCRIPTION = "Incremental percentage chance increase of keeping the scrap item when purchasing further levels of the upgrade";

		internal const string PARTICLE_INFUSER_ENABLED_KEY = "Enable Particle Infuser Upgrade";

		internal const bool PARTICLE_INFUSER_ENABLED_DEFAULT = true;

		internal const string PARTICLE_INFUSER_ENABLED_DESCRIPTION = "Tier upgrade which increases the speed of the teleporter during teleportation phase.";

		internal const string PARTICLE_INFUSER_PRICE_KEY = "Price of Particle Infuser Upgrade";

		internal const int PARTICLE_INFUSER_PRICE_DEFAULT = 650;

		internal const string PARTICLE_INFUSER_INITIAL_TELEPORT_SPEED_INCREASE_KEY = "Initial Teleport Speed Increase";

		internal const int PARTICLE_INFUSER_INITIAL_TELEPORT_SPEED_INCREASE_DEFAULT = 20;

		internal const string PARTICLE_INFUSER_INITIAL_TELEPORT_SPEED_INCREASE_DESCRIPTION = "Initial speed percentage increase of the teleporters when first purchasing the upgrade";

		internal const string PARTICLE_INFUSER_INCREMENTAL_TELEPORT_SPEED_INCREASE_KEY = "Incremental Teleport Speed Increase";

		internal const int PARTICLE_INFUSER_INCREMENTAL_TELEPORT_SPEED_INCREASE_DEFAULT = 10;

		internal const string PARTICLE_INFUSER_INCREMENTAL_TELEPORT_SPEED_INCREASE_DESCRIPTION = "Incremental speed percentage increase of the teleporters when purchasing further levels of the upgrade";

		internal const string SILVER_BULLETS_ENABLED_KEY = "Enable Silver Bullets Upgrade";

		internal const bool SILVER_BULLETS_ENABLED_DEFAULT = true;

		internal const string SILVER_BULLETS_ENABLED_DESCRIPTION = "One time upgrade which allows you to eliminate ghost girl entities with the shotgun.";

		internal const string SILVER_BULLETS_PRICE_KEY = "Price of Silver Bullets Upgrade";

		internal const int SILVER_BULLETS_PRICE_DEFAULT = 500;

		internal const string FUSION_MATTER_ENABLED_KEY = "Enable Fusion Matter Upgrade";

		internal const bool FUSION_MATTER_ENABLED_DEFAULT = true;

		internal const string FUSION_MATTER_ENABLED_DESCRIPTION = "Tier upgrade which allows you to teleport with specified items during teleportation (both in and out)";

		internal const string FUSION_MATTER_PRICE_KEY = "Price of Fusion Matter Upgrade";

		internal const int FUSION_MATTER_PRICE_DEFAULT = 500;

		internal const string FUSION_MATTER_TIERS_KEY = "Fusion Matter Tiers";

		internal static readonly string FUSION_MATTER_TIERS_DEFAULT = $"key{','} flashlight{','} walkie-talkie{'@'}" + $"shovel{','} pro-flashlight{'@'}" + $"belt bag{','} radar-booster";

		internal static readonly string FUSION_MATTER_TIERS_DESCRIPTION = "List of items that will be kept in the player's inventory once reached a certain level of the upgrade. You can include names shown in their scan nodes or the names shown in the Company store.\n" + $"'{','}' is used to separate items in a tier.\n" + $"'{'@'}' is used to separate tiers of the upgrade";

		internal const char FUSION_MATTER_TIER_DELIMITER = '@';

		internal const char FUSION_MATTER_ITEM_DELIMITER = ',';

		internal const string LONG_BARREL_ENABLED_KEY = "Enable Long Barrel Upgrade";

		internal const bool LONG_BARREL_ENABLED_DEFAULT = true;

		internal const string LONG_BARREL_ENABLED_DESCRIPTION = "Tier upgrade which increases the overall range of the shotgun and its effective damage ranges.";

		internal const string LONG_BARREL_PRICE_KEY = "Price of Long Barrel Upgrade";

		internal const int LONG_BARREL_PRICE_DEFAULT = 500;

		internal const string LONG_BARREL_INITIAL_SHOTGUN_RANGE_INCREASE_KEY = "Initial Shotgun Range Increase";

		internal const int LONG_BARREL_INITIAL_SHOTGUN_RANGE_INCREASE_DEFAULT = 10;

		internal const string LONG_BARREL_INITIAL_SHOTGUN_RANGE_INCREASE_DESCRIPTION = "Initial range percentage increase of the shotgun when first purchasing the upgrade";

		internal const string LONG_BARREL_INCREMENTAL_SHOTGUN_RANGE_INCREASE_KEY = "Incremental Shotgun Range Increase";

		internal const int LONG_BARREL_INCREMENTAL_SHOTGUN_RANGE_INCREASE_DEFAULT = 10;

		internal const string LONG_BARREL_INCREMENTAL_SHOTGUN_RANGE_INCREASE_DESCRIPTION = "Incremental range percentage increase of the shotgun when purchasing further levels of the upgrade";

		internal const string HOLLOW_POINT_ENABLED_KEY = "Enable Hollow Point Upgrade";

		internal const bool HOLLOW_POINT_ENABLED_DEFAULT = true;

		internal const string HOLLOW_POINT_ENABLED_DESCRIPTION = "Tier upgrade which increases the amount of damage done by the shotgun.";

		internal const string HOLLOW_POINT_PRICE_KEY = "Price of Hollow Point Upgrade";

		internal const int HOLLOW_POINT_PRICE_DEFAULT = 750;

		internal const string HOLLOW_POINT_INITIAL_SHOTGUN_DAMAGE_INCREASE_KEY = "Initial Shotgun Damage Increase";

		internal const int HOLLOW_POINT_INITIAL_SHOTGUN_DAMAGE_INCREASE_DEFAULT = 1;

		internal const string HOLLOW_POINT_INITIAL_SHOTGUN_DAMAGE_INCREASE_DESCRIPTION = "Initial damage increase of the shotgun when first purchasing the upgrade";

		internal const string HOLLOW_POINT_INCREMENTAL_SHOTGUN_DAMAGE_INCREASE_KEY = "Incremental Shotgun Damage Increase";

		internal const int HOLLOW_POINT_INCREMENTAL_SHOTGUN_DAMAGE_INCREASE_DEFAULT = 1;

		internal const string HOLLOW_POINT_INCREMENTAL_SHOTGUN_DAMAGE_INCREASE_DESCRIPTION = "Incremental damage increase of the shotgun when purchasing further levels of the upgrade";

		internal const string JETPACK_THRUSTERS_ENABLED_KEY = "Enable Jetpack Thrusters Upgrade";

		internal const bool JETPACK_THRUSTERS_ENABLED_DEFAULT = true;

		internal const string JETPACK_THRUSTERS_ENABLED_DESCRIPTION = "Tier upgrade which increases the maximum speed of the jetpack during flight.";

		internal const string JETPACK_THRUSTERS_PRICE_KEY = "Price of Jetpack Thrusters Upgrade";

		internal const int JETPACK_THRUSTERS_PRICE_DEFAULT = 300;

		internal const string JETPACK_THRUSTERS_INITIAL_MAXIMUM_POWER_INCREASE_KEY = "Initial Maximum Speed Increase";

		internal const int JETPACK_THRUSTERS_INITIAL_MAXIMUM_POWER_INCREASE_DEFAULT = 20;

		internal const string JETPACK_THRUSTERS_INITIAL_MAXIMUM_POWER_INCREASE_DESCRIPTION = "Initial percentage increase of jetpack's maximum speed during flight when first purchasing the upgrade";

		internal const string JETPACK_THRUSTERS_INCREMENTAL_MAXIMUM_POWER_INCREASE_KEY = "Incremental Maximum Speed Increase";

		internal const int JETPACK_THRUSTERS_INCREMENTAL_MAXIMUM_POWER_INCREASE_DEFAULT = 20;

		internal const string JETPACK_THRUSTERS_INCREMENTAL_MAXIMUM_POWER_INCREASE_DESCRIPTION = "Incremental percentage increase of jetpack's maximum speed during flight when purchasing further levels of the upgrade";

		internal const string JET_FUEL_ENABLED_KEY = "Enable Jet Fuel Upgrade";

		internal const bool JET_FUEL_ENABLED_DEFAULT = true;

		internal const string JET_FUEL_ENABLED_DESCRIPTION = "Tier upgrade which increases the acceleration of the jetpack during flight.";

		internal const string JET_FUEL_PRICE_KEY = "Price of Jet Fuel Upgrade";

		internal const int JET_FUEL_PRICE_DEFAULT = 400;

		internal const string JET_FUEL_INITIAL_ACCELERATION_INCREASE_KEY = "Initial Acceleration Increase";

		internal const int JET_FUEL_INITIAL_ACCELERATION_INCREASE_DEFAULT = 20;

		internal const string JET_FUEL_INITIAL_ACCELERATION_INCREASE_DESCRIPTION = "Initial percentage increase of jetpack acceleration when first purchasing the upgrade";

		internal const string JET_FUEL_INCREMENTAL_ACCELERATION_INCREASE_KEY = "Incremental Acceleration Increase";

		internal const int JET_FUEL_INCREMENTAL_ACCELERATION_INCREASE_DEFAULT = 20;

		internal const string JET_FUEL_INCREMENTAL_ACCELERATION_INCREASE_DESCRIPTION = "Incremental percentage increase of jetpack acceleration when purchasing further levels of the upgrade";

		internal const string QUICK_HANDS_ENABLED_KEY = "Enable Quick Hands Upgrade";

		internal const bool QUICK_HANDS_ENABLED_DEFAULT = true;

		internal const string QUICK_HANDS_ENABLED_DESCRIPTION = "Tier upgrade which increases the interaction speed of the player.";

		internal const string QUICK_HANDS_PRICE_KEY = "Price of Quick Hands Upgrade";

		internal const int QUICK_HANDS_PRICE_DEFAULT = 100;

		internal const string QUICK_HANDS_INITIAL_INTERACTION_SPEED_INCREASE_KEY = "Initial Interaction Speed Increase";

		internal const int QUICK_HANDS_INITIAL_INTERACTION_SPEED_INCREASE_DEFAULT = 20;

		internal const string QUICK_HANDS_INITIAL_INTERACTION_SPEED_INCREASE_DESCRIPTION = "Initial percentage increase of interaction speed when first purchasing the upgrade";

		internal const string QUICK_HANDS_INCREMENTAL_INTERACTION_SPEED_INCREASE_KEY = "Incremental Interaction Speed Increase";

		internal const int QUICK_HANDS_INCREMENTAL_INTERACTION_SPEED_INCREASE_DEFAULT = 20;

		internal const string QUICK_HANDS_INCREMENTAL_INTERACTION_SPEED_INCREASE_DESCRIPTION = "Incremental percentage increase of interaction speed when purchasing further levels of the upgrade";

		internal const string MIDAS_TOUCH_ENABLED_KEY = "Enable Midas Touch Upgrade";

		internal const bool MIDAS_TOUCH_ENABLED_DEFAULT = true;

		internal const string MIDAS_TOUCH_ENABLED_DESCRIPTION = "Tier upgrade which increases the value of the scrap found in the moons.";

		internal const string MIDAS_TOUCH_PRICE_KEY = "Price of Midas Touch Upgrade";

		internal const int MIDAS_TOUCH_PRICE_DEFAULT = 1000;

		internal const string MIDAS_TOUCH_INITIAL_SCRAP_VALUE_INCREASE_KEY = "Initial Scrap Value Increase";

		internal const int MIDAS_TOUCH_INITIAL_SCRAP_VALUE_INCREASE_DEFAULT = 20;

		internal const string MIDAS_TOUCH_INITIAL_SCRAP_VALUE_INCREASE_DESCRIPTION = "Initial percentage increase of value of the scrap found in the moons when first purchasing the upgrade";

		internal const string MIDAS_TOUCH_INCREMENTAL_SCRAP_VALUE_INCREASE_KEY = "Incremental Scrap Value Increase";

		internal const int MIDAS_TOUCH_INCREMENTAL_SCRAP_VALUE_INCREASE_DEFAULT = 20;

		internal const string MIDAS_TOUCH_INCREMENTAL_SCRAP_VALUE_INCREASE_DESCRIPTION = "Incremental percentage increase of value of the scrap found in the moons when purchasing further levels of the upgrade";

		internal const string CARBON_KNEEJOINTS_ENABLED_KEY = "Enable Carbon Kneejoints Upgrade";

		internal const bool CARBON_KNEEJOINTS_ENABLED_DEFAULT = true;

		internal const string CARBON_KNEEJOINTS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the movement speed loss due to crouching.";

		internal const string CARBON_KNEEJOINTS_PRICE_KEY = "Price of Carbon Kneejoints Upgrade";

		internal const int CARBON_KNEEJOINTS_PRICE_DEFAULT = 100;

		internal const string CARBON_KNEEJOINTS_INITIAL_CROUCH_DEBUFF_DECREASE_KEY = "Initial Crouch Movement Speed Debuff Decrease";

		internal const int CARBON_KNEEJOINTS_INITIAL_CROUCH_DEBUFF_DECREASE_DEFAULT = 20;

		internal const string CARBON_KNEEJOINTS_INITIAL_CROUCH_DEBUFF_DECREASE_DESCRIPTION = "Initial percentage decrease of the movement speed loss while crouching when first purchasing the upgrade";

		internal const string CARBON_KNEEJOINTS_INCREMENTAL_CROUCH_DEBUFF_DECREASE_KEY = "Incremental Crouch Movement Speed Debuff Decrease";

		internal const int CARBON_KNEEJOINTS_INCREMENTAL_CROUCH_DEBUFF_DECREASE_DEFAULT = 20;

		internal const string CARBON_KNEEJOINTS_INCREMENTAL_CROUCH_DEBUFF_DECREASE_DESCRIPTION = "Incremental percentage decrease of the movement speed loss while crouching when purchasing further levels of the upgrade";

		internal const string LIFE_INSURANCE_ENABLED_KEY = "Enable Life Insurance Upgrade";

		internal const bool LIFE_INSURANCE_ENABLED_DEFAULT = true;

		internal const string LIFE_INSURANCE_ENABLED_DESCRIPTION = "Tier upgrade which reduces the credit loss from leaving a body behind when exiting a moon.";

		internal const string LIFE_INSURANCE_PRICE_KEY = "Price of Life Insurance Upgrade";

		internal const int LIFE_INSURANCE_PRICE_DEFAULT = 200;

		internal const string LIFE_INSURANCE_INITIAL_COST_PERCENTAGE_DECREASE_KEY = "Initial Credit Loss Decrease";

		internal const int LIFE_INSURANCE_INITIAL_COST_PERCENTAGE_DECREASE_DEFAULT = 20;

		internal const string LIFE_INSURANCE_INITIAL_COST_PERCENTAGE_DECREASE_DESCRIPTION = "Initial percentage decrease of the credit loss when first purchasing the upgrade";

		internal const string LIFE_INSURANCE_INCREMENTAL_COST_PERCENTAGE_DECREASE_KEY = "Incremental Credit Loss Decrease";

		internal const int LIFE_INSURANCE_INCREMENTAL_COST_PERCENTAGE_DECREASE_DEFAULT = 20;

		internal const string LIFE_INSURANCE_INCREMENTAL_COST_PERCENTAGE_DECREASE_DESCRIPTION = "Incremental percentage decrease of the credit loss when purchasing further levels of the upgrade";

		internal const string RUBBER_BOOTS_ENABLED_KEY = "Enable Rubber Boots Upgrade";

		internal const bool RUBBER_BOOTS_ENABLED_DEFAULT = true;

		internal const string RUBBER_BOOTS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the movement hinderance when walking on water surfaces.";

		internal const string RUBBER_BOOTS_PRICE_KEY = "Price of Rubber Boots Upgrade";

		internal const int RUBBER_BOOTS_PRICE_DEFAULT = 50;

		internal const string RUBBER_BOOTS_INITIAL_MOVEMENT_HINDERANCE_DECREASE_KEY = "Initial Movement Hinderance Decrease";

		internal const int RUBBER_BOOTS_INITIAL_MOVEMENT_HINDERANCE_DECREASE_DEFAULT = 20;

		internal const string RUBBER_BOOTS_INITIAL_MOVEMENT_HINDERANCE_DECREASE_DESCRIPTION = "Initial percentage decrease of movement hinderance on water surfaces when first purchasing the upgrade";

		internal const string RUBBER_BOOTS_INCREMENTAL_MOVEMENT_HINDERANCE_DECREASE_KEY = "Incremental Movement Hinderance Decrease";

		internal const int RUBBER_BOOTS_INCREMENTAL_MOVEMENT_HINDERANCE_DECREASE_DEFAULT = 20;

		internal const string RUBBER_BOOTS_INCREMENTAL_MOVEMENT_HINDERANCE_DECREASE_DESCRIPTION = "Incremental percentage decrease of movement hinderance on water surfaces when purchasing further levels of the upgrade";

		internal const string OXYGEN_CANISTERS_ENABLED_KEY = "Enable Oxygen Canisters Upgrade";

		internal const bool OXYGEN_CANISTERS_ENABLED_DEFAULT = true;

		internal const string OXYGEN_CANISTERS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the consumption rate of oxygen while underwater.";

		internal const string OXYGEN_CANISTERS_PRICE_KEY = "Price of Oxygen Canisters Upgrade";

		internal const int OXYGEN_CANISTERS_PRICE_DEFAULT = 100;

		internal const string OXYGEN_CANISTERS_INITIAL_OXYGEN_CONSUMPTION_DECREASE_KEY = "Initial Oxygen Consumption Decrease";

		internal const int OXYGEN_CANISTERS_INITIAL_OXYGEN_CONSUMPTION_DECREASE_DEFAULT = 20;

		internal const string OXYGEN_CANISTERS_INITIAL_OXYGEN_CONSUMPTION_DECREASE_DESCRIPTION = "Initial percentage of oxygen consumption decrease when first purchasing the upgrade";

		internal const string OXYGEN_CANISTERS_INCREMENTAL_OXYGEN_CONSUMPTION_DECREASE_KEY = "Incremental Oxygen Consumption Decrease";

		internal const int OXYGEN_CANISTERS_INCREMENTAL_OXYGEN_CONSUMPTION_DECREASE_DEFAULT = 20;

		internal const string OXYGEN_CANISTERS_INCREMENTAL_OXYGEN_CONSUMPTION_DECREASE_DESCRIPTION = "Incremental percentage of oxygen consumption decrease when purchasing further levels of the upgrade";

		internal const string SLEIGHT_OF_HAND_ENABLED_KEY = "Enable Sleight of Hand Upgrade";

		internal const bool SLEIGHT_OF_HAND_ENABLED_DEFAULT = true;

		internal const string SLEIGHT_OF_HAND_ENABLED_DESCRIPTION = "Tier upgrade which reduces the reload time of the shotgun.";

		internal const string SLEIGHT_OF_HAND_PRICE_KEY = "Price of Sleight of Hand Upgrade";

		internal const int SLEIGHT_OF_HAND_PRICE_DEFAULT = 100;

		internal const string SLEIGHT_OF_HAND_INITIAL_INCREASE_KEY = "Initial Reload Speed Increase";

		internal const int SLEIGHT_OF_HAND_INITIAL_INCREASE_DEFAULT = 25;

		internal const string SLEIGHT_OF_HAND_INITIAL_INCREASE_DESCRIPTION = "Initial percentage of the reload speed increase when first purchasing the upgrade";

		internal const string SLEIGHT_OF_HAND_INCREMENTAL_INCREASE_KEY = "Incremental Reload Speed Increase";

		internal const int SLEIGHT_OF_HAND_INCREMENTAL_INCREASE_DEFAULT = 25;

		internal const string SLEIGHT_OF_HAND_INCREMENTAL_INCREASE_DESCRIPTION = "Incremental percentage of the reload speed increase when purchasing further levels of the upgrade";

		internal const string HIKING_BOOTS_ENABLED_KEY = "Enable Hiking Boots Upgrade";

		internal const bool HIKING_BOOTS_ENABLED_DEFAULT = true;

		internal const string HIKING_BOOTS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the impact of going through uphill slopes";

		internal const string HIKING_BOOTS_PRICE_KEY = "Price of Hiking Boots Upgrade";

		internal const int HIKING_BOOTS_PRICE_DEFAULT = 75;

		internal const string HIKING_BOOTS_INITIAL_DECREASE_KEY = "Initial Uphill Slope Debuff Decrease";

		internal const int HIKING_BOOTS_INITIAL_DECREASE_DEFAULT = 25;

		internal const string HIKING_BOOTS_INITIAL_DECREASE_DESCRIPTION = "Initial percentage of the uphill slope debuff removed when first purchasing the upgrade";

		internal const string HIKING_BOOTS_INCREMENTAL_DECREASE_KEY = "Incremental Uphill Slope Debuff Decrease";

		internal const int HIKING_BOOTS_INCREMENTAL_DECREASE_DEFAULT = 25;

		internal const string HIKING_BOOTS_INCREMENTAL_DECREASE_DESCRIPTION = "Incremental percetange of the uphill slope debuff removed when purchasing further levels of the upgrade";

		internal const string TRACTION_BOOTS_ENABLED_KEY = "Enable Traction Boots Upgrade";

		internal const bool TRACTION_BOOTS_ENABLED_DEFAULT = true;

		internal const string TRACTION_BOOTS_ENABLED_DESCRIPTION = "Tier upgrade which increases the traction factor on the player's movement";

		internal const string TRACTION_BOOTS_PRICE_KEY = "Price of Traction Boots Upgrade";

		internal const int TRACTION_BOOTS_PRICE_DEFAULT = 100;

		internal const string TRACTION_BOOTS_INITIAL_INCREASE_KEY = "Initial Traction Increase";

		internal const int TRACTION_BOOTS_INITIAL_INCREASE_DEFAULT = 25;

		internal const string TRACTION_BOOTS_INITIAL_INCREASE_DESCRIPTION = "Multiplier value (%) applied to the player's walking force when first purchasing the upgrade.";

		internal const string TRACTION_BOOTS_INCREMENTAL_INCREASE_KEY = "Incremental Traction Increase";

		internal const int TRACTION_BOOTS_INCREMENTAL_INCREASE_DEFAULT = 25;

		internal const string TRACTION_BOOTS_INCREMENTAL_INCREASE_DESCRIPTION = "Multiplier value (%) added to the initial which then gets applied to the player's walking force when first purchasing the upgrade.";

		internal const string FEDORA_SUIT_ENABLED_KEY = "Enable Fedora Suit Upgrade";

		internal const bool FEDORA_SUIT_ENABLED_DEFAULT = true;

		internal const string FEDORA_SUIT_ENABLED_DESCRIPTION = "One Time upgrade which makes Butler enemies not be angry at you when alone. (It will still be angry when you hit them)";

		internal const string FEDORA_SUIT_PRICE_KEY = "Price of Fedora Suit Upgrade";

		internal const int FEDORA_SUIT_PRICE_DEFAULT = 750;

		internal const string WEED_GENETIC_MANIPULATION_ENABLED_KEY = "Enable Weed Genetic Manipulation Upgrade";

		internal const bool WEED_GENETIC_MANIPULATION_ENABLED_DEFAULT = true;

		internal const string WEED_GENETIC_MANIPULATION_ENABLED_DESCRIPTION = "Tier upgrade which increases the effectiveness of the Weed Killer on eradicating plants";

		internal const string WEED_GENETIC_MANIPULATION_PRICE_KEY = "Price of Weed Genetic Manipulation Upgrade";

		internal const int WEED_GENETIC_MANIPULATION_PRICE_DEFAULT = 100;

		internal const string WEED_GENETIC_INITIAL_EFFECTIVENESS_INCREASE_KEY = "Initial Effectiveness Increase";

		internal const int WEED_GENETIC_INITIAL_EFFECTIVENESS_INCREASE_DEFAULT = 75;

		internal const string WEED_GENETIC_INITIAL_EFFECTIVENESS_INCREASE_DESCRIPTION = "Amount of effectiveness (%) when first purchasing the upgrade increased on the Weed Killer to eradicate plants";

		internal const string WEED_GENETIC_INCREMENTAL_EFFECTIVENESS_INCREASE_KEY = "Incremental Effectiveness Increase";

		internal const int WEED_GENETIC_INCREMENTAL_EFFECTIVENESS_INCREASE_DEFAULT = 50;

		internal const string WEED_GENETIC_INCREMENTAL_EFFECTIVENESS_INCREASE_DESCRIPTION = "Amount of effectiveness (%) when purchasing further levels of the upgrade increased on the Weed Killer to eradicate plants";

		internal const string CLAY_GLASSES_ENABLED_KEY = "Enable Clay Glasses Upgrade";

		internal const bool CLAY_GLASSES_ENABLED_DEFAULT = true;

		internal const string CLAY_GLASSES_ENABLED_DESCRIPTION = "Tier upgrade which increases the distance to start seeing the Clay Surgeon Entity.";

		internal const string CLAY_GLASSES_PRICE_KEY = "Price of Clay Glasses Upgrade";

		internal const int CLAY_GLASSES_PRICE_DEFAULT = 200;

		internal const string CLAY_GLASSES_DISTANCE_INITIAL_INCREASE_KEY = "Initial Distance Increase";

		internal const float CLAY_GLASSES_DISTANCE_INITIAL_INCREASE_DEFAULT = 10f;

		internal const string CLAY_GLASSES_DISTANCE_INITIAL_INCREASE_DESCRIPTION = "Distance increased when first purchasing the upgrade to be able to spot the Clay Surgeon";

		internal const string CLAY_GLASSES_DISTANCE_INCREMENTAL_INCREASE_KEY = "Incremental Distance Increase";

		internal const float CLAY_GLASSES_DISTANCE_INCREMENTAL_INCREASE_DEFAULT = 5f;

		internal const string CLAY_GLASSES_DISTANCE_INCREMENTAL_INCREASE_DESCRIPTION = "Distance increased when purchasing further levels of the upgrade to be able to spot the Clay Surgeon";

		internal const string HUNTER_ENABLED_KEY = "Enable Hunter Upgrade";

		internal const bool HUNTER_ENABLED_DEFAULT = true;

		internal const string HUNTER_ENABLED_DESCRIPTION = "Collect and sell samples from dead enemies";

		internal const string HUNTER_PRICE_KEY = "Price of Hunter Upgrade";

		internal const int HUNTER_PRICE_DEFAULT = 700;

		internal const string HUNTER_SAMPLE_TIERS_KEY = "Samples dropping at each tier";

		internal const string HUNTER_SAMPLE_TIERS_DEFAULT = "Hoarding Bug, Centipede, Spore Lizard-Bunker Spider, Baboon hawk, Tulip Snake, Kidnapper Fox, Giant Kiwi-Flowerman, MouthDog, Crawler, Manticoil, Maneater-Forest Giant";

		internal const string HUNTER_SAMPLE_TIERS_DESCRIPTION = "Specifies at which tier of Hunter do each sample start dropping from. Each tier is separated with a dash ('-') and each list of monsters will be separated with a comma (',')\nSupported Enemies: Hoarding Bug, Centipede (Snare Flea),Bunker Spider, Baboon Hawk, Crawler (Half/Thumper), Flowerman (Bracken), MouthDog (Eyeless Dog), Forest Giant, Tulip Snake, Manticoil, Kidnapper Fox, Spore Lizard and Giant Kiwi (Giant Sapsucker/Woodpecker).";

		internal const string MINIMUM_SAMPLE_VALUE_FORMAT = "Minimum scrap value of a {0} sample";

		internal const string MAXIMUM_SAMPLE_VALUE_FORMAT = "Maximum scrap value of a {0} sample";

		internal static readonly string SNARE_FLEA_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Snare Flea");

		internal const int SNARE_FLEA_SAMPLE_MINIMUM_VALUE_DEFAULT = 35;

		internal static readonly string SNARE_FLEA_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Snare Flea");

		internal const int SNARE_FLEA_SAMPLE_MAXIMUM_VALUE_DEFAULT = 60;

		internal static readonly string BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Bunker Spider");

		internal const int BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE_DEFAULT = 65;

		internal static readonly string BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Bunker Spider");

		internal const int BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE_DEFAULT = 95;

		internal static readonly string HOARDING_BUG_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Hoarding Bug");

		internal const int HOARDING_BUG_SAMPLE_MINIMUM_VALUE_DEFAULT = 45;

		internal static readonly string HOARDING_BUG_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Hoarding Bug");

		internal const int HOARDING_BUG_SAMPLE_MAXIMUM_VALUE_DEFAULT = 75;

		internal static readonly string BRACKEN_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Bracken");

		internal const int BRACKEN_SAMPLE_MINIMUM_VALUE_DEFAULT = 80;

		internal static readonly string BRACKEN_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Bracken");

		internal const int BRACKEN_SAMPLE_MAXIMUM_VALUE_DEFAULT = 125;

		internal static readonly string EYELESS_DOG_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Eyeless Dog");

		internal const int EYELESS_DOG_SAMPLE_MINIMUM_VALUE_DEFAULT = 100;

		internal static readonly string EYELESS_DOG_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Eyeless Dog");

		internal const int EYELESS_DOG_SAMPLE_MAXIMUM_VALUE_DEFAULT = 150;

		internal static readonly string BABOON_HAWK_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Baboon Hawk");

		internal const int BABOON_HAWK_SAMPLE_MINIMUM_VALUE_DEFAULT = 75;

		internal static readonly string BABOON_HAWK_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Baboon Hawk");

		internal const int BABOON_HAWK_SAMPLE_MAXIMUM_VALUE_DEFAULT = 115;

		internal static readonly string THUMPER_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Half");

		internal const int THUMPER_SAMPLE_MINIMUM_VALUE_DEFAULT = 80;

		internal static readonly string THUMPER_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Half");

		internal const int THUMPER_SAMPLE_MAXIMUM_VALUE_DEFAULT = 125;

		internal static readonly string FOREST_KEEPER_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Forest Keeper");

		internal const int FOREST_KEEPER_SAMPLE_MINIMUM_VALUE_DEFAULT = 80;

		internal static readonly string FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Forest Keeper");

		internal const int FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE_DEFAULT = 125;

		internal static readonly string MANTICOIL_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Manticoil");

		internal const int MANTICOIL_SAMPLE_MINIMUM_VALUE_DEFAULT = 40;

		internal static readonly string MANTICOIL_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Manticoil");

		internal const int MANTICOIL_SAMPLE_MAXIMUM_VALUE_DEFAULT = 75;

		internal static readonly string TULIP_SNAKE_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Tulip Snake");

		internal const int TULIP_SNAKE_SAMPLE_MINIMUM_VALUE_DEFAULT = 30;

		internal static readonly string TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Tulip Snake");

		internal const int TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE_DEFAULT = 50;

		internal static readonly string KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Kidnapper Fox");

		internal const int KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE_DEFAULT = 60;

		internal static readonly string KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Kidnapper Fox");

		internal const int KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE_DEFAULT = 80;

		internal static readonly string SPORE_LIZARD_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Spore Lizard");

		internal const int SPORE_LIZARD_SAMPLE_MINIMUM_VALUE_DEFAULT = 30;

		internal static readonly string SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Spore Lizard");

		internal const int SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE_DEFAULT = 50;

		internal static readonly string MANEATER_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Maneater");

		internal const int MANEATER_SAMPLE_MINIMUM_VALUE_DEFAULT = 80;

		internal static readonly string MANEATER_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Maneater");

		internal const int MANEATER_SAMPLE_MAXIMUM_VALUE_DEFAULT = 120;

		internal static readonly string GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE_KEY = string.Format("Minimum scrap value of a {0} sample", "Giant Sapsucker");

		internal const int GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE_DEFAULT = 110;

		internal static readonly string GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE_KEY = string.Format("Maximum scrap value of a {0} sample", "Giant Sapsucker");

		internal const int GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE_DEFAULT = 160;

		internal const string NIGHT_VISION_ENABLED_KEY = "Enable Night Vision Upgrade";

		internal const bool NIGHT_VISION_ENABLED_DEFAULT = true;

		internal const string NIGHT_VISION_ENABLED_DESCRIPTION = "Toggleable night vision.";

		internal const string NIGHT_VISION_PRICE_KEY = "Price of Night Vision Upgrade";

		internal const int NIGHT_VISION_PRICE_DEFAULT = 380;

		internal const string NIGHT_VISION_BATTERY_MAX_KEY = "The max charge for your Night Vision battery";

		internal const float NIGHT_VISION_BATTERY_MAX_DEFAULT = 10f;

		internal const string NIGHT_VISION_BATTERY_MAX_DESCRIPTION = "Default settings this will be the unupgraded time in seconds the battery will drain and regen in. Increase to increase battery life.";

		internal const string NIGHT_VISION_DRAIN_SPEED_KEY = "Multiplier for night vis battery drain";

		internal const float NIGHT_VISION_DRAIN_SPEED_DEFAULT = 1f;

		internal const string NIGHT_VISION_DRAIN_SPEED_DESCRIPTION = "Multiplied by timedelta, lower to increase battery life.";

		internal const string NIGHT_VISION_REGEN_SPEED_KEY = "Multiplier for night vis battery regen";

		internal const float NIGHT_VISION_REGEN_SPEED_DEFAULT = 1f;

		internal const string NIGHT_VISION_REGEN_SPEED_DESCRIPTION = "Multiplied by timedelta, raise to speed up battery regen time.";

		internal const string NIGHT_VISION_COLOR_KEY = "Night Vision Color";

		internal const string NIGHT_VISION_COLOR_DEFAULT = "#00FF00FF";

		internal const string NIGHT_VISION_COLOR_DESCRIPTION = "The color your Night Vision light emits.";

		internal const string NIGHT_VISION_UI_TEXT_COLOR_KEY = "Night Vision UI Text Color";

		internal const string NIGHT_VISION_UI_TEXT_COLOR_DEFAULT = "#FFFFFFFF";

		internal const string NIGHT_VISION_UI_TEXT_COLOR_DESCRIPTION = "The color used for the Night Vision's UI text.";

		internal const string NIGHT_VISION_UI_BAR_COLOR_KEY = "Night Vision UI Bar Color";

		internal const string NIGHT_VISION_UI_BAR_COLOR_DEFAULT = "#00FF00FF";

		internal const string NIGHT_VISION_UI_BAR_COLOR_DESCRIPTION = "The color used for the Night Vision's UI battery bar.";

		internal const string NIGHT_VISION_RANGE_KEY = "Night Vision Range";

		internal const float NIGHT_VISION_RANGE_DEFAULT = 2000f;

		internal const string NIGHT_VISION_RANGE_DESCRIPTION = "Kind of like the distance your Night Vision travels.";

		internal const string NIGHT_VISION_RANGE_INCREMENT_KEY = "Night Vision Range Increment";

		internal const float NIGHT_VISION_RANGE_INCREMENT_DEFAULT = 0f;

		internal const string NIGHT_VISION_RANGE_INCREMENT_DESCRIPTION = "Increases your range by this value each upgrade.";

		internal const string NIGHT_VISION_INTENSITY_KEY = "Night Vision Intensity";

		internal const float NIGHT_VISION_INTENSITY_DEFAULT = 1000f;

		internal const string NIGHT_VISION_INTENSITY_DESCRIPTION = "Kind of like the brightness of your Night Vision.";

		internal const string NIGHT_VISION_INTENSITY_INCREMENT_KEY = "Night Vision Intensity Increment";

		internal const float NIGHT_VISION_INTENSITY_INCREMENT_DEFAULT = 0f;

		internal const string NIGHT_VISION_INTENSITY_INCREMENT_DESCRIPTION = "Increases your intensity by this value each upgrade.";

		internal const string NIGHT_VISION_STARTUP_KEY = "Night Vision StartUp Cost";

		internal const float NIGHT_VISION_STARTUP_DEFAULT = 0.1f;

		internal const string NIGHT_VISION_STARTUP_DESCRIPTION = "The percent battery drained when turned on (0.1 = 10%).";

		internal const string NIGHT_VISION_EXHAUST_KEY = "Night Vision Exhaustion";

		internal const float NIGHT_VISION_EXHAUST_DEFAULT = 2f;

		internal const string NIGHT_VISION_EXHAUST_DESCRIPTION = "How many seconds Night Vision stays fully depleted.";

		internal const string NIGHT_VISION_DRAIN_INCREMENT_KEY = "Decrease for Night Vision battery drain";

		internal const float NIGHT_VISION_DRAIN_INCREMENT_DEFAULT = 0.15f;

		internal const string NIGHT_VISION_DRAIN_INCREMENT_DESCRIPTION = "Applied to drain speed on each upgrade.";

		internal const string NIGHT_VISION_REGEN_INCREMENT_KEY = "Increase for Night Vision battery regen";

		internal const float NIGHT_VISION_REGEN_INCREMENT_DEFAULT = 0.4f;

		internal const string NIGHT_VISION_REGEN_INCREMENT_DESCRIPTION = "Applied to regen speed on each upgrade.";

		internal const string NIGHT_VISION_BATTERY_INCREMENT_KEY = "Increase for Night Vision battery life";

		internal const float NIGHT_VISION_BATTERY_INCREMENT_DEFAULT = 2f;

		internal const string NIGHT_VISION_BATTERY_INCREMENT_DESCRIPTION = "Applied to the max charge for Night Vision battery on each upgrade.";

		internal const string LOSE_NIGHT_VISION_ON_DEATH_KEY = "Lose Night Vision On Death";

		internal const bool LOSE_NIGHT_VISION_ON_DEATH_DEFAULT = true;

		internal const string LOSE_NIGHT_VISION_ON_DEATH_DESCRIPTION = "If true when you die the Night Vision will disable and will need a new pair of goggles.";

		internal const string NIGHT_VISION_DROP_ON_DEATH_KEY = "Drop Night Vision Goggles on Death";

		internal const bool NIGHT_VISION_DROP_ON_DEATH_DEFAULT = true;

		internal const string NIGHT_VISION_DROP_ON_DEATH_DESCRIPTION = "If true, when you die and lose Night Vision upon death, you will drop the Night Vision Goggles on your body.";

		internal const string MECHANICAL_ARMS_ENABLED_KEY = "Enable Mechanical Arms Upgrade";

		internal const bool MECHANICAL_ARMS_ENABLED_DEFAULT = true;

		internal const string MECHANICAL_ARMS_ENABLED_DESCRIPTION = "Tier upgrade which increases the range of interacting with objects (both grabbing and interacting such as open or close a door)";

		internal const string MECHANICAL_ARMS_PRICE_KEY = "Price of Mechanical Arms Upgrade";

		internal const int MECHANICAL_ARMS_PRICE_DEFAULT = 300;

		internal const string MECHANICAL_ARMS_INITIAL_RANGE_INCREASE_KEY = "Initial range increase";

		internal const float MECHANICAL_ARMS_INITIAL_RANGE_INCREASE_DEFAULT = 1f;

		internal const string MECHANICAL_ARMS_INITIAL_RANGE_INCREASE_DESCRIPTION = "Amount of interaction range increased (in Unity units) when first purchasing the upgrade";

		internal const string MECHANICAL_ARMS_INCREMENTAL_RANGE_INCREASE_KEY = "Incremental range increase";

		internal const float MECHANICAL_ARMS_INCREMENTAL_RANGE_INCREASE_DEFAULT = 1f;

		internal const string MECHANICAL_ARMS_INCREMENTAL_RANGE_INCREASE_DESCRIPTION = "Amount of interaction range increased (in Unity units) on further purchases of the upgrade";

		internal const string SCAVENGER_INSTINCTS_ENABLED_KEY = "Enable Scavenger Instincts Upgrade";

		internal const bool SCAVENGER_INSTINCTS_ENABLED_DEFAULT = true;

		internal const string SCAVENGER_INSTINCTS_ENABLED_DESCRIPTION = "Tier upgrade which increases the amount of scrap that can spawn on a given level.";

		internal const string SCAVENGER_INSTINCTS_PRICE_KEY = "Price of Scavenger Instincts Upgrade";

		internal const int SCAVENGER_INSTINCTS_PRICE_DEFAULT = 800;

		internal const string SCAVENGER_INSTINCTS_INITIAL_AMOUNT_SCRAP_INCREASE_KEY = "Initial amount of scrap spawn increase";

		internal const int SCAVENGER_INSTINCTS_INITIAL_AMOUNT_SCRAP_INCREASE_DEFAULT = 4;

		internal const string SCAVENGER_INSTINCTS_INITIAL_AMOUNT_SCRAP_INCREASE_DESCRIPTION = "The amount of additional scrap that can spawn in a given level when first purchased";

		internal const string SCAVENGER_INSTINCTS_INCREMENTAL_AMOUNT_SCRAP_INCREASE_KEY = "Incremental amount of scrap spawn increase";

		internal const int SCAVENGER_INSTINCTS_INCREMENTAL_AMOUNT_SCRAP_INCREASE_DEFAULT = 2;

		internal const string SCAVENGER_INSTINCTS_INCREMENTAL_AMOUNT_SCRAP_INCREASE_DESCRIPTION = "The amount of additional scrap that can spawn in a given level on further purchases";

		internal const string LANDING_THRUSTERS_ENABLED_KEY = "Enable Landing Thrusters Upgrade";

		internal const bool LANDING_THRUSTERS_ENABLED_DEFAULT = true;

		internal const string LANDING_THRUSTERS_ENABLED_DESCRIPTION = "Tier upgrade which increases the speed of the ship landing and departing between moons";

		internal const string LANDING_THURSTERS_PRICE_KEY = "Price of Landing Thrusters Upgrade";

		internal const int LANDING_THRUSTERS_PRICE_DEFAULT = 300;

		internal const string LANDING_THRUSTERS_INITIAL_SPEED_INCREASE_KEY = "Initial speed increase";

		internal const int LANDING_THRUSTERS_INITIAL_SPEED_INCREASE_DEFAULT = 25;

		internal const string LANDING_THRUSTERS_INITIAL_SPEED_INCREASE_DESCRIPTION = "Initial amount (%) to increment to the ship speed when first purchasing the upgrade";

		internal const string LANDING_THRUSTERS_INCREMENTAL_SPEED_INCREASE_KEY = "Incremental speed increase";

		internal const int LANDING_THRUSTERS_INCREMENTAL_SPEED_INCREASE_DEFAULT = 25;

		internal const string LANDING_THRUSTERS_INCREMENTAL_SPEED_INCREASE_DESCRIPTION = "Incremental amount (%) to increment to the ship speed on further purchases of the upgrade";

		internal const string LANDING_THRUSTERS_AFFECT_LANDING_KEY = "Affect landing sequence speed";

		internal const bool LANDING_THRUSTERS_AFFECT_LANDING_DEFAULT = true;

		internal const string LANDING_THRUSTERS_AFFECT_LANDING_DESCRIPTION = "If true, the effect will be applied on the ship speed when landing on a moon";

		internal const string LANDING_THRUSTERS_AFFECT_DEPARTING_KEY = "Affect departing sequence speed";

		internal const bool LANDING_THRUSTERS_AFFECT_DEPARTING_DEFAULT = true;

		internal const string LANDING_THRUSTERS_AFFECT_DEPARTING_DESCRIPTION = "If true, the effect will be applied on the ship speed when departing from a moon";

		internal const string REINFORCED_BOOTS_ENABLED_KEY = "Enable Reinforced Boots Upgrade";

		internal const bool REINFORCED_BOOTS_ENABLED_DEFAULT = true;

		internal const string REINFORCED_BOOTS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the damage taken when falling from great heights";

		internal const string REINFORCED_BOOTS_PRICE_KEY = "Price of Reinforced Boots Upgrade";

		internal const int REINFORCED_BOOTS_PRICE_DEFAULT = 250;

		internal const string REINFORCED_BOOTS_INITIAL_DAMAGE_REDUCTION_KEY = "Initial damage reduction";

		internal const int REINFORCED_BOOTS_INITIAL_DAMAGE_REDUCTION_DEFAULT = 25;

		internal const string REINFORCED_BOOTS_INITIAL_DAMAGE_REDUCTION_DESCRIPTION = "Percentage of the damage taken from great height falls mitigated when purchased the upgrade for the first time";

		internal const string REINFORCED_BOOTS_INCREMENTAL_DAMAGE_REDUCTION_KEY = "Incremental damage reduction";

		internal const int REINFORCED_BOOTS_INCREMENTAL_DAMAGE_REDUCTION_DEFAULT = 10;

		internal const string REINFORCED_BOOTS_INCREMENTAL_DAMAGE_REDUCTION_DESCRIPTION = "Percentage of the damage taken from great height falls mitigated in further purchases of the upgrade";

		internal const string DEEPER_POCKETS_ENABLED_KEY = "Enable Deeper Pockets Upgrade";

		internal const bool DEEPER_POCKETS_ENABLED_DEFAULT = true;

		internal const string DEEPER_POCKETS_ENABLED_DESCRIPTION = "Tier upgrade which allows the player to carry more than one two handed item in their inventory";

		internal const string DEEPER_POCKETS_PRICE_KEY = "Price of Deeper Pockets Upgrade";

		internal const int DEEPER_POCKETS_PRICE_DEFAULT = 500;

		internal const string DEEPER_POCKETS_INITIAL_TWO_HANDED_AMOUNT_KEY = "Initial carry capacity increase";

		internal const int DEEPER_POCKETS_INITIAL_TWO_HANDED_AMOUNT_DEFAULT = 1;

		internal const string DEEPER_POCKETS_INITIAL_TWO_HANDED_AMOUNT_DESCRIPTION = "The amount of two handed carry capacity increased to the player when first buying the upgrade";

		internal const string DEEPER_POCKETS_INCREMENTAL_TWO_HANDED_AMOUNT_KEY = "Incremental carry capacity increase";

		internal const int DEEPER_POCKETS_INCREMENTAL_TWO_HANDED_AMOUNT_DEFAULT = 1;

		internal const string DEEPER_POCKETS_INCREMENTAL_TWO_HANDED_AMOUNT_DESCRIPTION = "The amount of two handed carry capacity increased to the player when increase the upgrade level";

		internal const string DEEPER_POCKETS_ALLOW_WHEELBARROWS_KEY = "Allow wheelbarrows to be stored in deeper pockets";

		internal const bool DEEPER_POCKETS_ALLOW_WHEELBARROWS_DEFAULT = true;

		internal const string DEEPER_POCKETS_ALLOW_WHEELBARROWS_DESCRIPTION = "Whether or not wheelbarrows and shopping carts can be stored in deeper pockets";

		internal const string ALUMINIUM_COILS_ENABLED_KEY = "Enable Aluminium Coils Upgrade";

		internal const bool ALUMINIUM_COILS_ENABLED_DEFAULT = true;

		internal const string ALUMINIUM_COILS_ENABLED_DESCRIPTION = "Tier upgrade which reduces the zap gun minigame's difficulty, making it easier to manage.";

		internal const string ALUMINIUM_COILS_PRICE_KEY = "Price of Aluminium Coils upgrade";

		internal const int ALUMINIUM_COILS_PRICE_DEFAULT = 750;

		internal const string ALUMINIUM_COILS_INITIAL_DIFFICULTY_MULTIPLIER_KEY = "Initial multiplier applied to the minigame difficulty multiplier (%)";

		internal const int ALUMINIUM_COILS_INITIAL_DIFFICULTY_MULTIPLIER_DEFAULT = 25;

		internal const string ALUMINIUM_COILS_INITIAL_DIFFICULTY_MULTIPLIER_DESCRIPTION = "Past 100%, the zap gun minigame will have no difficulty in following it.";

		internal const string ALUMINIUM_COILS_INCREMENTAL_DIFFICULTY_MULTIPLIER_KEY = "Incremental multiplier applied to the minigame difficulty multiplier (%)";

		internal const int ALUMINIUM_COILS_INCREMENTAL_DIFFICULTY_MULTIPLIER_DEFAULT = 10;

		internal const string ALUMINIUM_COILS_INCREMENTAL_DIFFICULTY_MULTIPLIER_DESCRIPTION = "Past 100%, the zap gun minigame will have no difficulty in following it.";

		internal const string ALUMINIUM_COILS_INITIAL_STUN_TIMER_KEY = "Initial value incremented to the enemy stun timer when using the zap gun";

		internal const float ALUMINIUM_COILS_INITIAL_STUN_TIMER_DEFAULT = 1f;

		internal const string ALUMINIUM_COILS_INCREMENTAL_STUN_TIMER_KEY = "Incremental value incremented to the enemy stun timer when using the zap gun";

		internal const float ALUMINIUM_COILS_INCREMENTAL_STUN_TIMER_DEFAULT = 1f;

		internal const string ALUMINIUM_COILS_INITIAL_RANGE_KEY = "Initial value incremented to the zap guns range to stun an enemy";

		internal const float ALUMINIUM_COILS_INITIAL_RANGE_DEFAULT = 2f;

		internal const string ALUMINIUM_COILS_INCREMENTAL_RANGE_KEY = "Incremental value incremented to the zap guns range to stun an enemy";

		internal const float ALUMINIUM_COILS_INCREMENTAL_RANGE_DEFAULT = 1f;

		internal const string ALUMINIUM_COILS_INITIAL_COOLDOWN_KEY = "Initial multiplier applied to the zap guns cooldown (%)";

		internal const int ALUMINIUM_COILS_INITIAL_COOLDOWN_DEFAULT = 10;

		internal const string ALUMINIUM_COILS_INITIAL_COOLDOWN_DESCRIPTION = "Past 100%, the zap gun will have no cooldown after being used";

		internal const string ALUMINIUM_COILS_INCREMENTAL_COOLDOWN_KEY = "Incremental multiplier applied to the zap guns cooldown";

		internal const int ALUMINIUM_COILS_INCREMENTAL_COOLDOWN_DEFAULT = 10;

		internal const string ALUMINIUM_COILS_INCREMENTAL_COOLDOWN_DESCRIPTION = "Past 100%, the zap gun will have no cooldown after being used";

		internal const string BACK_MUSCLES_ENABLED_KEY = "Enable Back Muscles Upgrade";

		internal const bool BACK_MUSCLES_ENABLED_DEFAULT = true;

		internal const string BACK_MUSCLES_ENABLED_DESCRIPTION = "Reduce carry weight";

		internal const string BACK_MUSCLES_PRICE_KEY = "Price of Back Muscles Upgrade";

		internal const int BACK_MUSCLES_PRICE_DEFAULT = 715;

		internal const string BACK_MUSCLES_INITIAL_WEIGHT_MULTIPLIER_KEY = "Carry Weight Multiplier";

		internal const float BACK_MUSCLES_INITIAL_WEIGHT_MULTIPLIER_DEFAULT = 0.5f;

		internal const string BACK_MUSCLES_INITIAL_WEIGHT_MULTIPLIER_DESCRIPTION = "Your carry weight is multiplied by this.";

		internal const string BACK_MUSCLES_INCREMENTAL_WEIGHT_MULTIPLIER_KEY = "Carry Weight Increment";

		internal const float BACK_MUSCLES_INCREMENTAL_WEIGHT_MULTIPLIER_DEFAULT = 0.1f;

		internal const string BACK_MUSCLES_INCREMENTAL_WEIGHT_MULTIPLIER_DESCRIPTION = "Each upgrade subtracts this from the above coefficient.";

		internal const string BACK_MUSCLES_UPGRADE_MODE_KEY = "Upgrade Mode for Back Muscles";

		internal const BackMuscles.UpgradeMode BACK_MUSCLES_UPGRADE_MODE_DEFAULT = BackMuscles.UpgradeMode.ReduceWeight;

		internal const string BACK_MUSCLES_UPGRADE_MODE_DESCRIPTION = "Applied mode when purchasing the upgrade:\nReduceWeight (Reduces the overall weight of items when grabbed), ReduceCarryInfluence (Reduces the carry weight influence when sprinting), ReduceStrain (Reduces the carry weight influence on stamina consumption when running),";

		internal const string BARGAIN_CONNECTIONS_ENABLED_KEY = "Enable Bargain Connections Upgrade";

		internal const bool BARGAIN_CONNECTIONS_ENABLED_DEFAULT = true;

		internal const string BARGAIN_CONNECTIONS_ENABLED_DESCRIPTION = "Tier upgrade which increases the amount of items that can be on sale in the store";

		internal const string BARGAIN_CONNECTIONS_PRICE_KEY = "Price of Bargain Connections";

		internal const int BARGAIN_CONNECTIONS_PRICE_DEFAULT = 200;

		internal const string BARGAIN_CONNECTIONS_INITIAL_AMOUNT_KEY = "Initial additional amount of items that can go on sale";

		internal const int BARGAIN_CONNECTIONS_INITIAL_AMOUNT_DEFAULT = 3;

		internal const string BARGAIN_CONNECTIONS_INCREMENTAL_AMOUNT_KEY = "Incremental additional amount of items that can go on sale";

		internal const int BARGAIN_CONNECTIONS_INCREMENTAL_AMOUNT_DEFAULT = 2;

		internal const string BEEKEEPER_ENABLED_KEY = "Enable Beekeeper Upgrade";

		internal const bool BEEKEEPER_ENABLED_DEFAULT = true;

		internal const string BEEKEEPER_ENABLED_DESCRIPTION = "Take less damage from bees and hornets";

		internal const string BEEKEEPER_PRICE_KEY = "Price of Beekeeper Upgrade";

		internal const int BEEKEEPER_PRICE_DEFAULT = 450;

		internal const string BEEKEEPER_DAMAGE_MULTIPLIER_KEY = "Multiplied to incoming damage (rounded to int)";

		internal const float BEEKEEPER_DAMAGE_MULTIPLIER_DEFAULT = 0.64f;

		internal const string BEEKEEPER_DAMAGE_MULTIPLIER_DESCRIPTION = "Incoming damage from bees (from hives) is 10 and butler's deal 40 (20 if solo).";

		internal const string BEEKEEPER_DAMAGE_INCREMENTAL_MULTIPLIER_KEY = "Additional % Reduced per level";

		internal const float BEEKEEPER_DAMAGE_INCREMENTAL_MULTIPLIER_DEFAULT = 0.15f;

		internal const string BEEKEEPER_DAMAGE_INCREMENTAL_MULTIPLIER_DESCRIPTION = "Every time Beekeeper is upgraded this value will be subtracted to the base multiplier above.";

		internal const string BEEKEEPER_HIVE_MULTIPLIER_KEY = "Hive value increase multiplier";

		internal const float BEEKEEPER_HIVE_MULTIPLIER_DEFAULT = 1.5f;

		internal const string BEEKEEPER_HIVE_MULTIPLIER_DESCRIPTION = "Multiplier applied to the value of beehive when reached max level";

		internal const string BETTER_SCANNER_ENABLED_KEY = "Enable Better Scanner Upgrade";

		internal const bool BETTER_SCANNER_ENABLED_DEFAULT = true;

		internal const string BETTER_SCANNER_ENABLED_DESCRIPTION = "Further scan distance, no LOS needed.";

		internal const string BETTER_SCANNER_PRICE_KEY = "Price of Better Scanner Upgrade";

		internal const int BETTER_SCANNER_PRICE_DEFAULT = 650;

		internal const string BETTER_SCANNER_OUTSIDE_NODE_DISTANCE_INCREASE_KEY = "Ship and Entrance node distance boost";

		internal const float BETTER_SCANNER_OUTSIDE_NODE_DISTANCE_INCREASE_DEFAULT = 150f;

		internal const string BETTER_SCANNER_OUTSIDE_NODE_DISTANCE_INCREASE_DESCRIPTION = "How much further away you can scan the ship and entrance.";

		internal const string BETTER_SCANNER_NODE_DISTANCE_INCREASE_KEY = "Node distance boost";

		internal const float BETTER_SCANNER_NODE_DISTANCE_INCREASE_DEFAULT = 20f;

		internal const string BETTER_SCANNER_NODE_DISTANCE_INCREASE_DESCRIPTION = "How much further away you can scan other nodes.";

		internal const string BETTER_SCANNER_SECOND_TIER_PRICE_KEY = "Price of second Better Scanner tier";

		internal const int BETTER_SCANNER_SECOND_TIER_PRICE_DEFAULT = 500;

		internal const string BETTER_SCANNER_SECOND_TIER_PRICE_DESCRIPTION = "This tier unlocks ship scan commands.";

		internal const string BETTER_SCANNER_THIRD_TIER_PRICE_KEY = "Price of third Better Scanner tier";

		internal const int BETTER_SCANNER_THIRD_TIER_PRICE_DEFAULT = 800;

		internal const string BETTER_SCANNER_THIRD_TIER_PRICE_DESCRIPTION = "This tier unlocks scanning through walls.";

		internal const string BETTER_SCANNER_ENEMIES_THROUGH_WALLS_KEY = "Scan enemies through walls on final upgrade";

		internal const bool BETTER_SCANNER_ENEMIES_THROUGH_WALLS_DEFAULT = false;

		internal const string BETTER_SCANNER_ENEMIES_THROUGH_WALLS_DESCRIPTION = "If true the final upgrade will scan scrap AND enemies through walls.";

		internal const string BETTER_SCANNER_VERBOSE_ENEMIES_KEY = "Verbose `scan enemies` command";

		internal const bool BETTER_SCANNER_VERBOSE_ENEMIES_DEFAULT = true;

		internal const string BETTER_SCANNER_VERBOSE_ENEMIES_DESCRIPTION = "If false `scan enemies` only returns a count of outside and inside enemies, else it returns the count for each enemy type.";

		internal const string BIGGER_LUNGS_ENABLED_KEY = "Enable Bigger Lungs Upgrade";

		internal const bool BIGGER_LUNGS_ENABLED_DEFAULT = true;

		internal const string BIGGER_LUNGS_ENABLED_DESCRIPTION = "More Stamina";

		internal const string BIGGER_LUNGS_PRICE_KEY = "Price of Bigger Lungs Upgrade";

		internal const int BIGGER_LUNGS_PRICE_DEFAULT = 600;

		internal const string BIGGER_LUNGS_INITIAL_SPRINT_TIME_KEY = "Sprint Time Unlock";

		internal const float BIGGER_LUNGS_INITIAL_SPRINT_TIME_DEFAULT = 6f;

		internal const string BIGGER_LUNGS_INITIAL_SPRINT_TIME_DESCRIPTION = "Amount of sprint time gained when unlocking the upgrade.\nDefault vanilla value is 11f.";

		internal const string BIGGER_LUNGS_INCREMENTAL_SPRINT_TIME_KEY = "Sprint Time Increment";

		internal const float BIGGER_LUNGS_INCREMENTAL_SPRINT_TIME_DEFAULT = 1.25f;

		internal const string BIGGER_LUNGS_INCREMENTAL_SPRINT_TIME_DESCRIPTION = "Amount of sprint time gained when increasing the level of upgrade.";

		internal const string BIGGER_LUNGS_STAMINA_APPLY_LEVEL_KEY = "Level of Bigger Lungs to apply stamina regeneration";

		internal const int BIGGER_LUNGS_STAMINA_APPLY_LEVEL_DEFAULT = 1;

		internal const string BIGGER_LUNGS_STAMINA_APPLY_LEVEL_DESCRIPTION = "When reached provided level, the effect will start applying.";

		internal const string BIGGER_LUNGS_INITIAL_STAMINA_REGEN_KEY = "Stamina Regeneration Increase";

		internal const float BIGGER_LUNGS_INITIAL_STAMINA_REGEN_DEFAULT = 1.05f;

		internal const string BIGGER_LUNGS_INITIAL_STAMINA_REGEN_DESCRIPTION = "Affects the rate of the player regaining stamina";

		internal const string BIGGER_LUNGS_INCREMENTAL_STAMINA_REGEN_KEY = "Incremental stamina regeneration increase";

		internal const float BIGGER_LUNGS_INCREMENTAL_STAMINA_REGEN_DEFAULT = 0.05f;

		internal const string BIGGER_LUNGS_INCREMENTAL_STAMINA_REGEN_DESCRIPTION = "Added to initial multiplier";

		internal const string BIGGER_LUNGS_JUMP_STAMINA_DECREASE_APPLY_LEVEL_KEY = "Level of Bigger Lungs to apply stamina cost decrease on jumps";

		internal const int BIGGER_LUNGS_JUMP_STAMINA_DECREASE_APPLY_LEVEL_DEFAULT = 2;

		internal const string BIGGER_LUNGS_JUMP_STAMINA_DECREASE_APPLY_LEVEL_DESCRIPTION = "When reached provided level, the effect will start applying.";

		internal const string BIGGER_LUNGS_INITIAL_JUMP_STAMINA_DECREASE_KEY = "Stamina cost decrease on jumps";

		internal const float BIGGER_LUNGS_INITIAL_JUMP_STAMINA_DECREASE_DEFAULT = 0.9f;

		internal const string BIGGER_LUNGS_INITIAL_JUMP_STAMINA_DECREASE_DESCRIPTION = "Multiplied with the vanilla cost of jumping";

		internal const string BIGGER_LUNGS_INCREMENTAL_JUMP_STAMINA_DECREASE_KEY = "Incremental stamina cost decrease on jumps";

		internal const float BIGGER_LUNGS_INCREMENTAL_JUMP_STAMINA_DECREASE_DEFAULT = 0.05f;

		internal const string BIGGER_LUNGS_INCREMENTAL_JUMP_STAMINA_DECREASE_DESCRIPTION = "Added to initial multiplier (as in reduce the factor)";

		internal const string CHARGING_BOOSTER_ENABLED_KEY = "Enable Charging Booster Upgrade";

		internal const bool CHARGING_BOOSTER_ENABLED_DEFAULT = true;

		internal const string CHARGING_BOOSTER_ENABLED_DESCRIPTION = "Tier upgrade which allows charging items in a radar booster";

		internal const string CHARGING_BOOSTER_PRICE_KEY = "Price of Charging Booster Upgrade";

		internal const int CHARGING_BOOSTER_PRICE_DEFAULT = 300;

		internal const string CHARGING_BOOSTER_PRICES_DEFAULT = "300,250,300,400";

		internal const string CHARGING_BOOSTER_COOLDOWN_KEY = "Cooldown of the charging station in radar boosters when used";

		internal const float CHARGING_BOOSTER_COOLDOWN_DEFAULT = 90f;

		internal const string CHARGING_BOOSTER_INCREMENTAL_COOLDOWN_DECREASE_KEY = "Incremental cooldown decrease whenever the level of the upgrade is incremented";

		internal const float CHARGING_BOOSTER_INCREMENTAL_COOLDOWN_DECREASE_DEFAULT = 10f;

		internal const string CHARGING_BOOSTER_CHARGE_PERCENTAGE_KEY = "Percentage of charge that is added to the held item when using the radar booster charge station";

		internal const int CHARGING_BOOSTER_CHARGE_PERCENTAGE_DEFAULT = 50;

		internal const string CLIMBING_GLOVES_ENABLED_KEY = "Enable Climbing Gloves Upgrade";

		internal const bool CLIMBING_GLOVES_ENABLED_DEFAULT = true;

		internal const string CLIMBING_GLOVES_ENABLED_DESCRIPTION = "Tier upgrade which increases the speed of climbing ladders";

		internal const string CLIMBING_GLOVES_PRICE_KEY = "Price of Climbing Gloves Upgrade";

		internal const int CLIMBING_GLOVES_PRICE_DEFAULT = 150;

		internal const string CLIMBING_GLOVES_INITIAL_MULTIPLIER_KEY = "Initial value added to the players climbing speed";

		internal const float CLIMBING_GLOVES_INITIAL_MULTIPLIER_DEFAULT = 1f;

		internal const string CLIMBING_GLOVES_INITIAL_MULTIPLIER_DESCRIPTION = "Vanilla climb speed is 4 units";

		internal const string CLIMBING_GLOVES_INCREMENTAL_MULTIPLIER_KEY = "Incremental value added to the players climbing speed";

		internal const float CLIMBING_GLOVES_INCREMENTAL_MULTIPLIER_DEFAULT = 0.5f;

		internal const string DISCOMBOBULATOR_ENABLED_KEY = "Enable Discombobulator Upgrade";

		internal const bool DISCOMBOBULATOR_ENABLED_DEFAULT = true;

		internal const string DISCOMBOBULATOR_ENABLED_DESCRIPTION = "Stun enemies around the ship.";

		internal const string DISCOMBOBULATOR_PRICE_KEY = "Price of Discombobulator Upgrade";

		internal const int DISCOMBOBULATOR_PRICE_DEFAULT = 450;

		internal const string DISCOMBOBULATOR_COOLDOWN_KEY = "Discombobulator Cooldown";

		internal const float DISCOMBOBULATOR_COOLDOWN_DEFAULT = 120f;

		internal const string DISCOMBOBULATOR_EFFECT_RADIUS_KEY = "Discombobulator Effect Radius";

		internal const float DISCOMBOBULATOR_EFFECT_RADIUS_DEFAULT = 40f;

		internal const string DISCOMBOBULATOR_STUN_DURATION_KEY = "Discombobulator Stun Duration";

		internal const float DISCOMBOBULATOR_STUN_DURATION_DEFAULT = 7.5f;

		internal const string DISCOMBOBULATOR_NOTIFY_CHAT_KEY = "Notify Local Chat of Enemy Stun Duration";

		internal const bool DISCOMBOBULATOR_NOTIFY_CHAT_DEFAULT = true;

		internal const string DISCOMBOBULATOR_INCREMENTAL_STUN_TIME_KEY = "Discombobulator Increment";

		internal const float DISCOMBOBULATOR_INCREMENTAL_STUN_TIME_DEFAULT = 1f;

		internal const string DISCOMBOBULATOR_INCREMENTAL_STUN_TIME_DESCRIPTION = "The amount added to stun duration on upgrade.";

		internal const string DISCOMBOBULATOR_APPLY_DAMAGE_LEVEL_KEY = "Initial level of dealing damage";

		internal const int DISCOMBOBULATOR_APPLY_DAMAGE_LEVEL_DEFAULT = 2;

		internal const string DISCOMBOBULATOR_APPLY_DAMAGE_LEVEL_DESCRIPTION = "Level of Discombobulator in which it starts dealing damage on enemies it stuns";

		internal const string DISCOMBOBULATOR_INITIAL_DAMAGE_KEY = "Initial amount of damage";

		internal const int DISCOMBOBULATOR_INITIAL_DAMAGE_DEFAULT = 2;

		internal const string DISCOMBOBULATOR_INITIAL_DAMAGE_DESCRIPTION = "Amount of damage when reaching the first level that unlocks damage on stun\nTo give an idea of what's too much, Eyeless Dogs have 12 health.";

		internal const string DISCOMBOBULATOR_INCREMENTAL_DAMAGE_KEY = "Damage Increase on Purchase";

		internal const int DISCOMBOBULATOR_INCREMENTAL_DAMAGE_DEFAULT = 1;

		internal const string DISCOMBOBULATOR_INCREMENTAL_DAMAGE_DESCRIPTION = "Damage increase when purchasing later levels";

		internal const string DROP_POD_THRUSTERS_ENABLED_KEY = "Enable the Drop Pod Thrusters upgrade";

		internal const bool DROP_POD_THRUSTERS_ENABLED_DEFAULT = true;

		internal const string DROP_POD_THRUSTERS_ENABLED_DESCRIPTION = "Make the Drop Pod, the ship that deliver items bought on the terminal, land faster.";

		internal const string DROP_POD_THRUSTERS_PRICE_KEY = "Drop Pod Thrusters Price";

		internal const int DROP_POD_THRUSTERS_PRICE_DEFAULT = 300;

		internal const string DROP_POD_THRUSTERS_PRICE_DESCRIPTION = "Default price for upgrade. If set to 0 it will enable the Drop Pod Thrusters without buying the upgrade.";

		internal const string DROP_POD_THRUSTERS_TIME_DECREASE_KEY = "Time decrement on the timer used for subsequent item deliveries";

		internal const float DROP_POD_THRUSTERS_TIME_DECREASE_DEFAULT = 20f;

		internal const string DROP_POD_THRUSTERS_FIRST_TIME_DECREASE_KEY = "Time decrement on the timer used for the first ever item delivery";

		internal const float DROP_POD_THRUSTERS_FIRST_TIME_DECREASE_DEFAULT = 10f;

		internal const string DROP_POD_THRUSTERS_LEAVE_TIMER_KEY = "Time for item dropship to exit";

		internal const float DROP_POD_THRUSTERS_LEAVE_TIMER_DEFAULT = 0f;

		internal const string DROP_POD_THRUSTERS_LEAVE_TIMER_DESCRIPTION = "How long (in seconds) the item drop ship stays after being opened";

		internal const string EFFICIENT_ENGINES_ENABLED_KEY = "Enable Efficient Engines Upgrade";

		internal const bool EFFICIENT_ENGINES_ENABLED_DEFAULT = true;

		internal const string EFFICIENT_ENGINES_ENABLED_DESCRIPTION = "Tier upgrade which applies a discount on moon routing prices for cheaper travels";

		internal const string EFFICIENT_ENGINES_PRICE_KEY = "Price of Efficient Engines";

		internal const int EFFICIENT_ENGINES_PRICE_DEFAULT = 450;

		internal const string EFFICIENT_ENGINES_INITIAL_MULTIPLIER_KEY = "Initial discount applied to moon routing (%)";

		internal const int EFFICIENT_ENGINES_INITIAL_MULTIPLIER_DEFAULT = 15;

		internal const string EFFICIENT_ENGINES_INCREMENTAL_MULTIPLIER_KEY = "Incremental discount applied to moon routing (%)";

		internal const int EFFICIENT_ENGINES_INCREMENTAL_MULTIPLIER_DEFAULT = 5;

		internal const string FAST_ENCRYPTION_ENABLED_KEY = "Enable Fast Encryption";

		internal const bool FAST_ENCRYPTION_ENABLED_DEFAULT = true;

		internal const string FAST_ENCRYPTION_ENABLED_DESCRIPTION = "Upgrades the transmitter.";

		internal const string FAST_ENCRYPTION_PRICE_KEY = "Fast Encryption Price";

		internal const int FAST_ENCRYPTION_PRICE_DEFAULT = 300;

		internal const string LETHAL_DEALS_ENABLED_KEY = "Enable Lethal Deals Upgrade";

		internal const bool LETHAL_DEALS_ENABLED_DEFAULT = true;

		internal const string LETHAL_DEALS_ENABLED_DESCRIPTION = "One time upgrade which guarantees at least one item will be on sale in the store.";

		internal const string LETHAL_DEALS_PRICE_KEY = "Price of Lethal Deals";

		internal const int LETHAL_DEALS_PRICE_DEFAULT = 300;

		internal const string LITHIUM_BATTERIES_ENABLED_KEY = "Enable Lithium Batteries Upgrade";

		internal const bool LITHIUM_BATTERIES_ENABLED_DEFAULT = true;

		internal const string LITHIUM_BATTERIES_ENABLED_DESCRIPTION = "Tier upgrade which decreases the rate of battery consumed when using the item";

		internal const string LITHIUM_BATTERIES_PRICE_KEY = "Price of Lithium Batteries upgrade";

		internal const int LITHIUM_BATTERIES_PRICE_DEFAULT = 100;

		internal const string LITHIUM_BATTERIES_INITIAL_MULTIPLIER_KEY = "Initial multiplier applied to the use rate of the battery (%)";

		internal const int LITHIUM_BATTERIES_INITIAL_MULTIPLIER_DEFAULT = 10;

		internal const string LITHIUM_BATTERIES_INITIAL_MULTIPLIER_DESCRIPTION = "Past 100%, it won't consume any battery charge from the item";

		internal const string LITHIUM_BATTERIES_INCREMENTAL_MULTIPLIER_KEY = "Incremental multiplier applied to the use rate of the battery (%)";

		internal const int LITHIUM_BATTERIES_INCREMENTAL_MULTIPLIER_DEFAULT = 10;

		internal const string LITHIUM_BATTERIES_INCREMENTAL_MULTIPLIER_DESCRIPTION = "Past 100%, it won't consume any battery charge from the item";

		internal const string LOCKSMITH_ENABLED_KEY = "Enable Locksmith upgrade";

		internal const bool LOCKSMITH_ENABLED_DEFAULT = true;

		internal const string LOCKSMITH_ENABLED_DESCRIPTION = "Allows you to pick locked doors by completing a minigame.";

		internal const string LOCKSMITH_PRICE_KEY = "Locksmith Price";

		internal const int LOCKSMITH_PRICE_DEFAULT = 640;

		internal const string LOCKSMITH_PRICE_DESCRIPTION = "Default price of Locksmith upgrade.";

		internal const string MALWARE_BROADCASTER_ENABLED_KEY = "Enable Malware Broadcaster Upgrade";

		internal const bool MALWARE_BROADCASTER_ENABLED_DEFAULT = true;

		internal const string MALWARE_BROADCASTER_ENABLED_DESCRIPTION = "Explode Map Hazards";

		internal const string MALWARE_BROADCASTER_PRICE_KEY = "Price of Malware Broadcaster Upgrade";

		internal const int MALWARE_BROADCASTER_PRICE_DEFAULT = 550;

		internal const string MALWARE_BROADCASTER_DESTROY_TRAPS_KEY = "Destroy Trap";

		internal const bool MALWARE_BROADCASTER_DESTROY_TRAPS_DEFAULT = true;

		internal const string MALWARE_BROADCASTER_DESTROY_TRAPS_DESCRIPTION = "If false Malware Broadcaster will disable the trap for a long time instead of destroying.";

		internal const string MALWARE_BROADCASTER_DISARM_TIME_KEY = "Disarm Time";

		internal const float MALWARE_BROADCASTER_DISARM_TIME_DEFAULT = 7f;

		internal const string MALWARE_BROADCASTER_DISARM_TIME_DESCRIPTION = "If `Destroy Trap` is false this is the duration traps will be disabled.";

		internal const string MALWARE_BROADCASTER_EXPLODE_TRAPS_KEY = "Explode Trap";

		internal const bool MALWARE_BROADCASTER_EXPLODE_TRAPS_DEFAULT = true;

		internal const string MALWARE_BROADCASTER_EXPLODE_TRAPS_DESCRIPTION = "Destroy Trap must be true! If this is true when destroying a trap it will also explode.";

		internal const string MARKET_INFLUENCE_ENABLED_KEY = "Enable Market Influence Upgrade";

		internal const bool MARKET_INFLUENCE_ENABLED_DEFAULT = true;

		internal const string MARKET_INFLUENCE_ENABLED_DESCRIPTION = "Tier upgrade which guarantees a minimum percentage sale on the selected item in the store.";

		internal const string MARKET_INFLUENCE_PRICE_KEY = "Price of Market Influence";

		internal const int MARKET_INFLUENCE_PRICE_DEFAULT = 250;

		internal const string MARKET_INFLUENCE_INITIAL_PERCENTAGE_KEY = "Initial percentage guarantee on the items on sale";

		internal const int MARKET_INFLUENCE_INITIAL_PERCENTAGE_DEFAULT = 10;

		internal const string MARKET_INFLUENCE_INCREMENTAL_PERCENTAGE_KEY = "Incremental percentage guarantee on the items on sale";

		internal const int MARKET_INFLUENCE_INCREMENTAL_PERCENTAGE_DEFAULT = 5;

		internal const string RUNNING_SHOES_ENABLED_KEY = "Enable Running Shoes Upgrade";

		internal const bool RUNNING_SHOES_ENABLED_DEFAULT = true;

		internal const string RUNNING_SHOES_ENABLED_DESCRIPTION = "Run Faster";

		internal const string RUNNING_SHOES_PRICE_KEY = "Price of Running Shoes Upgrade";

		internal const int RUNNING_SHOES_PRICE_DEFAULT = 650;

		internal const string RUNNING_SHOES_INITIAL_MOVEMENT_BOOST_KEY = "Movement Speed Unlock";

		internal const float RUNNING_SHOES_INITIAL_MOVEMENT_BOOST_DEFAULT = 1.4f;

		internal const string RUNNING_SHOES_INITIAL_MOVEMENT_BOOST_DESCRIPTION = "Value added to player's movement speed when first purchased.\nDefault vanilla value is 4.6f.";

		internal const string RUNNING_SHOES_INCREMENTAL_MOVEMENT_BOOST_KEY = "Movement Speed Increment";

		internal const float RUNNING_SHOES_INCREMENTAL_MOVEMENT_BOOST_DEFAULT = 0.5f;

		internal const string RUNNING_SHOES_INCREMENTAL_MOVEMENT_BOOST_DESCRIPTION = "How much the above value is increased on upgrade.";

		internal const string RUNNING_SHOES_NOISE_REDUCTION_KEY = "Noise Reduction";

		internal const float RUNNING_SHOES_NOISE_REDUCTION_DEFAULT = 10f;

		internal const string RUNNING_SHOES_NOISE_REDUCTION_DESCRIPTION = "Distance units to subtract from footstep noise when reached final level.";

		internal const string QUANTUM_DISRUPTOR_ENABLED_KEY = "Enable Quantum Disruptor Upgrade";

		internal const bool QUANTUM_DISRUPTOR_ENABLED_DEFAULT = true;

		internal const string QUANTUM_DISRUPTOR_ENABLED_DESCRIPTION = "Tier upgrade which increases the time you can stay in a moon landing";

		internal const string QUANTUM_DISRUPTOR_PRICE_KEY = "Price of Quantum Disruptor Upgrade";

		internal const int QUANTUM_DISRUPTOR_PRICE_DEFAULT = 1000;

		internal const string QUANTUM_DISRUPTOR_INITIAL_MULTIPLIER_KEY = "How slower (in %) time will go by when unlocking the Quantum Disruptor upgrade";

		internal const int QUANTUM_DISRUPTOR_INITIAL_MULTIPLIER_DEFAULT = 20;

		internal const string QUANTUM_DISRUPTOR_INCREMENTAL_MULTIPLIER_KEY = "How slower (in %) time will go by when incrementing the Quantum Disruptor level";

		internal const int QUANTUM_DISRUPTOR_INCREMENTAL_MULTIPLIER_DEFAULT = 10;

		internal const string QUANTUM_DISRUPTOR_UPGRADE_MODE_KEY = "Mode of Quantum Disruptor";

		internal const QuantumDisruptor.UpgradeModes QUANTUM_DISRUPTOR_UPGRADE_MODE_DEFAULT = QuantumDisruptor.UpgradeModes.SlowdownTime;

		internal const string QUANTUM_DISRUPTOR_UPGRADE_MODE_DESCRIPTION = "Applied mode when purchasing the upgrade.\nSupported modes: SlowdownTime (makes the time go slower in moons), RevertTime (command prompt which reverts hours when executed, maximum usages per moon).";

		internal const string QUANTUM_DISRUPTOR_RESET_MODE_KEY = "Reset Time of Quantum Disruptor current usages";

		internal const QuantumDisruptor.ResetModes QUANTUM_DISRUPTOR_RESET_MODE_DEFAULT = QuantumDisruptor.ResetModes.MoonLanding;

		internal const string QUANTUM_DISRUPTOR_RESET_MODE_DESCRIPTION = "Reset mode of when the current counter of usages reset to use the ability. Only applied when RevertTime mode is selected.\nSupported Values: MoonLanding (reset counter per each moon landing), MoonRerouting (reset counter per each moon routing), NewQuota (reset counter per each new quota)";

		internal const string QUANTUM_DISRUPTOR_USES_DESCRIPTION = "Amount of times you can execute the quantum command. Only applied when RevertTime mode is selected";

		internal const string QUANTUM_DISRUPTOR_INITIAL_USES_KEY = "Initial amount of usages of Quantum Disruptor";

		internal const int QUANTUM_DISRUPTOR_INITIAL_USES_DEFAULT = 1;

		internal const string QUANTUM_DISRUPTOR_INITIAL_USES_DESCRIPTION = "Amount of times you can execute the quantum command. Only applied when RevertTime mode is selected";

		internal const string QUANTUM_DISRUPTOR_INCREMENTAL_USES_KEY = "Incremental amount of usages of Quantum Disruptor";

		internal const int QUANTUM_DISRUPTOR_INCREMENTAL_USES_DEFAULT = 1;

		internal const string QUANTUM_DISRUPTOR_INCREMENTAL_USES_DESCRIPTION = "Amount of times you can execute the quantum command. Only applied when RevertTime mode is selected";

		internal const string QUANTUM_DISRUPTOR_HOURS_REVERT_DESCRIPTION = "Amount of hours to revert when executing the quantum command. Only applied when RevertTime mode is selected";

		internal const string QUANTUM_DISRUPTOR_INITIAL_HOURS_ON_REVERT_KEY = "Initial amount of hours reverted from Quantum Disruptor";

		internal const int QUANTUM_DISRUPTOR_INITIAL_HOURS_ON_REVERT_DEFAULT = 1;

		internal const string QUANTUM_DISRUPTOR_INITIAL_HOURS_ON_REVERT_DESCRIPTION = "Amount of hours to revert when executing the quantum command. Only applied when RevertTime mode is selected";

		internal const string QUANTUM_DISRUPTOR_INCREMENTAL_HOURS_ON_REVERT_KEY = "Incremental amount of hours reverted from Quantum Disruptor";

		internal const int QUANTUM_DISRUPTOR_INCREMENTAL_HOURS_ON_REVERT_DEFAULT = 1;

		internal const string QUANTUM_DISRUPTOR_INCREMENTAL_HOURS_ON_REVERT_DESCRIPTION = "Amount of hours to revert when executing the quantum command. Only applied when RevertTime mode is selected";

		internal const string SICK_BEATS_ENABLED_KEY = "Enable Sick Beats Upgrade";

		internal const bool SICK_BEATS_ENABLED_DEFAULT = true;

		internal const string SICK_BEATS_ENABLED_DESCRIPTION = "Get buffs from nearby active boomboxes.";

		internal const string SICK_BEATS_PRICE_KEY = "Default unlock price";

		internal const int SICK_BEATS_PRICE_DEFAULT = 500;

		internal const string SICK_BEATS_SPEED_KEY = "Enable Speed Boost Effect";

		internal const bool SICK_BEATS_SPEED_DEFAULT = true;

		internal const string SICK_BEATS_DAMAGE_KEY = "Enable Damage Boost Effect";

		internal const bool SICK_BEATS_DAMAGE_DEFAULT = true;

		internal const string SICK_BEATS_STAMINA_KEY = "Enable Stamina Boost Effect";

		internal const bool SICK_BEATS_STAMINA_DEFAULT = false;

		internal const string SICK_BEATS_DEFENSE_KEY = "Enable Defense Boost Effect";

		internal const bool SICK_BEATS_DEFENSE_DEFAULT = false;

		internal const string SICK_BEATS_DEFENSE_MULTIPLIER_KEY = "Defense Boost Coefficient";

		internal const float SICK_BEATS_DEFENSE_MULTIPLIER_DEFAULT = 0.5f;

		internal const string SICK_BEATS_DEFENSE_MULTIPLIER_DESCRIPTION = "Multiplied to incoming damage.";

		internal const string SICK_BEATS_STAMINA_MULTIPLIER_KEY = "Stamina Regen Coefficient";

		internal const float SICK_BEATS_STAMINA_MULTIPLIER_DEFAULT = 1.25f;

		internal const string SICK_BEATS_STAMINA_MULTIPLIER_DESCRIPTION = "Multiplied to stamina regen.";

		internal const string SICK_BEATS_APPLY_STAMINA_CONSUMPTION_KEY = "Apply Stamina Buff on stamina consumption situations";

		internal const bool SICK_BEATS_APPLY_STAMINA_CONSUMPTION_DEFAULT = false;

		internal const string SICK_BEATS_APPLY_STAMINA_CONSUMPTION_DESCRIPTION = "If enabled, moments where stamina is consumed overtime will include the stamina buff in mind";

		internal const string SICK_BEATS_ADDITIONAL_DAMAGE_KEY = "Additional Damage Dealt";

		internal const int SICK_BEATS_ADDITIONAL_DAMAGE_DEFAULT = 1;

		internal const string SICK_BEATS_ADDITIONAL_SPEED_KEY = "Speed Boost Addition";

		internal const float SICK_BEATS_ADDITIONAL_SPEED_DEFAULT = 1.5f;

		internal const string SICK_BEATS_EFFECT_RADIUS_KEY = "Effect Radius";

		internal const float SICK_BEATS_EFFECT_RADIUS_DEFAULT = 15f;

		internal const string SICK_BEATS_EFFECT_RADIUS_DESCRIPTION = "Radius in unity units players will be effected by an active boombox.";

		internal const string SICK_BEATS_BOOMBOX_ATTRACT_SOUND_KEY = "Boombox Attract Sound Toggle";

		internal const bool SICK_BEATS_BOOMBOX_ATTRACT_SOUND_DEFAULT = true;

		internal const string SICK_BEATS_BOOMBOX_ATTRACT_SOUND_DESCRIPTION = "After the upgrade has been purchased, wether the boombox attracts nearby enemies to its location or not";

		internal const string SIGURD_ACCESS_ENABLED_KEY = "Enable the Sigurd Access upgrade";

		internal const bool SIGURD_ACCESS_ENABLED_DEFAULT = true;

		internal const string SIGURD_ACCESS_ENABLED_DESCRIPTION = "There's a chance that The Company will pay more for the scrap.";

		internal const string SIGURD_ACCESS_ENABLED_LAST_DAY_KEY = "Enable the Sigurd Access upgrade for the last day";

		internal const bool SIGURD_ACCESS_ENABLED_LAST_DAY_DEFAULT = true;

		internal const string SIGURD_ACCESS_ENABLED_LAST_DAY_DESCRIPTION = "There's a chance that the last day scrap you go over 100% value.";

		internal const string SIGURD_ACCESS_PRICE_KEY = "Sigurd Access Price";

		internal const int SIGURD_ACCESS_PRICE_DEFAULT = 500;

		internal const string SIGURD_ACCESS_PRICE_DESCRIPTION = "Default price for upgrade. If set to 0 it will enable the Sigurd Access without buying the upgrade.";

		internal const string SIGURD_ACCESS_CHANCE_KEY = "Chance for the upgrade to activate";

		internal const float SIGURD_ACCESS_CHANCE_DEFAULT = 20f;

		internal const string SIGURD_ACCESS_CHANCE_LAST_DAY_KEY = "Chance for the upgrade to activate on the last day";

		internal const float SIGURD_ACCESS_CHANCE_LAST_DAY_DEFAULT = 20f;

		internal const string SIGURD_ACCESS_ADDITIONAL_PERCENT_KEY = "How much the percentage will go up";

		internal const float SIGURD_ACCESS_ADDITIONAL_PERCENT_DEFAULT = 20f;

		internal const string SIGURD_ACCESS_ADDITIONAL_PERCENT_LAST_DAY_KEY = "How much the percentage will go up on the last day";

		internal const float SIGURD_ACCESS_ADDITIONAL_PERCENT_LAST_DAY_DEFAULT = 20f;

		internal const string STRONG_LEGS_ENABLED_KEY = "Enable Strong Legs Upgrade";

		internal const bool STRONG_LEGS_ENABLED_DEFAULT = true;

		internal const string STRONG_LEGS_ENABLED_DESCRIPTION = "Jump Higher";

		internal const string STRONG_LEGS_PRICE_KEY = "Price of Strong Legs Upgrade";

		internal const int STRONG_LEGS_PRICE_DEFAULT = 300;

		internal const string STRONG_LEGS_INITIAL_JUMP_FORCE_KEY = "Jump Force Unlock";

		internal const float STRONG_LEGS_INITIAL_JUMP_FORCE_DEFAULT = 3f;

		internal const string STRONG_LEGS_INITIAL_JUMP_FORCE_DESCRIPTION = "Amount of jump force added when unlocking the upgrade.\nDefault vanilla value is 13f.";

		internal const string STRONG_LEGS_INCREMENTAL_JUMP_FORCE_KEY = "Jump Force Increment";

		internal const float STRONG_LEGS_INCREMENTAL_JUMP_FORCE_DEFAULT = 0.75f;

		internal const string STRONG_LEGS_INCREMENTAL_JUMP_FORCE_DESCRIPTION = "How much the above value is increased on upgrade.";

		internal const string WALKIE_GPS_ENABLED_KEY = "Enable the Walkie GPS upgrade";

		internal const bool WALKIE_GPS_ENABLED_DEFAULT = true;

		internal const string WALKIE_GPS_ENABLED_DESCRIPTION = "Holding a walkie talkie displays location.";

		internal const string WALKIE_GPS_PRICE_KEY = "Walkie GPS Price";

		internal const int WALKIE_GPS_PRICE_DEFAULT = 450;

		internal const string WALKIE_GPS_PRICE_DESCRIPTION = "Default price for Walkie GPS upgrade.";

		internal const string BABY_PACIFIER_ENABLED_KEY = "Enable the Baby Pacifier upgrade.";

		internal const bool BABY_PACIFIER_ENABLED_DEFAULT = true;

		internal const string BABY_PACIFIER_ENABLED_DESCRIPTION = "Decreases the growth rate of baby maneater when they are crying";

		internal const string BABY_PACIFIER_INITIAL_PERCENTAGE_KEY = "Initial percentage of Growth Decrease";

		internal const int BABY_PACIFIER_INITIAL_PERCENTAGE_DEFAULT = 15;

		internal const string BABY_PACIFIER_INITIAL_PERCENTAGE_DESCRIPTION = "Initial percentage (%) removed from Maneaters Growth Increment when crying";

		internal const string BABY_PACIFIER_INCREMENTAL_PERCENTAGE_KEY = "Incremental percentage of Growth Decrease";

		internal const int BABY_PACIFIER_INCREMENTAL_PERCENTAGE_DEFAULT = 15;

		internal const string BABY_PACIFIER_INCREMENTAL_PERCENTAGE_DESCRIPTION = "Incremental percentage (%) removed from Maneaters Growth Increment when crying";

		internal const string ITEM_DUPLICATOR_ENABLED_DESCRIPTION = "Possibly duplicates the items purchased from the Company Store without occupying space in the drop pod.";

		internal const string ITEM_DUPLICATOR_INITIAL_PERCENTAGE_KEY = "Initial percentage of duplication chance";

		internal const int ITEM_DUPLICATOR_INITIAL_PERCENTAGE_DEFAULT = 30;

		internal const string ITEM_DUPLICATOR_INITIAL_PERCENTAGE_DESCRIPTION = "Initial percentage (%) of chance that the purchased item will be duplicated from the drop pod.";

		internal const string ITEM_DUPLICATOR_INCREMENTAL_PERCENTAGE_KEY = "Incremental percentage of duplication chance";

		internal const int ITEM_DUPLICATOR_INCREMENTAL_PERCENTAGE_DEFAULT = 15;

		internal const string ITEM_DUPLICATOR_INCREMENTAL_PERCENTAGE_DESCRIPTION = "Incremental percentage (%) of chance that the purchased item will be duplicated from the drop pod.";

		internal const string ALTERNATIVE_CURRENCY_ALIAS = "PC";

		internal const string ALTERNATIVE_CURRENCY_TOPSECTION = "_Alternative Currency_";

		internal const string ALTERNATIVE_CURRENCY_ENABLED_KEY = "Enable Alternative Currency System";

		internal const bool ALTERNATIVE_CURRENCY_ENABLED_DEFAULT = false;

		internal const string ALTERNATIVE_CURRENCY_ENABLED_DESCRIPTION = "Allows purchasing Lategame Upgrades with another currency other than Company Credits";

		internal const string ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_RATIO_KEY = "Credits to Alternative Currency Ratio";

		internal const int ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_RATIO_DEFAULT = 100;

		internal const string ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_RATIO_DESCRIPTION = "How much a single unit of Alternative Currency is worth in Company Credits when purchasing upgrades.";

		internal const string ALTERNATIVE_CURRENCY_QUOTA_TO_CURRENCY_RATIO_KEY = "Quota to Alternative Currency Ratio";

		internal const int ALTERNATIVE_CURRENCY_QUOTA_TO_CURRENCY_RATIO_DEFAULT = 100;

		internal const string ALTERNATIVE_CURRENCY_QUOTA_TO_CURRENCY_RATIO_DESCRIPTION = "How much a single unit of Alternative Currency is worth in Quota Fullfilled";

		internal const string ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_CONVERSION_RATIO_KEY = "Credits to Alternative Currency Conversion Ratio";

		internal const int ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_CONVERSION_RATIO_DEFAULT = 100;

		internal const string ALTERNATIVE_CURRENCY_CREDITS_TO_CURRENCY_CONVERSION_RATIO_DESCRIPTION = "How many Company Credits you require to purchase a single unit of Alternative Currency.";

		internal const string ALTERNATIVE_CURRENCY_CURRENCY_TO_CREDITS_CONVERSION_RATIO_KEY = "Alternative Currency to Credits Conversion Ratio";

		internal const int ALTERNATIVE_CURRENCY_CURRENCY_TO_CREDITS_CONVERSION_RATIO_DEFAULT = 100;

		internal const string ALTERNATIVE_CURRENCY_CURRENCY_TO_CREDITS_CONVERSION_RATIO_DESCRIPTION = "How many Company Credits you obtain when converting a single unit of Alternative Currency.";

		internal static string[] TRADE_PLAYER_CREDITS_COMMAND_PROMPT = new string[3] { "trade", "trade player credits", "lgu trade" };

		internal static string[] CONVERT_PLAYER_CREDITS_COMMAND_PROMPT = new string[2] { "convert", "PC" };

		internal const string COLOR_INITIAL_FORMAT = "<color={0}>";

		internal const string COLOR_FINAL_FORMAT = "</color>";

		internal const string DEFAULT_DEACTIVATED_TEXT_COLOUR = "#66666655";

		internal static string[] LGU_COMMAND_PROMPTS = new string[2] { "lgu", "lategame store" };

		internal const string MAIN_SCREEN_TITLE = "Lategame Upgrades";

		internal const string MAIN_SCREEN_TOP_TEXT = "Select an upgrade to purchase:";

		internal const string MAIN_SCREEN_TOP_TEXT_NO_ENTRIES = "There are no upgrades for purchase.";

		internal const string MAIN_SCREEN_INDIVIDUAL_UPGRADES_TEXT = "Individual Upgrades";

		internal const string MAIN_SCREEN_SHARED_UPGRADES_TEXT = "Shared Upgrades";

		internal const string NOT_ENOUGH_CREDITS = "You do not have enough credits to purchase this upgrade.";

		internal const string REACHED_MAX_LEVEL = "You have reached the maximum level of this upgrade.";

		internal const string LOCKED_UPGRADE = "This upgrade has been assigned to another crew member.";

		internal const string PURCHASE_UPGRADE_FORMAT = "Do you wish to purchase this upgrade for {0} credits?";

		internal const string PURCHASE_UPGRADE_ALTERNATE_FORMAT = "Do you wish to purchase this upgrade for {0} player credits?";

		internal const char CURSOR = '>';

		internal const string SELECTED_CURSOR_ELEMENT_FORMAT = "<mark={0}><color={1}>{2}</color></mark>";

		internal const string DEFAULT_BACKGROUND_SELECTED_COLOR = "#00FF0033";

		internal const string DEFAULT_TEXT_SELECTED_COLOR = "#FFFFFFFF";

		internal const string GO_BACK_PROMPT = "Back";

		internal const string CONFIRM_PROMPT = "Confirm";

		internal const string CANCEL_PROMPT = "Abort";

		internal const int AVAILABLE_CHARACTERS_PER_LINE = 51;

		internal const char TOP_LEFT_CORNER = '╭';

		internal const char TOP_RIGHT_CORNER = '╮';

		internal const char BOTTOM_LEFT_CORNER = '╰';

		internal const char BOTTOM_RIGHT_CORNER = '╯';

		internal const char VERTICAL_LINE = '│';

		internal const char HORIZONTAL_LINE = '─';

		internal const char CONNECTING_TITLE_LEFT = '╢';

		internal const char CONNECTING_TITLE_RIGHT = '╟';

		internal const char TOP_RIGHT_TITLE_CORNER = '╗';

		internal const char TOP_LEFT_TITLE_CORNER = '╔';

		internal const char BOTTOM_RIGHT_TITLE_CORNER = '╝';

		internal const char BOTTOM_LEFT_TITLE_CORNER = '╚';

		internal const char VERTICAL_TITLE_LINE = '║';

		internal const char HORIZONTAL_TITLE_LINE = '═';

		internal const int START_PAGE_COUNTER = 30;

		internal const int NAME_LENGTH = 17;

		internal const int LEVEL_LENGTH = 7;

		internal const char EMPTY_LEVEL = '○';

		internal const char FILLED_LEVEL = '●';

		internal static readonly Color Invisible = new Color(0f, 0f, 0f, 0f);

		internal const string DISCOMBOBULATOR_NOT_ACTIVE = "You don't have access to this command yet. Purchase the 'Discombobulator'.\n\n";

		internal const string DISCOMBOBULATOR_ON_COOLDOWN_FORMAT = "You can discombobulate again in {0} seconds.\nType 'cooldown' or 'cd' to check discombobulation cooldown.\n\n";

		internal const string DISCOMBOBULATOR_NO_ENEMIES = "No stunned enemies detected.\n\n";

		internal const string DISCOMBULATOR_HIT_ENEMIES = "Discombobulator hit {0} enemies.\n\n";

		internal const string DISCOMBOBULATOR_DISPLAY_COOLDOWN = "You can discombobulate again in {0} seconds.\n\n";

		internal const string DISCOMBOBULATOR_READY = "Discombobulate is ready, Type 'initattack' or 'atk' to execute.\n\n";

		internal const string LGU_SAVE_WIPED = "LGU save has been wiped.\n\n";

		internal const string LGU_SAVE_NOT_FOUND = "LGU save was not found!\n\n";

		internal const string FORCE_CREDITS_SUCCESS_FORMAT = "All clients should now have ${0}\n\n";

		internal const string FORCE_CREDITS_HOST_ONLY = "Only the host can do this";

		internal const string FORCE_CREDITS_PARSED_FAIL_FORMAT = "Failed to parse value {0}.\n\n";

		internal const string INTERNS_NOT_ENOUGH_CREDITS_FORMAT = "Interns cost {0} credits and you have {1} credits.\n";

		internal const string INTERNS_PLAYER_ALREADY_ALIVE_FORMAT = "{0} is still alive, they can't be replaced with an intern.\n\n";

		internal const string LOAD_LGU_NO_NAME = "Enter the name of the user whos upgrades/save you want to copy. Ex: `load lgu steve`\n";

		internal const string LOAD_LGU_SUCCESS_FORMAT = "Attempting to overwrite local save data with {0}'s save data\nYou should see a popup in 5 seconds...\n.\n";

		internal const string LOAD_LGU_FAILURE_FORMAT = "The name {0} was not found. The following names were found:\n{1}\n";

		internal const string UNLOAD_LGU_SUCCESS_FORMAT = "Unwinding {0}\n\n";

		internal const string SCANNER_LEVEL_REQUIRED = "Upgrade Better Scanner to level 2 to use this command\nEnter `info better scanner` to check upgrades.\n\n";

		internal const string CONTRACT_CANCEL_FAIL = "You must have accepted a contract to execute this command...\n\n";

		internal const string CONTRACT_CANCEL_CONFIRM_PROMPT = "Type CONFIRM to cancel your current contract. There will be no refunds.\n\n";

		internal const string CONTRACT_FAIL = "Not possible to provide a contract due to configuration having it disabled.\n\n";

		internal const string BRUTEFORCE_USAGE = "Enter a valid address for a device to connect to!\n\n";

		internal const string CONTRACT_CANCEL_CONFIRM_PROMPT_FAIL = "Failed to confirm user's input. Invalidated cancel contract request.\n\n";

		internal const string CONTRACT_CANCEL_CONFIRM_PROMPT_SUCCESS = "Cancelling contract...\n\n";

		internal const string CONTRACT_SPECIFY_CONFIRM_PROMPT_FAIL = "Failed to confirm user's input. Invalidated specified moon contract request.\n\n";

		internal const string CONTRACT_SPECIFY_CONFIRM_PROMPT_SUCCESS_FORMAT = "A {0} contract has been accepted for {1}!{2}";

		internal const string SCRAP_INSURANCE_ALREADY_PURCHASED = "You already purchased insurance to protect your scrap belongings.\n\n";

		internal const string SCRAP_INSURANCE_ONLY_IN_ORBIT = "You can only acquire insurance while in orbit.\n\n";

		internal const string SCRAP_INSURANCE_NOT_ENOUGH_CREDITS_FORMAT = "Not enough credits to purchase Scrap Insurance.\nPrice: {0}\nCurrent credits: {1}\n\n";

		internal const string SCRAP_INSURANCE_SUCCESS = "Scrap Insurance has been activated.\nIn case of a team wipe in your next trip, your scrap will be preserved.\n\n";

		internal const string LOOKUP_NOT_IN_CONTRACT = "YOU MUST BE IN A DEFUSAL CONTRACT TO USE THIS COMMAND!\n\n";

		internal const string LOOKUP_USAGE = "YOU MUST ENTER A SERIAL NUMBER TO LOOK UP!\n\n";

		internal const string LOOKUP_CUT_WIRES_FORMAT = "CUT THE WIRES IN THE FOLLOWING ORDER:\n\n{0}\n\n";

		internal const string UPGRADE_LOADED_NOTIFICATION_DEFAULT_COLOR = "#FF0000";

		internal const string UPGRADE_UNLOADED_NOTIFICATION_DEFAULT_COLOR = "#FF0000";

		internal const string DEFUSAL_CONTRACT_NAME = "Defusal";

		internal const string EXTRACTION_CONTRACT_NAME = "Extraction";

		internal const string DATA_CONTRACT_NAME = "Data";

		internal const string EXTERMINATOR_CONTRACT_NAME = "Exterminator";

		internal const string EXORCISM_CONTRACT_NAME = "Exorcism";

		internal static string[] CONTRACT_COMMAND_PROMPT = new string[2] { "contracts", "contract" };
	}
	public class StringContainer : INetworkSerializable
	{
		public string SomeText;

		public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (serializer.IsWriter)
			{
				FastBufferWriter fastBufferWriter = serializer.GetFastBufferWriter();
				((FastBufferWriter)(ref fastBufferWriter)).WriteValueSafe(SomeText, false);
			}
			else
			{
				FastBufferReader fastBufferReader = serializer.GetFastBufferReader();
				((FastBufferReader)(ref fastBufferReader)).ReadValueSafe(ref SomeText, false);
			}
		}
	}
	internal static class Tools
	{
		private static LguLogger logger = new LguLogger("Tools");

		public static void FindCodeInstructionReverse(ref int index, ref List<CodeInstruction> codes, object findValue, MethodInfo addCode, bool skip = false, bool requireInstance = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, string errorMessage = "Not found")
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			bool flag = false;
			while (index >= 0)
			{
				if (CheckCodeInstruction(codes[index], findValue))
				{
					flag = true;
					if (!skip)
					{
						if (andInstruction)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.And, (object)null));
						}
						if (!andInstruction && orInstruction)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Or, (object)null));
						}
						if (notInstruction)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Not, (object)null));
						}
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, (object)addCode));
						if (requireInstance)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
					}
					break;
				}
				index--;
			}
			if (!flag)
			{
				logger.LogError(errorMessage);
			}
			index--;
		}

		public static void FindCodeInstruction(ref int index, ref List<CodeInstruction> codes, object findValue, MethodInfo addCode, bool skip = false, bool requireInstance = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool instanceBefore = false, string errorMessage = "Not found")
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			bool flag = false;
			while (index < codes.Count)
			{
				if (CheckCodeInstruction(codes[index], findValue))
				{
					flag = true;
					if (skip)
					{
						break;
					}
					if (andInstruction)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.And, (object)null));
					}
					if (!andInstruction && orInstruction)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Or, (object)null));
					}
					if (notInstruction)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Not, (object)null));
					}
					codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, (object)addCode));
					if (requireInstance)
					{
						if (!instanceBefore)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
						else
						{
							codes.Insert(index, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
					}
					break;
				}
				index++;
			}
			if (!flag)
			{
				logger.LogError(errorMessage);
			}
			index++;
		}

		public static void FindLocalFieldReverse(ref int index, ref List<CodeInstruction> codes, int localIndex, object addCode = null, bool skip = false, bool store = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			bool flag = false;
			while (index >= 0)
			{
				if (CheckCodeInstruction(codes[index], localIndex, store))
				{
					flag = true;
					if (!skip)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, addCode));
						if (requireInstance)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
					}
					break;
				}
				index--;
			}
			if (!flag)
			{
				logger.LogError(errorMessage);
			}
			index--;
		}

		public static void FindLocalField(ref int index, ref List<CodeInstruction> codes, int localIndex, object addCode = null, bool skip = false, bool store = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			bool flag = false;
			while (index < codes.Count)
			{
				if (CheckCodeInstruction(codes[index], localIndex, store))
				{
					flag = true;
					if (!skip)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, addCode));
						if (requireInstance)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
					}
					break;
				}
				index++;
			}
			if (!flag)
			{
				logger.LogError(errorMessage);
			}
			index++;
		}

		public static void FindArgumentField(ref int index, ref List<CodeInstruction> codes, int argumentIndex, object addCode = null, bool skip = false, bool store = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			bool flag = false;
			while (index < codes.Count)
			{
				if (CheckCodeInstruction(codes[index], argumentIndex, store, argument: true))
				{
					flag = true;
					if (!skip)
					{
						codes.Insert(index + 1, new CodeInstruction(OpCodes.Call, addCode));
						if (requireInstance)
						{
							codes.Insert(index + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
						}
					}
					break;
				}
				index++;
			}
			if (!flag)
			{
				logger.LogError(errorMessage);
			}
			index++;
		}

		public static void FindString(ref int index, ref List<CodeInstruction> codes, string findValue, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore: false, errorMessage);
		}

		public static void FindFieldReverse(ref int index, ref List<CodeInstruction> codes, FieldInfo findField, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			FindCodeInstructionReverse(ref index, ref codes, findField, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, errorMessage);
		}

		public static void FindField(ref int index, ref List<CodeInstruction> codes, FieldInfo findField, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, bool instanceBefore = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findField, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore, errorMessage);
		}

		public static void FindMethod(ref int index, ref List<CodeInstruction> codes, MethodInfo findMethod, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findMethod, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore: false, errorMessage);
		}

		public static void FindFloat(ref int index, ref List<CodeInstruction> codes, float findValue, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, bool instanceBefore = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore, errorMessage);
		}

		public static void FindIntegerReverse(ref int index, ref List<CodeInstruction> codes, sbyte findValue, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			FindCodeInstructionReverse(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, errorMessage);
		}

		public static void FindInteger(ref int index, ref List<CodeInstruction> codes, sbyte findValue, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, bool instanceBefore = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore, errorMessage);
		}

		public static void FindExplicitInteger(ref int index, ref List<CodeInstruction> codes, int findValue, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction, andInstruction, orInstruction, instanceBefore: false, errorMessage);
		}

		public static void FindSub(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			object findValue = OpCodes.Sub;
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, instanceBefore: false, errorMessage);
		}

		public static void FindDiv(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			object findValue = OpCodes.Div;
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, instanceBefore: false, errorMessage);
		}

		public static void FindAdd(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			object findValue = OpCodes.Add;
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, instanceBefore: false, errorMessage);
		}

		public static void FindMul(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			object findValue = OpCodes.Mul;
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstruction(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, instanceBefore: false, errorMessage);
		}

		public static void FindMulReverse(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, string errorMessage = "Not found")
		{
			object findValue = OpCodes.Mul;
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstructionReverse(ref index, ref codes, findValue, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, errorMessage);
		}

		public static void FindNull(ref int index, ref List<CodeInstruction> codes, MethodInfo addCode = null, bool skip = false, bool notInstruction = false, bool andInstruction = false, bool orInstruction = false, bool requireInstance = false, bool instanceBefore = false, string errorMessage = "Not Found")
		{
			bool notInstruction2 = notInstruction;
			bool andInstruction2 = andInstruction;
			bool orInstruction2 = orInstruction;
			FindCodeInstruction(ref index, ref codes, null, addCode, skip, requireInstance, notInstruction2, andInstruction2, orInstruction2, instanceBefore, errorMessage);
		}

		private static bool CheckCodeInstruction(CodeInstruction code, int index, bool store = false, bool argument = false)
		{
			if (!argument)
			{
				if (!store)
				{
					return index switch
					{
						0 => code.opcode == OpCodes.Ldloc_0, 
						1 => code.opcode == OpCodes.Ldloc_1, 
						2 => code.opcode == OpCodes.Ldloc_2, 
						3 => code.opcode == OpCodes.Ldloc_3, 
						_ => code.opcode == OpCodes.Ldloc && (int)code.operand == index, 
					};
				}
				return index switch
				{
					0 => code.opcode == OpCodes.Stloc_0, 
					1 => code.opcode == OpCodes.Stloc_1, 
					2 => code.opcode == OpCodes.Stloc_2, 
					3 => code.opcode == OpCodes.Stloc_3, 
					_ => code.opcode == OpCodes.Stloc && (int)code.operand == index, 
				};
			}
			if (!store)
			{
				return index switch
				{
					0 => code.opcode == OpCodes.Ldarg_0, 
					1 => code.opcode == OpCodes.Ldarg_1, 
					2 => code.opcode == OpCodes.Ldarg_2, 
					3 => code.opcode == OpCodes.Ldarg_3, 
					_ => code.opcode == OpCodes.Ldarg && (int)code.operand == index, 
				};
			}
			return code.opcode == OpCodes.Starg && (int)code.operand == index;
		}

		private static bool CheckCodeInstruction(CodeInstruction code, object findValue)
		{
			if (findValue is sbyte)
			{
				return CheckIntegerCodeInstruction(code, findValue);
			}
			if (findValue is int)
			{
				return code.opcode == OpCodes.Ldc_I4 && code.operand.Equals(findValue);
			}
			if (findValue is float)
			{
				return code.opcode == OpCodes.Ldc_R4 && code.operand.Equals(findValue);
			}
			if (findValue is string)
			{
				return code.opcode == OpCodes.Ldstr && code.operand.Equals(findValue);
			}
			if (findValue is MethodInfo)
			{
				return (code.opcode == OpCodes.Call || code.opcode == OpCodes.Callvirt) && code.operand == findValue;
			}
			if (findValue is FieldInfo)
			{
				return (code.opcode == OpCodes.Ldfld || code.opcode == OpCodes.Stfld) && code.operand == findValue;
			}
			if (findValue is OpCode)
			{
				return code.opcode == (OpCode)findValue;
			}
			if (findValue == null)
			{
				return code.opcode == OpCodes.Ldnull;
			}
			return false;
		}

		private static bool CheckIntegerCodeInstruction(CodeInstruction code, object findValue)
		{
			return (sbyte)findValue switch
			{
				0 => code.opcode == OpCodes.Ldc_I4_0, 
				1 => code.opcode == OpCodes.Ldc_I4_1, 
				2 => code.opcode == OpCodes.Ldc_I4_2, 
				3 => code.opcode == OpCodes.Ldc_I4_3, 
				4 => code.opcode == OpCodes.Ldc_I4_4, 
				5 => code.opcode == OpCodes.Ldc_I4_5, 
				6 => code.opcode == OpCodes.Ldc_I4_6, 
				7 => code.opcode == OpCodes.Ldc_I4_7, 
				8 => code.opcode == OpCodes.Ldc_I4_8, 
				_ => code.opcode == OpCodes.Ldc_I4_S && code.operand.Equals(findValue), 
			};
		}

		public static void ShuffleList<T>(List<T> list)
		{
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			Random random = new Random();
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int index = random.Next(num + 1);
				T value = list[index];
				list[index] = list[num];
				list[num] = value;
			}
		}

		public static bool SpawnMob(string mob, Vector3 position, int numToSpawn)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < RoundManager.Instance.currentLevel.Enemies.Count; i++)
			{
				if (RoundManager.Instance.currentLevel.Enemies[i].enemyType.enemyName == mob)
				{
					for (int j = 0; j < numToSpawn; j++)
					{
						RoundManager.Instance.SpawnEnemyOnServer(position, 0f, i);
					}
					return true;
				}
			}
			return false;
		}

		internal static string GenerateInfoForUpgrade(string infoFormat, int initialPrice, int[] incrementalPrices, Func<int, float> infoFunction, bool skipFirst = false, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency)
		{
			string text = (skipFirst ? "" : string.Format(infoFormat, 1, BaseUpgrade.GetUpgradePrice(initialPrice, purchaseMode), infoFunction(0)));
			for (int i = 0; i < incrementalPrices.Length; i++)
			{
				float num = infoFunction(i + 1);
				text = ((num % 1f != 0f) ? (text + string.Format(infoFormat, i + 2, BaseUpgrade.GetUpgradePrice(incrementalPrices[i], purchaseMode), num)) : (text + string.Format(infoFormat, i + 2, BaseUpgrade.GetUpgradePrice(incrementalPrices[i], purchaseMode), Mathf.RoundToInt(num))));
			}
			return text;
		}

		public static Color ConvertValueToColor(string hex, Color defaultValue)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			Color result = default(Color);
			if (hex == null || !ColorUtility.TryParseHtmlString("#" + hex.Trim('#', ' '), ref result))
			{
				return defaultValue;
			}
			return result;
		}

		internal static void SpawnExplosion(Vector3 explosionPosition, bool spawnExplosionEffect = false, float killRange = 1f, float damageRange = 1f, int nonLethalDamage = 50, float physicsForce = 0f, GameObject overridePrefab = null, bool goThroughCar = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Landmine.SpawnExplosion(explosionPosition, spawnExplosionEffect, killRange, damageRange, nonLethalDamage, physicsForce, overridePrefab, goThroughCar);
		}

		internal static void SetupGameObject<T>(string name) where T : Component
		{
			GameObject perkGameObject = AssetBundleHandler.GetPerkGameObject(name);
			if (Object.op_Implicit((Object)(object)perkGameObject))
			{
				perkGameObject.AddComponent<T>();
				((Object)perkGameObject).hideFlags = (HideFlags)61;
				ItemManager.RegisterNetworkPrefab(perkGameObject);
			}
		}
	}
}
namespace MoreShipUpgrades.Misc.Upgrades
{
	public abstract class BaseUpgrade : NetworkBehaviour
	{
		protected string upgradeName = "Base Upgrade";

		protected string overridenUpgradeName;

		public const string INDIVIDUAL_SECTION = "Individual Purchase";

		public const bool INDIVIDUAL_DEFAULT = true;

		public const string INDIVIDUAL_DESCRIPTION = "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)";

		public const string PRICES_SECTION = "Price of each additional upgrade";

		public const string PRICES_DESCRIPTION = "Value must be seperated by commas EX: '123,321,222'";

		public abstract bool CanInitializeOnStart { get; }

		internal virtual void Start()
		{
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Register();
		}

		public virtual void Load()
		{
			LategameConfiguration configuration = GetConfiguration();
			UpgradeBus.Instance.activeUpgrades[upgradeName] = true;
			if (configuration.SHOW_UPGRADES_CHAT.LocalValue)
			{
				ShowUpgradeNotification("#FF0000", (SyncedEntry<bool>.op_Implicit(configuration.OVERRIDE_UPGRADE_NAMES) ? overridenUpgradeName : upgradeName) + " is active!");
			}
		}

		public virtual void Register()
		{
			if (!UpgradeBus.Instance.UpgradeObjects.ContainsKey(upgradeName))
			{
				UpgradeBus.Instance.UpgradeObjects.Add(upgradeName, ((Component)this).gameObject);
			}
		}

		public virtual void Unwind()
		{
			LategameConfiguration configuration = GetConfiguration();
			UpgradeBus.Instance.activeUpgrades[upgradeName] = false;
			if (configuration.SHOW_UPGRADES_CHAT.LocalValue)
			{
				ShowUpgradeNotification("#FF0000", (SyncedEntry<bool>.op_Implicit(configuration.OVERRIDE_UPGRADE_NAMES) ? overridenUpgradeName : upgradeName) + " has been disabled!");
			}
		}

		protected void ShowUpgradeNotification(string colourHex, string message)
		{
			string text = "\n<color=" + colourHex + ">" + message + "</color>";
			TextMeshProUGUI chatText = HUDManager.Instance.chatText;
			((TMP_Text)chatText).text = ((TMP_Text)chatText).text + text;
		}

		public static bool GetActiveUpgrade(string upgradeName)
		{
			return UpgradeBus.Instance.activeUpgrades.GetValueOrDefault(upgradeName, defaultValue: false);
		}

		public static int GetUpgradeLevel(string upgradeName)
		{
			return UpgradeBus.Instance.upgradeLevels.GetValueOrDefault(upgradeName, 0);
		}

		public static LategameConfiguration GetConfiguration()
		{
			return UpgradeBus.Instance.PluginConfiguration;
		}

		public static string GetUpgradePrice(int price, PurchaseMode mode)
		{
			if (!CurrencyManager.Enabled)
			{
				return $"${price}";
			}
			mode = (SyncedEntry<bool>.op_Implicit(GetConfiguration().AlternativeCurrencyConfiguration.EnableGlobalPurchase) ? SyncedEntry<PurchaseMode>.op_Implicit(GetConfiguration().AlternativeCurrencyConfiguration.GlobalPurchaseMode) : mode);
			return mode switch
			{
				PurchaseMode.Both => $"${price}/{CurrencyManager.Instance.GetCurrencyAmountFromCredits(price)} PC", 
				PurchaseMode.AlternateCurrency => $"{CurrencyManager.Instance.GetCurrencyAmountFromCredits(price)} PC", 
				PurchaseMode.CompanyCredits => $"${price}", 
				_ => string.Empty, 
			};
		}

		public static void RegisterUpgrade()
		{
			throw new NotSupportedException();
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			throw new NotSupportedException();
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			throw new NotSupportedException();
		}

		internal static void SetupGenericPerk<T>(string upgradeName) where T : Component
		{
			Tools.SetupGameObject<T>(upgradeName);
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BaseUpgrade";
		}
	}
	public abstract class GameAttributeTierUpgrade : TierUpgrade, IPlayerSync
	{
		protected enum GameAttribute
		{
			NONE,
			PLAYER_HEALTH
		}

		protected bool activeUpgrade;

		protected int currentUpgradeLevel;

		protected float initialValue;

		protected float incrementalValue;

		protected GameAttribute changingAttribute;

		protected LguLogger logger;

		private PlayerControllerB GetLocalPlayer()
		{
			return UpgradeBus.Instance.GetLocalPlayer();
		}

		protected void LoadUpgradeAttribute()
		{
			if (!activeUpgrade)
			{
				AddInitialValue();
			}
			activeUpgrade = true;
			int upgradeLevel = BaseUpgrade.GetUpgradeLevel(upgradeName);
			AddPossibleIncrementalValues(upgradeLevel);
			currentUpgradeLevel = upgradeLevel;
		}

		private void AddInitialValue()
		{
			PlayerControllerB localPlayer = GetLocalPlayer();
			GameAttribute gameAttribute = changingAttribute;
			GameAttribute gameAttribute2 = gameAttribute;
			if (gameAttribute2 == GameAttribute.PLAYER_HEALTH)
			{
				localPlayer.health += (int)initialValue;
			}
			else
			{
				logger.LogError("No attribute was set for this upgrade to add the initial value");
			}
		}

		private void AddIncrementalValue()
		{
			PlayerControllerB localPlayer = GetLocalPlayer();
			GameAttribute gameAttribute = changingAttribute;
			GameAttribute gameAttribute2 = gameAttribute;
			if (gameAttribute2 == GameAttribute.PLAYER_HEALTH)
			{
				localPlayer.health += (int)incrementalValue;
			}
			else
			{
				logger.LogError("No attribute was set for this upgrade to add the incremental value");
			}
		}

		private void AddPossibleIncrementalValues(int upgradeLevel = 0)
		{
			float num = 0f;
			for (int i = 1; i < upgradeLevel + 1; i++)
			{
				if (i > currentUpgradeLevel)
				{
					num += incrementalValue;
				}
			}
			PlayerControllerB localPlayer = GetLocalPlayer();
			GameAttribute gameAttribute = changingAttribute;
			GameAttribute gameAttribute2 = gameAttribute;
			if (gameAttribute2 == GameAttribute.PLAYER_HEALTH)
			{
				localPlayer.health += (int)num;
			}
			else
			{
				logger.LogError("No attribute was set for this upgrade to add the incremental values");
			}
		}

		internal void UnloadUpgradeAttribute()
		{
			bool flag = BaseUpgrade.GetActiveUpgrade(upgradeName);
			int upgradeLevel = BaseUpgrade.GetUpgradeLevel(upgradeName);
			if (flag)
			{
				RemoveInitialValue();
			}
			RemovePossibleIncrementalValues(upgradeLevel);
			activeUpgrade = false;
			currentUpgradeLevel = 0;
		}

		private void RemoveInitialValue()
		{
			PlayerControllerB localPlayer = GetLocalPlayer();
			GameAttribute gameAttribute = changingAttribute;
			GameAttribute gameAttribute2 = gameAttribute;
			if (gameAttribute2 == GameAttribute.PLAYER_HEALTH)
			{
				localPlayer.health -= (int)initialValue;
			}
			else
			{
				logger.LogError("No attribute was set for this upgrade to remove the initial value");
			}
		}

		protected void RemovePossibleIncrementalValues(int upgradeLevel = 0)
		{
			PlayerControllerB localPlayer = GetLocalPlayer();
			float num = 0f;
			for (int i = 0; i < upgradeLevel; i++)
			{
				num += incrementalValue;
			}
			if (!(num <= 0f))
			{
				GameAttribute gameAttribute = changingAttribute;
				GameAttribute gameAttribute2 = gameAttribute;
				if (gameAttribute2 == GameAttribute.PLAYER_HEALTH)
				{
					localPlayer.health -= (int)num;
				}
				else
				{
					logger.LogError("No attribute was set for this upgrade to remove the incremental values");
				}
			}
		}

		public override void Increment()
		{
			base.Increment();
			AddIncrementalValue();
			currentUpgradeLevel++;
		}

		public override void Load()
		{
			LoadUpgradeAttribute();
			base.Load();
		}

		public override void Unwind()
		{
			UnloadUpgradeAttribute();
			base.Unwind();
		}

		public void ResetPlayerAttribute()
		{
			UnloadUpgradeAttribute();
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "GameAttributeTierUpgrade";
		}
	}
	public abstract class OneTimeUpgrade : BaseUpgrade
	{
		public abstract string GetDisplayInfo(int price = -1);

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "OneTimeUpgrade";
		}
	}
	public abstract class TierUpgrade : BaseUpgrade
	{
		public override void Unwind()
		{
			base.Unwind();
			UpgradeBus.Instance.upgradeLevels[upgradeName] = 0;
		}

		public abstract string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null);

		public virtual void Increment()
		{
			UpgradeBus.Instance.upgradeLevels[upgradeName] = BaseUpgrade.GetUpgradeLevel(upgradeName) + 1;
		}

		public virtual void Decrement()
		{
			UpgradeBus.Instance.upgradeLevels[upgradeName] = BaseUpgrade.GetUpgradeLevel(upgradeName) - 1;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "TierUpgrade";
		}
	}
}
namespace MoreShipUpgrades.Misc.Commands
{
	public abstract class BaseCommand : NetworkBehaviour
	{
		public static void RegisterCommand()
		{
			throw new NotSupportedException();
		}

		internal static void SetupGenericCommand<T>(string commandName) where T : Component
		{
			Tools.SetupGameObject<T>(commandName);
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "BaseCommand";
		}
	}
}
namespace MoreShipUpgrades.Managers
{
	internal class ContractManager : NetworkBehaviour
	{
		private static readonly LguLogger logger = new LguLogger("ContractManager");

		private static TerminalKeyword routeKeyword;

		private static readonly ContractsConfiguration config = UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration;

		internal string contractLevel = "None";

		internal string contractType = "None";

		internal int lastContractIndex = -1;

		internal string DataMinigameKey = "";

		internal string DataMinigameUser = "";

		internal string DataMinigamePass = "";

		internal Dictionary<string, List<string>> fakeBombOrders = new Dictionary<string, List<string>>();

		internal List<string> bombOrder = new List<string>();

		internal string SerialNumber;

		private const int UNDEFINED_INDEX = -1;

		private const int MAXIMUM_RITUAL_ITEMS = 5;

		internal static ContractManager Instance { get; set; }

		private void Awake()
		{
			Instance = this;
		}

		[ServerRpc(RequireOwnership = false)]
		internal void ReqSyncContractDetailsServerRpc(string contractLvl, int contractType)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3456415163u, val, (RpcDelivery)0);
				bool flag = contractLvl != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(contractLvl, false);
				}
				BytePacker.WriteValueBitPacked(val2, contractType);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3456415163u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SyncContractDetailsClientRpc(contractLvl, contractType);
				logger.LogInfo("Syncing contract details on all clients...");
			}
		}

		[ClientRpc]
		internal void SyncContractDetailsClientRpc(string contractLvl = "None", int contractType = -1)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(779001597u, val, (RpcDelivery)0);
				bool flag = contractLvl != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(contractLvl, false);
				}
				BytePacker.WriteValueBitPacked(val2, contractType);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 779001597u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				contractLevel = contractLvl;
				if (contractType == -1)
				{
					this.contractType = "None";
				}
				else
				{
					this.contractType = CommandParser.contracts[contractType];
					lastContractIndex = contractType;
				}
				fakeBombOrders = new Dictionary<string, List<string>>();
				logger.LogInfo($"New contract details received. level: {contractLvl}, type: {contractType}");
				LguStore.Instance.SaveInfo = new SaveInfo();
				LguStore.Instance.UpdateLGUSaveServerRpc(LguStore.Instance.playerID, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)LguStore.Instance.SaveInfo)), saveFile: true);
			}
		}

		internal static string RandomLevel()
		{
			string text = Instance.contractLevel;
			string text2 = null;
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			bool[] array = new bool[levels.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = false;
			}
			bool flag = true;
			while (text == Instance.contractLevel)
			{
				int num = Random.Range(0, levels.Length);
				if (array[num])
				{
					continue;
				}
				array[num] = true;
				SelectableLevel level = levels[num];
				text2 = level.PlanetName;
				if (level.PlanetName.Contains("Gordion") || level.PlanetName.Contains("Liquidation") || IsBlacklistedMoon(level.PlanetName) || (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.IsLocked(ref level)))
				{
					continue;
				}
				logger.LogDebug("Picked " + level.PlanetName + " as possible moon for contract...");
				if ((Object)(object)routeKeyword == (Object)null)
				{
					routeKeyword = UpgradeBus.Instance.GetTerminal().terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "route");
				}
				for (int j = 0; j < routeKeyword.compatibleNouns.Length; j++)
				{
					if (!(text == Instance.contractLevel))
					{
						break;
					}
					TerminalNode result = routeKeyword.compatibleNouns[j].result;
					CompatibleNoun[] terminalOptions = result.terminalOptions;
					if (IsSelectedLevel(terminalOptions, text, num))
					{
						int itemCost = result.itemCost;
						if (config.FreeMoonsOnly.Value && itemCost != 0)
						{
							logger.LogDebug($"Criteria algorithm skipped a choice due to configuration only allowing free moons (Choice: {level.PlanetName}, Attached Price: {itemCost})");
							break;
						}
						logger.LogDebug("Criteria algorithm made a choice and decided to assign contract on " + level.PlanetName);
						text = level.PlanetName;
					}
				}
				if (text != Instance.contractLevel)
				{
					break;
				}
				flag = true;
				for (int l = 0; l < array.Length; l++)
				{
					flag &= array[l];
				}
				if (!flag)
				{
					continue;
				}
				break;
			}
			if (text == Instance.contractLevel && flag)
			{
				logger.LogDebug("Criteria algorithm did not make a choice, we will use the last selected moon (" + text2 + ")");
				text = text2;
			}
			logger.LogDebug(text + " will be the moon for the random contract...");
			Instance.contractLevel = text;
			return text;
		}

		internal static bool IsBlacklistedMoon(string moonName)
		{
			if (config.BlacklistedMoons.Value.Length == 0)
			{
				return false;
			}
			string[] array = config.BlacklistedMoons.Value.Split(',');
			foreach (string value in array)
			{
				if (moonName.Contains(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsSelectedLevel(CompatibleNoun[] additionalNodes, string lvl, int levelIndex)
		{
			for (int i = 0; i < additionalNodes.Length; i++)
			{
				if (!(lvl == Instance.contractLevel))
				{
					break;
				}
				TerminalNode result = additionalNodes[i].result;
				if (!((Object)(object)result == (Object)null) && result.buyRerouteToMoon == levelIndex)
				{
					return true;
				}
			}
			return false;
		}

		internal void ResetAllValues()
		{
			contractType = "None";
			contractLevel = "None";
		}

		internal static void SetupContractMapObjects(ref AssetBundle bundle)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			AnimationCurve curve = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
			{
				new Keyframe(0f, 1f),
				new Keyframe(1f, 1f)
			});
			SetupScavContract(ref bundle, curve);
			SetupExterminatorContract(curve);
			SetupDataContract(curve);
			SetupExorcismContract(curve);
			SetupBombContract(curve);
		}

		private static void SetupBombContract(AnimationCurve curve)
		{
			Item itemObject = AssetBundleHandler.GetItemObject("Bomb");
			itemObject.spawnPrefab.AddComponent<ScrapValueSyncer>();
			itemObject.isConductiveMetal = false;
			DefusalContract defusalContract = itemObject.spawnPrefab.AddComponent<DefusalContract>();
			defusalContract.SetPosition = true;
			BombDefusalScript bombDefusalScript = itemObject.spawnPrefab.AddComponent<BombDefusalScript>();
			bombDefusalScript.snip = AssetBundleHandler.GetAudioClip("Bomb Cut");
			bombDefusalScript.tick = AssetBundleHandler.GetAudioClip("Bomb Tick");
			RegisterSpawnableContractObject(itemObject, curve);
		}

		private static void SetupExorcismContract(AnimationCurve curve)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			Item itemObject = AssetBundleHandler.GetItemObject("Demon Tome");
			itemObject.spawnPrefab.AddComponent<ScrapValueSyncer>();
			ItemManager.SetupItem(itemObject);
			ItemManager.FixMixerGroups(itemObject.spawnPrefab);
			ItemManager.RegisterNetworkPrefab(itemObject.spawnPrefab);
			Item itemObject2 = AssetBundleHandler.GetItemObject("Pentagram");
			for (int i = 0; i < 5; i++)
			{
				Item itemObject3 = AssetBundleHandler.GetItemObject("RitualItem" + i);
				itemObject3.spawnPrefab.AddComponent<ExorcismContract>();
				RegisterSpawnableContractObject(itemObject3, new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0f, 3f),
					new Keyframe(1f, 3f)
				}));
			}
			itemObject2.weight = 1f;
			ExorcismContract exorcismContract = itemObject2.spawnPrefab.AddComponent<ExorcismContract>();
			exorcismContract.SetPosition = true;
			PentagramScript pentagramScript = itemObject2.spawnPrefab.AddComponent<PentagramScript>();
			pentagramScript.loot = itemObject.spawnPrefab;
			pentagramScript.chant = AssetBundleHandler.GetAudioClip("Ritual Fail");
			pentagramScript.portal = AssetBundleHandler.GetAudioClip("Ritual Success");
			RegisterSpawnableContractObject(itemObject2, curve);
		}

		private static void RegisterSpawnableContractObject(Item item, AnimationCurve curve)
		{
			ItemManager.FixMixerGroups(item.spawnPrefab);
			ItemManager.RegisterNetworkPrefab(item.spawnPrefab);
			ItemManager.SetupItem(item);
			ItemManager.SetupMapObject(item, curve);
		}

		private static void SetupExterminatorContract(AnimationCurve curve)
		{
			Item itemObject = AssetBundleHandler.GetItemObject("HoardingBugEggsLoot");
			itemObject.spawnPrefab.AddComponent<ScrapValueSyncer>();
			ItemManager.SetupItem(itemObject);
			ItemManager.FixMixerGroups(itemObject.spawnPrefab);
			ItemManager.RegisterNetworkPrefab(itemObject.spawnPrefab);
			Item itemObject2 = AssetBundleHandler.GetItemObject("HoardingBugEggs");
			ExterminatorContract exterminatorContract = itemObject2.spawnPrefab.AddComponent<ExterminatorContract>();
			exterminatorContract.SetPosition = true;
			BugNestScript bugNestScript = itemObject2.spawnPrefab.AddComponent<BugNestScript>();
			bugNestScript.loot = itemObject.spawnPrefab;
			RegisterSpawnableContractObject(itemObject2, curve);
		}

		private static void SetupScavContract(ref AssetBundle bundle, AnimationCurve curve)
		{
			Item itemObject = AssetBundleHandler.GetItemObject("Scavenger");
			if (!((Object)(object)itemObject == (Object)null))
			{
				itemObject.weight = config.ExtractionConfiguration.ScavengerWeight.Value;
				ExtractionContract extractionContract = itemObject.spawnPrefab.AddComponent<ExtractionContract>();
				extractionContract.SetPosition = true;
				itemObject.spawnPrefab.AddComponent<ExtractPlayerScript>();
				itemObject.spawnPrefab.AddComponent<ScrapValueSyncer>();
				TextAsset genericAsset = AssetBundleHandler.GetGenericAsset<TextAsset>("Scavenger Sounds");
				Dictionary<string, string[]> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string[]>>(genericAsset.text);
				ExtractPlayerScript.clipDict.Add("lost", CreateAudioClipArray(dictionary["lost"], ref bundle));
				ExtractPlayerScript.clipDict.Add("heal", CreateAudioClipArray(dictionary["heal"], ref bundle));
				ExtractPlayerScript.clipDict.Add("safe", CreateAudioClipArray(dictionary["safe"], ref bundle));
				ExtractPlayerScript.clipDict.Add("held", CreateAudioClipArray(dictionary["held"], ref bundle));
				RegisterSpawnableContractObject(itemObject, curve);
			}
		}

		private static void SetupDataContract(AnimationCurve curve)
		{
			Item itemObject = AssetBundleHandler.GetItemObject("Floppy Disk");
			itemObject.spawnPrefab.AddComponent<ScrapValueSyncer>();
			ItemManager.SetupItem(itemObject);
			ItemManager.FixMixerGroups(itemObject.spawnPrefab);
			ItemManager.RegisterNetworkPrefab(itemObject.spawnPrefab);
			Item itemObject2 = AssetBundleHandler.GetItemObject("Laptop");
			itemObject2.weight = 1f;
			DataRetrievalContract dataRetrievalContract = itemObject2.spawnPrefab.AddComponent<DataRetrievalContract>();
			dataRetrievalContract.SetPosition = true;
			DataPCScript dataPCScript = itemObject2.spawnPrefab.AddComponent<DataPCScript>();
			dataPCScript.error = AssetBundleHandler.GetAudioClip("Laptop Error");
			dataPCScript.startup = AssetBundleHandler.GetAudioClip("Laptop Start");
			dataPCScript.loot = itemObject.spawnPrefab;
			RegisterSpawnableContractObject(itemObject2, curve);
		}

		private static AudioClip[] CreateAudioClipArray(string[] paths, ref AssetBundle bundle)
		{
			AudioClip[] array = (AudioClip[])(object)new AudioClip[paths.Length];
			for (int i = 0; i < paths.Length; i++)
			{
				array[i] = AssetBundleHandler.TryLoadAudioClipAsset(ref bundle, paths[i]);
			}
			return array;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3456415163u, new RpcReceiveHandler(__rpc_handler_3456415163), "ReqSyncContractDetailsServerRpc");
			((NetworkBehaviour)this).__registerRpc(779001597u, new RpcReceiveHandler(__rpc_handler_779001597), "SyncContractDetailsClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3456415163(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string contractLvl = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref contractLvl, false);
				}
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ContractManager)(object)target).ReqSyncContractDetailsServerRpc(contractLvl, num);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_779001597(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string contractLvl = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref contractLvl, false);
				}
				int num = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref num);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ContractManager)(object)target).SyncContractDetailsClientRpc(contractLvl, num);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ContractManager";
		}
	}
	public class CurrencyManager : NetworkBehaviour
	{
		public static CurrencyManager Instance;

		private bool showCurrencyAmount;

		private int currencyAmount;

		private int spentCurrencyAmount;

		public bool ShowCurrentAmount
		{
			get
			{
				return showCurrencyAmount;
			}
			set
			{
				showCurrencyAmount = value;
			}
		}

		public int CurrencyAmount
		{
			get
			{
				return currencyAmount;
			}
			set
			{
				currencyAmount = value;
			}
		}

		public int SpentCurrencyAmount
		{
			get
			{
				return spentCurrencyAmount;
			}
			set
			{
				spentCurrencyAmount = value;
			}
		}

		public static AlternativeCurrencyConfiguration Config => UpgradeBus.Instance.PluginConfiguration.AlternativeCurrencyConfiguration;

		public static bool Enabled => SyncedEntry<bool>.op_Implicit(Config.Enabled);

		public static bool BlockGainOperations => SyncedEntry<bool>.op_Implicit(Config.BlockGainOperations);

		public static int MaximumAmountPerPlayer => SyncedEntry<int>.op_Implicit(Config.MaximumAmountPerPlayer);

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			showCurrencyAmount = false;
		}

		public static string GetNewCreditFormat(string format)
		{
			if (!Enabled)
			{
				return format;
			}
			if (!Instance.ShowCurrentAmount)
			{
				return format;
			}
			if (MaximumAmountPerPlayer > 0)
			{
				return string.Format("{0} / {1} {2}", Instance.CurrencyAmount, Mathf.Clamp(Instance.CurrencyAmount + Instance.SpentCurrencyAmount, 0, MaximumAmountPerPlayer), "PC");
			}
			return string.Format("{0} / {1} {2}", Instance.CurrencyAmount, Instance.CurrencyAmount + Instance.SpentCurrencyAmount, "PC");
		}

		public float GetCreditRatio()
		{
			return 1f / (float)SyncedEntry<int>.op_Implicit(Config.CreditsToCurrencyRatio);
		}

		public float GetQuotaRatio()
		{
			return 1f / (float)SyncedEntry<int>.op_Implicit(Config.QuotaToCurrencyRatio);
		}

		public float GetCreditToCurrencyConversionRatio()
		{
			return 1f / (float)SyncedEntry<int>.op_Implicit(Config.CreditsToCurrencyConversionRatio);
		}

		public float GetCurrencyToCreditConversionRatio()
		{
			return 1f / (float)SyncedEntry<int>.op_Implicit(Config.CurrencyToCreditsConversionRatio);
		}

		public int GetCurrencyAmountFromQuota(int quotaFullfilled)
		{
			return Mathf.RoundToInt(GetQuotaRatio() * (float)quotaFullfilled);
		}

		public int GetCurrencyAmountFromCredits(int credits)
		{
			return Mathf.CeilToInt(GetCreditRatio() * (float)credits);
		}

		public int GetRequiredCreditsFromCurrencyConversion(int currencyAmount)
		{
			return Mathf.CeilToInt((float)currencyAmount / GetCreditToCurrencyConversionRatio());
		}

		public int GetCurrencyAmountFromCreditsConversion(int convertedCredits)
		{
			return Mathf.CeilToInt(GetCreditToCurrencyConversionRatio() * (float)convertedCredits);
		}

		public int GetCreditsFromCurrencyAmountConversion(int convertedCurrencyAmount)
		{
			return Mathf.CeilToInt((float)convertedCurrencyAmount / GetCurrencyToCreditConversionRatio());
		}

		[ClientRpc]
		public void AddCurrencyAmountFromQuotaClientRpc(int quotaFullfilled)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2904414515u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, quotaFullfilled);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2904414515u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AddCurrencyAmountFromQuota(quotaFullfilled);
				}
			}
		}

		public void AddCurrencyAmountFromQuota(int quota)
		{
			AddCurrencyAmount(GetCurrencyAmountFromQuota(quota));
			HUDManager.Instance.DisplayTip("Player Credits", string.Format("You currently have {0} {1}s to use in the upgrade shop.", CurrencyAmount, "PC"), false, false, "LC_Tip1");
		}

		public void AddCurrencyAmount(int amount, bool trackSpent = false)
		{
			CurrencyAmount = Mathf.Clamp(CurrencyAmount + amount, 0, (MaximumAmountPerPlayer > 0) ? MaximumAmountPerPlayer : int.MaxValue);
			if (trackSpent)
			{
				SpentCurrencyAmount -= amount;
			}
		}

		public void RemoveCurrencyAmount(int amount, bool trackSpent = false)
		{
			CurrencyAmount -= amount;
			if (trackSpent)
			{
				SpentCurrencyAmount += amount;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TradePlayerCreditsServerRpc(ulong tradingClientId, int playerCreditAmount, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3400678019u, serverRpcParams, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, tradingClientId);
					BytePacker.WriteValueBitPacked(val, playerCreditAmount);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 3400678019u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(tradingClientId)
					};
					ClientRpcParams clientRpcParams = val2;
					TradePlayerCreditsClientRpc(serverRpcParams.Receive.SenderClientId, playerCreditAmount, clientRpcParams);
				}
			}
		}

		[ClientRpc]
		public void TradePlayerCreditsClientRpc(ulong traderClientId, int playerCreditAmount, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3239730022u, clientRpcParams, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, traderClientId);
					BytePacker.WriteValueBitPacked(val, playerCreditAmount);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3239730022u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AddCurrencyAmount(playerCreditAmount);
					PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[traderClientId];
					HUDManager.Instance.DisplayTip("Player Credits", string.Format("You have received {0} {1}s from {2}. You currently have {3} {4}s to use in the upgrade shop.", playerCreditAmount, "PC", val2.playerUsername, CurrencyAmount, "PC"), false, false, "LC_Tip1");
				}
			}
		}

		internal bool BlockExceedOperations(int amount)
		{
			if (MaximumAmountPerPlayer <= 0 || !BlockGainOperations)
			{
				return false;
			}
			return (SyncedEntry<bool>.op_Implicit(Config.IncludeSpentInMaximum) ? SpentCurrencyAmount : 0) + CurrencyAmount + amount > MaximumAmountPerPlayer;
		}

		internal void ResetAllValues()
		{
			currencyAmount = 0;
			spentCurrencyAmount = 0;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2904414515u, new RpcReceiveHandler(__rpc_handler_2904414515), "AddCurrencyAmountFromQuotaClientRpc");
			((NetworkBehaviour)this).__registerRpc(3400678019u, new RpcReceiveHandler(__rpc_handler_3400678019), "TradePlayerCreditsServerRpc");
			((NetworkBehaviour)this).__registerRpc(3239730022u, new RpcReceiveHandler(__rpc_handler_3239730022), "TradePlayerCreditsClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2904414515(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int quotaFullfilled = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref quotaFullfilled);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CurrencyManager)(object)target).AddCurrencyAmountFromQuotaClientRpc(quotaFullfilled);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3400678019(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong tradingClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref tradingClientId);
				int playerCreditAmount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerCreditAmount);
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CurrencyManager)(object)target).TradePlayerCreditsServerRpc(tradingClientId, playerCreditAmount, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3239730022(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong traderClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref traderClientId);
				int playerCreditAmount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerCreditAmount);
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CurrencyManager)(object)target).TradePlayerCreditsClientRpc(traderClientId, playerCreditAmount, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "CurrencyManager";
		}
	}
	internal class ItemManager : NetworkBehaviour
	{
		internal Dictionary<string, WeightingGroup<GameObject>> samplePrefabs = new Dictionary<string, WeightingGroup<GameObject>>();

		internal static ItemManager Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		internal void SpawnSample(string name, Vector3 position)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject item = samplePrefabs[name].GetItem();
			GameObject val = Object.Instantiate<GameObject>(item, position + Vector3.up, Quaternion.identity);
			val.GetComponent<NetworkObject>().Spawn(false);
		}

		internal static TerminalNode SetupInfoNode(Item storeItem)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			GrabbableObject component = storeItem.spawnPrefab.GetComponent<GrabbableObject>();
			if (component is IDisplayInfo displayInfo)
			{
				val.displayText = val.displayText + displayInfo.GetDisplayInfo() + "\n";
			}
			if (component is IItemWorldBuilding itemWorldBuilding)
			{
				val.displayText = val.displayText + itemWorldBuilding.GetWorldBuildingText() + "\n";
			}
			val.clearPreviousText = true;
			return val;
		}

		internal static void SetupSampleItem(Item sampleItem, bool registerNetworkPrefab, string monsterName, double weight)
		{
			if (registerNetworkPrefab)
			{
				RegisterNetworkPrefab(sampleItem.spawnPrefab);
			}
			if (!Instance.samplePrefabs.ContainsKey(monsterName.ToLower()))
			{
				Instance.samplePrefabs.Add(monsterName.ToLower(), new WeightingGroup<GameObject>());
			}
			Instance.samplePrefabs[monsterName.ToLower()].Add(sampleItem.spawnPrefab, weight);
			SetupItem(sampleItem);
		}

		internal static void SetupStoreItem(Item storeItem)
		{
			RegisterNetworkPrefab(storeItem.spawnPrefab);
			TerminalNode val = SetupInfoNode(storeItem);
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				Items.RegisterShopItem(storeItem, (TerminalNode)null, (TerminalNode)null, val, storeItem.creditsWorth);
			}
			else
			{
				DawnLibCompat.SetupStoreItem(storeItem, val);
			}
		}

		internal static void SetupMapObject(Item item, AnimationCurve curve)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				SpawnableMapObjectDef val = ScriptableObject.CreateInstance<SpawnableMapObjectDef>();
				val.spawnableMapObject = new SpawnableMapObject
				{
					prefabToSpawn = item.spawnPrefab
				};
				MapObjects.RegisterMapObject(val, (LevelTypes)(-1), (Func<SelectableLevel, AnimationCurve>)((SelectableLevel _) => curve));
			}
			else
			{
				DawnLibCompat.SetupMapObject(item, curve);
			}
		}

		internal static void RegisterNetworkPrefab(GameObject prefab)
		{
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				NetworkPrefabs.RegisterNetworkPrefab(prefab);
			}
			else
			{
				DawnLibCompat.RegisterNetworkPrefab(prefab);
			}
		}

		internal static void SetupItem(Item item)
		{
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				Items.RegisterItem(item);
			}
			else
			{
				DawnLibCompat.SetupItem(item);
			}
		}

		internal static void FixMixerGroups(GameObject prefab)
		{
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				Utilities.FixMixerGroups(prefab);
			}
			else
			{
				DawnLibCompat.FixMixerGroups(prefab);
			}
		}

		internal static void RemoveShopItem(Item storeItem)
		{
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				Items.RemoveShopItem(storeItem);
			}
			else
			{
				DawnLibCompat.RemoveShopItem(storeItem);
			}
		}

		internal static void UpdateShopItemPrice(Item storeItem, int configuredPrice)
		{
			if (!DawnLibCompat.Enabled || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.UseDawnLib))
			{
				Items.UpdateShopItemPrice(storeItem, configuredPrice);
			}
			else
			{
				DawnLibCompat.UpdateShopItemPrice(storeItem, configuredPrice);
			}
		}

		internal static GameObject CreateNetworkPrefab(string prefabName)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(prefabName);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<NetworkObject>();
			byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(Assembly.GetCallingAssembly().GetName().Name + prefabName));
			val.GetComponent<NetworkObject>().GlobalObjectIdHash = BitConverter.ToUInt32(value, 0);
			RegisterNetworkPrefab(val);
			return val;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ItemManager";
		}
	}
	public static class ItemProgressionManager
	{
		public enum CollectionModes
		{
			CustomScrap,
			UniqueScrap,
			NearestValue,
			ChancePerScrap,
			Apparatice
		}

		public enum ChancePerScrapModes
		{
			Random,
			Cheapest,
			LowestLevel
		}

		private static readonly List<string> blacklistedItems = new List<string>();

		private static readonly Dictionary<string, int> contributedRecently = new Dictionary<string, int>();

		private static readonly Dictionary<string, int> apparatusItems = new Dictionary<string, int>();

		private const int ITEM_NAME_INDEX = 0;

		private const int ITEM_UPGRADE_COUNTER_INDEX = 1;

		internal static CollectionModes CurrentCollectionMode => SyncedEntry<CollectionModes>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_MODE);

		private static ChancePerScrapModes CurrentChancePerScrapMode => SyncedEntry<ChancePerScrapModes>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.SCRAP_UPGRADE_CHANCE_MODE);

		private static float ConfiguredChancePerScrapValue => SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.SCRAP_UPGRADE_CHANCE);

		private static float ConfiguredItemContributionMultiplier => SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER);

		private static void ExecuteApparaticeLogic(GrabbableObject scrapItem, string scrapName)
		{
			if (VerifyApparatus(ref scrapItem, ref scrapName))
			{
				int num = apparatusItems[scrapName];
				for (int i = 0; i < num; i++)
				{
					RankUpUpgrade(PickRandomUpgrade());
				}
			}
		}

		private static void ExecuteChancerPerScrapLogic()
		{
			if (!(Random.Range(0f, 1f) >= ConfiguredChancePerScrapValue))
			{
				RankUpUpgrade(SelectChancePerScrapUpgrade());
			}
		}

		private static void ExecuteSpecificScrapLogic(GrabbableObject scrapItem, string scrapName)
		{
			if (!VerifyScrap(ref scrapItem, ref scrapName))
			{
				return;
			}
			int scrapValue = scrapItem.scrapValue;
			scrapValue = Mathf.CeilToInt(StartOfRound.Instance.companyBuyingRate * (float)scrapValue);
			scrapValue = Mathf.CeilToInt(ConfiguredItemContributionMultiplier * (float)scrapValue);
			foreach (string item in UpgradeBus.Instance.scrapToCollectionUpgrade[scrapName])
			{
				ContributeTowardsUpgrade(item, scrapValue);
			}
		}

		private static void RankUpUpgrade(CustomTerminalNode node)
		{
			LguStore.Instance.HandleUpgradeForNoHostClientRpc(node.OriginalName, node.Unlocked);
			LguStore.Instance.UpdateUpgrades(node, node.Unlocked);
		}

		internal static void ContributeTowardsUpgrade(string upgradeName, int scrapValue)
		{
			CustomTerminalNode upgradeNode = UpgradeBus.Instance.GetUpgradeNode(upgradeName);
			if (upgradeNode != null && upgradeNode.Visible)
			{
				ContributeTowardsUpgrade(upgradeNode, scrapValue);
			}
		}

		internal static void ContributeTowardsUpgrade(CustomTerminalNode assignedUpgrade, int scrapValue)
		{
			int num = UpgradeBus.Instance.contributionValues[assignedUpgrade.OriginalName];
			int num2 = assignedUpgrade.GetCurrentPrice() + num;
			num += scrapValue;
			while (num >= num2 && assignedUpgrade.GetRemainingLevels() > 0)
			{
				RankUpUpgrade(assignedUpgrade);
				num -= num2;
				num2 = assignedUpgrade.GetCurrentPrice();
			}
			LguStore.Instance.SetContributionValueClientRpc(assignedUpgrade.OriginalName, num);
		}

		private static bool VerifyScrap(ref GrabbableObject scrapItem, ref string scrapName)
		{
			return VerifyItem(UpgradeBus.Instance.scrapToCollectionUpgrade, ref scrapItem, ref scrapName);
		}

		private static bool VerifyApparatus(ref GrabbableObject scrapItem, ref string scrapName)
		{
			return VerifyItem(apparatusItems, ref scrapItem, ref scrapName);
		}

		private static bool VerifyItem<T>(Dictionary<string, T> collection, ref GrabbableObject scrapItem, ref string scrapName)
		{
			if (!collection.ContainsKey(scrapName))
			{
				Plugin.mls.LogInfo((object)(scrapName + " from ItemProperties was not found in the dictionary, looking through scan node..."));
				ScanNodeProperties componentInChildren = ((Component)scrapItem).GetComponentInChildren<ScanNodeProperties>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Plugin.mls.LogInfo((object)(scrapName + " doesn't have a scan node, skipping..."));
					return false;
				}
				scrapName = componentInChildren.headerText.ToLower().Trim();
				if (!collection.ContainsKey(scrapName))
				{
					Plugin.mls.LogInfo((object)(scrapName + " from Scan Node was not found in the dictionary."));
					return false;
				}
			}
			return !IsBlacklisted(scrapName);
		}

		public static void CheckCollectionScrap(GrabbableObject scrapItem)
		{
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION))
			{
				string scrapName = scrapItem.itemProperties.itemName.ToLower();
				LguStore.Instance.DiscoverItemClientRpc(scrapName);
				switch (CurrentCollectionMode)
				{
				case CollectionModes.Apparatice:
					ExecuteApparaticeLogic(scrapItem, scrapName);
					break;
				case CollectionModes.ChancePerScrap:
					ExecuteChancerPerScrapLogic();
					break;
				case CollectionModes.CustomScrap:
				case CollectionModes.UniqueScrap:
					ExecuteSpecificScrapLogic(scrapItem, scrapName);
					break;
				case CollectionModes.NearestValue:
					break;
				}
			}
		}

		public static void CheckNewQuota(int fullfilledQuota)
		{
			if (!((NetworkBehaviour)LguStore.Instance).IsServer || !SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ALTERNATIVE_ITEM_PROGRESSION))
			{
				return;
			}
			CollectionModes currentCollectionMode = CurrentCollectionMode;
			CollectionModes collectionModes = currentCollectionMode;
			if (collectionModes == CollectionModes.NearestValue)
			{
				CustomTerminalNode customTerminalNode = SelectNearestValueUpgrade(fullfilledQuota);
				if (customTerminalNode != null)
				{
					LguStore.Instance.HandleUpgradeClientRpc(customTerminalNode.OriginalName, customTerminalNode.Unlocked, downgrade: false);
				}
			}
		}

		public static CustomTerminalNode SelectNearestValueUpgrade(int fullfilledQuota)
		{
			CustomTerminalNode result = null;
			int num = int.MaxValue;
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				int currentPrice = upgradeNode.GetCurrentPrice();
				int num2 = fullfilledQuota - currentPrice;
				if (num2 > 0 && num2 < num)
				{
					num = num2;
					result = upgradeNode;
				}
			}
			return result;
		}

		public static void InitializeBlacklistItems()
		{
			blacklistedItems.Clear();
			string text = SyncedEntry<string>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_BLACKLISTED_ITEMS);
			string[] array = text.Split(",");
			foreach (string text2 in array)
			{
				blacklistedItems.Add(text2.ToLower());
			}
		}

		public static void InitializeApparatusItems()
		{
			apparatusItems.Clear();
			string text = SyncedEntry<string>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_APPARATICE_ITEMS);
			string[] array = text.Split(",");
			foreach (string text2 in array)
			{
				string[] array2 = text2.Split("@");
				string text3 = array2[0];
				int.TryParse(array2[1], out var result);
				apparatusItems[text3.ToLower()] = result;
			}
		}

		private static bool IsBlacklisted(string scrapName)
		{
			return blacklistedItems.Contains(scrapName);
		}

		public static CustomTerminalNode PickRandomUpgrade()
		{
			List<CustomTerminalNode> upgradeNodes = UpgradeBus.GetUpgradeNodes();
			return upgradeNodes[Random.Range(0, upgradeNodes.Count)];
		}

		private static void AssignRandomScrap()
		{
			AllItemsList allItemsList = StartOfRound.Instance.allItemsList;
			if (UpgradeBus.Instance.scrapToCollectionUpgrade.Count == allItemsList.itemsList.Count)
			{
				return;
			}
			foreach (Item items in allItemsList.itemsList)
			{
				if (items.isScrap)
				{
					string text = items.itemName.ToLower();
					if (!UpgradeBus.Instance.scrapToCollectionUpgrade.ContainsKey(text))
					{
						CustomTerminalNode node = PickRandomUpgrade();
						AddScrapToUpgrade(ref node, text);
					}
				}
			}
		}

		private static void AssignConfiguredScrap()
		{
			UpgradeBus.Instance.scrapToCollectionUpgrade.Clear();
			foreach (Type upgradeType in UpgradeBus.Instance.upgradeTypes)
			{
				MethodInfo method = upgradeType.GetMethod("RegisterScrapToUpgrade", BindingFlags.Static | BindingFlags.Public);
				(string, string[]) tuple = ((string, string[]))method.Invoke(null, null);
				AddScrapToUpgrade(tuple.Item1, tuple.Item2);
			}
		}

		public static void AssignScrapToUpgrades()
		{
			switch (CurrentCollectionMode)
			{
			case CollectionModes.UniqueScrap:
				AssignRandomScrap();
				break;
			case CollectionModes.CustomScrap:
				AssignConfiguredScrap();
				break;
			}
			LguStore.Instance.ServerSaveFile();
		}

		public static void AddScrapToUpgrade(string upgradeName, string[] scrapNames)
		{
			foreach (string scrapName in scrapNames)
			{
				AddScrapToUpgrade(upgradeName, scrapName);
			}
		}

		public static void AddScrapToUpgrade(ref CustomTerminalNode node, string scrapName)
		{
			AddScrapToUpgrade(node.OriginalName, scrapName);
		}

		public static void AddScrapToUpgrade(string upgradeName, string scrapName)
		{
			string key = scrapName.ToLower().Trim();
			if (!UpgradeBus.Instance.scrapToCollectionUpgrade.ContainsKey(key))
			{
				UpgradeBus.Instance.scrapToCollectionUpgrade[key] = new List<string>();
			}
			UpgradeBus.Instance.scrapToCollectionUpgrade[key].Add(upgradeName);
		}

		private static void SelectTerminalNode(ref CustomTerminalNode selectedNode, CustomTerminalNode possibleNode)
		{
			if (selectedNode == null)
			{
				selectedNode = possibleNode;
				return;
			}
			switch (CurrentChancePerScrapMode)
			{
			case ChancePerScrapModes.LowestLevel:
				if (selectedNode.Unlocked && (!possibleNode.Unlocked || selectedNode.MaxUpgrade <= selectedNode.CurrentUpgrade || (selectedNode.CurrentUpgrade > possibleNode.CurrentUpgrade && possibleNode.MaxUpgrade <= possibleNode.CurrentUpgrade)))
				{
					selectedNode = possibleNode;
				}
				break;
			case ChancePerScrapModes.Cheapest:
			{
				int currentPrice = selectedNode.GetCurrentPrice();
				int currentPrice2 = possibleNode.GetCurrentPrice();
				if (currentPrice > currentPrice2)
				{
					selectedNode = possibleNode;
				}
				break;
			}
			default:
				selectedNode = possibleNode;
				break;
			}
		}

		public static CustomTerminalNode SelectChancePerScrapUpgrade()
		{
			List<CustomTerminalNode> upgradeNodes = UpgradeBus.GetUpgradeNodes();
			CustomTerminalNode selectedNode = null;
			if (CurrentChancePerScrapMode == ChancePerScrapModes.Random)
			{
				int num = 0;
				selectedNode = PickRandomUpgrade();
				while (selectedNode.MaxUpgrade <= selectedNode.CurrentUpgrade && num < upgradeNodes.Count * 2)
				{
					selectedNode = PickRandomUpgrade();
					num++;
				}
				return selectedNode;
			}
			foreach (CustomTerminalNode item in upgradeNodes)
			{
				SelectTerminalNode(ref selectedNode, item);
			}
			return selectedNode;
		}

		internal static void InitializeContributionValues()
		{
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				if (!UpgradeBus.Instance.contributionValues.ContainsKey(upgradeNode.OriginalName))
				{
					UpgradeBus.Instance.contributionValues.Add(upgradeNode.OriginalName, 0);
				}
			}
		}

		internal static void SetContributionValue(string key, int value)
		{
			UpgradeBus.Instance.contributionValues[key] = value;
			contributedRecently[key] = value;
		}

		internal static int GetCurrentContribution(CustomTerminalNode node)
		{
			return UpgradeBus.Instance.contributionValues.GetValueOrDefault(node.OriginalName, 0);
		}

		internal static List<string> GetDiscoveredItems(CustomTerminalNode node)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, List<string>> item in UpgradeBus.Instance.scrapToCollectionUpgrade)
			{
				List<string> value = item.Value;
				string key = item.Key;
				if (key.Length == 0)
				{
					continue;
				}
				foreach (string item2 in value)
				{
					if (item2 == node.OriginalName && (UpgradeBus.Instance.discoveredItems.Contains(key) || SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS)))
					{
						list.Add(key);
					}
				}
			}
			return list;
		}

		internal static void DiscoverScrap(string scrapName)
		{
			if (!UpgradeBus.Instance.discoveredItems.Contains(scrapName))
			{
				UpgradeBus.Instance.discoveredItems.Add(scrapName);
			}
		}
	}
	public class LguStore : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <WaitForConfigSync>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LguStore <>4__this;

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

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

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

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

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

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

			private object <>2__current;

			public LguStore <>4__this;

			private PlayerControllerB <player>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitWhile((Func<bool>)(() => (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (GameNetworkManager.Instance.disableSteam)
					{
						break;
					}
					goto IL_00cb;
				case 2:
					{
						<>1__state = -1;
						<player>5__1 = null;
						goto IL_00cb;
					}
					IL_00cb:
					if (<>4__this.playerID == 0)
					{
						<player>5__1 = GameNetworkManager.Instance.localPlayerController;
						<>4__this.playerID = <player>5__1.playerSteamId;
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					}
					break;
				}
				if (<>4__this.playerID != 0)
				{
					logger.LogInfo($"Loading SteamID: {<>4__this.playerID}");
					<>4__this.UpdateUpgradeBus();
				}
				else
				{
					logger.LogInfo("LAN detected, loading under ID 0");
					<>4__this.UpdateUpgradeBus(UseLocalSteamID: true, checkID: false);
				}
				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();
			}
		}

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

			private object <>2__current;

			public LguStore <>4__this;

			private List<CustomTerminalNode>.Enumerator <>s__1;

			private CustomTerminalNode <customNode>5__2;

			private bool <activeUpgrade>5__3;

			private int <upgradeLevel>5__4;

			private BaseUpgrade <comp>5__5;

			private bool <free>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					logger.LogInfo("Applying loaded upgrades...");
					<>s__1 = UpgradeBus.GetUpgradeNodes().GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<customNode>5__2 = <>s__1.Current;
							<activeUpgrade>5__3 = UpgradeBus.Instance.activeUpgrades.GetValueOrDefault(<customNode>5__2.OriginalName, defaultValue: false);
							<upgradeLevel>5__4 = UpgradeBus.Instance.upgradeLevels.GetValueOrDefault(<customNode>5__2.OriginalName, 0);
							<customNode>5__2.Unlocked = <activeUpgrade>5__3;
							<customNode>5__2.CurrentUpgrade = <upgradeLevel>5__4;
							<comp>5__5 = UpgradeBus.Instance.UpgradeObjects[<customNode>5__2.OriginalName].GetComponent<BaseUpgrade>();
							<free>5__6 = <comp>5__5.CanInitializeOnStart;
							if (<activeUpgrade>5__3 | <free>5__6)
							{
								<comp>5__5.Load();
								if (!<customNode>5__2.SharedUpgrade)
								{
									<>4__this.LockUpgradeServerRpc(<customNode>5__2.OriginalName, UpgradeBus.Instance.GetLocalPlayer().actualClientId);
								}
							}
							if (<free>5__6)
							{
								<customNode>5__2.Unlocked = true;
							}
							<comp>5__5 = null;
							<customNode>5__2 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(List<CustomTerminalNode>.Enumerator);
					RandomizeUpgradeManager.RandomizeUpgrades();
					return false;
				}
			}

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

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

		private LguSaveV1 oldSave;

		internal ulong playerID = 0uL;

		private static readonly LguLogger logger = new LguLogger("LguStore");

		private const string saveDataKey = "LGU_SAVE_DATA";

		private bool receivedSave;

		internal bool alreadyReceivedScrapToUpgrade = false;

		public static LguStore Instance { get; internal set; }

		public SaveInfo SaveInfo { get; internal set; }

		public LguSave LguSave { get; internal set; }

		private void Awake()
		{
			Instance = this;
			if (((NetworkBehaviour)this).NetworkManager.IsHost)
			{
				FetchLGUSaveFile();
				UpdateUpgradeBus();
				UpgradeBus.Instance.Reconstruct();
				HandleSpawns();
				receivedSave = true;
				alreadyReceivedScrapToUpgrade = true;
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(WaitForConfigSync());
			}
		}

		[IteratorStateMachine(typeof(<WaitForConfigSync>d__19))]
		private IEnumerator WaitForConfigSync()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForConfigSync>d__19(0)
			{
				<>4__this = this
			};
		}

		private void FetchLGUSaveFile()
		{
			string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
			int saveFileNum = GameNetworkManager.Instance.saveFileNum;
			string path = Path.Combine(Application.persistentDataPath, $"LGU_{saveFileNum}.json");
			if (File.Exists(path))
			{
				string text = File.ReadAllText(path);
				oldSave = JsonConvert.DeserializeObject<LguSaveV1>(text);
				File.Delete(path);
			}
			string text2 = (string)ES3.Load("LGU_SAVE_DATA", currentSaveFileName, (object)null);
			if (text2 != null)
			{
				logger.LogInfo($"Loading save file for slot {saveFileNum}.");
				LguSave = JsonConvert.DeserializeObject<LguSave>(text2);
			}
			else
			{
				logger.LogInfo($"No save file found for slot {saveFileNum}. Creating new.");
				LguSave = new LguSave();
			}
			RandomizeUpgradeManager.SetRandomUpgradeSeed(LguSave.randomUpgradeSeed);
			UpgradeBus.Instance.discoveredItems = LguSave.discoveredItems;
			UpgradeBus.Instance.contributionValues = LguSave.contributedValues;
			UpgradeBus.Instance.scrapToCollectionUpgrade = LguSave.scrapToUpgrade;
		}

		[ServerRpc(RequireOwnership = false)]
		public void ServerSaveFileServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3660140255u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3660140255u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ServerSaveFile();
				}
			}
		}

		internal void ServerSaveFile()
		{
			string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
			LguSave.scrapToUpgrade = UpgradeBus.Instance.scrapToCollectionUpgrade;
			LguSave.contributedValues = UpgradeBus.Instance.contributionValues;
			LguSave.discoveredItems = UpgradeBus.Instance.discoveredItems;
			LguSave.randomUpgradeSeed = RandomizeUpgradeManager.GetRandomUpgradeSeed();
			string text = JsonConvert.SerializeObject((object)LguSave);
			ES3.Save<string>("LGU_SAVE_DATA", text, currentSaveFileName);
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateLGUSaveServerRpc(ulong id, byte[] json, bool saveFile = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3403782248u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				bool flag = json != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<byte>(json, default(ForPrimitives));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref saveFile, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3403782248u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				string @string = Encoding.ASCII.GetString(json);
				LguSave.playerSaves[id] = JsonConvert.DeserializeObject<SaveInfo>(@string);
				logger.LogInfo($"Received and updated save info for client: {id}");
				if (saveFile)
				{
					ServerSaveFile();
				}
			}
		}

		public void HandleSpawns()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				num++;
				GameObject val = Object.Instantiate<GameObject>(upgradeNode.Prefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
			logger.LogInfo($"Successfully spawned {num} upgrade objects.");
			GameObject val2 = Object.Instantiate<GameObject>(AssetBundleHandler.GetPerkGameObject("Interns"));
			((Object)val2).hideFlags = (HideFlags)61;
			val2.GetComponent<NetworkObject>().Spawn(false);
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayersFiredServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2089982450u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2089982450u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ResetUpgradeBusClientRpc();
					UpgradeBus.Instance.ResetAllValues(wipeObjRefs: false);
					string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
					LguSave = new LguSave();
					string text = JsonConvert.SerializeObject((object)LguSave);
					ES3.Save<string>("LGU_SAVE_DATA", text, currentSaveFileName);
				}
			}
		}

		[ClientRpc]
		private void ResetUpgradeBusClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1911080320u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1911080320u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				logger.LogInfo("Players fired, reseting upgrade bus.");
				UpgradeBus.Instance.ResetAllValues(wipeObjRefs: false);
				if (!((NetworkBehaviour)this).IsHost || !((NetworkBehaviour)this).IsServer)
				{
					LguSave = new LguSave();
				}
				SaveInfo = new SaveInfo();
				((MonoBehaviour)this).StartCoroutine(WaitForUpgradeObject());
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ShareSaveServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(281725566u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 281725566u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			string s = JsonConvert.SerializeObject((object)LguSave);
			ShareSaveClientRpc(Encoding.ASCII.GetBytes(s));
			List<StringContainer> list = new List<StringContainer>();
			List<StringContainer> list2 = new List<StringContainer>();
			foreach (KeyValuePair<string, List<string>> item in UpgradeBus.Instance.scrapToCollectionUpgrade)
			{
				foreach (string item2 in item.Value)
				{
					list.Add(new StringContainer
					{
						SomeText = item.Key
					});
					list2.Add(new StringContainer
					{
						SomeText = item2
					});
				}
			}
			SetScrapToUpgradeDictionaryClientRpc(list.ToArray(), list2.ToArray());
		}

		[ClientRpc]
		internal void SetScrapToUpgradeDictionaryClientRpc(StringContainer[] scraps, StringContainer[] upgrades)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3283209017u, val, (RpcDelivery)0);
				bool flag = scraps != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<StringContainer>(scraps, default(ForNetworkSerializable));
				}
				bool flag2 = upgrades != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<StringContainer>(upgrades, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3283209017u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!alreadyReceivedScrapToUpgrade)
			{
				for (int i = 0; i < scraps.Length; i++)
				{
					ItemProgressionManager.AddScrapToUpgrade(upgrades[i].SomeText, scraps[i].SomeText);
				}
				alreadyReceivedScrapToUpgrade = true;
			}
		}

		[ClientRpc]
		public void ShareSaveClientRpc(byte[] json)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1063442667u, val, (RpcDelivery)0);
				bool flag = json != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<byte>(json, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1063442667u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (receivedSave)
			{
				logger.LogInfo("Save file already received from host, disregarding.");
				{
					foreach (CustomTerminalNode key in UpgradeBus.Instance.lockedUpgrades.Keys)
					{
						LockUpgradeServerRpc(key.OriginalName, UpgradeBus.Instance.lockedUpgrades[key]);
					}
					return;
				}
			}
			receivedSave = true;
			logger.LogInfo("Save file received, registering upgrade objects and deserializing.");
			BaseUpgrade[] array = Object.FindObjectsOfType<BaseUpgrade>();
			foreach (BaseUpgrade baseUpgrade in array)
			{
				baseUpgrade.Register();
			}
			LguSave = JsonConvert.DeserializeObject<LguSave>(Encoding.ASCII.GetString(json));
			List<ulong> list = LguSave.playerSaves.Keys.ToList();
			if (UpgradeBus.Instance.PluginConfiguration.SHARED_UPGRADES.Value && list.Count > 0)
			{
				ulong num = LguSave.playerSaves.Keys.ToList()[0];
				logger.LogInfo($"SHARED SAVE FILE: Loading index 0 save under steam ID: {num}");
				SaveInfo = LguSave.playerSaves[num];
				UpdateUpgradeBus(UseLocalSteamID: false);
			}
			else
			{
				UpdateUpgradeBus();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RegisterNewPlayerServerRpc(ulong id, byte[] json, ServerRpcParams parameters = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1893924666u, parameters, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, id);
				bool flag = json != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<byte>(json, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1893924666u, parameters, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				LguSave.playerSaves.Add(id, JsonConvert.DeserializeObject<SaveInfo>(Encoding.ASCII.GetString(json)));
			}
		}

		private void CheckForOldData(SaveInfoV1 saveInfo)
		{
			if (saveInfo.exoskeleton)
			{
				UpgradeBus.Instance.activeUpgrades["Back Muscles"] = saveInfo.exoskeleton;
				UpgradeBus.Instance.upgradeLevels["Back Muscles"] = saveInfo.backLevel;
			}
			if (saveInfo.beekeeper)
			{
				UpgradeBus.Instance.activeUpgrades["Beekeeper"] = saveInfo.beekeeper;
				UpgradeBus.Instance.upgradeLevels["Beekeeper"] = saveInfo.beeLevel;
			}
			if (saveInfo.biggerLungs)
			{
				UpgradeBus.Instance.activeUpgrades["Bigger Lungs"] = saveInfo.biggerLungs;
				UpgradeBus.Instance.upgradeLevels["Bigger Lungs"] = saveInfo.lungLevel;
			}
			if (saveInfo.doorsHydraulicsBattery)
			{
				UpgradeBus.Instance.activeUpgrades["Shutter Batteries"] = saveInfo.doorsHydraulicsBattery;
				UpgradeBus.Instance.upgradeLevels["Shutter Batteries"] = saveInfo.doorsHydraulicsBatteryLevel;
			}
			if (saveInfo.hunter)
			{
				UpgradeBus.Instance.activeUpgrades["Hunter"] = saveInfo.hunter;
				UpgradeBus.Instance.upgradeLevels["Hunter"] = saveInfo.huntLevel;
			}
			if (saveInfo.nightVision)
			{
				UpgradeBus.Instance.activeUpgrades["NV Headset Batteries"] = saveInfo.nightVision;
				UpgradeBus.Instance.upgradeLevels["NV Headset Batteries"] = saveInfo.nightVisionLevel;
			}
			if (saveInfo.playerHealth)
			{
				UpgradeBus.Instance.activeUpgrades["Stimpack"] = saveInfo.playerHealth;
				UpgradeBus.Instance.upgradeLevels["Stimpack"] = saveInfo.playerHealthLevel;
			}
			if (saveInfo.proteinPowder)
			{
				UpgradeBus.Instance.activeUpgrades["Protein Powder"] = saveInfo.proteinPowder;
				UpgradeBus.Instance.upgradeLevels["Protein Powder"] = saveInfo.proteinLevel;
			}
			if (saveInfo.runningShoes)
			{
				UpgradeBus.Instance.activeUpgrades["Running Shoes"] = saveInfo.runningShoes;
				UpgradeBus.Instance.upgradeLevels["Running Shoes"] = saveInfo.runningLevel;
			}
			if (saveInfo.scannerUpgrade)
			{
				UpgradeBus.Instance.activeUpgrades["Better Scanner"] = saveInfo.scannerUpgrade;
				UpgradeBus.Instance.upgradeLevels["Better Scanner"] = saveInfo.scanLevel;
			}
			if (saveInfo.strongLegs)
			{
				UpgradeBus.Instance.activeUpgrades["Strong Legs"] = saveInfo.strongLegs;
				UpgradeBus.Instance.upgradeLevels["Strong Legs"] = saveInfo.legLevel;
			}
			if (saveInfo.terminalFlash)
			{
				UpgradeBus.Instance.activeUpgrades["Strong Legs"] = saveInfo.terminalFlash;
				UpgradeBus.Instance.upgradeLevels["Strong Legs"] = saveInfo.discoLevel;
			}
			if (saveInfo.walkies)
			{
				UpgradeBus.Instance.activeUpgrades["Walkie GPS"] = saveInfo.walkies;
			}
			if (saveInfo.lockSmith)
			{
				UpgradeBus.Instance.activeUpgrades["Locksmith"] = saveInfo.lockSmith;
			}
			if (saveInfo.sickBeats)
			{
				UpgradeBus.Instance.activeUpgrades["Sick Beats"] = saveInfo.sickBeats;
			}
			if (saveInfo.pager)
			{
				UpgradeBus.Instance.activeUpgrades["Fast Encryption"] = saveInfo.pager;
			}
			if (saveInfo.DestroyTraps)
			{
				UpgradeBus.Instance.activeUpgrades["Malware Broadcaster"] = saveInfo.DestroyTraps;
			}
			if (saveInfo.lightningRod)
			{
				UpgradeBus.Instance.activeUpgrades["Lightning Rod"] = saveInfo.lightningRod;
			}
		}

		public void UpdateUpgradeBus(bool UseLocalSteamID = true, bool checkID = true)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (UseLocalSteamID)
			{
				if (playerID == 0 && checkID)
				{
					logger.LogInfo("SteamID is not available yet, waiting...");
					((MonoBehaviour)this).StartCoroutine(WaitForSteamID());
					return;
				}
				if (!LguSave.playerSaves.ContainsKey(playerID))
				{
					logger.LogInfo($"{playerID} Was not found in save dictionary! Creating new save for ID.");
					SaveInfo = new SaveInfo();
					RegisterNewPlayerServerRpc(playerID, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)SaveInfo)));
					((MonoBehaviour)this).StartCoroutine(WaitForUpgradeObject());
					return;
				}
				SaveInfo = LguSave.playerSaves[playerID];
				logger.LogInfo($"Successfully loaded save data for ID: {playerID}");
			}
			UpgradeBus.Instance.activeUpgrades = SaveInfo.activeUpgrades;
			UpgradeBus.Instance.upgradeLevels = SaveInfo.upgradeLevels;
			if (oldSave != null && oldSave.playerSaves.ContainsKey(playerID))
			{
				CheckForOldData(oldSave.playerSaves[playerID]);
				ServerSaveFileServerRpc();
			}
			ContractManager.Instance.contractLevel = SaveInfo.contractLevel;
			ContractManager.Instance.contractType = SaveInfo.contractType;
			CurrencyManager.Instance.CurrencyAmount = SaveInfo.currencyAmount;
			CurrencyManager.Instance.SpentCurrencyAmount = SaveInfo.spentCurrencyAmount;
			UpgradeBus.Instance.SaleData = SaveInfo.SaleData;
			UpgradeBus.Instance.LoadSales();
			((MonoBehaviour)this).StartCoroutine(WaitForUpgradeObject());
		}

		[IteratorStateMachine(typeof(<WaitForSteamID>d__33))]
		private IEnumerator WaitForSteamID()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForSteamID>d__33(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<WaitForUpgradeObject>d__34))]
		private IEnumerator WaitForUpgradeObject()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForUpgradeObject>d__34(0)
			{
				<>4__this = this
			};
		}

		internal void UpdateUpgrades(CustomTerminalNode node, bool increment = false, bool downgrade = false)
		{
			if (downgrade)
			{
				ExecuteUpgradeDowngrade(node);
				return;
			}
			node.Unlocked = true;
			BaseUpgrade component = UpgradeBus.Instance.UpgradeObjects[node.OriginalName].GetComponent<BaseUpgrade>();
			if (increment)
			{
				node.CurrentUpgrade++;
				if (component is TierUpgrade tierUpgrade)
				{
					logger.LogInfo("upgrade already unlocked, executing TierUpgrade.Increment()");
					tierUpgrade.Increment();
				}
				else
				{
					logger.LogInfo("Upgrade cannot be incremented. Skipping...");
				}
			}
			else
			{
				logger.LogInfo("First purchase, executing BaseUpgrade.load()");
				component.Load();
			}
			logger.LogInfo($"Node found ({node.OriginalName}) and unlocked (level = {node.CurrentUpgrade})");
			ItemProgressionManager.SetContributionValue(node.OriginalName, 0);
			if (node.SalePercentage != 1f && UpgradeBus.Instance.PluginConfiguration.SALE_APPLY_ONCE.Value)
			{
				node.SalePercentage = 1f;
				UpgradeBus.Instance.SaleData[node.Name] = node.SalePercentage;
			}
			SaveInfo = new SaveInfo();
			UpdateLGUSaveServerRpc(playerID, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)SaveInfo)));
		}

		private void ExecuteUpgradeDowngrade(CustomTerminalNode node)
		{
			BaseUpgrade component = UpgradeBus.Instance.UpgradeObjects[node.OriginalName].GetComponent<BaseUpgrade>();
			if (node.CurrentUpgrade > 0)
			{
				node.CurrentUpgrade--;
				if (component is TierUpgrade tierUpgrade)
				{
					tierUpgrade.Decrement();
				}
			}
			else
			{
				node.Unlocked = false;
				component.Unwind();
			}
		}

		public void HandleUpgrade(CustomTerminalNode node, bool increment = false, bool downgrade = false)
		{
			if (node.SharedUpgrade)
			{
				logger.LogInfo(node.OriginalName + " is registered as a shared upgrade! Calling ServerRpc...");
				HandleUpgradeServerRpc(node.OriginalName, increment, downgrade);
			}
			else
			{
				logger.LogInfo(node.OriginalName + " is not registered as a shared upgrade! Unlocking on this client only...");
				LockUpgradeServerRpc(node.OriginalName, UpgradeBus.Instance.GetLocalPlayer().actualClientId);
				UpdateUpgrades(node, increment, downgrade);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void LockUpgradeServerRpc(string upgradeName, ulong purchasingClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(870083266u, val, (RpcDelivery)0);
				bool flag = upgradeName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(upgradeName, false);
				}
				BytePacker.WriteValueBitPacked(val2, purchasingClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 870083266u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.BuyableUpgradeOnce))
				{
					LockUpgradeClientRpc(upgradeName, purchasingClientId);
				}
			}
		}

		[ClientRpc]
		private void LockUpgradeClientRpc(string upgradeName, ulong purchasingClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2992734589u, val, (RpcDelivery)0);
				bool flag = upgradeName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(upgradeName, false);
				}
				BytePacker.WriteValueBitPacked(val2, purchasingClientId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2992734589u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (UpgradeBus.Instance.GetLocalPlayer().actualClientId != purchasingClientId)
			{
				CustomTerminalNode upgradeNode = UpgradeBus.Instance.GetUpgradeNode(upgradeName);
				if (!UpgradeBus.Instance.lockedUpgrades.Keys.Contains(upgradeNode))
				{
					UpgradeBus.Instance.lockedUpgrades.Add(upgradeNode, purchasingClientId);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void HandleUpgradeServerRpc(string name, bool increment, bool downgrade)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4190380145u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref increment, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref downgrade, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4190380145u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				logger.LogInfo($"Received server request to handle shared upgrade for: {name} increment: {increment}");
				HandleUpgradeClientRpc(name, increment, downgrade);
			}
		}

		[ClientRpc]
		public void HandleUpgradeClientRpc(string name, bool increment, bool downgrade)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3782564916u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref increment, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref downgrade, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3782564916u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			logger.LogInfo($"Received client request to handle shared upgrade for: {name} increment: {increment}");
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				if (upgradeNode.OriginalName == name)
				{
					UpdateUpgrades(upgradeNode, increment, downgrade);
				}
			}
		}

		[ClientRpc]
		public void HandleUpgradeForNoHostClientRpc(string name, bool increment)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3882434201u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref increment, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3882434201u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsHost)
			{
				return;
			}
			logger.LogInfo($"Received client request to handle shared upgrade for: {name} increment: {increment}");
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				if (upgradeNode.OriginalName == name)
				{
					UpdateUpgrades(upgradeNode, increment);
				}
			}
		}

		[ClientRpc]
		public void GenerateSalesClientRpc(int seed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3488565042u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, seed);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3488565042u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GenerateSales(seed);
				}
			}
		}

		internal void GenerateSales(int seed = -1)
		{
			if (seed == -1)
			{
				seed = Random.Range(0, 999999);
			}
			logger.LogInfo($"Generating sales with seed: {seed} on this client...");
			Random.InitState(seed);
			UpgradeBus.Instance.SaleData = new Dictionary<string, float>();
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				if (Random.value > UpgradeBus.Instance.PluginConfiguration.SALE_PERC.Value)
				{
					upgradeNode.SalePercentage = Random.Range(0.6f, 0.9f);
					logger.LogInfo($"Set sale percentage to: {upgradeNode.SalePercentage} for {upgradeNode.Name}.");
				}
				else
				{
					upgradeNode.SalePercentage = 1f;
				}
				if (((NetworkBehaviour)this).IsHost || ((NetworkBehaviour)this).IsServer)
				{
					logger.LogInfo("Saving node into save");
					UpgradeBus.Instance.SaleData.Add(upgradeNode.Name, upgradeNode.SalePercentage);
				}
			}
			SaveInfo = new SaveInfo();
			UpdateLGUSaveServerRpc(playerID, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)SaveInfo)), saveFile: true);
		}

		[ClientRpc]
		internal void SetContributionValueClientRpc(string key, int value)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4288430646u, val, (RpcDelivery)0);
				bool flag = key != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(key, false);
				}
				BytePacker.WriteValueBitPacked(val2, value);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4288430646u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ItemProgressionManager.SetContributionValue(key, value);
			}
		}

		[ClientRpc]
		internal void DiscoverItemClientRpc(string scrapName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(177203986u, val, (RpcDelivery)0);
				bool flag = scrapName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(scrapName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 177203986u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ItemProgressionManager.DiscoverScrap(scrapName);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void RandomizeUpgradesServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3308832361u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3308832361u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RandomizeUpgradesClientRpc(RandomizeUpgradeManager.GetRandomUpgradeSeed());
				}
			}
		}

		[ClientRpc]
		internal void RandomizeUpgradesClientRpc(int seed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3149719403u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, seed);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3149719403u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RandomizeUpgradeManager.RandomizeUpgrades(seed);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void AddUpgradeSpentCreditsServerRpc(int price)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2594588404u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, price);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2594588404u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerManager.instance.IncreaseUpgradeSpentCredits(price);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncCreditsServerRpc(int newAmount)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3086427496u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, newAmount);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3086427496u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Terminal terminal = UpgradeBus.Instance.GetTerminal();
					terminal.SyncGroupCreditsClientRpc(newAmount, terminal.numberOfItemsInDropship);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3660140255u, new RpcReceiveHandler(__rpc_handler_3660140255), "ServerSaveFileServerRpc");
			((NetworkBehaviour)this).__registerRpc(3403782248u, new RpcReceiveHandler(__rpc_handler_3403782248), "UpdateLGUSaveServerRpc");
			((NetworkBehaviour)this).__registerRpc(2089982450u, new RpcReceiveHandler(__rpc_handler_2089982450), "PlayersFiredServerRpc");
			((NetworkBehaviour)this).__registerRpc(1911080320u, new RpcReceiveHandler(__rpc_handler_1911080320), "ResetUpgradeBusClientRpc");
			((NetworkBehaviour)this).__registerRpc(281725566u, new RpcReceiveHandler(__rpc_handler_281725566), "ShareSaveServerRpc");
			((NetworkBehaviour)this).__registerRpc(3283209017u, new RpcReceiveHandler(__rpc_handler_3283209017), "SetScrapToUpgradeDictionaryClientRpc");
			((NetworkBehaviour)this).__registerRpc(1063442667u, new RpcReceiveHandler(__rpc_handler_1063442667), "ShareSaveClientRpc");
			((NetworkBehaviour)this).__registerRpc(1893924666u, new RpcReceiveHandler(__rpc_handler_1893924666), "RegisterNewPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(870083266u, new RpcReceiveHandler(__rpc_handler_870083266), "LockUpgradeServerRpc");
			((NetworkBehaviour)this).__registerRpc(2992734589u, new RpcReceiveHandler(__rpc_handler_2992734589), "LockUpgradeClientRpc");
			((NetworkBehaviour)this).__registerRpc(4190380145u, new RpcReceiveHandler(__rpc_handler_4190380145), "HandleUpgradeServerRpc");
			((NetworkBehaviour)this).__registerRpc(3782564916u, new RpcReceiveHandler(__rpc_handler_3782564916), "HandleUpgradeClientRpc");
			((NetworkBehaviour)this).__registerRpc(3882434201u, new RpcReceiveHandler(__rpc_handler_3882434201), "HandleUpgradeForNoHostClientRpc");
			((NetworkBehaviour)this).__registerRpc(3488565042u, new RpcReceiveHandler(__rpc_handler_3488565042), "GenerateSalesClientRpc");
			((NetworkBehaviour)this).__registerRpc(4288430646u, new RpcReceiveHandler(__rpc_handler_4288430646), "SetContributionValueClientRpc");
			((NetworkBehaviour)this).__registerRpc(177203986u, new RpcReceiveHandler(__rpc_handler_177203986), "DiscoverItemClientRpc");
			((NetworkBehaviour)this).__registerRpc(3308832361u, new RpcReceiveHandler(__rpc_handler_3308832361), "RandomizeUpgradesServerRpc");
			((NetworkBehaviour)this).__registerRpc(3149719403u, new RpcReceiveHandler(__rpc_handler_3149719403), "RandomizeUpgradesClientRpc");
			((NetworkBehaviour)this).__registerRpc(2594588404u, new RpcReceiveHandler(__rpc_handler_2594588404), "AddUpgradeSpentCreditsServerRpc");
			((NetworkBehaviour)this).__registerRpc(3086427496u, new RpcReceiveHandler(__rpc_handler_3086427496), "SyncCreditsServerRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3660140255(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).ServerSaveFileServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3403782248(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				byte[] json = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref json, default(ForPrimitives));
				}
				bool saveFile = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref saveFile, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).UpdateLGUSaveServerRpc(id, json, saveFile);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2089982450(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).PlayersFiredServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1911080320(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).ResetUpgradeBusClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_281725566(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).ShareSaveServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3283209017(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				StringContainer[] scraps = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<StringContainer>(ref scraps, default(ForNetworkSerializable));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				StringContainer[] upgrades = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<StringContainer>(ref upgrades, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).SetScrapToUpgradeDictionaryClientRpc(scraps, upgrades);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1063442667(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				byte[] json = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref json, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).ShareSaveClientRpc(json);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1893924666(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				byte[] json = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref json, default(ForPrimitives));
				}
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).RegisterNewPlayerServerRpc(id, json, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_870083266(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string upgradeName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref upgradeName, false);
				}
				ulong purchasingClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref purchasingClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).LockUpgradeServerRpc(upgradeName, purchasingClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2992734589(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string upgradeName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref upgradeName, false);
				}
				ulong purchasingClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref purchasingClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).LockUpgradeClientRpc(upgradeName, purchasingClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4190380145(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool increment = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref increment, default(ForPrimitives));
				bool downgrade = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref downgrade, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).HandleUpgradeServerRpc(name, increment, downgrade);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3782564916(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool increment = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref increment, default(ForPrimitives));
				bool downgrade = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref downgrade, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).HandleUpgradeClientRpc(name, increment, downgrade);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3882434201(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool increment = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref increment, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).HandleUpgradeForNoHostClientRpc(name, increment);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3488565042(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int seed = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref seed);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).GenerateSalesClientRpc(seed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4288430646(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string key = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref key, false);
				}
				int value = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref value);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).SetContributionValueClientRpc(key, value);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_177203986(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string scrapName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref scrapName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).DiscoverItemClientRpc(scrapName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3308832361(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).RandomizeUpgradesServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3149719403(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int seed = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref seed);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).RandomizeUpgradesClientRpc(seed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2594588404(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int price = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref price);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).AddUpgradeSpentCreditsServerRpc(price);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3086427496(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int newAmount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newAmount);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LguStore)(object)target).SyncCreditsServerRpc(newAmount);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LguStore";
		}
	}
	[Serializable]
	public class SaveInfo
	{
		public Dictionary<string, bool> activeUpgrades;

		public Dictionary<string, int> upgradeLevels;

		public string contractType;

		public string contractLevel;

		public Dictionary<string, float> SaleData;

		public string Version = "V2";

		public int currencyAmount;

		public int spentCurrencyAmount;

		public SaveInfo()
		{
			activeUpgrades = new Dictionary<string, bool>(UpgradeBus.Instance.activeUpgrades);
			upgradeLevels = new Dictionary<string, int>(UpgradeBus.Instance.upgradeLevels);
			SaleData = new Dictionary<string, float>(UpgradeBus.Instance.SaleData);
			contractType = ContractManager.Instance.contractType;
			contractLevel = ContractManager.Instance.contractLevel;
			currencyAmount = CurrencyManager.Instance.CurrencyAmount;
			spentCurrencyAmount = CurrencyManager.Instance.SpentCurrencyAmount;
		}
	}
	[Serializable]
	public class LguSave
	{
		public Dictionary<ulong, SaveInfo> playerSaves = new Dictionary<ulong, SaveInfo>();

		public Dictionary<string, List<string>> scrapToUpgrade;

		public Dictionary<string, int> contributedValues;

		public List<string> discoveredItems;

		public int randomUpgradeSeed;
	}
	internal static class PatchManager
	{
		internal static readonly Harmony harmony = new Harmony("com.malco.lethalcompany.moreshipupgrades");

		internal static void PatchMainVersion()
		{
			PatchEnemies();
			PatchHUD();
			PatchInteractables();
			PatchItems();
			PatchVitalComponents();
			PatchWeather();
			PatchCompatibility();
		}

		private static void PatchCompatibility()
		{
			if (OxygenCompat.Enabled)
			{
				Plugin.mls.LogInfo((object)"Oxygen mod has been detected. Proceeding to patch...");
				harmony.PatchAll(typeof(OxygenLogicPatcher));
				Plugin.mls.LogInfo((object)"Patched Oxygen mod related components for correct behaviour on Oxygen Canisters upgrade in relation to oxygen consumption. If any issues arise related to the oxygen mechanic when both LGU and Oxygen mods are present, report to LGU first.");
			}
			if (LethalCompanyVRCompat.Enabled)
			{
				Plugin.mls.LogInfo((object)"Lethal Company Virtual Reality mod has been detected. Proceeding to patch...");
				harmony.PatchAll(typeof(VRControllerPatcher));
				Plugin.mls.LogInfo((object)"Patched Lethal Company Virtual Reality mod related components for correct behaviour on Back Muscles upgrade in relation to player's weight. If any issues arise related to the weight mechanic when both LGU and Lethal Company Virtual Reality mods are present, report to LGU first.");
			}
			if (LethalConstellationsCompat.Enabled)
			{
				Plugin.mls.LogInfo((object)"Lethal Constellations has been detected. Proceeding to patch...");
				harmony.PatchAll(typeof(LevelStuffPatcher));
				Plugin.mls.LogInfo((object)"Patched Lethal Constellations mod related components for correct behaviour on Efficient Engines to affect constellation prices. If any issues arise related to this mechanic with both mods installed, report to LGU first.");
			}
			if (BrutalCompanyMinusExtraCompat.Enabled)
			{
				Plugin.mls.LogInfo((object)BrutalCompanyMinusExtraCompat.BeforePatchMessage);
				harmony.PatchAll(typeof(BrutalCompanyMinusExtraCompat.ManagerSpawnPatcher));
				harmony.PatchAll(typeof(BrutalCompanyMinusExtraCompat.GrabbableTurretPatcher));
				harmony.PatchAll(typeof(BrutalCompanyMinusExtraCompat.GrabbableLandminePatcher));
				harmony.PatchAll(typeof(BrutalCompanyMinusExtraCompat.LevelModificationsPatcher));
				Plugin.mls.LogInfo((object)BrutalCompanyMinusExtraCompat.SuccessfulPatchMessage);
			}
			if (ToilheadCompat.Enabled)
			{
				Plugin.mls.LogInfo((object)"Toilhead has been detected. Proceeding to patch...");
				harmony.PatchAll(typeof(ToilheadCompat.FollowTerminalAccessibleObjectBehaviourPatcher));
				Plugin.mls.LogInfo((object)"Patched Toilhead mod related components for correct behaviour on Malware Broadcaster to allow destroying and increased down time. If any issues arise related to turret enemies, report to LGU first.");
			}
		}

		private static void PatchEnemies()
		{
			harmony.PatchAll(typeof(ButlerEnemyAIPatcher));
			harmony.PatchAll(typeof(ButlerBeesPatcher));
			harmony.PatchAll(typeof(ClaySurgeonAIPatcher));
			harmony.PatchAll(typeof(EnemyAIPatcher));
			harmony.PatchAll(typeof(EnemyAICollisionDetectPatcher));
			harmony.PatchAll(typeof(HoarderBugAIPatcher));
			harmony.PatchAll(typeof(RedLocustBeesPatch));
			harmony.PatchAll(typeof(CaveDwellerAIPatcher));
			Plugin.mls.LogInfo((object)"Enemies have been patched");
		}

		private static void PatchHUD()
		{
			harmony.PatchAll(typeof(HudManagerPatcher));
			Plugin.mls.LogInfo((object)"HUD has been patched");
		}

		private static void PatchInteractables()
		{
			harmony.PatchAll(typeof(DepositItemsDeskPatcher));
			harmony.PatchAll(typeof(DoorLockPatcher));
			harmony.PatchAll(typeof(HangarShipDoorPatcher));
			harmony.PatchAll(typeof(InteractTriggerPatcher));
			harmony.PatchAll(typeof(QuicksandTriggerPatcher));
			harmony.PatchAll(typeof(SteamValveHazardPatch));
			harmony.PatchAll(typeof(EntranceTeleportPatcher));
			harmony.PatchAll(typeof(ShipTeleporterPatcher));
			harmony.PatchAll(typeof(VehicleControllerPatcher));
			Plugin.mls.LogInfo((object)"Interactables have been patched");
		}

		private static void PatchItems()
		{
			harmony.PatchAll(typeof(BeltBagItemPatcher));
			harmony.PatchAll(typeof(BoomBoxPatcher));
			harmony.PatchAll(typeof(DropPodPatcher));
			harmony.PatchAll(typeof(GrabbableObjectPatcher));
			harmony.PatchAll(typeof(KnifePatcher));
			harmony.PatchAll(typeof(PatchToolPatcher));
			harmony.PatchAll(typeof(RadarBoosterPatcher));
			harmony.PatchAll(typeof(ShovelPatcher));
			harmony.PatchAll(typeof(ShotgunPatcher));
			harmony.PatchAll(typeof(WalkiePatcher));
			harmony.PatchAll(typeof(SprayPaintItemPatcher));
			harmony.PatchAll(typeof(JetpackItemPatcher));
			harmony.PatchAll(typeof(LungPropPatcher));
			Plugin.mls.LogInfo((object)"Items have been patched");
		}

		private static void PatchVitalComponents()
		{
			harmony.PatchAll(typeof(GameNetworkManagerPatcher));
			harmony.PatchAll(typeof(PlayerControllerBPatcher));
			harmony.PatchAll(typeof(RoundManagerPatcher));
			harmony.PatchAll(typeof(StartOfRoundPatcher));
			harmony.PatchAll(typeof(TimeOfDayPatcher));
			harmony.PatchAll(typeof(TimeOfDayTranspilerPatcher));
			harmony.PatchAll(typeof(TerminalAccessibleObjectPatcher));
			harmony.PatchAll(typeof(TerminalPatcher));
			harmony.PatchAll(typeof(Keybinds));
			Plugin.mls.LogInfo((object)"Game managers have been patched");
		}

		private static void PatchWeather()
		{
			harmony.PatchAll(typeof(StormyWeatherPatcher));
			Plugin.mls.LogInfo((object)"Weathers have been patched");
		}
	}
	internal class PlayerManager : MonoBehaviour
	{
		internal int upgradeSpendCredits = 0;

		internal static PlayerManager instance;

		private void Awake()
		{
			instance = this;
		}

		internal void IncreaseUpgradeSpentCredits(int amount)
		{
			upgradeSpendCredits += amount;
		}

		internal void ResetUpgradeSpentCredits()
		{
			upgradeSpendCredits = 0;
		}

		internal int GetUpgradeSpentCredits()
		{
			return upgradeSpendCredits;
		}
	}
	public static class RandomizeUpgradeManager
	{
		public enum RandomizeUpgradeEvents
		{
			PerQuota,
			PerMoonRouting,
			PerMoonLanding
		}

		private static int visibleNodes;

		private const double UPGRADE_PICK_PROBABILITY = 0.5;

		private static RandomizeUpgradeEvents ConfiguredChangeEvent => SyncedEntry<RandomizeUpgradeEvents>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT);

		private static int ConfiguredUpgradeAmount => SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.RANDOMIZE_UPGRADES_AMOUNT);

		private static bool IsRandomizedEnabled => SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.RANDOMIZE_UPGRADES_ENABLED);

		private static bool AlwaysShowPurchased => SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED);

		internal static void RandomizeUpgrades()
		{
			if (IsRandomizedEnabled)
			{
				RandomizeUpgrades(UpgradeBus.Instance.randomUpgradeSeed);
			}
		}

		internal static void RandomizeUpgrades(RandomizeUpgradeEvents triggeredEvent)
		{
			if (((NetworkBehaviour)LguStore.Instance).IsHost && IsRandomizedEnabled && ConfiguredChangeEvent == triggeredEvent)
			{
				LguStore.Instance.RandomizeUpgradesClientRpc(new Random().Next());
			}
		}

		internal static void RandomizeUpgrades(int seed)
		{
			if (!IsRandomizedEnabled)
			{
				return;
			}
			SetRandomUpgradeSeed(seed);
			Random random = new Random(seed);
			ResetAllUpgrades();
			int configuredUpgradeAmount = ConfiguredUpgradeAmount;
			List<CustomTerminalNode> upgradeNodes = UpgradeBus.GetUpgradeNodes();
			if (upgradeNodes.Count - visibleNodes < configuredUpgradeAmount)
			{
				foreach (CustomTerminalNode item in upgradeNodes)
				{
					item.Visible = true;
				}
				return;
			}
			int num = 0;
			while (num < configuredUpgradeAmount)
			{
				CustomTerminalNode customTerminalNode = upgradeNodes[random.Next(0, upgradeNodes.Count)];
				if (!customTerminalNode.Visible && num < configuredUpgradeAmount && random.NextDouble() > 0.5)
				{
					customTerminalNode.Visible = true;
					num++;
				}
			}
		}

		private static void ResetAllUpgrades()
		{
			visibleNodes = 0;
			foreach (CustomTerminalNode upgradeNode in UpgradeBus.GetUpgradeNodes())
			{
				upgradeNode.Visible = !IsRandomizedEnabled || (upgradeNode.Unlocked && AlwaysShowPurchased);
				if (upgradeNode.Visible)
				{
					visibleNodes++;
				}
			}
		}

		internal static void SetRandomUpgradeSeed(int seed)
		{
			if (seed == 0)
			{
				Plugin.mls.LogInfo((object)"Random upgrades seed wasn't set, calculating a new seed..");
				UpgradeBus.Instance.randomUpgradeSeed = new Random().Next();
				LguStore.Instance.ServerSaveFile();
			}
			else
			{
				UpgradeBus.Instance.randomUpgradeSeed = seed;
			}
		}

		internal static int GetRandomUpgradeSeed()
		{
			return UpgradeBus.Instance.randomUpgradeSeed;
		}
	}
	public class UpgradeBus : MonoBehaviour
	{
		private static readonly LguLogger logger = new LguLogger("UpgradeBus");

		internal Dictionary<string, bool> activeUpgrades = new Dictionary<string, bool>();

		internal Dictionary<string, int> upgradeLevels = new Dictionary<string, int>();

		internal Dictionary<string, List<string>> scrapToCollectionUpgrade = new Dictionary<string, List<string>>();

		internal Dictionary<string, int> contributionValues = new Dictionary<string, int>();

		internal List<string> discoveredItems = new List<string>();

		internal int randomUpgradeSeed;

		internal Dictionary<string, float> SaleData = new Dictionary<string, float>();

		internal AudioClip flashNoise;

		internal GameObject modStorePrefab;

		internal readonly List<Type> upgradeTypes = new List<Type>();

		internal readonly List<Type> commandTypes = new List<Type>();

		internal readonly List<Type> itemTypes = new List<Type>();

		internal List<CustomTerminalNode> terminalNodes = new List<CustomTerminalNode>();

		internal Dictionary<CustomTerminalNode, ulong> lockedUpgrades = new Dictionary<CustomTerminalNode, ulong>();

		internal Dictionary<string, GameObject> UpgradeObjects = new Dictionary<string, GameObject>();

		internal Dictionary<string, Item> ItemsToSync = new Dictionary<string, Item>();

		internal AssetBundle UpgradeAssets;

		private Terminal terminal;

		private PlayerControllerB playerController;

		internal static UpgradeBus Instance { get; set; }

		internal LategameConfiguration PluginConfiguration { get; set; }

		private void Awake()
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public Terminal GetTerminal()
		{
			if ((Object)(object)terminal == (Object)null)
			{
				terminal = GameObject.Find("TerminalScript").GetComponent<Terminal>();
			}
			return terminal;
		}

		public PlayerControllerB GetLocalPlayer()
		{
			if ((Object)(object)playerController == (Object)null)
			{
				playerController = GameNetworkManager.Instance.localPlayerController;
			}
			return playerController;
		}

		public void ResetAllValues(bool wipeObjRefs = true)
		{
			if ((Object)(object)LguStore.Instance == (Object)null)
			{
				return;
			}
			ResetPlayerAttributes();
			if (PluginConfiguration.SickBeatsUpgradeConfiguration.Enabled.Value)
			{
				SickBeats.Instance.EffectsActive = false;
				SickBeats.Instance.BoomboxIcon.SetActive(false);
			}
			if (PluginConfiguration.NightVisionUpgradeConfiguration.Enabled.Value)
			{
				NightVision.Instance.nightVisionActive = false;
			}
			if (SyncedEntry<bool>.op_Implicit(PluginConfiguration.FedoraSuitConfiguration.Enabled))
			{
				FedoraSuit.instance.wearingFedora.Clear();
			}
			ContractManager.Instance.ResetAllValues();
			CurrencyManager.Instance.ResetAllValues();
			if (SyncedEntry<bool>.op_Implicit(PluginConfiguration.WalkieGpsConfiguration.Enabled))
			{
				WalkieGPS.instance.WalkieDeactivate();
			}
			if (PluginConfiguration.DiscombobulatorUpgradeConfiguration.Enabled.Value)
			{
				Discombobulator.instance.flashCooldown = 0f;
			}
			if (PluginConfiguration.BackMusclesConfiguration.Enabled.Value)
			{
				BackMuscles.Instance.alteredWeight = 1f;
			}
			if (SyncedEntry<bool>.op_Implicit(PluginConfiguration.LightningRodConfiguration.Enabled))
			{
				LightningRod.instance.ResetValues();
			}
			if (wipeObjRefs)
			{
				UpgradeObjects = new Dictionary<string, GameObject>();
				discoveredItems.Clear();
				scrapToCollectionUpgrade.Clear();
				contributionValues.Clear();
			}
			foreach (CustomTerminalNode terminalNode in terminalNodes)
			{
				terminalNode.Unlocked = false;
				terminalNode.CurrentUpgrade = 0;
			}
			foreach (string item in activeUpgrades.Keys.ToList())
			{
				activeUpgrades[item] = false;
			}
			foreach (string item2 in upgradeLevels.Keys.ToList())
			{
				upgradeLevels[item2] = 0;
			}
			terminal = null;
			playerController = null;
		}

		private void ResetPlayerAttributes()
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!((Object)(object)localPlayerController == (Object)null))
			{
				logger.LogDebug("Resetting " + localPlayerController.playerUsername + "'s attributes");
				IPlayerSync[] array = UpgradeObjects.Values.Select((GameObject upgrade) => upgrade.GetComponent<BaseUpgrade>()).OfType<IPlayerSync>().ToArray();
				foreach (IPlayerSync playerSync in array)
				{
					playerSync.ResetPlayerAttribute();
				}
			}
		}

		internal CustomTerminalNode GetUpgradeNode(string upgradeName)
		{
			foreach (CustomTerminalNode terminalNode in terminalNodes)
			{
				if (terminalNode.OriginalName.Equals(upgradeName, StringComparison.OrdinalIgnoreCase) || terminalNode.Name.Equals(upgradeName, StringComparison.OrdinalIgnoreCase))
				{
					return terminalNode;
				}
			}
			return null;
		}

		internal static bool ContainsUpgradeNode(CustomTerminalNode node)
		{
			foreach (CustomTerminalNode terminalNode in Instance.GetTerminalNodes())
			{
				if (terminalNode.OriginalName == node.OriginalName && terminalNode.Name == node.Name)
				{
					return true;
				}
			}
			return false;
		}

		internal List<CustomTerminalNode> GetTerminalNodes()
		{
			return terminalNodes;
		}

		internal static List<CustomTerminalNode> GetUpgradeNodes()
		{
			return Instance.GetTerminalNodes();
		}

		internal void LoadSales()
		{
			if (SaleData.Count == 0)
			{
				logger.LogInfo("Sale data empty, continuing...");
				return;
			}
			foreach (CustomTerminalNode terminalNode in terminalNodes)
			{
				if (SaleData.ContainsKey(terminalNode.Name))
				{
					terminalNode.SalePercentage = SaleData[terminalNode.Name];
					if (terminalNode.SalePercentage != 1f)
					{
						logger.LogInfo($"Loaded sale of {terminalNode.SalePercentage} for {terminalNode.Name}.");
					}
				}
			}
		}

		internal void AlterStoreItem(string itemName, bool configuredEnable, int configuredPrice)
		{
			Item val = ItemsToSync[itemName];
			if (!configuredEnable)
			{
				ItemManager.RemoveShopItem(val);
				logger.LogInfo("Removing " + itemName + " from store.");
			}
			else if (val.creditsWorth != configuredPrice)
			{
				logger.LogInfo($"Changing {itemName}'s price from {val.creditsWorth} to {configuredPrice}");
				ItemManager.UpdateShopItemPrice(val, configuredPrice);
			}
		}

		internal void AlterStoreItems()
		{
			AlterStoreItem("Medkit", SyncedEntry<bool>.op_Implicit(PluginConfiguration.MEDKIT_ENABLED), SyncedEntry<int>.op_Implicit(PluginConfiguration.MEDKIT_PRICE));
			AlterStoreItem("Night Vision Goggles", SyncedEntry<bool>.op_Implicit(PluginConfiguration.NightVisionUpgradeConfiguration.Enabled), SyncedEntry<int>.op_Implicit(PluginConfiguration.NightVisionUpgradeConfiguration.ItemPrice));
		}

		private void SyncAvailableContracts()
		{
			if (!PluginConfiguration.ContractsConfiguration.DataConfiguration.Enabled.Value || !PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				logger.LogInfo("Removing data contract");
				int num = CommandParser.contracts.IndexOf("Data");
				if (num != -1)
				{
					CommandParser.contractInfos.RemoveAt(num);
					CommandParser.contracts.RemoveAt(num);
				}
			}
			if (!PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.Enabled.Value || !PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				logger.LogInfo("Removing extraction contract");
				int num2 = CommandParser.contracts.IndexOf("Extraction");
				if (num2 != -1)
				{
					CommandParser.contractInfos.RemoveAt(num2);
					CommandParser.contracts.RemoveAt(num2);
				}
			}
			if (!PluginConfiguration.ContractsConfiguration.ExorcismConfiguration.Enabled.Value || !PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				logger.LogInfo("Removing exorcism contract");
				int num3 = CommandParser.contracts.IndexOf("Exorcism");
				if (num3 != -1)
				{
					CommandParser.contractInfos.RemoveAt(num3);
					CommandParser.contracts.RemoveAt(num3);
				}
			}
			if (!PluginConfiguration.ContractsConfiguration.DefusalConfiguration.Enabled.Value || !PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				logger.LogInfo("Removing defusal contract");
				int num4 = CommandParser.contracts.IndexOf("Defusal");
				if (num4 != -1)
				{
					CommandParser.contractInfos.RemoveAt(num4);
					CommandParser.contracts.RemoveAt(num4);
				}
			}
			if (PluginConfiguration.ContractsConfiguration.ExterminationConfiguration.Enabled.Value && PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				return;
			}
			if (CommandParser.contracts.Count == 1 && PluginConfiguration.ContractsConfiguration.Enabled.Value)
			{
				logger.LogInfo("Why must you do the things you do");
				logger.LogWarning("User tried to remove all contracts! Leaving exterminator present. Did you mean to disable contracts?");
				return;
			}
			logger.LogInfo("Removing exterminator contract");
			int num5 = CommandParser.contracts.IndexOf("Exterminator");
			if (num5 != -1)
			{
				CommandParser.contractInfos.RemoveAt(num5);
				CommandParser.contracts.RemoveAt(num5);
			}
		}

		internal void Reconstruct()
		{
			AlterStoreItems();
			BuildCustomNodes();
			SyncAvailableContracts();
			logger.LogInfo("Successfully reconstructed with hosts config.");
			if (((NetworkBehaviour)LguStore.Instance).IsClient && !((NetworkBehaviour)LguStore.Instance).IsHost)
			{
				LguStore.Instance.RandomizeUpgradesServerRpc();
			}
		}

		internal void BuildCustomNodes()
		{
			terminalNodes = new List<CustomTerminalNode>();
			foreach (Type upgradeType in upgradeTypes)
			{
				MethodInfo method = upgradeType.GetMethod("RegisterTerminalNode", BindingFlags.Static | BindingFlags.Public);
				CustomTerminalNode customTerminalNode = (CustomTerminalNode)method.Invoke(null, null);
				if (customTerminalNode != null)
				{
					terminalNodes.Add(customTerminalNode);
				}
			}
			terminalNodes.Sort();
			ItemProgressionManager.InitializeContributionValues();
			ItemProgressionManager.InitializeBlacklistItems();
			ItemProgressionManager.InitializeApparatusItems();
		}

		internal CustomTerminalNode SetupMultiplePurchasableTerminalNode(string upgradeName, bool shareStatus, bool enabled, int initialPrice, int[] prices, string overrideName = "", bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = true, float refundPercentage = 1f)
		{
			GameObject perkGameObject = AssetBundleHandler.GetPerkGameObject(upgradeName);
			return SetupMultiplePurchasableTerminalNode(upgradeName, shareStatus, enabled, initialPrice, prices, overrideName, perkGameObject, alternateCurrency, purchaseMode, refundable, refundPercentage);
		}

		internal CustomTerminalNode SetupMultiplePurchasableTerminalNode(string upgradeName, bool shareStatus, bool enabled, int initialPrice, int[] prices, string overrideName, GameObject prefab, bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = false, float refundPercentage = 1f)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			if (!enabled)
			{
				return null;
			}
			string text = SetupUpgradeInfo(prefab.GetComponent<BaseUpgrade>(), initialPrice, prices);
			if (SyncedEntry<bool>.op_Implicit(Instance.PluginConfiguration.SHOW_WORLD_BUILDING_TEXT) && prefab.GetComponent<BaseUpgrade>() is IUpgradeWorldBuilding upgradeWorldBuilding)
			{
				text = text + "\n\n" + upgradeWorldBuilding.GetWorldBuildingText(shareStatus) + "\n";
			}
			return new TierTerminalNode((overrideName != "") ? overrideName : upgradeName, initialPrice, text, prefab, prices, prices.Length, upgradeName, shareStatus, alternateCurrency, purchaseMode, refundable, refundPercentage);
		}

		public CustomTerminalNode SetupMultiplePurchaseableTerminalNode(string upgradeName, ITierUpgradeConfiguration configuration)
		{
			GameObject perkGameObject = AssetBundleHandler.GetPerkGameObject(upgradeName);
			return SetupMultiplePurchaseableTerminalNode(upgradeName, configuration, perkGameObject);
		}

		public CustomTerminalNode SetupMultiplePurchaseableTerminalNode(string upgradeName, ITierUpgradeConfiguration configuration, GameObject prefab)
		{
			bool shareStatus = !(configuration is IIndividualUpgradeConfiguration individualUpgradeConfiguration) || SyncedEntry<bool>.op_Implicit(PluginConfiguration.SHARED_UPGRADES) || !SyncedEntry<bool>.op_Implicit(individualUpgradeConfiguration.Individual);
			int[] array = ParseUpgradePrices(SyncedEntry<string>.op_Implicit(configuration.Prices));
			int initialPrice = ((array.Length != 0) ? array[0] : (-1));
			int[] prices = ((array.Length > 1) ? array[1..] : Array.Empty<int>());
			PurchaseMode purchaseMode = SyncedEntry<PurchaseMode>.op_Implicit(SyncedEntry<bool>.op_Implicit(PluginConfiguration.AlternativeCurrencyConfiguration.EnableGlobalPurchase) ? PluginConfiguration.AlternativeCurrencyConfiguration.GlobalPurchaseMode : configuration.PurchaseMode);
			bool refundable = SyncedEntry<bool>.op_Implicit(PluginConfiguration.REFUND_UPGRADES) || SyncedEntry<bool>.op_Implicit(configuration.Refundable);
			float refundPercentage = (float)SyncedEntry<int>.op_Implicit(configuration.RefundPercentage) / 100f;
			return SetupMultiplePurchasableTerminalNode(upgradeName, shareStatus, SyncedEntry<bool>.op_Implicit(configuration.Enabled), initialPrice, prices, SyncedEntry<bool>.op_Implicit(PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(configuration.OverrideName) : "", prefab, CurrencyManager.Enabled, purchaseMode, refundable, refundPercentage);
		}

		public CustomTerminalNode SetupOneTimeTerminalNode(string upgradeName, IOneTimeUpgradeConfiguration configuration)
		{
			GameObject perkGameObject = AssetBundleHandler.GetPerkGameObject(upgradeName);
			return SetupOneTimeTerminalNode(upgradeName, configuration, perkGameObject);
		}

		public CustomTerminalNode SetupOneTimeTerminalNode(string upgradeName, IOneTimeUpgradeConfiguration configuration, GameObject prefab)
		{
			bool shareStatus = !(configuration is IIndividualUpgradeConfiguration individualUpgradeConfiguration) || SyncedEntry<bool>.op_Implicit(PluginConfiguration.SHARED_UPGRADES) || !SyncedEntry<bool>.op_Implicit(individualUpgradeConfiguration.Individual);
			PurchaseMode purchaseMode = SyncedEntry<PurchaseMode>.op_Implicit(SyncedEntry<bool>.op_Implicit(PluginConfiguration.AlternativeCurrencyConfiguration.EnableGlobalPurchase) ? PluginConfiguration.AlternativeCurrencyConfiguration.GlobalPurchaseMode : configuration.PurchaseMode);
			bool refundable = SyncedEntry<bool>.op_Implicit(PluginConfiguration.REFUND_UPGRADES) || SyncedEntry<bool>.op_Implicit(configuration.Refundable);
			float refundPercentage = (float)SyncedEntry<int>.op_Implicit(configuration.RefundPercentage) / 100f;
			return SetupOneTimeTerminalNode(upgradeName, shareStatus, SyncedEntry<bool>.op_Implicit(configuration.Enabled), SyncedEntry<int>.op_Implicit(configuration.Price), SyncedEntry<bool>.op_Implicit(PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(configuration.OverrideName) : "", prefab, CurrencyManager.Enabled, purchaseMode, refundable, refundPercentage);
		}

		internal CustomTerminalNode SetupOneTimeTerminalNode(string upgradeName, bool shareStatus, bool enabled, int price, string overrideName, GameObject prefab, bool alternateCurrency = true, PurchaseMode purchaseMode = PurchaseMode.AlternateCurrency, bool refundable = false, float refundPercentage = 1f)
		{
			if (!enabled)
			{
				return null;
			}
			string text = SetupUpgradeInfo(prefab.GetComponent<BaseUpgrade>(), price);
			string text2 = text;
			if (SyncedEntry<bool>.op_Implicit(Instance.PluginConfiguration.SHOW_WORLD_BUILDING_TEXT) && prefab.GetComponent<BaseUpgrade>() is IUpgradeWorldBuilding upgradeWorldBuilding)
			{
				text2 = text2 + "\n\n" + upgradeWorldBuilding.GetWorldBuildingText(shareStatus) + "\n";
			}
			return new OneTimeTerminalNode((overrideName != "") ? overrideName : upgradeName, price, text2, prefab, upgradeName, shareStatus, alternateCurrency, purchaseMode, refundable, refundPercentage);
		}

		public string SetupUpgradeInfo(BaseUpgrade upgrade = null, int price = -1, int[] incrementalPrices = null)
		{
			string text = "";
			if (upgrade is OneTimeUpgrade oneTimeUpgrade)
			{
				text = text + oneTimeUpgrade.GetDisplayInfo(price) + "\n";
			}
			if (upgrade is TierUpgrade tierUpgrade)
			{
				text += tierUpgrade.GetDisplayInfo(price, incrementalPrices.Length, incrementalPrices);
			}
			return text;
		}

		internal static int[] ParseUpgradePrices(string upgradePrices)
		{
			string[] array = upgradePrices.Split(',').ToArray();
			int[] array2 = new int[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				if (int.TryParse(array[i], out var result))
				{
					array2[i] = result;
					continue;
				}
				logger.LogWarning($"Invalid upgrade price submitted: {array2[i]}");
				array2[i] = -1;
			}
			if (array2.Length == 1 && array2[0] == -1)
			{
				array2 = Array.Empty<int>();
			}
			return array2;
		}

		internal void SetConfiguration(LategameConfiguration config)
		{
			PluginConfiguration = config;
		}
	}
}
namespace MoreShipUpgrades.Input
{
	internal class IngameKeybinds : LcInputActions
	{
		public static IngameKeybinds Instance;

		[InputAction("<Keyboard>/leftAlt", Name = "Toggle NVG")]
		public InputAction NvgKey { get; set; }

		[InputAction("<Keyboard>/leftShift", Name = "Show Alternative Currency Counter")]
		public InputAction ShowAlternativeCounterKey { get; set; }

		internal static InputActionAsset GetAsset()
		{
			return ((LcInputActions)Instance).Asset;
		}
	}
	[HarmonyPatch]
	internal static class Keybinds
	{
		public static InputActionAsset Asset;

		public static InputActionMap ActionMap;

		public static InputAction NvgAction;

		public static InputAction ShowAlternativeCounterAction;

		public static PlayerControllerB localPlayerController => StartOfRound.Instance?.localPlayerController;

		[HarmonyPatch(typeof(PreInitSceneScript), "Awake")]
		[HarmonyPrefix]
		public static void AddToKeybindMenu()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Asset = InputUtilsCompat.Asset;
			ActionMap = Asset.actionMaps[0];
			NvgAction = InputUtilsCompat.NvgKey;
			ShowAlternativeCounterAction = InputUtilsCompat.ShowAlternativeCounterKey;
		}

		[HarmonyPatch(typeof(StartOfRound), "OnEnable")]
		[HarmonyPostfix]
		public static void OnEnable()
		{
			Asset.Enable();
			NvgAction.performed += OnNvgActionPerformed;
			ShowAlternativeCounterAction.started += OnShowAlternativeCurrencyStarted;
			ShowAlternativeCounterAction.canceled += OnShowAlternativeCurrencyCanceled;
		}

		[HarmonyPatch(typeof(StartOfRound), "OnDisable")]
		[HarmonyPostfix]
		public static void OnDisable()
		{
			Asset.Disable();
			NvgAction.performed -= OnNvgActionPerformed;
			ShowAlternativeCounterAction.started -= OnShowAlternativeCurrencyStarted;
			ShowAlternativeCounterAction.canceled -= OnShowAlternativeCurrencyCanceled;
		}

		private static void OnNvgActionPerformed(CallbackContext context)
		{
			if (!((Object)(object)localPlayerController == (Object)null) && localPlayerController.isPlayerControlled && (!((NetworkBehaviour)localPlayerController).IsServer || localPlayerController.isHostPlayerObject) && Object.op_Implicit((Object)(object)NightVision.Instance) && !NightVision.Instance.batteryExhaustion)
			{
				NightVision.Instance.Toggle();
			}
		}

		private static void OnShowAlternativeCurrencyStarted(CallbackContext context)
		{
			if (!((Object)(object)localPlayerController == (Object)null) && localPlayerController.isPlayerControlled && (!((NetworkBehaviour)localPlayerController).IsServer || localPlayerController.isHostPlayerObject) && CurrencyManager.Enabled)
			{
				CurrencyManager.Instance.ShowCurrentAmount = true;
			}
		}

		private static void OnShowAlternativeCurrencyCanceled(CallbackContext context)
		{
			if (!((Object)(object)localPlayerController == (Object)null) && localPlayerController.isPlayerControlled && (!((NetworkBehaviour)localPlayerController).IsServer || localPlayerController.isHostPlayerObject) && CurrencyManager.Enabled)
			{
				CurrencyManager.Instance.ShowCurrentAmount = false;
			}
		}
	}
}
namespace MoreShipUpgrades.Extensions
{
	internal static class PlayerControllerBExtensions
	{
		public static float GetCurrentWeightFromInventory(this PlayerControllerB player)
		{
			float num = 0f;
			GrabbableObject[] itemSlots = player.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (!((Object)(object)val == (Object)null))
				{
					num = Mathf.Clamp(num + BackMuscles.DecreasePossibleWeight(val.itemProperties.weight - 1f), 0f, 10f);
				}
			}
			return num;
		}

		public static bool ContainsItemOfType<T>(this PlayerControllerB player, T excludingItem = default(T)) where T : GrabbableObject
		{
			GrabbableObject[] itemSlots = player.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (!((Object)(object)val == (Object)null) && (!((Object)(object)excludingItem != (Object)null) || !((Object)(object)val == (Object)(object)excludingItem)) && val is T)
				{
					return true;
				}
			}
			return false;
		}

		public static bool CheckIfCurrentlyHeldObjectIsInInventory(this PlayerControllerB player)
		{
			GrabbableObject[] itemSlots = player.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (!((Object)(object)val == (Object)null) && (Object)(object)val == (Object)(object)player.currentlyHeldObjectServer)
				{
					return true;
				}
			}
			return false;
		}

		public static bool CheckIfCurrentlyTwoHandedInInventory(this PlayerControllerB player)
		{
			int num = 0;
			int num2 = 1 + SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DeeperPocketsConfiguration.InitialEffect) + BaseUpgrade.GetUpgradeLevel("Deeper Pockets") * SyncedEntry<int>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DeeperPocketsConfiguration.IncrementalEffect);
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if (num >= num2)
				{
					break;
				}
				GrabbableObject val = player.ItemSlots[i];
				if (!((Object)(object)val == (Object)null) && val.itemProperties.twoHanded)
				{
					num++;
				}
			}
			if (num < num2)
			{
				((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
				return false;
			}
			return true;
		}

		public static bool IsTeleporting(this PlayerControllerB player)
		{
			return player.shipTeleporterId != -1 && player.shipTeleporterId != 0;
		}

		public static bool RemainIsHoldingObjectIfTeleporting(this PlayerControllerB player)
		{
			return player.IsTeleporting() && player.CheckIfCurrentlyHeldObjectIsInInventory();
		}

		public static bool RemainActivatingItemIfTeleporting(this PlayerControllerB player)
		{
			return player.IsTeleporting() && player.activatingItem;
		}

		public static bool RemainTwoHandedIfTeleporting(this PlayerControllerB player)
		{
			return player.IsTeleporting() && player.CheckIfCurrentlyTwoHandedInInventory();
		}

		public static GrabbableObject RemainCurrentlyHeldObjectServerIfTeleporting(this PlayerControllerB player, GrabbableObject defaultValue)
		{
			if (player.IsTeleporting())
			{
				return player.CheckIfCurrentlyHeldObjectIsInInventory() ? player.currentlyHeldObjectServer : defaultValue;
			}
			return defaultValue;
		}

		public static float RemainCarryWeightIfTeleporting(this PlayerControllerB player, float defaultValue)
		{
			if (player.IsTeleporting())
			{
				return Mathf.Clamp(defaultValue + player.GetCurrentWeightFromInventory(), 1f, 10f);
			}
			return defaultValue;
		}

		public static GrabbableObject RemainItemSlotIfTeleporting(this PlayerControllerB player, int itemSlotIndex)
		{
			Plugin.mls.LogDebug((object)((Object)(object)player == (Object)null));
			if (player.IsTeleporting())
			{
				return player.ItemSlots[itemSlotIndex];
			}
			return null;
		}
	}
}
namespace MoreShipUpgrades.Configuration
{
	public class AlternativeCurrencyConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Enabled { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> EnableGlobalPurchase { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<PurchaseMode> GlobalPurchaseMode { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MaximumAmountPerPlayer { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> IncludeSpentInMaximum { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> BlockGainOperations { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> CreditsToCurrencyRatio { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> QuotaToCurrencyRatio { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> CreditsToCurrencyConversionRatio { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> CurrencyToCreditsConversionRatio { get; set; }

		public AlternativeCurrencyConfiguration(ConfigFile cfg)
		{
			string text = "_Alternative Currency_";
			Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Alternative Currency System", false, "Allows purchasing Lategame Upgrades with another currency other than Company Credits");
			EnableGlobalPurchase = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Global Purchase", false, "Toggle which replaces all upgrades' configuration settings for purchase mode with this sections entry");
			GlobalPurchaseMode = SyncedBindingExtensions.BindSyncedEntry<PurchaseMode>(cfg, text, "Global Purchase Mode", PurchaseMode.Both, "If 'Enable Global Purchase' is enabled, all upgrades will take this configuration to determine which currency is used to purchase them");
			MaximumAmountPerPlayer = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Maximum Amount per Player", -1, "If greater than zero, in any moment where the player would obtain some unit of alternative currency, it will be capped at the selected value");
			IncludeSpentInMaximum = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Include spent amount in Maximum amount", false, "If enabled, units of alternative currency spent in upgrades will count towards the maximum amount per player");
			BlockGainOperations = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Block Gain Operations when Maxed", false, "If enabled, operations such as refund or conversion will be blocked (thus the player cannot willingly lose credits) if the amount obtained from the operation exceeds the selected maximum value.");
			CreditsToCurrencyRatio = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Credits to Alternative Currency Ratio", 100, "How much a single unit of Alternative Currency is worth in Company Credits when purchasing upgrades.");
			QuotaToCurrencyRatio = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Quota to Alternative Currency Ratio", 100, "How much a single unit of Alternative Currency is worth in Quota Fullfilled");
			CreditsToCurrencyConversionRatio = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Credits to Alternative Currency Conversion Ratio", 100, "How many Company Credits you require to purchase a single unit of Alternative Currency.");
			CurrencyToCreditsConversionRatio = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Alternative Currency to Credits Conversion Ratio", 100, "How many Company Credits you obtain when converting a single unit of Alternative Currency.");
		}
	}
	[DataContract]
	public class LategameConfiguration : SyncedConfig2<LategameConfiguration>
	{
		public ITierEffectUpgradeConfiguration<int> SmarterLockpickUpgradeConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> EffectiveBandaidsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> MedicalNanobotsConfiguration { get; set; }

		public ScrapKeeperUpgradeConfiguration ScrapKeeperConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> ParticleInfuserConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration SilverBulletsConfiguration { get; set; }

		public ITierCollectionUpgradeConfiguration FusionMatterConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> LongBarrelConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> HollowPointConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> JetpackThrustersConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> JetFuelConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> QuickHandsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> MidasTouchConfiguration { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> AffectSamples { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> AffectApparatus { get; set; }

		public ITierEffectUpgradeConfiguration<int> CarbonKneejointsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> LifeInsuranceConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> RubberBootsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> OxygenCanistersConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> SleightOfHandConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> HikingBootsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> TractionBootsConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration FedoraSuitConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> WeedGeneticManipulationConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<float> ClayGlassesConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<float> MechanicalArmsConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> ScavengerInstictsConfiguration { get; set; }

		public LandingThrusterUpgradeConfiguration LandingThrustersConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> ReinforcedBootsConfiguration { get; set; }

		public DeeperPocketsUpgradeConfiguration DeeperPocketsConfiguration { get; set; }

		public ITierMultipleEffectUpgradeConfiguration<int, float> AluminiumCoilConfiguration { get; set; }

		public ITierMultipleEffectUpgradeConfiguration<float, int> ChargingBoosterConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> MarketInfluenceConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> BargainConnectionsConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration LethalDealsConfiguration { get; set; }

		public QuantumDisruptorUpgradeConfiguration QuantumDisruptorConfiguration { get; set; }

		public ITierMultipleEffectUpgradeConfiguration<float> BeekeeperConfiguration { get; set; }

		public ITierMultipleEffectUpgradeConfiguration<int, float> ProteinPowderConfiguration { get; set; }

		public BiggerLungsUpgradeConfiguration BiggerLungsConfiguration { get; set; }

		public ITierAlternativeEffectUpgradeConfiguration<float, BackMuscles.UpgradeMode> BackMusclesConfiguration { get; set; }

		public ITierMultipleEffectUpgradeConfiguration<float> RunningShoesConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<float> StrongLegsConfiguration { get; set; }

		public IOneTimeAlternativeEffectUpgradeConfiguration<float, LightningRod.UpgradeMode> LightningRodConfiguration { get; set; }

		public ITierCollectionUpgradeConfiguration HunterConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> StimpackConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<float> ShutterBatteriesConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> EfficientEnginesConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<float> ClimblingGlovesConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> LithiumBatteriesConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration LocksmithConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration FastEncryptionConfiguration { get; set; }

		public DropPodThrustersUpgradeConfiguration DropPodThrustersConfiguration { get; set; }

		public SigurdAccessUpgradeConfiguration SigurdAccessConfiguration { get; set; }

		public IOneTimeUpgradeConfiguration WalkieGpsConfiguration { get; set; }

		public DiscombobulatorUpgradeConfiguration DiscombobulatorUpgradeConfiguration { get; set; }

		public MalwareBroadcasterUpgradeConfiguration MalwareBroadcasterUpgradeConfiguration { get; set; }

		public NightVisionUpgradeConfiguration NightVisionUpgradeConfiguration { get; set; }

		public SickBeatsUpgradeConfiguration SickBeatsUpgradeConfiguration { get; set; }

		public BetterScannerUpgradeConfiguration BetterScannerUpgradeConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> BabyPacifierUpgradeConfiguration { get; set; }

		public ITierEffectUpgradeConfiguration<int> ItemDuplicatorUpgradeConfiguration { get; set; }

		public ContractsConfiguration ContractsConfiguration { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MaximumIndividualUpgrades { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> INTERNS_DELAY_BEFORE_REVIVE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> INTERNS_USAGES_PER_LANDING { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> INTERNS_INTERVAL_BETWEEN_REVIVES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<Interns.TeleportRestriction> INTERNS_TELEPORT_RESTRICTION { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SHOW_WORLD_BUILDING_TEXT { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> MEDKIT_SCAN_NODE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> OVERRIDE_UPGRADE_NAMES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> INTERN_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> INTERN_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> SALE_PERC { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SHARED_UPGRADES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> REFUND_UPGRADES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> MEDKIT_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MEDKIT_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MEDKIT_HEAL_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MEDKIT_USES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> KEEP_UPGRADES_AFTER_FIRED_CUTSCENE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SNARE_FLEA_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SNARE_FLEA_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> HOARDING_BUG_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> HOARDING_BUG_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BRACKEN_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BRACKEN_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> EYELESS_DOG_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> EYELESS_DOG_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BABOON_HAWK_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BABOON_HAWK_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> THUMPER_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> THUMPER_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> FOREST_KEEPER_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MANTICOIL_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MANTICOIL_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> TULIP_SNAKE_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SPORE_LIZARD_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MANEATER_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> MANEATER_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SHOW_UPGRADES_CHAT { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SALE_APPLY_ONCE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> BuyableUpgradeOnce { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ShowLockedUpgrades { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> UseDawnLib { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ALTERNATIVE_ITEM_PROGRESSION { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<ItemProgressionManager.CollectionModes> ITEM_PROGRESSION_MODE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> SCRAP_UPGRADE_CHANCE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<ItemProgressionManager.ChancePerScrapModes> SCRAP_UPGRADE_CHANCE_MODE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> ITEM_PROGRESSION_BLACKLISTED_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> ITEM_PROGRESSION_APPARATICE_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ITEM_PROGRESSION_NO_PURCHASE_UPGRADES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> RANDOMIZE_UPGRADES_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> RANDOMIZE_UPGRADES_AMOUNT { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<RandomizeUpgradeManager.RandomizeUpgradeEvents> RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT { get; set; }

		public AlternativeCurrencyConfiguration AlternativeCurrencyConfiguration { get; set; }

		public LategameConfiguration(ConfigFile cfg)
			: base("com.malco.lethalcompany.moreshipupgrades")
		{
			AlternativeCurrencyConfiguration = new AlternativeCurrencyConfiguration(cfg);
			string text = "_Randomize Upgrades_";
			RANDOMIZE_UPGRADES_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Randomize Upgrades", false, "Upgrades will be randomized per selected event to be allowed purchased on the store.");
			RANDOMIZE_UPGRADES_AMOUNT = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Amount of Upgrades", 5, "Amount of Upgrades that will always appear in the store (if allowed).");
			RANDOMIZE_UPGRADES_ALWAYS_SHOW_PURCHASED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Show purchased upgrades", true, "Wether purchased upgrades will always show in the store and the specified amount of random upgrades will not include these in the selection.");
			RANDOMIZE_UPGRADES_CHANGE_UPGRADES_EVENT = SyncedBindingExtensions.BindSyncedEntry<RandomizeUpgradeManager.RandomizeUpgradeEvents>(cfg, text, "Randomize Upgrades Event", RandomizeUpgradeManager.RandomizeUpgradeEvents.PerQuota, "Event which triggers the random upgrades being changed in the store.");
			text = "_Item Progression Route_";
			ALTERNATIVE_ITEM_PROGRESSION = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Item Progression", false, "Alternative Item Progression\nIf true, items retrieved can be used for ship upgrades.");
			ITEM_PROGRESSION_MODE = SyncedBindingExtensions.BindSyncedEntry<ItemProgressionManager.CollectionModes>(cfg, text, "Item Progression Mode", ItemProgressionManager.CollectionModes.CustomScrap, "Item Progression Mode\nSupported Modes: \nCustomScrap: Specified scrap will contribute towards the level of the associated upgrade.\nUniqueScrap: All scrap (specifications will be ignored) will contribute towards the level of a random assigned upgrade\nNearestValue: At the end of each Quota, grant a random upgrade worth the nearest total scrap collected, rounded down.\nChancePerScrap: For each scrap sold, run a configured chance to receive a random/cheap/lowest tier upgrade.\nApparatice: Always receive an upgrade when an apparatus has been successfully sold.");
			ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Item Progression Multiplier", 0.85f, "Item Progression Contribution Multiplier\nThe multiplier for scrap's value contribution towards an upgrade.");
			SCRAP_UPGRADE_CHANCE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Scrap Upgrade Chance", 0.05f, "Upgrade Chance Calculation\nOnly used if Item Progression Mode is set to ChancePerScrap.\nX -> (X * 100) %");
			SCRAP_UPGRADE_CHANCE_MODE = SyncedBindingExtensions.BindSyncedEntry<ItemProgressionManager.ChancePerScrapModes>(cfg, text, "Upgrade Chance Priority", ItemProgressionManager.ChancePerScrapModes.LowestLevel, "Upgrade Chance Priority\nOnly used if Item Progression Mode is set to ChancePerScrap.\nAcceptable Values:\nRandom: Pick a random upgrade to apply.\nCheapest: Pick the cheapest upgrade to apply.\nLowest Tier: Pick the upgrade with the lowest level to apply.");
			ITEM_PROGRESSION_BLACKLISTED_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Blacklisted Items", "Clipboard", "Blacklisted items for Item Progression.\nOnly used if Item Progression Mode is set to UniqueScrap. These items will NOT contribute towards ANY upgrade");
			ITEM_PROGRESSION_APPARATICE_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Apparatus Items", "Apparatus@1,ExampleItemName@2", "Items that are considered \"Apparatice\" and provide a set amount of upgrades once sold to The Company.\nThe item name is either the one displayed in the scan node or its internal name.\nThis list is only valid if Item Progression Mode is set to Apparatice.");
			ITEM_PROGRESSION_NO_PURCHASE_UPGRADES = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Non-Purchaseable Upgrades", false, "Prevents the upgrades from being purchaseable in the store to be only used to know how far are they to acquiring one. Only valid if Item Progression mode is toggled on");
			ITEM_PROGRESSION_ALWAYS_SHOW_ITEMS = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Always Show Contribution Items", false, "Shows all the items associated to each upgrade regardless if they were sold before or not.");
			text = "_Misc_";
			SHARED_UPGRADES = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Convert all upgrades to be shared.", true, "If true this will ignore the individual shared upgrade option for all other upgrades and set all upgrades to be shared.");
			REFUND_UPGRADES = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "All Upgrades Refundable", false, "If enabled, it overrides all upgrades configuration settings to allow refunding a level");
			SALE_PERC = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Chance of upgrades going on sale", 0.85f, "0.85 = 15% chance of an upgrade going on sale.");
			KEEP_UPGRADES_AFTER_FIRED_CUTSCENE = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Keep upgrades after quota failure", false, "If true, you will keep your upgrades after being fired by The Company.");
			SHOW_UPGRADES_CHAT = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Show upgrades being loaded in chat", true, "If enabled, chat messages will be displayed when loading an upgrade for the first time.");
			SALE_APPLY_ONCE = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Apply upgrade sale on one purchase", false, "When an upgrade is on sale, apply the sale only on the first ever purchase of it while on sale. Consecutive purchases will not have the sale applied");
			SHOW_WORLD_BUILDING_TEXT = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Show World Building text in Upgrade information", true, "When viewing an upgrade's information, wether show world-building text along with pratical information or not.");
			BuyableUpgradeOnce = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Limited Buyable Upgrades", false, "If toggled on, the upgrade bought for the first time will only be buyable after by the purchasing player. This is only relevant to individual upgrades");
			ShowLockedUpgrades = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Show Locked Upgrades", true, "If toggled off, upgrades which are locked to other crew members for purchase will not appear in the store");
			OVERRIDE_UPGRADE_NAMES = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Override Upgrade Names", false, "When enabled, replaces the names of each upgrades with the ones defined in this section");
			UseDawnLib = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Use DawnLib for Initialization", false, "Replaces initialization phase that utilizes LethalLib with DawnLib callbacks instead. Use this if you are experiencing issues with LethalLib and believe DawnLib won't have the same issues.");
			MaximumIndividualUpgrades = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Maximum purchaseable individual upgrades", 0, "If greater than zero, limits each player's amount of purchased individual upgrades to the configurated value.");
			text = "Contracts";
			ContractsConfiguration = new ContractsConfiguration(cfg, text);
			text = "Medkit";
			MEDKIT_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable the Medkit item", true, "Allows you to buy a Medkit to heal yourself.");
			MEDKIT_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Medkit price", 300, "Default price for Medkit.");
			MEDKIT_HEAL_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Heal Amount", 20, "The amount the Medkit heals you.");
			MEDKIT_USES = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Uses", 3, "The amount of times the Medkit can heal you.");
			MEDKIT_SCAN_NODE = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, LguConstants.MEDKIT_SCAN_NODE_KEY, true, "Shows a scan node on the item when scanning");
			text = "Smarter Lockpick";
			SmarterLockpickUpgradeConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade that increases the efficiency of the lockpicker item, making it faster at opening doors.", "200,300,350,450")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Efficiency Increase", 100, "Initial increase (%) of efficiency of the lockpicker item in opening doors, decreasing the required time to be lockpicked"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Efficiency Increase", 100, "Incremental increase (%) of efficiency of the lockpicker item in opening doors, decreasing the required time to be lockpicked")
			};
			text = "Effective Bandaids";
			EffectiveBandaidsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the amount of health you regain when regenerating.", "250,300,400,550")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Health Regeneration Amount Increase", 1, "Initial health amount increase during health regeneration when first purchasing the upgrade."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Health Regeneration Amount Increase", 1, "Incremental health amount increase during health regeneration when purchasing further levels of the upgrade")
			};
			text = "Medical Nanobots";
			MedicalNanobotsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the health regeneration cap amount.", "300,400,500,750")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Health Regeneration Cap Increase", 50, "Initial percentage increase of the health regeneration cap when first purchasing the upgrade."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Health Regeneration Cap Increase", 50, "Incremental percentage increase of the health regeneration cap when purchasing further levels of the upgrade")
			};
			text = "Scrap Keeper";
			ScrapKeeperConfiguration = new ScrapKeeperUpgradeConfiguration(cfg, text, "Tier upgrade which adds a chance of keeping the scrap item incase of full team wipe.", "1000,1000,1500,3000")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Keep Scrap Chance Increase", 25, "Initial percentage chance increase of keeping the scrap item when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Keep Scrap Chance Increase", 25, "Incremental percentage chance increase of keeping the scrap item when purchasing further levels of the upgrade")
			};
			text = "Particle Infuser";
			ParticleInfuserConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the speed of the teleporter during teleportation phase.", "650,400,600")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Teleport Speed Increase", 20, "Initial speed percentage increase of the teleporters when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Teleport Speed Increase", 10, "Incremental speed percentage increase of the teleporters when purchasing further levels of the upgrade")
			};
			text = "Silver Bullets";
			SilverBulletsConfiguration = new OneTimeIndividualUpgradeConfiguration(cfg, text, "One time upgrade which allows you to eliminate ghost girl entities with the shotgun.", 500);
			text = "Fusion Matter";
			FusionMatterConfiguration = new TierCollectionUpgradeConfiguration(cfg, text, "Tier upgrade which allows you to teleport with specified items during teleportation (both in and out)", "500, 650, 700")
			{
				TierCollection = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Fusion Matter Tiers", LguConstants.FUSION_MATTER_TIERS_DEFAULT, LguConstants.FUSION_MATTER_TIERS_DESCRIPTION)
			};
			text = "Long Barrel";
			LongBarrelConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the overall range of the shotgun and its effective damage ranges.", "500,500,750")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Shotgun Range Increase", 10, "Initial range percentage increase of the shotgun when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Shotgun Range Increase", 10, "Incremental range percentage increase of the shotgun when purchasing further levels of the upgrade")
			};
			text = "Hollow Point";
			HollowPointConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the amount of damage done by the shotgun.", "800,1000")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Shotgun Damage Increase", 1, "Initial damage increase of the shotgun when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Shotgun Damage Increase", 1, "Incremental damage increase of the shotgun when purchasing further levels of the upgrade")
			};
			text = "Jetpack Thrusters";
			JetpackThrustersConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the maximum speed of the jetpack during flight.", "300,150,300,400")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Maximum Speed Increase", 20, "Initial percentage increase of jetpack's maximum speed during flight when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Maximum Speed Increase", 20, "Incremental percentage increase of jetpack's maximum speed during flight when purchasing further levels of the upgrade")
			};
			text = "Jet Fuel";
			JetFuelConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the acceleration of the jetpack during flight.", "400,200,400,500")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Acceleration Increase", 20, "Initial percentage increase of jetpack acceleration when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Acceleration Increase", 20, "Incremental percentage increase of jetpack acceleration when purchasing further levels of the upgrade")
			};
			text = "Quick Hands";
			QuickHandsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the interaction speed of the player.", "100,100,150,200,250")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Interaction Speed Increase", 20, "Initial percentage increase of interaction speed when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Interaction Speed Increase", 20, "Incremental percentage increase of interaction speed when purchasing further levels of the upgrade")
			};
			text = "Midas Touch";
			MidasTouchConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the value of the scrap found in the moons.", "1000,1000,1500,1800,2000")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Scrap Value Increase", 20, "Initial percentage increase of value of the scrap found in the moons when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Scrap Value Increase", 20, "Incremental percentage increase of value of the scrap found in the moons when purchasing further levels of the upgrade")
			};
			AffectSamples = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Affect Samples", true, "When enabled, Midas Touch will increase the value of the dropped samples from killing creatures.");
			AffectApparatus = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Affect Apparatus", true, "When enabled, Midas Touch will increase the value of the apparatus that spawns from special rooms");
			text = "Carbon Kneejoints";
			CarbonKneejointsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the movement speed loss due to crouching.", "100,50,100,150")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Crouch Movement Speed Debuff Decrease", 20, "Initial percentage decrease of the movement speed loss while crouching when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Crouch Movement Speed Debuff Decrease", 20, "Incremental percentage decrease of the movement speed loss while crouching when purchasing further levels of the upgrade")
			};
			text = "Life Insurance";
			LifeInsuranceConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the credit loss from leaving a body behind when exiting a moon.", "200,200,250,300")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Credit Loss Decrease", 20, "Initial percentage decrease of the credit loss when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Credit Loss Decrease", 20, "Incremental percentage decrease of the credit loss when purchasing further levels of the upgrade")
			};
			text = "Rubber Boots";
			RubberBootsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the movement hinderance when walking on water surfaces.", "50,50,100,200")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Movement Hinderance Decrease", 20, "Initial percentage decrease of movement hinderance on water surfaces when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Movement Hinderance Decrease", 20, "Incremental percentage decrease of movement hinderance on water surfaces when purchasing further levels of the upgrade")
			};
			text = "Oxygen Canisters";
			OxygenCanistersConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the consumption rate of oxygen while underwater.", "100,100,200,400")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Oxygen Consumption Decrease", 20, "Initial percentage of oxygen consumption decrease when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Oxygen Consumption Decrease", 20, "Incremental percentage of oxygen consumption decrease when purchasing further levels of the upgrade")
			};
			text = "Sleight of Hand";
			SleightOfHandConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the reload time of the shotgun.", "100,150,200,250")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Reload Speed Increase", 25, "Initial percentage of the reload speed increase when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Reload Speed Increase", 25, "Incremental percentage of the reload speed increase when purchasing further levels of the upgrade")
			};
			text = "Hiking Boots";
			HikingBootsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the impact of going through uphill slopes", "75,100,150,175")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Uphill Slope Debuff Decrease", 25, "Initial percentage of the uphill slope debuff removed when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Uphill Slope Debuff Decrease", 25, "Incremental percetange of the uphill slope debuff removed when purchasing further levels of the upgrade")
			};
			text = "Traction Boots";
			TractionBootsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the traction factor on the player's movement", "100,100,150,250")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Traction Increase", 25, "Multiplier value (%) applied to the player's walking force when first purchasing the upgrade."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Traction Increase", 25, "Multiplier value (%) added to the initial which then gets applied to the player's walking force when first purchasing the upgrade.")
			};
			text = "Fedora Suit";
			FedoraSuitConfiguration = new OneTimeIndividualUpgradeConfiguration(cfg, text, "One Time upgrade which makes Butler enemies not be angry at you when alone. (It will still be angry when you hit them)", 750);
			text = "Weed Genetic Manipulation";
			WeedGeneticManipulationConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the effectiveness of the Weed Killer on eradicating plants", "100,100,150,200")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Effectiveness Increase", 75, "Amount of effectiveness (%) when first purchasing the upgrade increased on the Weed Killer to eradicate plants"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Effectiveness Increase", 50, "Amount of effectiveness (%) when purchasing further levels of the upgrade increased on the Weed Killer to eradicate plants")
			};
			text = "Clay Glasses";
			ClayGlassesConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<float>(cfg, text, "Tier upgrade which increases the distance to start seeing the Clay Surgeon Entity.", "200,300,400,500,600")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial Distance Increase", 10f, "Distance increased when first purchasing the upgrade to be able to spot the Clay Surgeon"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental Distance Increase", 5f, "Distance increased when purchasing further levels of the upgrade to be able to spot the Clay Surgeon")
			};
			text = "Mechanical Arms";
			MechanicalArmsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<float>(cfg, text, "Tier upgrade which increases the range of interacting with objects (both grabbing and interacting such as open or close a door)", "300,400,600,800")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial range increase", 1f, "Amount of interaction range increased (in Unity units) when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental range increase", 1f, "Amount of interaction range increased (in Unity units) on further purchases of the upgrade")
			};
			text = "Scavenger Instincts";
			ScavengerInstictsConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the amount of scrap that can spawn on a given level.", "800,800,1000,1200,1400")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial amount of scrap spawn increase", 4, "The amount of additional scrap that can spawn in a given level when first purchased"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental amount of scrap spawn increase", 2, "The amount of additional scrap that can spawn in a given level on further purchases")
			};
			text = "Landing Thrusters";
			LandingThrustersConfiguration = new LandingThrusterUpgradeConfiguration(cfg, text, "Tier upgrade which increases the speed of the ship landing and departing between moons", "300,250,450,650")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial speed increase", 25, "Initial amount (%) to increment to the ship speed when first purchasing the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental speed increase", 25, "Incremental amount (%) to increment to the ship speed on further purchases of the upgrade")
			};
			text = "Reinforced Boots";
			ReinforcedBootsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which reduces the damage taken when falling from great heights", "250,200,300,400,500")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial damage reduction", 25, "Percentage of the damage taken from great height falls mitigated when purchased the upgrade for the first time"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental damage reduction", 10, "Percentage of the damage taken from great height falls mitigated in further purchases of the upgrade")
			};
			text = "Deeper Pockets";
			DeeperPocketsConfiguration = new DeeperPocketsUpgradeConfiguration(cfg, text, "Tier upgrade which allows the player to carry more than one two handed item in their inventory", "500,750")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial carry capacity increase", 1, "The amount of two handed carry capacity increased to the player when first buying the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental carry capacity increase", 1, "The amount of two handed carry capacity increased to the player when increase the upgrade level")
			};
			text = "Aluminium Coils";
			AluminiumCoilConfiguration = new TierIndividualMultiplePrimitiveUpgradeConfiguration<int, float>(cfg, text, "Tier upgrade which reduces the zap gun minigame's difficulty, making it easier to manage.", "750,600, 800, 1000")
			{
				InitialEffects = new List<SyncedEntry<int>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial multiplier applied to the minigame difficulty multiplier (%)", 25, "Past 100%, the zap gun minigame will have no difficulty in following it."),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial multiplier applied to the zap guns cooldown (%)", 10, "Past 100%, the zap gun will have no cooldown after being used")
				},
				IncrementalEffects = new List<SyncedEntry<int>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental multiplier applied to the minigame difficulty multiplier (%)", 10, "Past 100%, the zap gun minigame will have no difficulty in following it."),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental multiplier applied to the zap guns cooldown", 10, "Past 100%, the zap gun will have no cooldown after being used")
				},
				InitialSecondEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial value incremented to the enemy stun timer when using the zap gun", 1f, (ConfigDescription)null),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial value incremented to the zap guns range to stun an enemy", 2f, (ConfigDescription)null)
				},
				IncrementalSecondEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental value incremented to the enemy stun timer when using the zap gun", 1f, (ConfigDescription)null),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental value incremented to the zap guns range to stun an enemy", 1f, (ConfigDescription)null)
				}
			};
			text = "Back Muscles";
			BackMusclesConfiguration = new TierIndividualAlternativePrimitiveUpgradeConfiguration<float, BackMuscles.UpgradeMode>(cfg, text, "Reduce carry weight", "715,600,700,800")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Carry Weight Multiplier", 0.5f, "Your carry weight is multiplied by this."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Carry Weight Increment", 0.1f, "Each upgrade subtracts this from the above coefficient."),
				AlternativeMode = SyncedBindingExtensions.BindSyncedEntry<BackMuscles.UpgradeMode>(cfg, text, "Upgrade Mode for Back Muscles", BackMuscles.UpgradeMode.ReduceWeight, "Applied mode when purchasing the upgrade:\nReduceWeight (Reduces the overall weight of items when grabbed), ReduceCarryInfluence (Reduces the carry weight influence when sprinting), ReduceStrain (Reduces the carry weight influence on stamina consumption when running),")
			};
			text = "Bargain Connections";
			BargainConnectionsConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which increases the amount of items that can be on sale in the store", "200,225,300,375")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial additional amount of items that can go on sale", 3, (ConfigDescription)null),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental additional amount of items that can go on sale", 2, (ConfigDescription)null)
			};
			text = "Beekeeper";
			BeekeeperConfiguration = new TierIndividualMultiplePrimitiveUpgradeConfiguration<float>(cfg, text, "Take less damage from bees and hornets", "450,225,280,340")
			{
				InitialEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Multiplied to incoming damage (rounded to int)", 0.64f, "Incoming damage from bees (from hives) is 10 and butler's deal 40 (20 if solo)."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Hive value increase multiplier", 1.5f, "Multiplier applied to the value of beehive when reached max level")
				},
				IncrementalEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Additional % Reduced per level", 0.15f, "Every time Beekeeper is upgraded this value will be subtracted to the base multiplier above."),
					null
				}
			};
			text = "Better Scanner";
			BetterScannerUpgradeConfiguration = new BetterScannerUpgradeConfiguration(cfg, text, "Further scan distance, no LOS needed.", 650);
			text = "Bigger Lungs";
			BiggerLungsConfiguration = new BiggerLungsUpgradeConfiguration(cfg, text, "More Stamina", "600,350,450,550")
			{
				InitialEffects = new List<SyncedEntry<float>>(3)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Sprint Time Unlock", 6f, "Amount of sprint time gained when unlocking the upgrade.\nDefault vanilla value is 11f."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Stamina Regeneration Increase", 1.05f, "Affects the rate of the player regaining stamina"),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Stamina cost decrease on jumps", 0.9f, "Multiplied with the vanilla cost of jumping")
				},
				IncrementalEffects = new List<SyncedEntry<float>>(3)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Sprint Time Increment", 1.25f, "Amount of sprint time gained when increasing the level of upgrade."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental stamina regeneration increase", 0.05f, "Added to initial multiplier"),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental stamina cost decrease on jumps", 0.05f, "Added to initial multiplier (as in reduce the factor)")
				},
				StaminaRegenerationLevel = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Level of Bigger Lungs to apply stamina regeneration", 1, "When reached provided level, the effect will start applying."),
				JumpReductionLevel = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Level of Bigger Lungs to apply stamina cost decrease on jumps", 2, "When reached provided level, the effect will start applying.")
			};
			text = "Charging Booster";
			ChargingBoosterConfiguration = new TierMultiplePrimitiveUpgradeConfiguration<float, int>(cfg, text, "Tier upgrade which allows charging items in a radar booster", "300,250,300,400")
			{
				InitialEffects = new List<SyncedEntry<float>>(1) { SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Cooldown of the charging station in radar boosters when used", 90f, (ConfigDescription)null) },
				IncrementalEffects = new List<SyncedEntry<float>>(1) { SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental cooldown decrease whenever the level of the upgrade is incremented", 10f, (ConfigDescription)null) },
				InitialSecondEffects = new List<SyncedEntry<int>>(1) { SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Percentage of charge that is added to the held item when using the radar booster charge station", 50, (ConfigDescription)null) },
				IncrementalSecondEffects = new List<SyncedEntry<int>>(1) { null }
			};
			text = "Climbing Gloves";
			ClimblingGlovesConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<float>(cfg, text, "Tier upgrade which increases the speed of climbing ladders", "150,200,250,300")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial value added to the players climbing speed", 1f, "Vanilla climb speed is 4 units"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental value added to the players climbing speed", 0.5f, (ConfigDescription)null)
			};
			text = "Discombobulator";
			DiscombobulatorUpgradeConfiguration = new DiscombobulatorUpgradeConfiguration(cfg, text, "Stun enemies around the ship.", "450,330,460,620")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Discombobulator Stun Duration", 7.5f, (ConfigDescription)null),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Discombobulator Increment", 1f, "The amount added to stun duration on upgrade.")
			};
			text = "Drop Pod Thrusters";
			DropPodThrustersConfiguration = new DropPodThrustersUpgradeConfiguration(cfg, text, "Make the Drop Pod, the ship that deliver items bought on the terminal, land faster.", 300);
			text = "Efficient Engines";
			EfficientEnginesConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which applies a discount on moon routing prices for cheaper travels", "450,600, 750, 900")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial discount applied to moon routing (%)", 15, (ConfigDescription)null),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental discount applied to moon routing (%)", 5, (ConfigDescription)null)
			};
			text = "Fast Encryption";
			FastEncryptionConfiguration = new OneTimeUpgradeConfiguration(cfg, text, "Upgrades the transmitter.", 300);
			text = "Hunter";
			HunterConfiguration = new TierCollectionUpgradeConfiguration(cfg, text, "Collect and sell samples from dead enemies", "500,600,700")
			{
				TierCollection = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Samples dropping at each tier", "Hoarding Bug, Centipede, Spore Lizard-Bunker Spider, Baboon hawk, Tulip Snake, Kidnapper Fox, Giant Kiwi-Flowerman, MouthDog, Crawler, Manticoil, Maneater-Forest Giant", "Specifies at which tier of Hunter do each sample start dropping from. Each tier is separated with a dash ('-') and each list of monsters will be separated with a comma (',')\nSupported Enemies: Hoarding Bug, Centipede (Snare Flea),Bunker Spider, Baboon Hawk, Crawler (Half/Thumper), Flowerman (Bracken), MouthDog (Eyeless Dog), Forest Giant, Tulip Snake, Manticoil, Kidnapper Fox, Spore Lizard and Giant Kiwi (Giant Sapsucker/Woodpecker).")
			};
			SNARE_FLEA_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.SNARE_FLEA_SAMPLE_MINIMUM_VALUE_KEY, 35, (ConfigDescription)null);
			SNARE_FLEA_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.SNARE_FLEA_SAMPLE_MAXIMUM_VALUE_KEY, 60, (ConfigDescription)null);
			BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BUNKER_SPIDER_SAMPLE_MINIMUM_VALUE_KEY, 65, (ConfigDescription)null);
			BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BUNKER_SPIDER_SAMPLE_MAXIMUM_VALUE_KEY, 95, (ConfigDescription)null);
			HOARDING_BUG_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.HOARDING_BUG_SAMPLE_MINIMUM_VALUE_KEY, 45, (ConfigDescription)null);
			HOARDING_BUG_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.HOARDING_BUG_SAMPLE_MAXIMUM_VALUE_KEY, 75, (ConfigDescription)null);
			BRACKEN_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BRACKEN_SAMPLE_MINIMUM_VALUE_KEY, 80, (ConfigDescription)null);
			BRACKEN_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BRACKEN_SAMPLE_MAXIMUM_VALUE_KEY, 125, (ConfigDescription)null);
			EYELESS_DOG_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.EYELESS_DOG_SAMPLE_MINIMUM_VALUE_KEY, 100, (ConfigDescription)null);
			EYELESS_DOG_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.EYELESS_DOG_SAMPLE_MAXIMUM_VALUE_KEY, 150, (ConfigDescription)null);
			BABOON_HAWK_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BABOON_HAWK_SAMPLE_MINIMUM_VALUE_KEY, 75, (ConfigDescription)null);
			BABOON_HAWK_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.BABOON_HAWK_SAMPLE_MAXIMUM_VALUE_KEY, 115, (ConfigDescription)null);
			THUMPER_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.THUMPER_SAMPLE_MINIMUM_VALUE_KEY, 80, (ConfigDescription)null);
			THUMPER_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.THUMPER_SAMPLE_MAXIMUM_VALUE_KEY, 125, (ConfigDescription)null);
			FOREST_KEEPER_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.FOREST_KEEPER_SAMPLE_MINIMUM_VALUE_KEY, 80, (ConfigDescription)null);
			FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.FOREST_KEEPER_SAMPLE_MAXIMUM_VALUE_KEY, 125, (ConfigDescription)null);
			MANTICOIL_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.MANTICOIL_SAMPLE_MINIMUM_VALUE_KEY, 40, (ConfigDescription)null);
			MANTICOIL_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.MANTICOIL_SAMPLE_MAXIMUM_VALUE_KEY, 75, (ConfigDescription)null);
			TULIP_SNAKE_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.TULIP_SNAKE_SAMPLE_MINIMUM_VALUE_KEY, 30, (ConfigDescription)null);
			TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.TULIP_SNAKE_SAMPLE_MAXIMUM_VALUE_KEY, 50, (ConfigDescription)null);
			KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.KIDNAPPER_FOX_SAMPLE_MINIMUM_VALUE_KEY, 60, (ConfigDescription)null);
			KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.KIDNAPPER_FOX_SAMPLE_MAXIMUM_VALUE_KEY, 80, (ConfigDescription)null);
			SPORE_LIZARD_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.SPORE_LIZARD_SAMPLE_MINIMUM_VALUE_KEY, 30, (ConfigDescription)null);
			SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.SPORE_LIZARD_SAMPLE_MAXIMUM_VALUE_KEY, 50, (ConfigDescription)null);
			MANEATER_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.MANEATER_SAMPLE_MINIMUM_VALUE_KEY, 80, (ConfigDescription)null);
			MANEATER_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.MANEATER_SAMPLE_MAXIMUM_VALUE_KEY, 120, (ConfigDescription)null);
			GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.GIANT_SAPSUCKER_SAMPLE_MINIMUM_VALUE_KEY, 110, (ConfigDescription)null);
			GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, LguConstants.GIANT_SAPSUCKER_SAMPLE_MAXIMUM_VALUE_KEY, 160, (ConfigDescription)null);
			text = "Lethal Deals";
			LethalDealsConfiguration = new OneTimeUpgradeConfiguration(cfg, text, "One time upgrade which guarantees at least one item will be on sale in the store.", 300);
			text = "Lightning Rod";
			LightningRodConfiguration = new OneTimeAlternativePrimitiveUpgradeConfiguration<float, LightningRod.UpgradeMode>(cfg, text, "A device which redirects lightning bolts to the ship.", 1000)
			{
				Effect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Effective Distance of Lightning Rod.", 175f, "The closer you are the more likely the rod will reroute lightning."),
				AlternativeMode = SyncedBindingExtensions.BindSyncedEntry<LightningRod.UpgradeMode>(cfg, text, "Current Upgrade Mode for Lightning Rod", LightningRod.UpgradeMode.EffectiveRange, "Supported Values:\nEffectiveRange: The closer the item is to the ship, the more likely the lightning directed to it will be redirected to the ship instead.\nAlwaysRerouteItem: Whenever an item is picked to be hit by lightning, the bolt will be redirected to the ship instead.\nAlwaysRerouteRandom: Whenever a random lightning bolt (not the one used to target items) is produced, the bolt will be redirected to the ship instead.\nAlwaysRerouteAll: Whenever any kind of lightning bolt is produced, the bolt will be redirected to the ship instead.\n")
			};
			text = "Lithium Batteries";
			LithiumBatteriesConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which decreases the rate of battery consumed when using the item", "100,150, 200, 250, 300")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial multiplier applied to the use rate of the battery (%)", 10, "Past 100%, it won't consume any battery charge from the item"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental multiplier applied to the use rate of the battery (%)", 10, "Past 100%, it won't consume any battery charge from the item")
			};
			text = "Locksmith";
			LocksmithConfiguration = new OneTimeIndividualUpgradeConfiguration(cfg, text, "Allows you to pick locked doors by completing a minigame.", 640);
			text = "Malware Broadcaster";
			MalwareBroadcasterUpgradeConfiguration = new MalwareBroadcasterUpgradeConfiguration(cfg, text, "Explode Map Hazards", 550);
			text = "Market Influence";
			MarketInfluenceConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Tier upgrade which guarantees a minimum percentage sale on the selected item in the store.", "200,350,500")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial percentage guarantee on the items on sale", 10, (ConfigDescription)null),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental percentage guarantee on the items on sale", 5, (ConfigDescription)null)
			};
			text = "Night Vision";
			NightVisionUpgradeConfiguration = new NightVisionUpgradeConfiguration(cfg, text, "Toggleable night vision.", "300,400,500")
			{
				InitialEffects = new List<SyncedEntry<float>>(5)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "The max charge for your Night Vision battery", 10f, "Default settings this will be the unupgraded time in seconds the battery will drain and regen in. Increase to increase battery life."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Multiplier for night vis battery regen", 1f, "Multiplied by timedelta, raise to speed up battery regen time."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Multiplier for night vis battery drain", 1f, "Multiplied by timedelta, lower to increase battery life."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Night Vision Range", 2000f, "Kind of like the distance your Night Vision travels."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Night Vision Intensity", 1000f, "Kind of like the brightness of your Night Vision.")
				},
				IncrementalEffects = new List<SyncedEntry<float>>(5)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Increase for Night Vision battery life", 2f, "Applied to the max charge for Night Vision battery on each upgrade."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Increase for Night Vision battery regen", 0.4f, "Applied to regen speed on each upgrade."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Decrease for Night Vision battery drain", 0.15f, "Applied to drain speed on each upgrade."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Night Vision Range Increment", 0f, "Increases your range by this value each upgrade."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Night Vision Intensity Increment", 0f, "Increases your intensity by this value each upgrade.")
				}
			};
			text = "Protein Powder";
			ProteinPowderConfiguration = new TierIndividualMultiplePrimitiveUpgradeConfiguration<int, float>(cfg, text, "Do more damage with shovels", "1000,700")
			{
				InitialEffects = new List<SyncedEntry<int>>(1) { SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial additional hit force", 1, "The value added to hit force on initial unlock.") },
				IncrementalEffects = new List<SyncedEntry<int>>(1) { SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Additional hit force per level", 1, "Every time Protein Powder is upgraded this value will be added to the value above.") },
				InitialSecondEffects = new List<SyncedEntry<float>>(1) { SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Chance of dealing a crit which will instakill the enemy.", 0.01f, "This value is only valid when maxed out Protein Powder. Any previous levels will not apply crit.") },
				IncrementalSecondEffects = new List<SyncedEntry<float>>(1) { null }
			};
			text = "Quantum Disruptor";
			QuantumDisruptorConfiguration = new QuantumDisruptorUpgradeConfiguration(cfg, text, "Tier upgrade which increases the time you can stay in a moon landing", "1000,1200,1500,1800")
			{
				ResetMode = SyncedBindingExtensions.BindSyncedEntry<QuantumDisruptor.ResetModes>(cfg, text, "Reset Time of Quantum Disruptor current usages", QuantumDisruptor.ResetModes.MoonLanding, "Reset mode of when the current counter of usages reset to use the ability. Only applied when RevertTime mode is selected.\nSupported Values: MoonLanding (reset counter per each moon landing), MoonRerouting (reset counter per each moon routing), NewQuota (reset counter per each new quota)"),
				AlternativeMode = SyncedBindingExtensions.BindSyncedEntry<QuantumDisruptor.UpgradeModes>(cfg, text, "Mode of Quantum Disruptor", QuantumDisruptor.UpgradeModes.SlowdownTime, "Applied mode when purchasing the upgrade.\nSupported modes: SlowdownTime (makes the time go slower in moons), RevertTime (command prompt which reverts hours when executed, maximum usages per moon)."),
				InitialEffects = new List<SyncedEntry<int>>(3)
				{
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "How slower (in %) time will go by when unlocking the Quantum Disruptor upgrade", 20, (ConfigDescription)null),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial amount of usages of Quantum Disruptor", 1, "Amount of times you can execute the quantum command. Only applied when RevertTime mode is selected"),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial amount of hours reverted from Quantum Disruptor", 1, "Amount of hours to revert when executing the quantum command. Only applied when RevertTime mode is selected")
				},
				IncrementalEffects = new List<SyncedEntry<int>>(3)
				{
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "How slower (in %) time will go by when incrementing the Quantum Disruptor level", 10, (ConfigDescription)null),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental amount of usages of Quantum Disruptor", 1, "Amount of times you can execute the quantum command. Only applied when RevertTime mode is selected"),
					SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental amount of hours reverted from Quantum Disruptor", 1, "Amount of hours to revert when executing the quantum command. Only applied when RevertTime mode is selected")
				}
			};
			text = "Running Shoes";
			RunningShoesConfiguration = new TierIndividualMultiplePrimitiveUpgradeConfiguration<float>(cfg, text, "Run Faster", "650,500,750,1000")
			{
				InitialEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Movement Speed Unlock", 1.4f, "Value added to player's movement speed when first purchased.\nDefault vanilla value is 4.6f."),
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Noise Reduction", 10f, "Distance units to subtract from footstep noise when reached final level.")
				},
				IncrementalEffects = new List<SyncedEntry<float>>(2)
				{
					SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Movement Speed Increment", 0.5f, "How much the above value is increased on upgrade."),
					null
				}
			};
			text = "Shutter Batteries";
			ShutterBatteriesConfiguration = new TierPrimitiveUpgradeConfiguration<float>(cfg, text, "Increases the amount of time the doors can remain shut", "300,200,300,400")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial battery boost", 5f, "Initial battery boost for the doors' lock on first purchase"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental battery boost", 5f, "Incremental battery boost for the doors' lock after purchase")
			};
			text = "Sick Beats";
			SickBeatsUpgradeConfiguration = new SickBeatsUpgradeConfiguration(cfg, text, "Get buffs from nearby active boomboxes.", 500);
			text = "Sigurd Access";
			SigurdAccessConfiguration = new SigurdAccessUpgradeConfiguration(cfg, text, "There's a chance that The Company will pay more for the scrap.", 500)
			{
				Effect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "How much the percentage will go up", 20f, (ConfigDescription)null),
				Chance = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Chance for the upgrade to activate", 20f, (ConfigDescription)null),
				AlternativeMode = SyncedBindingExtensions.BindSyncedEntry<Sigurd.FunctionModes>(cfg, text, "Sigurd Function Mode", Sigurd.FunctionModes.AllDays, "Supported Modes:\nAllDays: All days have a chance of increased Company Buy Rate\nLastDay: Day of the deadline has a chance of increased COmpany Buy Rate")
			};
			text = "Stimpack";
			StimpackConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<int>(cfg, text, "Increases player's health.", "600,300, 450, 600")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial health boost", 20, "Amount of health gained when unlocking the upgrade"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Additional health boost", 20, "Every time Stimpack is upgraded this value will be added to the value above.")
			};
			text = "Strong Legs";
			StrongLegsConfiguration = new TierIndividualPrimitiveUpgradeConfiguration<float>(cfg, text, "Jump Higher", "300,150,190,250")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Jump Force Unlock", 3f, "Amount of jump force added when unlocking the upgrade.\nDefault vanilla value is 13f."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Jump Force Increment", 0.75f, "How much the above value is increased on upgrade.")
			};
			text = "Walkie GPS";
			WalkieGpsConfiguration = new OneTimeIndividualUpgradeConfiguration(cfg, text, "Holding a walkie talkie displays location.", 450);
			text = "Baby Pacifier";
			BabyPacifierUpgradeConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Decreases the growth rate of baby maneater when they are crying", "100,100,200,200,400")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial percentage of Growth Decrease", 15, "Initial percentage (%) removed from Maneaters Growth Increment when crying"),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental percentage of Growth Decrease", 15, "Incremental percentage (%) removed from Maneaters Growth Increment when crying")
			};
			text = "Item Duplicator";
			ItemDuplicatorUpgradeConfiguration = new TierPrimitiveUpgradeConfiguration<int>(cfg, text, "Possibly duplicates the items purchased from the Company Store without occupying space in the drop pod.", "250,350,500,750")
			{
				InitialEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial percentage of duplication chance", 30, "Initial percentage (%) of chance that the purchased item will be duplicated from the drop pod."),
				IncrementalEffect = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental percentage of duplication chance", 15, "Incremental percentage (%) of chance that the purchased item will be duplicated from the drop pod.")
			};
			text = "Interns";
			INTERN_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable hiring of interns", true, "Pay x amount of credits to revive a player.");
			INTERN_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Interns Price", 1000, "Default price to hire an intern.");
			INTERNS_TELEPORT_RESTRICTION = SyncedBindingExtensions.BindSyncedEntry<Interns.TeleportRestriction>(cfg, text, "Teleport Restriction when using Interns", Interns.TeleportRestriction.None, "Supported modes:\nNone: No restrictions applied.\nExitBuilding: Player must exit the facility to be able to be teleported.\nEnterShip: Player must enter the ship to be able to be teleported.");
			INTERNS_USAGES_PER_LANDING = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Revives per Landing", -1, "Amount of times you can use the command per landing. Once the amount is reached, you can no longer revive more teammates. Use \"-1\" for infinite");
			INTERNS_INTERVAL_BETWEEN_REVIVES = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Interval between Revives", 0f, "Time interval between each revival");
			INTERNS_DELAY_BEFORE_REVIVE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Delay before Revive", 0f, "Time after purchasing it to perform the revive");
			base.InitialSyncCompleted += PluginConfig_InitialSyncCompleted;
			ConfigManager.Register<LategameConfiguration>((SyncedConfig2<LategameConfiguration>)this);
		}

		private void PluginConfig_InitialSyncCompleted(object sender, EventArgs e)
		{
			if (!((Object)(object)LguStore.Instance == (Object)null))
			{
				CheckMedkit();
				UpgradeBus.Instance.Reconstruct();
			}
		}

		private void CheckMedkit()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//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_006d: Expected O, but got Unknown
			AnimationCurve curve = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
			{
				new Keyframe(0f, (float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.AmountMedkits.Value),
				new Keyframe(1f, (float)UpgradeBus.Instance.PluginConfiguration.ContractsConfiguration.ExtractionConfiguration.AmountMedkits.Value)
			});
			ItemManager.SetupMapObject(AssetBundleHandler.GetItemObject("MedkitMapItem"), curve);
		}
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Interfaces
{
	public interface IAlternativeUpgradeConfiguration<T> : IUpgradeConfiguration where T : Enum
	{
		SyncedEntry<T> AlternativeMode { get; set; }
	}
	public interface IIndividualUpgradeConfiguration : IUpgradeConfiguration
	{
		SyncedEntry<bool> Individual { get; set; }
	}
	public interface IUpgradeConfiguration
	{
		SyncedEntry<bool> Enabled { get; set; }

		SyncedEntry<int> MinimumSalePercentage { get; set; }

		SyncedEntry<int> MaximumSalePercentage { get; set; }

		SyncedEntry<string> OverrideName { get; set; }

		SyncedEntry<PurchaseMode> PurchaseMode { get; set; }

		SyncedEntry<string> ItemProgressionItems { get; set; }

		SyncedEntry<bool> Refundable { get; set; }

		SyncedEntry<int> RefundPercentage { get; set; }
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Interfaces.TierUpgrades
{
	public interface ITierAlternativeEffectUpgradeConfiguration<K, T> : ITierEffectUpgradeConfiguration<K>, ITierUpgradeConfiguration, IUpgradeConfiguration, IAlternativeUpgradeConfiguration<T> where T : Enum
	{
	}
	internal interface ITierAlternativeMultipleEffectUpgradeConfiguration<K, V, T> : ITierMultipleEffectUpgradeConfiguration<K, V>, ITierMultipleEffectUpgradeConfiguration<K>, ITierUpgradeConfiguration, IUpgradeConfiguration, IAlternativeUpgradeConfiguration<T> where T : Enum
	{
	}
	public interface ITierCollectionUpgradeConfiguration : ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		SyncedEntry<string> TierCollection { get; set; }
	}
	public interface ITierEffectUpgradeConfiguration<T> : ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		SyncedEntry<T> InitialEffect { get; set; }

		SyncedEntry<T> IncrementalEffect { get; set; }
	}
	public interface ITierMultipleEffectUpgradeConfiguration<T> : ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		List<SyncedEntry<T>> InitialEffects { get; set; }

		List<SyncedEntry<T>> IncrementalEffects { get; set; }

		void AddEffectPair(SyncedEntry<T> initialEffect, SyncedEntry<T> incrementalEffect);

		(SyncedEntry<T>, SyncedEntry<T>) GetEffectPair(int index);
	}
	public interface ITierMultipleEffectUpgradeConfiguration<K, T> : ITierMultipleEffectUpgradeConfiguration<K>, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		List<SyncedEntry<T>> InitialSecondEffects { get; set; }

		List<SyncedEntry<T>> IncrementalSecondEffects { get; set; }

		void AddSecondEffectPair(SyncedEntry<T> initialEffect, SyncedEntry<T> incrementalEffect);

		(SyncedEntry<T>, SyncedEntry<T>) GetSecondEffectPair(int index);
	}
	public interface ITierUpgradeConfiguration : IUpgradeConfiguration
	{
		SyncedEntry<string> Prices { get; set; }
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Interfaces.OneTimeUpgrades
{
	public interface IOneTimeAlternativeEffectUpgradeConfiguration<K, T> : IOneTimeEffectUpgrade<K>, IOneTimeUpgradeConfiguration, IUpgradeConfiguration, IAlternativeUpgradeConfiguration<T> where T : Enum
	{
	}
	public interface IOneTimeEffectUpgrade<T> : IOneTimeUpgradeConfiguration, IUpgradeConfiguration
	{
		SyncedEntry<T> Effect { get; set; }
	}
	public interface IOneTimeUpgradeConfiguration : IUpgradeConfiguration
	{
		SyncedEntry<int> Price { get; set; }
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Custom
{
	public class BetterScannerUpgradeConfiguration : OneTimeIndividualUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> SecondPrice { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> ThirdPrice { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> OutsideNodesRangeIncrease { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> NodeRangeIncrease { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SeeEnemiesThroughWalls { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> VerboseEnemies { get; set; }

		public BetterScannerUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			OutsideNodesRangeIncrease = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Ship and Entrance node distance boost", 150f, "How much further away you can scan the ship and entrance.");
			NodeRangeIncrease = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Node distance boost", 20f, "How much further away you can scan other nodes.");
			SeeEnemiesThroughWalls = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Scan enemies through walls on final upgrade", false, "If true the final upgrade will scan scrap AND enemies through walls.");
			VerboseEnemies = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Verbose `scan enemies` command", true, "If false `scan enemies` only returns a count of outside and inside enemies, else it returns the count for each enemy type.");
			SecondPrice = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Price of second Better Scanner tier", 500, "This tier unlocks ship scan commands.");
			ThirdPrice = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Price of third Better Scanner tier", 800, "This tier unlocks scanning through walls.");
		}
	}
	public class BiggerLungsUpgradeConfiguration : TierIndividualMultiplePrimitiveUpgradeConfiguration<float>
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> JumpReductionLevel { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> StaminaRegenerationLevel { get; set; }

		public BiggerLungsUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}
	}
	public class DeeperPocketsUpgradeConfiguration : TierIndividualPrimitiveUpgradeConfiguration<int>
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> AllowWheelbarrows { get; set; }

		public DeeperPocketsUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			AllowWheelbarrows = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Allow wheelbarrows to be stored in deeper pockets", true, "Whether or not wheelbarrows and shopping carts can be stored in deeper pockets");
		}
	}
	public class DiscombobulatorUpgradeConfiguration : TierPrimitiveUpgradeConfiguration<float>
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> DamageLevel { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> InitialDamage { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> IncrementalDamage { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BlacklistEnemies { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> NotifyChat { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> Radius { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> Cooldown { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> Absolute { get; set; }

		public DiscombobulatorUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			NotifyChat = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Notify Local Chat of Enemy Stun Duration", true, (ConfigDescription)null);
			DamageLevel = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Initial level of dealing damage", 2, "Level of Discombobulator in which it starts dealing damage on enemies it stuns");
			InitialDamage = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Initial amount of damage", 2, "Amount of damage when reaching the first level that unlocks damage on stun\nTo give an idea of what's too much, Eyeless Dogs have 12 health.");
			IncrementalDamage = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Damage Increase on Purchase", 1, "Damage increase when purchasing later levels");
			BlacklistEnemies = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Blacklisted Enemies", "", "Enemies that aren't affected by Discombobulator. Either the internal name (EnemyType.enemyName) or the name shown in the scan node if it has one. Each enemy is separated by a comma (',')");
			Radius = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Discombobulator Effect Radius", 40f, (ConfigDescription)null);
			Cooldown = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Discombobulator Cooldown", 120f, (ConfigDescription)null);
			Absolute = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Absolute Stun Duration", true, "If enabled, the stun time used during trigger is absolute and it is not influenced by the enemy stun resistance.");
		}
	}
	public class DropPodThrustersUpgradeConfiguration : OneTimeUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<float> InitialTimer { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> Timer { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> ExitTimer { get; set; }

		public DropPodThrustersUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			Timer = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Time decrement on the timer used for subsequent item deliveries", 20f, (ConfigDescription)null);
			InitialTimer = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Time decrement on the timer used for the first ever item delivery", 10f, (ConfigDescription)null);
			ExitTimer = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Time for item dropship to exit", 0f, "How long (in seconds) the item drop ship stays after being opened");
		}
	}
	public class LandingThrusterUpgradeConfiguration : TierPrimitiveUpgradeConfiguration<int>
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> AffectLanding { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> AffectDeparture { get; set; }

		public LandingThrusterUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			AffectLanding = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Affect landing sequence speed", true, "If true, the effect will be applied on the ship speed when landing on a moon");
			AffectDeparture = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Affect departing sequence speed", true, "If true, the effect will be applied on the ship speed when departing from a moon");
		}
	}
	public class MalwareBroadcasterUpgradeConfiguration : OneTimeIndividualUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> DestroyTraps { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ExplodeTraps { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> DisarmTime { get; set; }

		public MalwareBroadcasterUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			DestroyTraps = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Destroy Trap", true, "If false Malware Broadcaster will disable the trap for a long time instead of destroying.");
			DisarmTime = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Disarm Time", 7f, "If `Destroy Trap` is false this is the duration traps will be disabled.");
			ExplodeTraps = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Explode Trap", true, "Destroy Trap must be true! If this is true when destroying a trap it will also explode.");
		}
	}
	public class NightVisionUpgradeConfiguration : TierIndividualMultiplePrimitiveUpgradeConfiguration<float>
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> ItemPrice { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> LightColour { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> TextColour { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BarColour { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> StartupPercentage { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> ExhaustTime { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> LoseOnDeath { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> DropOnDeath { get; set; }

		public NightVisionUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			ItemPrice = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Price of Night Vision Upgrade", 380, (ConfigDescription)null);
			LightColour = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Night Vision Color", "#00FF00FF", "The color your Night Vision light emits.");
			TextColour = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Night Vision UI Text Color", "#FFFFFFFF", "The color used for the Night Vision's UI text.");
			BarColour = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Night Vision UI Bar Color", "#00FF00FF", "The color used for the Night Vision's UI battery bar.");
			StartupPercentage = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Night Vision StartUp Cost", 0.1f, "The percent battery drained when turned on (0.1 = 10%).");
			ExhaustTime = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Night Vision Exhaustion", 2f, "How many seconds Night Vision stays fully depleted.");
			LoseOnDeath = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Lose Night Vision On Death", true, "If true when you die the Night Vision will disable and will need a new pair of goggles.");
			DropOnDeath = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Drop Night Vision Goggles on Death", true, "If true, when you die and lose Night Vision upon death, you will drop the Night Vision Goggles on your body.");
		}
	}
	public class QuantumDisruptorUpgradeConfiguration : TierAlternativeMultiplePrimitiveUpgradeConfiguration<int, QuantumDisruptor.UpgradeModes>
	{
		[field: SyncedEntryField]
		public SyncedEntry<QuantumDisruptor.ResetModes> ResetMode { get; set; }

		public QuantumDisruptorUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}
	}
	public class ScrapKeeperUpgradeConfiguration : TierPrimitiveUpgradeConfiguration<int>
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> OnlyKeepItemsInShip { get; set; }

		public ScrapKeeperUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			OnlyKeepItemsInShip = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Only Keep Previous Items", false, "If enabled, the upgrade will ignore the items that were stored in the same day and only apply its effect to the items kept from previous rounds.");
		}
	}
	public class SickBeatsUpgradeConfiguration : OneTimeIndividualUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> EnableDamage { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> DamageBoost { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> EnableDefense { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> DefenseBoost { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> EnableSpeed { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> SpeedBoost { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> EnableStaminaRegen { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> StaminaRegenBoost { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> ApplyStaminaDuringConsumption { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> BoomboxAttract { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> Radius { get; set; }

		public SickBeatsUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			EnableDamage = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Enable Damage Boost Effect", true, (ConfigDescription)null);
			DamageBoost = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Additional Damage Dealt", 1, (ConfigDescription)null);
			EnableStaminaRegen = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Enable Stamina Boost Effect", false, (ConfigDescription)null);
			StaminaRegenBoost = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Stamina Regen Coefficient", 1.25f, "Multiplied to stamina regen.");
			EnableDefense = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Enable Defense Boost Effect", false, (ConfigDescription)null);
			DefenseBoost = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Defense Boost Coefficient", 0.5f, "Multiplied to incoming damage.");
			EnableSpeed = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Enable Speed Boost Effect", true, (ConfigDescription)null);
			SpeedBoost = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Speed Boost Addition", 1.5f, (ConfigDescription)null);
			Radius = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, topSection, "Effect Radius", 15f, "Radius in unity units players will be effected by an active boombox.");
			ApplyStaminaDuringConsumption = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Apply Stamina Buff on stamina consumption situations", false, "If enabled, moments where stamina is consumed overtime will include the stamina buff in mind");
			BoomboxAttract = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Boombox Attract Sound Toggle", true, "After the upgrade has been purchased, wether the boombox attracts nearby enemies to its location or not");
		}
	}
	public class SigurdAccessUpgradeConfiguration : OneTimeAlternativePrimitiveUpgradeConfiguration<float, Sigurd.FunctionModes>
	{
		[field: SyncedEntryField]
		public SyncedEntry<float> Chance { get; set; }

		public SigurdAccessUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
		}
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Abstractions
{
	public abstract class UpgradeConfiguration : IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Enabled { get; set; } = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, $"Enable {topSection} Upgrade", true, enabledDescription);


		[field: SyncedEntryField]
		public SyncedEntry<int> MinimumSalePercentage { get; set; } = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Minimum Sale Percentage", 60, "Minimum percentage achieved when the upgrade goes on sale");


		[field: SyncedEntryField]
		public SyncedEntry<int> MaximumSalePercentage { get; set; } = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Maximum Sale Percentage", 90, "Maximum percentage achieved when the upgrade goes on sale");


		[field: SyncedEntryField]
		public SyncedEntry<string> OverrideName { get; set; } = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, $"Alternative name for {topSection} upgrade", topSection, (ConfigDescription)null);


		[field: SyncedEntryField]
		public SyncedEntry<string> ItemProgressionItems { get; set; } = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Contribution Items", "", "Items that when sold contribute to the purchase of the upgrade. Either the scan node's name or ItemProperties.itemName can be inserted here");


		[field: SyncedEntryField]
		public SyncedEntry<PurchaseMode> PurchaseMode { get; set; } = SyncedBindingExtensions.BindSyncedEntry<PurchaseMode>(cfg, topSection, "Purchase Mode", MoreShipUpgrades.UI.TerminalNodes.PurchaseMode.Both, "Method of purchase allowed for the upgrade");


		[field: SyncedEntryField]
		public SyncedEntry<bool> Refundable { get; set; } = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Allow refund", false, "If enabled, you are able to refund a level from the selected upgrade.");


		[field: SyncedEntryField]
		public SyncedEntry<int> RefundPercentage { get; set; } = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Refund percentage", 100, "Amount of credits in percentage (%) given back from the refunded level");


		protected UpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription)
		{
		}
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Abstractions.TIerUpgrades
{
	public class TierAlternativeMultiplePrimitiveUpgradeConfiguration<K, T> : TierMultiplePrimitiveUpgradeConfiguration<K>, IAlternativeUpgradeConfiguration<T>, IUpgradeConfiguration where T : Enum
	{
		public SyncedEntry<T> AlternativeMode { get; set; }

		public TierAlternativeMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}

		public TierAlternativeMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, SyncedEntry<T> alternativeMode)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			AlternativeMode = alternativeMode;
		}
	}
	public class TierAlternativePrimitiveUpgradeConfiguration<K, T> : TierPrimitiveUpgradeConfiguration<K>, ITierAlternativeEffectUpgradeConfiguration<K, T>, ITierEffectUpgradeConfiguration<K>, ITierUpgradeConfiguration, IUpgradeConfiguration, IAlternativeUpgradeConfiguration<T> where T : Enum
	{
		public SyncedEntry<T> AlternativeMode { get; set; }

		public TierAlternativePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}

		public TierAlternativePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, SyncedEntry<T> alternativeMode)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			AlternativeMode = alternativeMode;
		}
	}
	public class TierCollectionUpgradeConfiguration : TierUpgradeConfiguration, ITierCollectionUpgradeConfiguration, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<string> TierCollection { get; set; }

		public TierCollectionUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}
	}
	public class TierIndividualPrimitiveUpgradeConfiguration<T> : TierPrimitiveUpgradeConfiguration<T>, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<bool> Individual { get; set; }

		public TierIndividualPrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class TierIndividualMultiplePrimitiveUpgradeConfiguration<T> : TierMultiplePrimitiveUpgradeConfiguration<T>, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<bool> Individual { get; set; }

		public TierIndividualMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}

		public TierIndividualMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<T>> initialEffects, List<SyncedEntry<T>> incrementalEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class TierIndividualMultiplePrimitiveUpgradeConfiguration<K, T> : TierMultiplePrimitiveUpgradeConfiguration<K, T>, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<bool> Individual { get; set; }

		public TierIndividualMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}

		public TierIndividualMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<K>> initialEffects, List<SyncedEntry<K>> incrementalEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices, initialEffects, incrementalEffects)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}

		public TierIndividualMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<K>> initialEffects, List<SyncedEntry<K>> incrementalEffects, List<SyncedEntry<T>> initialSecondEffects, List<SyncedEntry<T>> incrementalSecondEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices, initialEffects, incrementalEffects, initialSecondEffects, incrementalSecondEffects)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class TierIndividualAlternativePrimitiveUpgradeConfiguration<K, T> : TierAlternativePrimitiveUpgradeConfiguration<K, T>, IIndividualUpgradeConfiguration, IUpgradeConfiguration where T : Enum
	{
		public SyncedEntry<bool> Individual { get; set; }

		public TierIndividualAlternativePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class TierIndividualUpgradeConfiguration : TierUpgradeConfiguration, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Individual { get; set; }

		public TierIndividualUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class TierMultiplePrimitiveUpgradeConfiguration<T> : TierUpgradeConfiguration, ITierMultipleEffectUpgradeConfiguration<T>, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		public List<SyncedEntry<T>> InitialEffects { get; set; }

		public List<SyncedEntry<T>> IncrementalEffects { get; set; }

		public TierMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			InitialEffects = new List<SyncedEntry<T>>();
			IncrementalEffects = new List<SyncedEntry<T>>();
		}

		public TierMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<T>> initialEffects, List<SyncedEntry<T>> incrementalEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			InitialEffects = initialEffects;
			IncrementalEffects = incrementalEffects;
		}

		public void AddEffectPair(SyncedEntry<T> initialEffect, SyncedEntry<T> incrementalEffect)
		{
			InitialEffects.Add(initialEffect);
			IncrementalEffects.Add(incrementalEffect);
		}

		public (SyncedEntry<T>, SyncedEntry<T>) GetEffectPair(int index)
		{
			return (InitialEffects[index], IncrementalEffects[index]);
		}
	}
	public class TierMultiplePrimitiveUpgradeConfiguration<K, T> : TierMultiplePrimitiveUpgradeConfiguration<K>, ITierMultipleEffectUpgradeConfiguration<K, T>, ITierMultipleEffectUpgradeConfiguration<K>, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		public List<SyncedEntry<T>> InitialSecondEffects { get; set; }

		public List<SyncedEntry<T>> IncrementalSecondEffects { get; set; }

		public TierMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
			InitialSecondEffects = new List<SyncedEntry<T>>();
			IncrementalSecondEffects = new List<SyncedEntry<T>>();
		}

		public TierMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<K>> initialEffects, List<SyncedEntry<K>> incrementalEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices, initialEffects, incrementalEffects)
		{
			InitialSecondEffects = new List<SyncedEntry<T>>();
			IncrementalSecondEffects = new List<SyncedEntry<T>>();
		}

		public TierMultiplePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices, List<SyncedEntry<K>> initialEffects, List<SyncedEntry<K>> incrementalEffects, List<SyncedEntry<T>> initialSecondEffects, List<SyncedEntry<T>> incrementalSecondEffects)
			: base(cfg, topSection, enabledDescription, defaultPrices, initialEffects, incrementalEffects)
		{
			InitialSecondEffects = initialSecondEffects;
			IncrementalSecondEffects = incrementalSecondEffects;
		}

		public void AddSecondEffectPair(SyncedEntry<T> initialEffect, SyncedEntry<T> incrementalEffect)
		{
			InitialSecondEffects.Add(initialEffect);
			IncrementalSecondEffects.Add(incrementalEffect);
		}

		public (SyncedEntry<T>, SyncedEntry<T>) GetSecondEffectPair(int index)
		{
			return (InitialSecondEffects[index], IncrementalSecondEffects[index]);
		}
	}
	public class TierPrimitiveUpgradeConfiguration<T> : TierUpgradeConfiguration, ITierEffectUpgradeConfiguration<T>, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<T> InitialEffect { get; set; }

		public SyncedEntry<T> IncrementalEffect { get; set; }

		public TierPrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription, defaultPrices)
		{
		}
	}
	public class TierUpgradeConfiguration : UpgradeConfiguration, ITierUpgradeConfiguration, IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<string> Prices { get; set; }

		public TierUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, string defaultPrices)
			: base(cfg, topSection, enabledDescription)
		{
			Prices = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Price of each additional upgrade", defaultPrices, "Value must be seperated by commas EX: '123,321,222'");
		}
	}
}
namespace MoreShipUpgrades.Configuration.Upgrades.Abstractions.OneTimeUpgrades
{
	public class OneTimeAlternativePrimitiveUpgradeConfiguration<K, V> : OneTimePrimitiveUpgradeConfiguration<K>, IOneTimeAlternativeEffectUpgradeConfiguration<K, V>, IOneTimeEffectUpgrade<K>, IOneTimeUpgradeConfiguration, IUpgradeConfiguration, IAlternativeUpgradeConfiguration<V> where V : Enum
	{
		public SyncedEntry<V> AlternativeMode { get; set; }

		public OneTimeAlternativePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
		}
	}
	public class OneTimeIndividualPrimitiveUpgradeConfiguration<T> : OneTimePrimitiveUpgradeConfiguration<T>, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<bool> Individual { get; set; }

		public OneTimeIndividualPrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class OneTimeIndividualUpgradeConfiguration : OneTimeUpgradeConfiguration, IIndividualUpgradeConfiguration, IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Individual { get; set; }

		public OneTimeIndividualUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
			Individual = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Individual Purchase", true, "If true: upgrade will apply only to the client that purchased it. (Overriden by 'Convert all upgrades to be shared' option in Misc section)");
		}
	}
	public class OneTimePrimitiveUpgradeConfiguration<T> : OneTimeUpgradeConfiguration, IOneTimeEffectUpgrade<T>, IOneTimeUpgradeConfiguration, IUpgradeConfiguration
	{
		public SyncedEntry<T> Effect { get; set; }

		public OneTimePrimitiveUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription, defaultPrice)
		{
		}
	}
	public class OneTimeUpgradeConfiguration : UpgradeConfiguration, IOneTimeUpgradeConfiguration, IUpgradeConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> Price { get; set; }

		public OneTimeUpgradeConfiguration(ConfigFile cfg, string topSection, string enabledDescription, int defaultPrice)
			: base(cfg, topSection, enabledDescription)
		{
			Price = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, $"Price of {topSection} Upgrade", defaultPrice, (ConfigDescription)null);
		}
	}
}
namespace MoreShipUpgrades.Configuration.Contracts
{
	public class ContractsConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Enabled { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> RandomPrice { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SpecifyPrice { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> RandomOnly { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> FreeMoonsOnly { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> FurthestSpawnPossible { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> RewardQuotaMultiplier { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BlacklistedMoons { get; set; }

		public DataContractConfiguration DataConfiguration { get; set; }

		public DefusalContractConfiguration DefusalConfiguration { get; set; }

		public ExorcismContractConfiguration ExorcismConfiguration { get; set; }

		public ExterminationContractConfiguration ExterminationConfiguration { get; set; }

		public ExtractionContractConfiguration ExtractionConfiguration { get; set; }

		public ContractsConfiguration(ConfigFile cfg, string topSection)
		{
			Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Enable the ability to purchase contracts / missions", true, (ConfigDescription)null);
			RandomOnly = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Random Contract on Keyword", false, "When enabled, typing contract will automatically assign you a random contract when possible. (Essentialy old behaviour)");
			FreeMoonsOnly = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Random contracts on free moons only", true, "If true, \"contract\" command will only generate contracts on free moons.");
			RandomPrice = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Price of a random contract", 500, (ConfigDescription)null);
			SpecifyPrice = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Price of a specified moon contract", 750, (ConfigDescription)null);
			FurthestSpawnPossible = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, topSection, "Spawn main object far away", true, "If true the main object for contracts will try spawn as far away from the main entrance as possible. If false it will spawn at a random location.");
			RewardQuotaMultiplier = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, topSection, "Multiplier applied to the contract loot items dependant on the current applied quota", 25, "0 = None of the quota value will influence the loot's value.\n100 = The quota value will be added fully to the loot's value.");
			BlacklistedMoons = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, topSection, "Blacklisted Moons", "", "Collection of moons' names separated by a comma (,) where you do not wish to obtain a contract on.\n This should be used when using custom moons where you do not wish to obtain a contract on.\n");
			ExtractionConfiguration = new ExtractionContractConfiguration(cfg, topSection);
			DataConfiguration = new DataContractConfiguration(cfg, topSection);
			DefusalConfiguration = new DefusalContractConfiguration(cfg, topSection);
			ExorcismConfiguration = new ExorcismContractConfiguration(cfg, topSection);
			ExterminationConfiguration = new ExterminationContractConfiguration(cfg, topSection);
		}
	}
	public class DefusalContractConfiguration : ContractEntryConfiguration
	{
		public DefusalContractConfiguration(ConfigFile config, string topSection)
		{
			base.Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(config, topSection, "Enable the data contract", true, "Make this false if you don't want the data contract");
			base.RewardValue = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Value of a data contract reward", 500, (ConfigDescription)null);
		}
	}
	public class DataContractConfiguration : ContractEntryConfiguration
	{
		public DataContractConfiguration(ConfigFile config, string topSection)
		{
			base.Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(config, topSection, "Enable the defusal contract", true, "Make this false if you don't want the defusal contract");
			base.RewardValue = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Value of an defusal contract reward", 500, (ConfigDescription)null);
		}
	}
	public class ExorcismContractConfiguration : ContractEntryConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> AmountSpawnsOnFail { get; set; }

		public ExorcismContractConfiguration(ConfigFile config, string topSection)
		{
			base.Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(config, topSection, "Enable the exorcism contract", true, "Make this false if you don't want the exorcism contract");
			base.RewardValue = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Value of an exorcism contract reward", 500, (ConfigDescription)null);
			AmountSpawnsOnFail = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Dress Girl / Thumper Spawn Number", 3, "How many ghosts/thumpers to spawn when failing exorcism contracts");
		}
	}
	public class ExterminationContractConfiguration : ContractEntryConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> AmountSpawns { get; set; }

		public ExterminationContractConfiguration(ConfigFile config, string topSection)
		{
			base.Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(config, topSection, "Enable the exterminator contract", true, "Make this false if you don't want the exterminator contract");
			base.RewardValue = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Value of an exterminator contract reward", 500, (ConfigDescription)null);
			AmountSpawns = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Hoarder Bug Spawn Number", 20, "How many bugs to spawn during exterminator contracts.");
		}
	}
	public class ExtractionContractConfiguration : ContractEntryConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<int> AmountMedkits { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> ScavengerVolume { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> ScavengerWeight { get; set; }

		public ExtractionContractConfiguration(ConfigFile config, string topSection)
		{
			base.Enabled = SyncedBindingExtensions.BindSyncedEntry<bool>(config, topSection, "Enable the extraction contract", true, "Make this false if you don't want the extraction contract");
			base.RewardValue = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Value of an extraction contract reward", 500, (ConfigDescription)null);
			AmountMedkits = SyncedBindingExtensions.BindSyncedEntry<int>(config, topSection, "Amount of medkits that can spawn in the Extraction contract", 3, (ConfigDescription)null);
			ScavengerVolume = SyncedBindingExtensions.BindSyncedEntry<float>(config, topSection, "Volume of the scavenger voice clips", 0.25f, "0.0 - 1.0");
			ScavengerWeight = SyncedBindingExtensions.BindSyncedEntry<float>(config, topSection, "Weight of an extraction human", 2.5f, "Subtract 1 and multiply by 100 (2.5 = 150lbs).");
		}
	}
}
namespace MoreShipUpgrades.Configuration.Contracts.Abstractions
{
	public abstract class ContractEntryConfiguration
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> Enabled { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> RewardValue { get; set; }
	}
}
namespace MoreShipUpgrades.Compat
{
	public static class BrutalCompanyMinusExtraCompat
	{
		private class GrabbableHazardState
		{
			public int minValue;

			public int maxValue;
		}

		[HarmonyPatch(typeof(Spawn))]
		internal static class ManagerSpawnPatcher
		{
			[HarmonyPatch("DoSpawnScrapInside")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> DoSpawnScrapInsideTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				return MultiplyScrapValueOnSpawn(instructions, "inside");
			}

			[HarmonyPatch("DoSpawnScrapOutside")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> DoSpawnScrapOutsideTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				return MultiplyScrapValueOnSpawn(instructions, "outside");
			}
		}

		[HarmonyPatch(typeof(GrabbableTurret), "onTurretStart")]
		internal static class GrabbableTurretPatcher
		{
			private static bool isProcessing;

			[HarmonyPrefix]
			private static void OnTurretStartPrefix(out GrabbableHazardState __state)
			{
				GrabbableHazardPrefix(out __state, ref isProcessing, Assets.grabbableTurret);
			}

			[HarmonyPostfix]
			private static void OnTurretStartPostfix(GrabbableHazardState __state)
			{
				GrabbableHazardPostfix(__state, delegate
				{
					isProcessing = false;
				}, Assets.grabbableTurret);
			}
		}

		[HarmonyPatch(typeof(GrabbableLandmine), "onLandmineStart")]
		internal static class GrabbableLandminePatcher
		{
			private static bool isProcessing;

			[HarmonyPrefix]
			private static void OnLandmineStartPrefix(out GrabbableHazardState __state)
			{
				GrabbableHazardPrefix(out __state, ref isProcessing, Assets.grabbableLandmine);
			}

			[HarmonyPostfix]
			private static void OnLandmineStartPostfix(GrabbableHazardState __state)
			{
				GrabbableHazardPostfix(__state, delegate
				{
					isProcessing = false;
				}, Assets.grabbableLandmine);
			}
		}

		[HarmonyPatch(typeof(LevelModifications))]
		internal static class LevelModificationsPatcher
		{
			[HarmonyPatch("OnwaitForScrapToSpawnToSync")]
			[HarmonyTranspiler]
			private static IEnumerable<CodeInstruction> OnwaitForScrapToSpawnToSyncTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				return MultiplyScrapValueOnSpawn(instructions, "transmuted");
			}
		}

		public const string BCMERebornGUID = "SoftDiamond.BrutalCompanyMinusExtraReborn";

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("SoftDiamond.BrutalCompanyMinusExtraReborn") || Chainloader.PluginInfos.ContainsKey("SoftDiamond.BrutalCompanyMinusExtraReborn");

		public static string BeforePatchMessage => "Brutal Company Minus Extra has been detected. Proceeding to patch...";

		public static string SuccessfulPatchMessage => "Patched Brutal Company Minus Extra mod related components for correct behaviour on Midas Touch upgrade for scrap that is spawned by Brutal's events/ScrapAmount multiplier stat. If any issues arise related to the scrap value calculation when both LGU and BCME mods are present, report to LGU first.";

		private static IEnumerable<CodeInstruction> MultiplyScrapValueOnSpawn(IEnumerable<CodeInstruction> instructions, string scrapErrorMessagePrefix)
		{
			MethodInfo method = typeof(MidasTouch).GetMethod("IncreaseScrapValue");
			FieldInfo field = typeof(RoundManager).GetField("scrapValueMultiplier");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Scrap value multiplier for brutal company minus extra's " + scrapErrorMessagePrefix + " scrap generation was not found.");
			return codes;
		}

		private static void GrabbableHazardPrefix(out GrabbableHazardState __state, ref bool isProcessing, Item grabbableHazard)
		{
			__state = new GrabbableHazardState
			{
				minValue = 0,
				maxValue = 0
			};
			if (!isProcessing)
			{
				isProcessing = true;
				__state.minValue = grabbableHazard.minValue;
				__state.maxValue = grabbableHazard.maxValue;
				grabbableHazard.minValue = MidasTouch.IncreaseScrapValueInteger(grabbableHazard.minValue);
				grabbableHazard.maxValue = MidasTouch.IncreaseScrapValueInteger(grabbableHazard.maxValue);
			}
		}

		private static void GrabbableHazardPostfix(GrabbableHazardState __state, Action isProcessing, Item grabbableHazard)
		{
			if (__state.minValue != __state.maxValue || __state.minValue != 0)
			{
				Task.Run(async delegate
				{
					await Task.Delay(10000);
					grabbableHazard.minValue = __state.minValue;
					grabbableHazard.maxValue = __state.maxValue;
					isProcessing();
				});
			}
		}
	}
	internal static class CustomItemBehaviourLibraryCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.github.WhiteSpike.CustomItemBehaviourLibrary");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool CheckForContainers(ref PlayerControllerB player)
		{
			if (player.currentlyHeldObjectServer is ContainerBehaviour)
			{
				return true;
			}
			if (player.currentlyHeldObject is ContainerBehaviour)
			{
				return true;
			}
			return false;
		}
	}
	internal static class DawnLibCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.github.teamxiaolan.dawnlib");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void RegisterNetworkPrefab(GameObject prefab)
		{
			DawnLib.RegisterNetworkPrefab(prefab);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void SetupItem(Item item)
		{
			NamespacedKey<DawnItemInfo> val = NamespacedKey<DawnItemInfo>.From("lategame_upgrades", item.itemName);
			DawnLib.DefineItem(val, item, (Action<ItemInfoBuilder>)delegate
			{
			});
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void FixMixerGroups(GameObject prefab)
		{
			DawnLib.FixMixerGroups(prefab);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void RemoveShopItem(Item storeItem)
		{
			NamespacedKey<DawnItemInfo> val = NamespacedKey<DawnItemInfo>.From("lategame_upgrades", storeItem.itemName);
			DawnItemInfo val2 = default(DawnItemInfo);
			if (((Registry<DawnItemInfo>)(object)LethalContent.Items).TryGetValue(val, ref val2))
			{
				return;
			}
			DawnLib.DefineItem(val, storeItem, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
			{
				builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
				{
					shopBuilder.SetPurchasePredicate(ITerminalPurchasePredicate.AlwaysHide());
				});
			});
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void UpdateShopItemPrice(Item storeItem, int configuredPrice)
		{
			TerminalNode infoNode = ItemManager.SetupInfoNode(storeItem);
			NamespacedKey<DawnItemInfo> val = NamespacedKey<DawnItemInfo>.From("lategame_upgrades", storeItem.itemName);
			DawnItemInfo val2 = default(DawnItemInfo);
			if (((Registry<DawnItemInfo>)(object)LethalContent.Items).TryGetValue(val, ref val2))
			{
				return;
			}
			DawnLib.DefineItem(val, storeItem, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
			{
				builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
				{
					shopBuilder.OverrideCost(configuredPrice).OverrideInfoNode(infoNode);
				});
			});
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void SetupMapObject(Item item, AnimationCurve curve)
		{
			NamespacedKey<DawnMapObjectInfo> val = NamespacedKey<DawnMapObjectInfo>.From("lategame_upgrades", item.itemName);
			DawnMapObjectInfo val2 = default(DawnMapObjectInfo);
			if (((Registry<DawnMapObjectInfo>)(object)LethalContent.MapObjects).TryGetValue(val, ref val2))
			{
				return;
			}
			DawnLib.DefineMapObject(val, item.spawnPrefab, (Action<MapObjectInfoBuilder>)delegate(MapObjectInfoBuilder builder)
			{
				builder.DefineInside((Action<InsideBuilder>)delegate(InsideBuilder insideBuilder)
				{
					insideBuilder.SetWeights((Action<CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(CurveTableBuilder<DawnMoonInfo, SpawnWeightContext> curveBuilder)
					{
						curveBuilder.SetGlobalCurve(curve);
					});
				});
			});
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void SetupStoreItem(Item storeItem, TerminalNode infoNode)
		{
			NamespacedKey<DawnItemInfo> val = NamespacedKey<DawnItemInfo>.From("lategame_upgrades", storeItem.itemName);
			DawnLib.DefineItem(val, storeItem, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
			{
				builder.DefineShop((Action<ShopBuilder>)delegate(ShopBuilder shopBuilder)
				{
					shopBuilder.OverrideCost(storeItem.creditsWorth).OverrideInfoNode(infoNode);
				});
			});
		}
	}
	internal static class GoodItemScanCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("TestAccount666.GoodItemScan");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void IncreaseScanDistance(int distance)
		{
			CheatsAPI.additionalDistance += distance;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void IncreaseEnemyScanDistance(int distance)
		{
			CheatsAPI.additionalEnemyDistance += distance;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void ToggleScanThroughWalls(bool scanThroughWalls)
		{
			CheatsAPI.noLineOfSightDistance += (scanThroughWalls ? ((int)SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.BetterScannerUpgradeConfiguration.NodeRangeIncrease)) : (-(int)SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.BetterScannerUpgradeConfiguration.NodeRangeIncrease)));
		}
	}
	public static class InputUtilsCompat
	{
		internal static InputActionAsset Asset => IngameKeybinds.GetAsset();

		public static InputAction NvgKey => IngameKeybinds.Instance.NvgKey;

		public static InputAction ShowAlternativeCounterKey => IngameKeybinds.Instance.ShowAlternativeCounterKey;

		internal static void Init()
		{
			IngameKeybinds.Instance = new IngameKeybinds();
		}
	}
	internal static class LethalCompanyVRCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("io.daxcess.lcvr");
	}
	[HarmonyPatch(typeof(VRController))]
	internal static class VRControllerPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("LateUpdate")]
		private static IEnumerable<CodeInstruction> LateUpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(PlayerControllerB).GetField("grabDistance");
			MethodInfo method = typeof(MechanicalArms).GetMethod("GetIncreasedGrabDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the grab distance field");
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the grab distance field");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("BeginGrabObject")]
		private static IEnumerable<CodeInstruction> BeginGrabObjectTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(PlayerControllerB).GetField("grabDistance");
			MethodInfo method = typeof(MechanicalArms).GetMethod("GetIncreasedGrabDistance");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the grab distance field");
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("GrabItem")]
		private static IEnumerable<CodeInstruction> GrabItemTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			PlayerControllerBPatcher.AddBackMusclesCodeInstruction(ref index, ref codes);
			return codes;
		}
	}
	internal static class LethalConstellationsCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.github.darmuh.LethalConstellations");
	}
	[HarmonyPatch(typeof(LevelStuff))]
	internal static class LevelStuffPatcher
	{
		[HarmonyPatch("GetConstPrice")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GetConstPriceTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(ClassMapper).GetField("constelPrice");
			MethodInfo method = typeof(EfficientEngines).GetMethod("GetDiscountedMoonPrice");
			int index = 0;
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			Tools.FindField(ref index, ref codes, field, method, skip: false, notInstruction: false, andInstruction: false, orInstruction: false, requireInstance: false, instanceBefore: false, "Couldn't find the price of the constellations");
			return codes;
		}
	}
	internal static class LethalLevelLoaderCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("imabatby.lethallevelloader");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void GrabAllAvailableLevels(ref SelectableLevel[] levels)
		{
			ExtendedLevel val = default(ExtendedLevel);
			levels = levels.Where((SelectableLevel x) => PatchedContent.TryGetExtendedContent(x, ref val) && !val.IsRouteLocked).ToArray();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool IsLocked(ref SelectableLevel level)
		{
			ExtendedLevel val = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level, ref val);
			if ((Object)(object)val == (Object)null || val.IsRouteLocked)
			{
				return true;
			}
			return false;
		}
	}
	internal static class MissileTurretsCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("Finnerex.MissileTurret");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool IsMissileTurret(ref TerminalAccessibleObject possibleHazard)
		{
			return (Object)(object)((Component)possibleHazard).GetComponent<MissileTurretAI>() != (Object)null;
		}
	}
	[Serializable]
	public class SaveInfoV1
	{
		public bool DestroyTraps;

		public bool scannerUpgrade;

		public bool nightVision;

		public bool exoskeleton;

		public bool TPButtonPressed;

		public bool beekeeper;

		public bool terminalFlash;

		public bool strongLegs;

		public bool proteinPowder;

		public bool runningShoes;

		public bool biggerLungs;

		public bool lockSmith;

		public bool walkies;

		public bool lightningRod;

		public bool pager;

		public bool hunter;

		public bool playerHealth;

		public bool wearingHelmet;

		public bool sickBeats;

		public bool doorsHydraulicsBattery;

		public int beeLevel;

		public int huntLevel;

		public int proteinLevel;

		public int lungLevel;

		public int backLevel;

		public int runningLevel;

		public int scanLevel;

		public int discoLevel;

		public int legLevel;

		public int nightVisionLevel;

		public int playerHealthLevel;

		public int doorsHydraulicsBatteryLevel;

		public string contractType;

		public string contractLevel;

		public Dictionary<string, float> SaleData;
	}
	[Serializable]
	public class LguSaveV1
	{
		public Dictionary<ulong, SaveInfoV1> playerSaves = new Dictionary<ulong, SaveInfoV1>();
	}
	internal static class OxygenCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("consequential.Oxygen");
	}
	[HarmonyPatch(typeof(OxygenLogic))]
	internal static class OxygenLogicPatcher
	{
		[HarmonyPatch("RunLogic")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RunLogicTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(OxygenCanisters).GetMethod("ReduceOxygenConsumption");
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = codes.Count - 1;
			Tools.FindLocalFieldReverse(ref index, ref codes, 2, method, skip: false, store: false, requireInstance: false, "Couldn't find the property used to deplete oxygen while underwater");
			return codes;
		}
	}
	internal static class ToilheadCompat
	{
		[HarmonyPatch(typeof(FollowTerminalAccessibleObjectBehaviour))]
		internal static class FollowTerminalAccessibleObjectBehaviourPatcher
		{
			[HarmonyPrefix]
			[HarmonyPatch("CallFunctionFromTerminal")]
			internal static bool DestroyObject(ref FollowTerminalAccessibleObjectBehaviour __instance)
			{
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				if (!BaseUpgrade.GetActiveUpgrade("Malware Broadcaster"))
				{
					return true;
				}
				if (((Component)__instance).gameObject.layer != LayerMask.NameToLayer("MapHazards") && ((Object)(object)((Component)__instance).transform.parent == (Object)null || ((Component)((Component)__instance).transform.parent).gameObject.layer != LayerMask.NameToLayer("MapHazards")))
				{
					return true;
				}
				if (UpgradeBus.Instance.PluginConfiguration.MalwareBroadcasterUpgradeConfiguration.DestroyTraps.Value)
				{
					MalwareBroadcaster.instance.ReqDestroyObjectServerRpc(new NetworkObjectReference(((Component)__instance).gameObject.GetComponentInParent<NetworkObject>()));
					return false;
				}
				if (!__instance.inCooldown)
				{
					__instance.codeAccessCooldownTimer = UpgradeBus.Instance.PluginConfiguration.MalwareBroadcasterUpgradeConfiguration.DisarmTime.Value;
				}
				return true;
			}
		}

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.github.zehsteam.ToilHead");
	}
}
namespace MoreShipUpgrades.API
{
	public static class DiscombobulatorApi
	{
		private const int ERROR = -1;

		private const int SUCCESS_FIRED = 0;

		public static bool IsDiscombobulatorEnabled()
		{
			return SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.DiscombobulatorUpgradeConfiguration.Enabled);
		}

		public static bool CanFireDiscombobulator()
		{
			if (!IsDiscombobulatorEnabled())
			{
				return false;
			}
			return Discombobulator.instance.flashCooldown <= 0f;
		}

		public static float GetDiscombobulatorCooldown()
		{
			if (!IsDiscombobulatorEnabled())
			{
				return -1f;
			}
			return Discombobulator.instance.flashCooldown;
		}

		public static void SetDiscombobulatorCooldown(float value)
		{
			if (IsDiscombobulatorEnabled())
			{
				Discombobulator.instance.SetCooldownServerRpc(value);
			}
		}

		public static void AddDiscombobulatorCooldown(float value)
		{
			if (IsDiscombobulatorEnabled())
			{
				Discombobulator.instance.SetCooldownServerRpc(Discombobulator.instance.flashCooldown + value);
			}
		}

		public static void RemoveDiscombobulatorCooldown(float value)
		{
			if (IsDiscombobulatorEnabled())
			{
				Discombobulator.instance.SetCooldownServerRpc(Discombobulator.instance.flashCooldown - value);
			}
		}

		public static int FireDiscombobulator()
		{
			if (!CanFireDiscombobulator())
			{
				return -1;
			}
			if (((NetworkBehaviour)Discombobulator.instance).IsServer)
			{
				Discombobulator.instance.UseDiscombobulatorClientRpc();
			}
			else
			{
				Discombobulator.instance.UseDiscombobulatorServerRpc();
			}
			return 0;
		}
	}
	internal static class HunterSamples
	{
		internal static readonly Dictionary<string, int> moddedLevels = new Dictionary<string, int>();

		private const float DEFAULT_ITEM_WEIGHT = 1f;

		public static void RegisterSample(Item sampleItem, EnemyAI monster, int hunterLevel, bool registerNetworkPrefab = false, bool grabbableToEnemies = true, double weight = 50.0)
		{
			if (CheckConditionsForRegister(monster))
			{
				RegisterSample(sampleItem, monster.enemyType, hunterLevel, registerNetworkPrefab, grabbableToEnemies, weight);
			}
		}

		public static void RegisterSample(Item sampleItem, EnemyType monsterType, int hunterLevel, bool registerNetworkPrefab = false, bool grabbableToEnemies = true, double weight = 50.0)
		{
			if (CheckConditionsForRegister(monsterType))
			{
				RegisterSample(sampleItem, monsterType.enemyName, hunterLevel, registerNetworkPrefab, grabbableToEnemies, weight);
			}
		}

		public static void RegisterSample(Item sampleItem, string monsterName, int hunterLevel, bool registerNetworkPrefab = false, bool grabbableToEnemies = true, double weight = 50.0)
		{
			if (CheckConditionsForRegister(ref sampleItem, ref monsterName, ref hunterLevel, ref weight))
			{
				RegisterSampleItem(sampleItem, monsterName, registerNetworkPrefab, grabbableToEnemies, weight);
				if (!moddedLevels.ContainsKey(monsterName))
				{
					moddedLevels.Add(monsterName, hunterLevel - 1);
				}
			}
		}

		public static void RegisterSample<T>(Item sampleItem, EnemyAI monster, int hunterLevel, bool registerNetworkPrefab = false, double weight = 50.0) where T : GrabbableObject
		{
			if (CheckConditionsForRegister(monster))
			{
				RegisterSample<T>(sampleItem, monster.enemyType, hunterLevel, registerNetworkPrefab, weight);
			}
		}

		public static void RegisterSample<T>(Item sampleItem, EnemyType monsterType, int hunterLevel, bool registerNetworkPrefab = false, double weight = 50.0) where T : GrabbableObject
		{
			if (CheckConditionsForRegister(monsterType))
			{
				RegisterSample<T>(sampleItem, monsterType.enemyName, hunterLevel, registerNetworkPrefab, weight);
			}
		}

		public static void RegisterSample<T>(Item sampleItem, string monsterName, int hunterLevel, bool registerNetworkPrefab = false, double weight = 50.0) where T : GrabbableObject
		{
			if (CheckConditionsForRegister(ref sampleItem, ref monsterName, ref hunterLevel, ref weight))
			{
				RegisterSampleItem<T>(sampleItem, monsterName, registerNetworkPrefab, weight);
				if (!moddedLevels.ContainsKey(monsterName))
				{
					moddedLevels.Add(monsterName, hunterLevel - 1);
				}
			}
		}

		public static bool IsHunterEnabled()
		{
			return UpgradeBus.Instance.PluginConfiguration.HunterConfiguration.Enabled.Value;
		}

		internal static void RegisterSampleItem<T>(Item sampleItem, string monsterName, bool registerNetworkPrefab = false, double weight = 50.0) where T : GrabbableObject
		{
			GrabbableObject val = (GrabbableObject)(object)sampleItem.spawnPrefab.AddComponent<T>();
			val.grabbable = true;
			val.itemProperties = sampleItem;
			sampleItem.spawnPrefab.AddComponent<SampleComponent>();
			sampleItem.spawnPrefab.AddComponent<ScrapValueSyncer>();
			ItemManager.SetupSampleItem(sampleItem, registerNetworkPrefab, monsterName, weight);
			Plugin.mls.LogInfo((object)("Registed sample for the enemy \"" + monsterName + "\"..."));
		}

		internal static void RegisterSampleItem(Item sampleItem, string monsterName, bool registerNetworkPrefab = false, bool grabbableToEnemies = true, double weight = 50.0)
		{
			GrabbableObject val = sampleItem.spawnPrefab.GetComponent<GrabbableObject>();
			if ((Object)(object)val == (Object)null)
			{
				val = (GrabbableObject)(object)sampleItem.spawnPrefab.AddComponent<MonsterSample>();
			}
			else
			{
				sampleItem.spawnPrefab.AddComponent<SampleComponent>();
			}
			val.grabbable = true;
			val.grabbableToEnemies = grabbableToEnemies;
			val.itemProperties = sampleItem;
			sampleItem.spawnPrefab.AddComponent<ScrapValueSyncer>();
			ItemManager.SetupSampleItem(sampleItem, registerNetworkPrefab, monsterName, weight);
			Plugin.mls.LogInfo((object)("Registed sample for the enemy \"" + monsterName + "\"..."));
		}

		private static bool CheckConditionsForRegister(EnemyAI monster)
		{
			if ((Object)(object)monster == (Object)null)
			{
				Plugin.mls.LogError((object)"Script of the enemy was not provided to pull the name of its type.");
				return false;
			}
			return true;
		}

		private static bool CheckConditionsForRegister(EnemyType monsterType)
		{
			if ((Object)(object)monsterType == (Object)null)
			{
				Plugin.mls.LogError((object)"An enemy type must be provided to know what monster will spawn the sample when killed.");
				return false;
			}
			return true;
		}

		private static bool CheckConditionsForRegister(ref Item sampleItem, ref string monsterName, ref int hunterLevel, ref double weight)
		{
			if (monsterName == "" || monsterName == null)
			{
				Plugin.mls.LogError((object)"A name must be provided in order to spawn the sample. The name must be the one set on the EnemyAI.enemyType.name.");
				return false;
			}
			if ((Object)(object)sampleItem == (Object)null)
			{
				Plugin.mls.LogError((object)("Item properties scriptable object was not provided when registering a custom sample for enemy registered as " + monsterName + "."));
				return false;
			}
			if ((Object)(object)sampleItem.spawnPrefab == (Object)null)
			{
				Plugin.mls.LogError((object)("Item properties scriptable object does not contain a spawn prefab when registering a custom sample for enemy registered as " + monsterName + "."));
				return false;
			}
			if ((Object)(object)sampleItem.itemIcon == (Object)null)
			{
				Plugin.mls.LogWarning((object)"Provided item properties scriptable object does not have an icon sprite for when it's shown in the inventory.");
				Plugin.mls.LogWarning((object)("It will be shown as blank white square when picked up the sample for the enemy \"" + monsterName + "\"..."));
			}
			if ((Object)(object)sampleItem.grabSFX == (Object)null || (Object)(object)sampleItem.dropSFX == (Object)null || (Object)(object)sampleItem.pocketSFX == (Object)null || (Object)(object)sampleItem.throwSFX == (Object)null)
			{
				Plugin.mls.LogWarning((object)"One or more sounds have been found missing in the provided item properties.");
				Plugin.mls.LogWarning((object)("Errors/Warnings related to sounds might be caused by this sample item for the enemy \"" + monsterName + "\"."));
			}
			if (sampleItem.weight < 1f)
			{
				Plugin.mls.LogWarning((object)"Provided item properties scriptable object has a weight value inferior to default, leading to losing weight when grabbed by the player.");
				Plugin.mls.LogWarning((object)("Defaulting to default value of 1.0 on the sample item for the enemy \"" + monsterName + "\"..."));
				sampleItem.weight = 1f;
			}
			if (sampleItem.minValue > sampleItem.maxValue)
			{
				Plugin.mls.LogWarning((object)("The minimum scrap value of the registering sample for enemy registered as " + monsterName + " can not surpass the maximum scrap value."));
				Plugin.mls.LogWarning((object)"Defaulting to equal values...");
				sampleItem.minValue = sampleItem.maxValue;
			}
			if (!sampleItem.isScrap)
			{
				Plugin.mls.LogWarning((object)"Provided item properties scriptable object is not considered as a scrap item.");
				Plugin.mls.LogWarning((object)("Defaulting the check to being considered scrap on the sample item for the enemy \"" + monsterName + "\"..."));
				sampleItem.isScrap = true;
			}
			if (!sampleItem.itemSpawnsOnGround)
			{
				Plugin.mls.LogWarning((object)"Provided item properties scriptable object is considered to not spawn on the ground.");
				Plugin.mls.LogWarning((object)("Defaulting the check to spawn on the ground on the sample item for the enemy \"" + monsterName + "\"..."));
				sampleItem.itemSpawnsOnGround = true;
			}
			if (hunterLevel <= 0)
			{
				Plugin.mls.LogWarning((object)"Provided hunter level is not valid for sample registration.");
				Plugin.mls.LogWarning((object)("Defaulting the hunter level to 1 for the sample item for the enemy \"" + monsterName + "\"..."));
				hunterLevel = 1;
			}
			if (hunterLevel > UpgradeBus.Instance.PluginConfiguration.HunterConfiguration.Prices.Value.Split(",").Length)
			{
				Plugin.mls.LogWarning((object)"Provided hunter level is too high for sample registration.");
				Plugin.mls.LogWarning((object)("Defaulting the hunter level to the maximum allowed level for the sample item for the enemy \"" + monsterName + "\"..."));
				Plugin.mls.LogWarning((object)"This is a configuration error, not a developer error as they cannot predict what is the maximum level Hunter upgrade can be without messing with internals (for now anyways).");
				hunterLevel = UpgradeBus.Instance.PluginConfiguration.HunterConfiguration.Prices.Value.Split(",").Length;
			}
			if (weight <= 0.0)
			{
				Plugin.mls.LogWarning((object)"Provided spawn weight is not valid for sample registration.");
				Plugin.mls.LogWarning((object)("Defaulting the spawn weight value to 50 for the sample item for the enemy \"" + monsterName + "\"..."));
				weight = 50.0;
			}
			return true;
		}
	}
	public static class QuantumDisruptorApi
	{
		public static bool IsQuantumDisruptorEnabled()
		{
			return SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.QuantumDisruptorConfiguration.Enabled);
		}

		public static bool IsQuantumDisruptorCommandEnabled()
		{
			return IsQuantumDisruptorEnabled() && QuantumDisruptor.CurrentMode == QuantumDisruptor.UpgradeModes.RevertTime;
		}

		public static QuantumDisruptor.ResetModes GetQuantumDisruptorResetMode()
		{
			return QuantumDisruptor.CurrentResetMode;
		}

		public static int GetCurrentRevertUsages()
		{
			if (!IsQuantumDisruptorCommandEnabled())
			{
				return -1;
			}
			return QuantumDisruptor.Instance.currentUsages;
		}

		public static int GetMaximumRevertUsages()
		{
			if (!IsQuantumDisruptorCommandEnabled())
			{
				return -1;
			}
			return QuantumDisruptor.Instance.availableUsages;
		}

		public static int GetHoursToReducePerUsage()
		{
			if (!IsQuantumDisruptorCommandEnabled())
			{
				return -1;
			}
			return QuantumDisruptor.Instance.hoursToReduce;
		}

		public static (bool, string) CanFireQuantumDisruptorRevertTime()
		{
			if (!IsQuantumDisruptorCommandEnabled())
			{
				return (false, "Quantum Disruptor Revert Command is not available.");
			}
			return QuantumDisruptor.Instance.CanRevertTime();
		}

		public static void TriggerQuantumDisruptorRevertTime()
		{
			if (CanFireQuantumDisruptorRevertTime().Item1)
			{
				if (((NetworkBehaviour)QuantumDisruptor.Instance).IsServer)
				{
					QuantumDisruptor.Instance.RevertTimeClientRpc();
				}
				else
				{
					QuantumDisruptor.Instance.RevertTimeServerRpc();
				}
			}
		}
	}
	internal class SampleComponent : MonoBehaviour
	{
		private static int usedMapSeed = -1;

		private static Random random = null;

		public void Start()
		{
			if (usedMapSeed < 0 || random == null || usedMapSeed != StartOfRound.Instance.randomMapSeed)
			{
				usedMapSeed = StartOfRound.Instance.randomMapSeed;
				random = new Random(usedMapSeed + 105);
			}
			Item itemProperties = ((Component)this).GetComponent<GrabbableObject>().itemProperties;
			int num = random.Next(itemProperties.minValue, itemProperties.maxValue);
			if (SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.AffectSamples))
			{
				Plugin.mls.LogDebug((object)$"Midas Touch affecting samples is enabled, increasing the original scrap value ({num})...");
				num = MidasTouch.IncreaseScrapValueInteger(num);
				Plugin.mls.LogDebug((object)$"Set the sample scrap value to {num}...");
			}
			((Component)this).GetComponent<ScrapValueSyncer>().SetScrapValue(num);
		}
	}
	public static class UpgradeApi
	{
		public static void TriggerUpgradeRankup(string upgradeName)
		{
			CustomTerminalNode upgradeNode = UpgradeBus.Instance.GetUpgradeNode(upgradeName);
			TriggerUpgradeRankup(upgradeNode);
		}

		public static void TriggerUpgradeRankup(CustomTerminalNode node)
		{
			if (CheckGeneralNodeConditions(node))
			{
				LguStore.Instance.HandleUpgrade(node, node.Unlocked);
			}
		}

		public static void TriggerUpgradeDowngrade(CustomTerminalNode node)
		{
			if (CheckGeneralNodeConditions(node))
			{
				LguStore.Instance.HandleUpgrade(node, node.Unlocked, downgrade: true);
			}
		}

		public static void ContributeTowardsUpgrade(string upgradeName, int scrapValue)
		{
			CustomTerminalNode upgradeNode = UpgradeBus.Instance.GetUpgradeNode(upgradeName);
			ContributeTowardsUpgrade(upgradeNode, scrapValue);
		}

		public static void ContributeTowardsUpgrade(CustomTerminalNode node, int scrapValue)
		{
			if (CheckGeneralNodeConditions(node))
			{
				ItemProgressionManager.ContributeTowardsUpgrade(node, Mathf.CeilToInt((float)scrapValue * SyncedEntry<float>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.ITEM_PROGRESSION_CONTRIBUTION_MULTIPLIER)));
			}
		}

		public static bool CheckGeneralNodeConditions(CustomTerminalNode node)
		{
			if (node == null)
			{
				Plugin.mls.LogWarning((object)"Provided upgrade node does not exist. Stopping requested execution...");
				return false;
			}
			if (!UpgradeBus.ContainsUpgradeNode(node))
			{
				Plugin.mls.LogWarning((object)"Provided upgrade node was created outside of LGU's generation. Stopping requested execution...");
				return false;
			}
			return true;
		}

		public static List<CustomTerminalNode> GetUpgradeNodes()
		{
			return UpgradeBus.GetUpgradeNodes();
		}

		private static IEnumerable<CustomTerminalNode> GetVisibleUpgradeNodesInternal()
		{
			return from x in GetUpgradeNodes()
				where x.Visible
				select x;
		}

		public static List<CustomTerminalNode> GetVisibleUpgradeNodes()
		{
			return GetVisibleUpgradeNodesInternal().ToList();
		}

		private static IEnumerable<CustomTerminalNode> GetPurchaseableUpgradeNodesInternal()
		{
			return from x in GetVisibleUpgradeNodesInternal()
				where x.UnlockPrice > 0 || x.Prices.Length != 0
				select x;
		}

		public static List<CustomTerminalNode> GetPurchaseableUpgradeNodes()
		{
			return GetPurchaseableUpgradeNodesInternal().ToList();
		}

		private static IEnumerable<CustomTerminalNode> GetRankableUpgradeNodesInternal()
		{
			return from x in GetPurchaseableUpgradeNodesInternal()
				where x.UnlockPrice > 0 || x.Prices.Length != 0
				select x;
		}

		public static List<CustomTerminalNode> GetRankableUpgradeNodes()
		{
			return GetRankableUpgradeNodesInternal().ToList();
		}
	}
	internal class WeightingGroup<T> : Dictionary<T, double> where T : class
	{
		public T GetItem()
		{
			double num = 0.0;
			foreach (double value in base.Values)
			{
				double num2 = Math.Abs(value);
				num += num2;
			}
			if (num <= 0.0)
			{
				return null;
			}
			double num3 = new Random().NextDouble();
			double num4 = 0.0;
			foreach (KeyValuePair<T, double> item in this.OrderByDescending((KeyValuePair<T, double> v) => v.Value))
			{
				num4 += item.Value / num;
				if (num3 <= num4)
				{
					return item.Key;
				}
			}
			return base.Keys.FirstOrDefault();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			return !_moveNextCalled && (_moveNextCalled = true);
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, (T)value)) ? (-1) : 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return (!EqualityComparer<T>.Default.Equals(_item, item)) ? (-1) : 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace MoreShipUpgrades.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}