using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Extensions;
using CSync.Lib;
using GameNetcodeStuff;
using HarmonyLib;
using LategameCompanyCruiserUpgrades.Misc;
using LategameCompanyCruiserUpgrades.NetcodePatcher;
using LategameCompanyCruiserUpgrades.Patches;
using LategameCompanyCruiserUpgrades.Upgrades.TierUpgrades;
using LategameCompanyCruiserUpgrades.Util;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using MoreShipUpgrades.Managers;
using MoreShipUpgrades.Misc.TerminalNodes;
using MoreShipUpgrades.Misc.Upgrades;
using MoreShipUpgrades.Misc.Util;
using UnityEngine;

[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]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 LategameCompanyCruiserUpgrades
{
	[BepInPlugin("com.github.WhiteSpike.LategameCompanyCruiserUpgrades", "Lategame Company Cruiser Upgrades", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static readonly Harmony harmony = new Harmony("com.github.WhiteSpike.LategameCompanyCruiserUpgrades");

		internal static readonly ManualLogSource mls = Logger.CreateLogSource("Lategame Company Cruiser Upgrades");

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

		public static PluginConfig Config;

		private void Awake()
		{
			Config = new PluginConfig(((BaseUnityPlugin)this).Config);
			IEnumerable<Type> types;
			try
			{
				types = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = ex.Types.Where((Type t) => t != null);
			}
			foreach (Type item in types)
			{
				MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo in array)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			SetupPerks(ref types);
			harmony.PatchAll(typeof(PlayerControllerBPatcher));
			mls.LogInfo((object)"Player controllers have been patched");
			harmony.PatchAll(typeof(VehicleControllerPatcher));
			mls.LogInfo((object)"Vehicles have been patched");
			mls.LogInfo((object)"Lategame Company Cruiser Upgrades 1.1.0 has been loaded successfully.");
		}

		private void SetupPerks(ref IEnumerable<Type> types)
		{
			foreach (Type type in types)
			{
				if (type.IsSubclassOf(typeof(BaseUpgrade)))
				{
					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");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LategameCompanyCruiserUpgrades";

		public const string PLUGIN_NAME = "MoreShipUpgrades";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace LategameCompanyCruiserUpgrades.Util
{
	internal static class Constants
	{
		internal static readonly string BRAKE_FLUID_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Brake Fluid");

		internal static readonly string TURBO_TANK_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Turbo Tank");

		internal static readonly string IGNITION_COIL_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Ignition Coil");

		internal static readonly string FLUFFY_SEATS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Fluffy Seats");

		internal static readonly string IMPROVED_STEERING_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Improved Steering");

		internal static readonly string SUPERCHARGED_PISTONS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Supercharged Pistons");

		internal static readonly string RAPID_MOTORS_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Rapid Motors");

		internal static readonly string VEHICLE_PLATING_OVERRIDE_NAME_KEY = string.Format("Alternative name for {0} upgrade", "Vehicle Plating");

		internal const string BRAKE_FLUID_ENABLED_KEY = "Enable Brake Fluid Upgrade";

		internal const bool BRAKE_FLUID_ENABLED_DEFAULT = true;

		internal const string BRAKE_FLUID_ENABLED_DESCRIPTION = "Tier upgrade which increases the braking capability of the Company Cruiser vehicle.";

		internal const string BRAKE_FLUID_PRICE_KEY = "Price of Brake Fluid Upgrade";

		internal const int BRAKE_FLUID_PRICE_DEFAULT = 100;

		internal const string BRAKE_FLUID_CAPACITY_INITIAL_INCREASE_KEY = "Initial Break Power Increase";

		internal const int BRAKE_FLUID_CAPACITY_INITIAL_INCREASE_DEFAULT = 25;

		internal const string BRAKE_FLUID_CAPACITY_INITIAL_INCREASE_DESCRIPTION = "Percentage of break power increased when first purchasing the upgrade on the Company Cruiser Vehicle";

		internal const string BRAKE_FLUID_CAPACITY_INCREMENTAL_INCREASE_KEY = "Incremental Break Power Increase";

		internal const int BRAKE_FLUID_CAPACITY_INCREMENTAL_INCREASE_DEFAULT = 25;

		internal const string BRAKE_FLUID_CAPACITY_INCREMENTAL_INCREASE_DESCRIPTION = "Percentage of break power increased when purchasing further levels of the upgrade on the Company Cruiser Vehicle";

		internal const string TURBO_TANK_ENABLED_KEY = "Enable Turbo Tank Upgrade";

		internal const bool TURBO_TANK_ENABLED_DEFAULT = true;

		internal const string TURBO_TANK_ENABLED_DESCRIPTION = "Tier upgrade which increases the maximum capacity of Company Cruiser Vehicle's turbo";

		internal const string TURBO_TANK_PRICE_KEY = "Price of Turbo Tank Upgrade";

		internal const int TURBO_TANK_PRICE_DEFAULT = 200;

		internal const string TURBO_TANK_CAPACITY_INITIAL_INCREASE_KEY = "Initial Turbo Capacity Increase";

		internal const int TURBO_TANK_CAPACITY_INITIAL_INCREASE_DEFAULT = 2;

		internal const string TURBO_TANK_CAPACITY_INITIAL_INCREASE_DESCRIPTION = "Amount of turbo capacity increased when first purchasing the upgrade on the Company Cruiser Vehicle";

		internal const string TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE_KEY = "Incremental Turbo Capacity Increase";

		internal const int TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE_DEFAULT = 1;

		internal const string TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of turbo capacity increased when purchasing further levels of the upgrade on the Company Cruiser Vehicle";

		internal const string IGNITION_COIL_ENABLED_KEY = "Enable Ignition Coil Upgrade";

		internal const bool IGNITION_COIL_ENABLED_DEFAULT = true;

		internal const string IGNITION_COIL_ENABLED_DESCRIPTION = "Tier upgrade which increases the chance of ignition to turn on the Company Cruiser Vehicle.";

		internal const string IGNITION_COIL_PRICE_KEY = "Price of Ignition Coil Upgrade";

		internal const int IGNITION_COIL_PRICE_DEFAULT = 50;

		internal const string IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE_KEY = "Initial Ignition Chance Increase";

		internal const int IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE_DEFAULT = 25;

		internal const string IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE_DESCRIPTION = "Amount of chance (%) increased when first purchasing the upgrade to ignite on the Company Cruiser Vehicle";

		internal const string IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE_KEY = "Incremental Ignition Chance Increase";

		internal const int IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE_DEFAULT = 25;

		internal const string IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE_DESCRIPTION = "Amount of chance (%) increased when purchasing further levels of the upgrade to ignite on the Company Cruiser Vehicle";

		internal const string FLUFFY_SEATS_ENABLED_KEY = "Enable Fluffy Seats Upgrade";

		internal const bool FLUFFY_SEATS_ENABLED_DEFAULT = true;

		internal const string FLUFFY_SEATS_ENABLED_DESCRIPTION = "Tier upgrade which provides player damage mitigation when bumping too hard with the Company Cruiser Vehicle.";

		internal const string FLUFFY_SEATS_PRICE_KEY = "Price of Fluffy Seats Upgrade";

		internal const int FLUFFY_SEATS_PRICE_DEFAULT = 100;

		internal const string FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE_KEY = "Initial Player Damage Mitigation Increase";

		internal const int FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE_DEFAULT = 25;

		internal const string FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE_DESCRIPTION = "Amount of damage mitigation (%) increased when first purchasing the upgrade when riding the Company Cruiser Vehicle.";

		internal const string FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE_KEY = "Incremental Player Damage Mitigation Increase";

		internal const int FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE_DEFAULT = 25;

		internal const string FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of damage mitigation (%) increased when purchasing further levels of the upgrade when riding the Company Cruiser Vehicle.";

		internal const string IMPROVED_STEERING_ENABLED_KEY = "Enable Improved Steering Upgrade";

		internal const bool IMPROVED_STEERING_ENABLED_DEFAULT = true;

		internal const string IMPROVED_STEERING_ENABLED_DESCRIPTION = "Tier upgrade which increases the turning speed of the Company Cruiser vehicle";

		internal const string IMPROVED_STEERING_PRICE_KEY = "Price of Improved Steering Upgrade";

		internal const int IMPROVED_STEERING_PRICE_DEFAULT = 100;

		internal const string IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE_KEY = "Initial Turning Speed Increase";

		internal const float IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE_DEFAULT = 1f;

		internal const string IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE_DESCRIPTION = "Amount of turning speed increased when first purchasing the upgrade to the Company Cruiser vehicle.";

		internal const string IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE_KEY = "Incremental Turning Speed Increase";

		internal const float IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE_DEFAULT = 0.5f;

		internal const string IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of turning speed increased when purchasing further levels of the upgrade to the Company Cruiser vehicle.";

		internal const string SUPERCHARGED_PISTONS_ENABLED_KEY = "Enable Supercharged Pistons Upgrade";

		internal const bool SUPERCHARGED_PISTONS_ENABLED_DEFAULT = true;

		internal const string SUPERCHARGED_PISTONS_ENABLED_DESCRIPTION = "Tier upgrade which increases the company cruiser's maximum speed when driving";

		internal const string SUPERCHARGED_PISTONS_PRICE_KEY = "Price of Supercharged Pistons Upgrade";

		internal const int SUPERCHARGED_PISTONS_PRICE_DEFAULT = 250;

		internal const string SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE_KEY = "Initial Engine Torque Increase";

		internal const float SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE_DEFAULT = 40f;

		internal const string SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE_DESCRIPTION = "Amount of maximum speed increased when first purchasing the upgrade to the Company Cruiser vehicle.";

		internal const string SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE_KEY = "Incremental Engine Torque Increase";

		internal const float SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE_DEFAULT = 20f;

		internal const string SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of maximum speed increased when purchasing further levels of the upgrade to the Company Cruiser vehicle.";

		internal const string RAPID_MOTORS_ENABLED_KEY = "Enable Rapid Motors Upgrade";

		internal const bool RAPID_MOTORS_ENABLED_DEFAULT = true;

		internal const string RAPID_MOTORS_ENABLED_DESCRIPTION = "Tier upgrade which increases the company cruiser's acceleration when driving.";

		internal const string RAPID_MOTORS_PRICE_KEY = "Price of Rapid Motors Upgrade";

		internal const int RAPID_MOTORS_PRICE_DEFAULT = 150;

		internal const string RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE_KEY = "Initial Acceleration Increase";

		internal const float RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE_DEFAULT = 2f;

		internal const string RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE_DESCRIPTION = "Amount of acceleration increased when first purchasing the upgrade to the company cruiser vehicle.";

		internal const string RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE_KEY = "Incremental Acceleration Increase";

		internal const float RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE_DEFAULT = 0.5f;

		internal const string RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of acceleration increased when purchasing further levels of the upgrade to the company cruiser vehicle.";

		internal const string VEHICLE_PLATING_ENABLED_KEY = "Enable Vehicle Plating Upgrade";

		internal const bool VEHICLE_PLATING_ENABLED_DEFAULT = true;

		internal const string VEHICLE_PLATING_ENABLED_DESCRIPTION = "Tier upgrade which increases the company cruiser's maximum health to sustain damage from outside sources.";

		internal const string VEHICLE_PLATING_PRICE_KEY = "Price of Vehicle Plating Upgrade";

		internal const int VEHICLE_PLATING_PRICE_DEFAULT = 150;

		internal const string VEHICLE_PLATING_HEALTH_INITIAL_INCREASE_KEY = "Initial Health Increase";

		internal const int VEHICLE_PLATING_HEALTH_INITIAL_INCREASE_DEFAULT = 10;

		internal const string VEHICLE_PLATING_HEALTH_INITIAL_INCREASE_DESCRIPTION = "Amount of health increased when first purchasing the upgrade to the company cruiser vehicle.";

		internal const string VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE_KEY = "Incremental Health Increase";

		internal const int VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE_DEFAULT = 5;

		internal const string VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE_DESCRIPTION = "Amount of health increased when purchasing further levels of the upgrade to the company cruiser vehicle.";
	}
}
namespace LategameCompanyCruiserUpgrades.Upgrades.TierUpgrades
{
	internal class BrakeFluid : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Brake Fluid";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.BRAKE_FLUID_PRICES.Value.Split(',');
				return Plugin.Config.BRAKE_FLUID_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Brake Fluid";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.BRAKE_FLUID_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public static float ComputeIncreasedBrakingPowerPercentage()
		{
			int num = SyncedEntry<int>.op_Implicit(Plugin.Config.BRAKE_FLUID_POWER_INITIAL_INCREASE) + BaseUpgrade.GetUpgradeLevel("Brake Fluid") * SyncedEntry<int>.op_Implicit(Plugin.Config.BRAKE_FLUID_POWER_INCREMENTAL_INCREASE);
			return (float)num / 100f;
		}

		public static int GetIncreasedBrakingPower(int defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.BRAKE_FLUID_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Brake Fluid"))
			{
				return defaultValue;
			}
			float num = ComputeIncreasedBrakingPowerPercentage();
			return Mathf.Clamp((int)((float)defaultValue + (float)defaultValue * num), 0, defaultValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - The Company Cruiser vehicle's breaks have an increased power of {2}%.\n", initialPrice, incrementalPrices, (Func<int, float>)infoFunction, false);
			static float infoFunction(int level)
			{
				return Plugin.Config.BRAKE_FLUID_POWER_INITIAL_INCREASE.Value + level * Plugin.Config.BRAKE_FLUID_POWER_INCREMENTAL_INCREASE.Value;
			}
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Brake Fluid", Plugin.Config.BRAKE_FLUID_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Brake Fluid");
			val.AddComponent<BrakeFluid>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Brake Fluid"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Brake Fluid", true, config.BRAKE_FLUID_ENABLED.Value, config.BRAKE_FLUID_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.BRAKE_FLUID_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.BRAKE_FLUID_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Brake Fluid"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "BrakeFluid";
		}
	}
	internal class FluffySeats : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Fluffy Seats";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.FLUFFY_SEATS_PRICES.Value.Split(',');
				return Plugin.Config.FLUFFY_SEATS_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Fluffy Seats";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.FLUFFY_SEATS_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public static float ComputePlayerDamageMitigation()
		{
			int num = SyncedEntry<int>.op_Implicit(Plugin.Config.FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE) + BaseUpgrade.GetUpgradeLevel("Fluffy Seats") * SyncedEntry<int>.op_Implicit(Plugin.Config.FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE);
			return (100f - (float)num) / 100f;
		}

		public static int GetPlayerDamageMitigation(int defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.FLUFFY_SEATS_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Fluffy Seats"))
			{
				return defaultValue;
			}
			float num = ComputePlayerDamageMitigation();
			return Mathf.Clamp((int)((float)defaultValue * num), 0, defaultValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Player damage is reduced by {2}% when bumping too hard with the Company Cruiser Vehicle.\n", initialPrice, incrementalPrices, (Func<int, float>)infoFunction, false);
			static float infoFunction(int level)
			{
				return Plugin.Config.FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE.Value + level * Plugin.Config.FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE.Value;
			}
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Fluffy Seats", Plugin.Config.FLUFFY_SEATS_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Fluffy Seats");
			val.AddComponent<FluffySeats>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Fluffy Seats"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Fluffy Seats", true, config.FLUFFY_SEATS_ENABLED.Value, config.FLUFFY_SEATS_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.FLUFFY_SEATS_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.FLUFFY_SEATS_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Fluffy Seats"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "FluffySeats";
		}
	}
	internal class IgnitionCoil : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Ignition Coil";

		internal const string PRICES_DEFAULT = "50,100,100";

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.IGNITION_COIL_PRICES.Value.Split(',');
				return Plugin.Config.IGNITION_COIL_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Ignition Coil";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.IGNITION_COIL_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public static float ComputeAdditionalIgnitionChance()
		{
			return SyncedEntry<int>.op_Implicit(Plugin.Config.IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE) + BaseUpgrade.GetUpgradeLevel("Ignition Coil") * SyncedEntry<int>.op_Implicit(Plugin.Config.IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE);
		}

		public static float GetAdditionalIgnitionChance(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.IMPROVED_STEERING_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Ignition Coil"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalIgnitionChance();
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE.Value + level * Plugin.Config.IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Chance to start ignition on Company Cruiser Vehicle is increased by {2}%.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Ignition Coil", Plugin.Config.IGNITION_COIL_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Ignition Coil");
			val.AddComponent<IgnitionCoil>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Ignition Coil"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Ignition Coil", true, config.IGNITION_COIL_ENABLED.Value, config.IGNITION_COIL_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.IGNITION_COIL_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.IGNITION_COIL_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Ignition Coil"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "IgnitionCoil";
		}
	}
	internal class ImprovedSteering : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Improved Steering";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.IMPROVED_STEERING_PRICES.Value.Split(',');
				return Plugin.Config.IMPROVED_STEERING_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Improved Steering";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.IMPROVED_STEERING_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public override void Load()
		{
			((BaseUpgrade)this).Load();
			UpdateCurrentVehicleTurningSpeed(ComputeAdditionalAcceleration(), add: true);
		}

		public override void Increment()
		{
			((TierUpgrade)this).Increment();
			UpdateCurrentVehicleTurningSpeed(SyncedEntry<float>.op_Implicit(Plugin.Config.IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE), add: true);
		}

		public override void Unwind()
		{
			UpdateCurrentVehicleTurningSpeed(ComputeAdditionalAcceleration(), add: false);
			((TierUpgrade)this).Unwind();
		}

		private void UpdateCurrentVehicleTurningSpeed(float additionalTurningSpeed, bool add)
		{
			VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
			foreach (VehicleController val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (add)
					{
						val.steeringWheelTurnSpeed += additionalTurningSpeed;
					}
					else
					{
						val.steeringWheelTurnSpeed -= additionalTurningSpeed;
					}
				}
			}
		}

		public static float ComputeAdditionalAcceleration()
		{
			return SyncedEntry<float>.op_Implicit(Plugin.Config.IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE) + (float)BaseUpgrade.GetUpgradeLevel("Improved Steering") * SyncedEntry<float>.op_Implicit(Plugin.Config.IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE);
		}

		public static float GetAdditionalTurningSpeed(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.IMPROVED_STEERING_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Improved Steering"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalAcceleration();
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE.Value + (float)level * Plugin.Config.IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Company Cruiser vehicle's steering speed (turning speed) is increased by {2}.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Improved Steering", Plugin.Config.IMPROVED_STEERING_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Improved Steering");
			val.AddComponent<ImprovedSteering>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Improved Steering"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Improved Steering", true, config.IMPROVED_STEERING_ENABLED.Value, config.IMPROVED_STEERING_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.IMPROVED_STEERING_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.IMPROVED_STEERING_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Improved Steering"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "ImprovedSteering";
		}
	}
	internal class RapidMotors : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Rapid Motors";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.RAPID_MOTORS_PRICES.Value.Split(',');
				return Plugin.Config.RAPID_MOTORS_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Rapid Motors";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.RAPID_MOTORS_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public override void Load()
		{
			((BaseUpgrade)this).Load();
			UpdateCurrentVehicleAcceleration(ComputeAdditionalAcceleration(), add: true);
		}

		public override void Increment()
		{
			((TierUpgrade)this).Increment();
			UpdateCurrentVehicleAcceleration(SyncedEntry<float>.op_Implicit(Plugin.Config.RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE), add: true);
		}

		public override void Unwind()
		{
			UpdateCurrentVehicleAcceleration(ComputeAdditionalAcceleration(), add: false);
			((TierUpgrade)this).Unwind();
		}

		private void UpdateCurrentVehicleAcceleration(float additionalAcceleration, bool add)
		{
			VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
			foreach (VehicleController val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (add)
					{
						val.carAcceleration += additionalAcceleration;
					}
					else
					{
						val.carAcceleration -= additionalAcceleration;
					}
				}
			}
		}

		public static float ComputeAdditionalAcceleration()
		{
			return SyncedEntry<float>.op_Implicit(Plugin.Config.RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE) + (float)BaseUpgrade.GetUpgradeLevel("Rapid Motors") * SyncedEntry<float>.op_Implicit(Plugin.Config.RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE);
		}

		public static float GetAdditionalAcceleration(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.RAPID_MOTORS_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Rapid Motors"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalAcceleration();
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE.Value + (float)level * Plugin.Config.RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Company Cruiser vehicle's maximum acceleration is increased by {2}.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Rapid Motors", Plugin.Config.RAPID_MOTORS_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Rapid Motors");
			val.AddComponent<RapidMotors>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Rapid Motors"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Rapid Motors", true, config.RAPID_MOTORS_ENABLED.Value, config.RAPID_MOTORS_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.RAPID_MOTORS_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.RAPID_MOTORS_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Rapid Motors"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "RapidMotors";
		}
	}
	internal class SuperchargedPistons : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Supercharged Pistons";

		internal const string PRICES_DEFAULT = "200,350";

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.SUPERCHARGED_PISTONS_PRICES.Value.Split(',');
				return Plugin.Config.SUPERCHARGED_PISTONS_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Supercharged Pistons";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.SUPERCHARGED_PISTONS_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public override void Load()
		{
			((BaseUpgrade)this).Load();
			UpdateCurrentVehicleEngineTorque(ComputeAdditionalEngineTorque(), add: true);
		}

		public override void Increment()
		{
			((TierUpgrade)this).Increment();
			UpdateCurrentVehicleEngineTorque(SyncedEntry<float>.op_Implicit(Plugin.Config.SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE), add: true);
		}

		public override void Unwind()
		{
			UpdateCurrentVehicleEngineTorque(ComputeAdditionalEngineTorque(), add: false);
			((TierUpgrade)this).Unwind();
		}

		private void UpdateCurrentVehicleEngineTorque(float additionalEngineTorque, bool add)
		{
			VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
			foreach (VehicleController val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (add)
					{
						val.EngineTorque += additionalEngineTorque;
					}
					else
					{
						val.EngineTorque -= additionalEngineTorque;
					}
				}
			}
		}

		public static float ComputeAdditionalEngineTorque()
		{
			return SyncedEntry<float>.op_Implicit(Plugin.Config.SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE) + (float)BaseUpgrade.GetUpgradeLevel("Supercharged Pistons") * SyncedEntry<float>.op_Implicit(Plugin.Config.SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE);
		}

		public static float GetAdditionalEngineTorque(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.SUPERCHARGED_PISTONS_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Supercharged Pistons"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalEngineTorque();
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE.Value + (float)level * Plugin.Config.SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Company Cruiser vehicle's maximum speed is increased by {2}.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Supercharged Pistons", Plugin.Config.SUPERCHARGED_PISTONS_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Supercharged Pistons");
			val.AddComponent<SuperchargedPistons>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Supercharged Pistons"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Supercharged Pistons", true, config.SUPERCHARGED_PISTONS_ENABLED.Value, config.SUPERCHARGED_PISTONS_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.SUPERCHARGED_PISTONS_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.SUPERCHARGED_PISTONS_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Supercharged Pistons"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "SuperchargedPistons";
		}
	}
	internal class TurboTank : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Turbo Tank";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.TURBO_TANK_PRICES.Value.Split(',');
				return Plugin.Config.TURBO_TANK_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Turbo Tank";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.TURBO_TANK_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public static int ComputeAdditionalTurboCapacity()
		{
			return SyncedEntry<int>.op_Implicit(Plugin.Config.TURBO_TANK_CAPACITY_INITIAL_INCREASE) + BaseUpgrade.GetUpgradeLevel("Turbo Tank") * SyncedEntry<int>.op_Implicit(Plugin.Config.TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE);
		}

		public static int GetAdditionalTurboCapacity(int defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.TURBO_TANK_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Turbo Tank"))
			{
				return defaultValue;
			}
			int num = ComputeAdditionalTurboCapacity();
			return Mathf.Clamp(defaultValue + num, defaultValue, int.MaxValue);
		}

		public static float GetAdditionalTurboCapacity(float defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.TURBO_TANK_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Turbo Tank"))
			{
				return defaultValue;
			}
			float num = ComputeAdditionalTurboCapacity();
			return Mathf.Clamp(defaultValue + num, defaultValue, float.MaxValue);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.TURBO_TANK_CAPACITY_INITIAL_INCREASE.Value + level * Plugin.Config.TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Company Cruiser vehicle's maximum turbo capacity is increased by {2}.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Turbo Tank", Plugin.Config.TURBO_TANK_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Turbo Tank");
			val.AddComponent<TurboTank>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Turbo Tank"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Turbo Tank", true, config.TURBO_TANK_ENABLED.Value, config.TURBO_TANK_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.TURBO_TANK_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.TURBO_TANK_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Turbo Tank"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "TurboTank";
		}
	}
	internal class VehiclePlating : TierUpgrade
	{
		internal const string UPGRADE_NAME = "Vehicle Plating";

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

		public override bool CanInitializeOnStart
		{
			get
			{
				string[] array = Plugin.Config.VEHICLE_PLATING_PRICES.Value.Split(',');
				return Plugin.Config.VEHICLE_PLATING_PRICE.Value <= 0 && array.Length == 1 && (array[0] == "" || array[0] == "0");
			}
		}

		public override void Start()
		{
			((BaseUpgrade)this).upgradeName = "Vehicle Plating";
			((BaseUpgrade)this).overridenUpgradeName = SyncedEntry<string>.op_Implicit(Plugin.Config.VEHICLE_PLATING_OVERRIDE_NAME);
			((BaseUpgrade)this).Start();
		}

		public override void Load()
		{
			((BaseUpgrade)this).Load();
			UpdateCurrentVehicleHealth(ComputeAdditionalMaximumHealth(), add: true);
		}

		public override void Increment()
		{
			((TierUpgrade)this).Increment();
			UpdateCurrentVehicleHealth(SyncedEntry<int>.op_Implicit(Plugin.Config.VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE), add: true);
		}

		public override void Unwind()
		{
			UpdateCurrentVehicleHealth(ComputeAdditionalMaximumHealth(), add: false);
			((TierUpgrade)this).Unwind();
		}

		public static int GetAdditionalMaximumHealth(int defaultValue)
		{
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.VEHICLE_PLATING_ENABLED))
			{
				return defaultValue;
			}
			if (!BaseUpgrade.GetActiveUpgrade("Vehicle Plating"))
			{
				return defaultValue;
			}
			int num = ComputeAdditionalMaximumHealth();
			return Mathf.Clamp(defaultValue + num, defaultValue, int.MaxValue);
		}

		private void UpdateCurrentVehicleHealth(int additionalHealth, bool add)
		{
			VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
			foreach (VehicleController val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (add)
					{
						val.carHP += additionalHealth;
					}
					else
					{
						val.carHP -= additionalHealth;
					}
				}
			}
		}

		public static int ComputeAdditionalMaximumHealth()
		{
			return SyncedEntry<int>.op_Implicit(Plugin.Config.VEHICLE_PLATING_HEALTH_INITIAL_INCREASE) + BaseUpgrade.GetUpgradeLevel("Vehicle Plating") * SyncedEntry<int>.op_Implicit(Plugin.Config.VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE);
		}

		public override string GetDisplayInfo(int initialPrice = -1, int maxLevels = -1, int[] incrementalPrices = null)
		{
			Func<int, float> func = (int level) => Plugin.Config.VEHICLE_PLATING_HEALTH_INITIAL_INCREASE.Value + level * Plugin.Config.VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE.Value;
			return Tools.GenerateInfoForUpgrade("LVL {0} - ${1} - Company Cruiser vehicle's maximum health is increased by {2}.\n", initialPrice, incrementalPrices, func, false);
		}

		public static (string, string[]) RegisterScrapToUpgrade()
		{
			return ("Vehicle Plating", Plugin.Config.VEHICLE_PLATING_ITEM_PROGRESSION_ITEMS.Value.Split(","));
		}

		public static void RegisterUpgrade()
		{
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("Vehicle Plating");
			val.AddComponent<VehiclePlating>();
			NetworkPrefabs.RegisterNetworkPrefab(val);
			Plugin.networkPrefabs["Vehicle Plating"] = val;
		}

		public static CustomTerminalNode RegisterTerminalNode()
		{
			PluginConfig config = Plugin.Config;
			return UpgradeBus.Instance.SetupMultiplePurchasableTerminalNode("Vehicle Plating", true, config.VEHICLE_PLATING_ENABLED.Value, config.VEHICLE_PLATING_PRICE.Value, UpgradeBus.ParseUpgradePrices(config.VEHICLE_PLATING_PRICES.Value), SyncedEntry<bool>.op_Implicit(UpgradeBus.Instance.PluginConfiguration.OVERRIDE_UPGRADE_NAMES) ? SyncedEntry<string>.op_Implicit(config.VEHICLE_PLATING_OVERRIDE_NAME) : "", Plugin.networkPrefabs["Vehicle Plating"]);
		}

		protected override void __initializeVariables()
		{
			((TierUpgrade)this).__initializeVariables();
		}

		protected internal override string __getTypeName()
		{
			return "VehiclePlating";
		}
	}
}
namespace LategameCompanyCruiserUpgrades.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerControllerBPatcher
	{
		[HarmonyPrefix]
		[HarmonyPatch("KillPlayer")]
		private static bool KillPlayerPrefix(PlayerControllerB __instance, Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation, Vector3 positionOffset)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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)
			return PreventInstantKill(ref __instance, bodyVelocity, spawnBody, causeOfDeath, deathAnimation, positionOffset);
		}

		private static bool PreventInstantKill(ref PlayerControllerB __instance, Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation, Vector3 positionOffset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_003d: 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)
			if ((int)causeOfDeath == 16)
			{
				if (!BaseUpgrade.GetActiveUpgrade("Fluffy Seats"))
				{
					return true;
				}
				Plugin.mls.LogInfo((object)"Kill player fired due to car crash with Fluffy Seats upgrade on, mitigating 100 damage instead of instant kill...");
				__instance.DamagePlayer(FluffySeats.GetPlayerDamageMitigation(100), true, true, causeOfDeath, deathAnimation, false, bodyVelocity);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(VehicleController))]
	internal static class VehicleControllerPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch("Start")]
		private static IEnumerable<CodeInstruction> StartTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			IncreaseMaximumHealthTranspile(ref index, ref codes);
			return codes;
		}

		[HarmonyPatch("Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			IncreaseMaximumHealthTranspile(ref index, ref codes);
			IncreaseBreakingPowerTranspile(ref index, ref codes);
			IncreaseBreakingPowerTranspile(ref index, ref codes);
			return codes;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("ReactToDamage")]
		private static IEnumerable<CodeInstruction> ReactToDamageTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			IncreaseMaximumHealthTranspile(ref index, ref codes);
			IncreaseTurboCapacityTranspile(ref index, ref codes, isFloat: true);
			return codes;
		}

		private static void IncreaseMaximumHealthTranspile(ref int index, ref List<CodeInstruction> codes)
		{
			FieldInfo field = typeof(VehicleController).GetField("baseCarHP");
			MethodInfo method = typeof(VehiclePlating).GetMethod("GetAdditionalMaximumHealth");
			Tools.FindField(ref index, ref codes, field, method, false, false, false, false, false, "Couldn't find the baseCarHP field");
		}

		private static void IncreaseBreakingPowerTranspile(ref int index, ref List<CodeInstruction> codes)
		{
			MethodInfo method = typeof(BrakeFluid).GetMethod("GetIncreasedBrakingPower");
			Tools.FindFloat(ref index, ref codes, 2000f, method, false, false, false, false, false, "Couldn't find the 2000f value for the first wheel");
			Tools.FindFloat(ref index, ref codes, 2000f, method, false, false, false, false, false, "Couldn't find the 2000f value for the second wheel");
			Tools.FindFloat(ref index, ref codes, 2000f, method, false, false, false, false, false, "Couldn't find the 2000f value for the third wheel");
			Tools.FindFloat(ref index, ref codes, 2000f, method, false, false, false, false, false, "Couldn't find the 2000f value for the fourth wheel");
			Tools.FindFloat(ref index, ref codes, 2000f, method, false, false, false, false, false, "Couldn't find the 2000f value for the remaining wheels");
		}

		[HarmonyTranspiler]
		[HarmonyPatch("DamagePlayerInVehicle")]
		private static IEnumerable<CodeInstruction> DamagePlayerInVehicleTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo method = typeof(FluffySeats).GetMethod("GetPlayerDamageMitigation");
			List<CodeInstruction> result = new List<CodeInstruction>(instructions);
			int num = 0;
			Tools.FindInteger(ref num, ref result, (sbyte)40, method, false, false, false, false, false, "Couldn't find the damage player with value of 40");
			Tools.FindInteger(ref num, ref result, (sbyte)30, method, false, false, false, false, false, "Couldn't find the damage player with value of 30");
			Tools.FindInteger(ref num, ref result, (sbyte)10, method, false, false, false, false, false, "Couldn't find the damage player with value of 10");
			return result;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> TryIgnitionTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo field = typeof(VehicleController).GetField("chanceToStartIgnition", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method = typeof(IgnitionCoil).GetMethod("GetAdditionalIgnitionChance");
			List<CodeInstruction> result = new List<CodeInstruction>(instructions);
			int num = 0;
			Tools.FindField(ref num, ref result, field, method, false, false, false, false, false, "Couldn't find usage of chanceToStartIgnition field");
			return result;
		}

		[HarmonyTranspiler]
		[HarmonyPatch("AddTurboBoost")]
		private static IEnumerable<CodeInstruction> AddTurboBoostTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> codes = new List<CodeInstruction>(instructions);
			int index = 0;
			IncreaseTurboCapacityTranspile(ref index, ref codes);
			return codes;
		}

		private static void IncreaseTurboCapacityTranspile(ref int index, ref List<CodeInstruction> codes, bool isFloat = false)
		{
			if (!isFloat)
			{
				MethodInfo method = typeof(TurboTank).GetMethod("GetAdditionalTurboCapacity", new Type[1] { typeof(int) });
				Tools.FindInteger(ref index, ref codes, (sbyte)5, method, false, false, false, false, false, "Couldn't find the defined maximum turbo capacity when adding turbo boost");
			}
			else
			{
				MethodInfo method2 = typeof(TurboTank).GetMethod("GetAdditionalTurboCapacity", new Type[1] { typeof(float) });
				Tools.FindFloat(ref index, ref codes, 5f, method2, false, false, false, false, false, "Couldn't find the defined maximum turbo capacity when updating turbo scale");
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void StartPostfix(VehicleController __instance)
		{
			__instance.carAcceleration = RapidMotors.GetAdditionalAcceleration(__instance.carAcceleration);
			__instance.EngineTorque = SuperchargedPistons.GetAdditionalEngineTorque(__instance.EngineTorque);
			__instance.steeringWheelTurnSpeed = ImprovedSteering.GetAdditionalTurningSpeed(__instance.steeringWheelTurnSpeed);
		}
	}
}
namespace LategameCompanyCruiserUpgrades.Misc
{
	[DataContract]
	public class PluginConfig : SyncedConfig2<PluginConfig>
	{
		[field: SyncedEntryField]
		public SyncedEntry<bool> BRAKE_FLUID_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BRAKE_FLUID_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BRAKE_FLUID_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BRAKE_FLUID_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BRAKE_FLUID_POWER_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> BRAKE_FLUID_POWER_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> BRAKE_FLUID_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> TURBO_TANK_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> TURBO_TANK_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> TURBO_TANK_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> TURBO_TANK_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> TURBO_TANK_CAPACITY_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> TURBO_TANK_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> IGNITION_COIL_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IGNITION_COIL_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IGNITION_COIL_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> IGNITION_COIL_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IGNITION_COIL_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> FLUFFY_SEATS_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> FLUFFY_SEATS_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> FLUFFY_SEATS_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> FLUFFY_SEATS_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> FLUFFY_SEATS_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> IMPROVED_STEERING_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> IMPROVED_STEERING_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IMPROVED_STEERING_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IMPROVED_STEERING_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> IMPROVED_STEERING_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> SUPERCHARGED_PISTONS_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> SUPERCHARGED_PISTONS_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> SUPERCHARGED_PISTONS_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> SUPERCHARGED_PISTONS_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> SUPERCHARGED_PISTONS_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> RAPID_MOTORS_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> RAPID_MOTORS_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> RAPID_MOTORS_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> RAPID_MOTORS_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<float> RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> RAPID_MOTORS_ITEM_PROGRESSION_ITEMS { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<bool> VEHICLE_PLATING_ENABLED { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> VEHICLE_PLATING_PRICE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> VEHICLE_PLATING_PRICES { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> VEHICLE_PLATING_OVERRIDE_NAME { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> VEHICLE_PLATING_HEALTH_INITIAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<int> VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE { get; set; }

		[field: SyncedEntryField]
		public SyncedEntry<string> VEHICLE_PLATING_ITEM_PROGRESSION_ITEMS { get; set; }

		public PluginConfig(ConfigFile cfg)
			: base("com.github.WhiteSpike.LategameCompanyCruiserUpgrades")
		{
			string text = "Brake Fluid";
			BRAKE_FLUID_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Brake Fluid Upgrade", true, "Tier upgrade which increases the braking capability of the Company Cruiser vehicle.");
			BRAKE_FLUID_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Brake Fluid Upgrade", 100, (ConfigDescription)null);
			BRAKE_FLUID_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "100,150,250", "Value must be seperated by commas EX: '123,321,222'");
			BRAKE_FLUID_POWER_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Break Power Increase", 25, "Percentage of break power increased when first purchasing the upgrade on the Company Cruiser Vehicle");
			BRAKE_FLUID_POWER_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Break Power Increase", 25, "Percentage of break power increased when purchasing further levels of the upgrade on the Company Cruiser Vehicle");
			BRAKE_FLUID_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Turbo Tank";
			TURBO_TANK_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Turbo Tank Upgrade", true, "Tier upgrade which increases the maximum capacity of Company Cruiser Vehicle's turbo");
			TURBO_TANK_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Turbo Tank Upgrade", 200, (ConfigDescription)null);
			TURBO_TANK_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "100,200,300", "Value must be seperated by commas EX: '123,321,222'");
			TURBO_TANK_CAPACITY_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Turbo Capacity Increase", 2, "Amount of turbo capacity increased when first purchasing the upgrade on the Company Cruiser Vehicle");
			TURBO_TANK_CAPACITY_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Turbo Capacity Increase", 1, "Amount of turbo capacity increased when purchasing further levels of the upgrade on the Company Cruiser Vehicle");
			TURBO_TANK_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Ignition Coil";
			IGNITION_COIL_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Ignition Coil Upgrade", true, "Tier upgrade which increases the chance of ignition to turn on the Company Cruiser Vehicle.");
			IGNITION_COIL_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Ignition Coil Upgrade", 50, (ConfigDescription)null);
			IGNITION_COIL_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "50,100,100", "Value must be seperated by commas EX: '123,321,222'");
			IGNITION_COIL_IGNITION_INITIAL_CHANCE_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Ignition Chance Increase", 25, "Amount of chance (%) increased when first purchasing the upgrade to ignite on the Company Cruiser Vehicle");
			IGNITION_COIL_IGNITION_INCREMENTAL_CHANCE_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Ignition Chance Increase", 25, "Amount of chance (%) increased when purchasing further levels of the upgrade to ignite on the Company Cruiser Vehicle");
			IGNITION_COIL_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Fluffy Seats";
			FLUFFY_SEATS_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Fluffy Seats Upgrade", true, "Tier upgrade which provides player damage mitigation when bumping too hard with the Company Cruiser Vehicle.");
			FLUFFY_SEATS_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Fluffy Seats Upgrade", 100, (ConfigDescription)null);
			FLUFFY_SEATS_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "100,150,200", "Value must be seperated by commas EX: '123,321,222'");
			FLUFFY_SEATS_DAMAGE_MITIGATION_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Player Damage Mitigation Increase", 25, "Amount of damage mitigation (%) increased when first purchasing the upgrade when riding the Company Cruiser Vehicle.");
			FLUFFY_SEATS_DAMAGE_MITIGATION_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Player Damage Mitigation Increase", 25, "Amount of damage mitigation (%) increased when purchasing further levels of the upgrade when riding the Company Cruiser Vehicle.");
			FLUFFY_SEATS_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Improved Steering";
			IMPROVED_STEERING_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Improved Steering Upgrade", true, "Tier upgrade which increases the turning speed of the Company Cruiser vehicle");
			IMPROVED_STEERING_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Improved Steering Upgrade", 100, (ConfigDescription)null);
			IMPROVED_STEERING_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "100,150,250", "Value must be seperated by commas EX: '123,321,222'");
			IMPROVED_STEERING_TURNING_SPEED_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial Turning Speed Increase", 1f, "Amount of turning speed increased when first purchasing the upgrade to the Company Cruiser vehicle.");
			IMPROVED_STEERING_TURNING_SPEED_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental Turning Speed Increase", 0.5f, "Amount of turning speed increased when purchasing further levels of the upgrade to the Company Cruiser vehicle.");
			IMPROVED_STEERING_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Supercharged Pistons";
			SUPERCHARGED_PISTONS_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Supercharged Pistons Upgrade", true, "Tier upgrade which increases the company cruiser's maximum speed when driving");
			SUPERCHARGED_PISTONS_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Supercharged Pistons Upgrade", 250, (ConfigDescription)null);
			SUPERCHARGED_PISTONS_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "200,350", "Value must be seperated by commas EX: '123,321,222'");
			SUPERCHARGED_PISTONS_ENGINE_TORQUE_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial Engine Torque Increase", 40f, "Amount of maximum speed increased when first purchasing the upgrade to the Company Cruiser vehicle.");
			SUPERCHARGED_PISTONS_ENGINE_TORQUE_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental Engine Torque Increase", 20f, "Amount of maximum speed increased when purchasing further levels of the upgrade to the Company Cruiser vehicle.");
			SUPERCHARGED_PISTONS_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Rapid Motors";
			RAPID_MOTORS_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Rapid Motors Upgrade", true, "Tier upgrade which increases the company cruiser's acceleration when driving.");
			RAPID_MOTORS_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Rapid Motors Upgrade", 150, (ConfigDescription)null);
			RAPID_MOTORS_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "200,300,400", "Value must be seperated by commas EX: '123,321,222'");
			RAPID_MOTORS_ACCELERATION_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Initial Acceleration Increase", 2f, "Amount of acceleration increased when first purchasing the upgrade to the company cruiser vehicle.");
			RAPID_MOTORS_ACCELERATION_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, text, "Incremental Acceleration Increase", 0.5f, "Amount of acceleration increased when purchasing further levels of the upgrade to the company cruiser vehicle.");
			RAPID_MOTORS_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Vehicle Plating";
			VEHICLE_PLATING_ENABLED = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, text, "Enable Vehicle Plating Upgrade", true, "Tier upgrade which increases the company cruiser's maximum health to sustain damage from outside sources.");
			VEHICLE_PLATING_PRICE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Price of Vehicle Plating Upgrade", 150, (ConfigDescription)null);
			VEHICLE_PLATING_PRICES = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "Price of each additional upgrade", "300,400,500,600", "Value must be seperated by commas EX: '123,321,222'");
			VEHICLE_PLATING_HEALTH_INITIAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Initial Health Increase", 10, "Amount of health increased when first purchasing the upgrade to the company cruiser vehicle.");
			VEHICLE_PLATING_HEALTH_INCREMENTAL_INCREASE = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, text, "Incremental Health Increase", 5, "Amount of health increased when purchasing further levels of the upgrade to the company cruiser vehicle.");
			VEHICLE_PLATING_ITEM_PROGRESSION_ITEMS = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, "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");
			text = "Override Names";
			BRAKE_FLUID_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.BRAKE_FLUID_OVERRIDE_NAME_KEY, "Brake Fluid", (ConfigDescription)null);
			TURBO_TANK_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.TURBO_TANK_OVERRIDE_NAME_KEY, "Turbo Tank", (ConfigDescription)null);
			IGNITION_COIL_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.IGNITION_COIL_OVERRIDE_NAME_KEY, "Ignition Coil", (ConfigDescription)null);
			FLUFFY_SEATS_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.FLUFFY_SEATS_OVERRIDE_NAME_KEY, "Fluffy Seats", (ConfigDescription)null);
			IMPROVED_STEERING_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.IMPROVED_STEERING_OVERRIDE_NAME_KEY, "Improved Steering", (ConfigDescription)null);
			SUPERCHARGED_PISTONS_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.SUPERCHARGED_PISTONS_OVERRIDE_NAME_KEY, "Supercharged Pistons", (ConfigDescription)null);
			RAPID_MOTORS_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.RAPID_MOTORS_OVERRIDE_NAME_KEY, "Rapid Motors", (ConfigDescription)null);
			VEHICLE_PLATING_OVERRIDE_NAME = SyncedBindingExtensions.BindSyncedEntry<string>(cfg, text, Constants.VEHICLE_PLATING_OVERRIDE_NAME_KEY, "Vehicle Plating", (ConfigDescription)null);
			base.InitialSyncCompleted += PluginConfig_InitialSyncCompleted;
			ConfigManager.Register<PluginConfig>((SyncedConfig2<PluginConfig>)this);
		}

		private void PluginConfig_InitialSyncCompleted(object sender, EventArgs e)
		{
			UpgradeBus.Instance.Reconstruct();
		}
	}
	internal static class Metadata
	{
		public const string GUID = "com.github.WhiteSpike.LategameCompanyCruiserUpgrades";

		public const string NAME = "Lategame Company Cruiser Upgrades";

		public const string VERSION = "1.1.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace LategameCompanyCruiserUpgrades.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}