using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using AdvancedCompany.Boot;
using AdvancedCompany.Config;
using AdvancedCompany.Game;
using AdvancedCompany.IL;
using AdvancedCompany.Network;
using AdvancedCompany.Network.Messages;
using AdvancedCompany.Objects;
using AdvancedCompany.Objects.Interfaces;
using AdvancedCompany.Patches;
using AdvancedCompany.PostProcessing;
using AdvancedCompany.Terminal;
using AdvancedCompany.Terminal.Applications;
using AdvancedCompany.UI;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Coroner;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[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)]
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 AdvancedCompany
{
	public class AnimationClipOverrides : List<KeyValuePair<AnimationClip, AnimationClip>>
	{
		public AnimationClip this[string name]
		{
			get
			{
				return Find((KeyValuePair<AnimationClip, AnimationClip> x) => ((Object)x.Key).name.Equals(name)).Value;
			}
			set
			{
				int num = FindIndex((KeyValuePair<AnimationClip, AnimationClip> x) => ((Object)x.Key).name.Equals(name));
				if (num != -1)
				{
					base[num] = new KeyValuePair<AnimationClip, AnimationClip>(base[num].Key, value);
				}
			}
		}

		public AnimationClipOverrides(int capacity)
			: base(capacity)
		{
		}
	}
	[Bootable]
	public class Assets
	{
		public static AssetBundle AssetBundle;

		public static void Boot()
		{
			string text = Path.Combine(Path.GetDirectoryName(typeof(Assets).Assembly.Location), "advancedcompany/advancedcompanyassets");
			AssetBundle = AssetBundle.LoadFromFile(text);
			BootManager.AddTypeCallback(delegate(Type type)
			{
				if (type.GetCustomAttribute<LoadAssets>() != null)
				{
					MethodInfo method = type.GetMethod("LoadAssets", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
					if (method != null)
					{
						ParameterInfo[] parameters = method.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType == typeof(AssetBundle))
						{
							method.Invoke(null, new object[1] { AssetBundle });
						}
						else
						{
							Plugin.Log.LogError((object)("Method " + method.DeclaringType.FullName + "->" + method.Name + " has wrong parameters."));
						}
					}
					else
					{
						Plugin.Log.LogError((object)("Type " + type.FullName + " is missing static LoadAssets method."));
					}
				}
			});
		}
	}
	public static class GameAssets
	{
		public static Dictionary<string, Item> Scrap = new Dictionary<string, Item>();

		public static Dictionary<string, AudioClip> Audio = new Dictionary<string, AudioClip>();
	}
	[Bootable]
	public class HDRPChanges
	{
		public static void Boot()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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)
			Plugin.Log.LogInfo((object)"Patching HDRP...");
			try
			{
				RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
				HDRenderPipelineAsset val = (HDRenderPipelineAsset)(object)((currentRenderPipeline is HDRenderPipelineAsset) ? currentRenderPipeline : null);
				RenderPipelineSettings currentPlatformRenderPipelineSettings = val.currentPlatformRenderPipelineSettings;
				Type type = typeof(HDRenderPipelineAsset).Assembly.GetType("UnityEngine.Rendering.HighDefinition.HDRenderPipelineGlobalSettings");
				PropertyInfo property = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
				object value = property.GetValue(null);
				FieldInfo field = type.GetField("afterPostProcessCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				List<string> list = (List<string>)field.GetValue(value);
				list.Add(typeof(AdvancedCompany.PostProcessing.NightVision).AssemblyQualifiedName);
				currentPlatformRenderPipelineSettings.lightLoopSettings.cookieAtlasSize = (CookieAtlasResolution)2048;
				Plugin.Log.LogInfo((object)"Patched HDRP!");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while patching HDRP!");
				Plugin.Log.LogError((object)ex);
			}
		}
	}
	public class LoadAssets : Attribute
	{
	}
	[Requires(typeof(ServerConfiguration))]
	[Bootable]
	public class Perks : NetworkBehaviour
	{
		internal static Perk SprintSpeedPerk;

		internal static Perk JumpHeightPerk;

		internal static Perk JumpStaminaPerk;

		internal static Perk SprintStaminaPerk;

		internal static Perk FallDamagePerk;

		internal static Perk DamagePerk;

		internal static Perk WeightPerk;

		internal static Perk InventorySlotsPerk;

		internal static Perk DealDamagePerk;

		internal static Perk ClimbingSpeedPerk;

		internal static Perk ScanDistancePerk;

		internal static Perk ExtraBatteryPerk;

		internal static Perk ExtendDeadlineDiscountPerk;

		internal static Perk LandingSpeedPerk;

		internal static Perk DeliverySpeedPerk;

		internal static Perk SaveLootPerk;

		internal static Perk TravelDiscountPerk;

		public static int ExtendDeadlinePrice
		{
			get
			{
				if ((Object)(object)TimeOfDay.Instance != (Object)null)
				{
					return (int)((float)TimeOfDay.Instance.profitQuota * GetMultiplier(ExtendDeadlineDiscountPerk));
				}
				return 0;
			}
		}

		public static void Boot()
		{
			SprintSpeedPerk = new Perk(Perk.Type.PLAYER, "SprintSpeed", "Sprint speed", "Increases your sprint speed by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.SprintSpeed, (float baseValue, float change, int level) => baseValue + (float)level * change);
			JumpHeightPerk = new Perk(Perk.Type.PLAYER, "JumpHeight", "Jump height", "Increases your jump height by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.JumpHeight, (float baseValue, float change, int level) => baseValue + (float)level * change);
			JumpStaminaPerk = new Perk(Perk.Type.PLAYER, "JumpStamina", "Jump endurance", "Reduces stamina usage of jumping by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.JumpStamina, (float baseValue, float change, int level) => baseValue + (float)level * change);
			SprintStaminaPerk = new Perk(Perk.Type.PLAYER, "SprintStamina", "Sprint endurance", "Reduces stamina usage of sprinting by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.SprintStamina, (float baseValue, float change, int level) => baseValue + (float)level * change);
			FallDamagePerk = new Perk(Perk.Type.PLAYER, "FallDamage", "Reinforced legs", "Increases the depth you can fall without damage by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.FallDamage, (float baseValue, float change, int level) => baseValue + (float)level * change);
			DamagePerk = new Perk(Perk.Type.PLAYER, "Damage", "Protective skin", "Reduces damage from enemies by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.Damage, (float baseValue, float change, int level) => baseValue - (float)level * change);
			WeightPerk = new Perk(Perk.Type.PLAYER, "Weight", "Weight reducer", "Reduces strain of weight by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.Weight, (float baseValue, float change, int level) => baseValue - (float)level * change);
			InventorySlotsPerk = new Perk(Perk.Type.PLAYER, "InventorySlots", "Carry bags", "Increases inventory size by 1 per level.", ServerConfiguration.Instance.PlayerPerks.InventorySlots, (float baseValue, float change, int level) => baseValue + (float)level);
			DealDamagePerk = new Perk(Perk.Type.PLAYER, "DealDamage", "Strong arms", "Increases the chance for a critical strike by [change]%. Critical strikes will kill enemies with one hit.", ServerConfiguration.Instance.PlayerPerks.DealDamage, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ClimbingSpeedPerk = new Perk(Perk.Type.PLAYER, "ClimbingSpeed", "Climbing speed", "Increases climbing speed by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.ClimbingSpeed, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ScanDistancePerk = new Perk(Perk.Type.SHIP, "ScanDistance", "Scanner distance", "Increases the distance of the scanner by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ScanDistance, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ExtraBatteryPerk = new Perk(Perk.Type.SHIP, "ExtraBattery", "Batterypack", "Increases battery capacity of items by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ExtraBattery, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ExtendDeadlineDiscountPerk = new Perk(Perk.Type.SHIP, "ExtendDeadlineDiscount", "Deadline discount", "Decreases the cost to extend the deadline by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ExtendDeadlineDiscount, (float baseValue, float change, int level) => baseValue - (float)level * change);
			LandingSpeedPerk = new Perk(Perk.Type.SHIP, "LandingSpeed", "Landing speed", "Reduces the time to land and lift off by [change]% per level.", ServerConfiguration.Instance.ShipPerks.LandingSpeed, (float baseValue, float change, int level) => baseValue - (float)level * change);
			DeliverySpeedPerk = new Perk(Perk.Type.SHIP, "DeliverySpeed", "Express delivery", "Reduces the time for deliveries to arrive by [change]% per level.", ServerConfiguration.Instance.ShipPerks.DeliverySpeed, (float baseValue, float change, int level) => baseValue - (float)level * change);
			SaveLootPerk = new Perk(Perk.Type.SHIP, "SaveLoot", "Loot saver", "Increases the amount of saved loot by [change]% per level.", ServerConfiguration.Instance.ShipPerks.SaveLoot, (float baseValue, float change, int level) => baseValue + (float)level * change);
			TravelDiscountPerk = new Perk(Perk.Type.SHIP, "TravelDiscount", "Travel discount", "Decreases the price to travel to moons by [change]% per level.", ServerConfiguration.Instance.ShipPerks.TravelDiscount, (float baseValue, float change, int level) => baseValue - (float)level * change);
			AdvancedCompany.Network.Manager.AddListener<AdvancedCompany.Network.Messages.ExtendDeadline>(delegate
			{
				ExtendDeadline();
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangePerk message)
			{
				Perk perk = Perk.Perks[message.ID];
				Plugin.Log.LogMessage((object)("Received " + message.ID + ": " + message.Level));
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					Player player3 = AdvancedCompany.Network.Manager.Lobby.Player(message.ClientID);
					player3.SetLevel(perk, message.Level);
					if (message.ClientID == GameNetworkManager.Instance.localPlayerController.playerClientId)
					{
						player3.SaveLocal();
					}
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player3.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				else if (perk.PerkType == Perk.Type.SHIP)
				{
					Ship currentShip2 = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					Plugin.Log.LogMessage((object)"Ship");
					currentShip2.SetLevel(perk, message.Level);
					if (NetworkManager.Singleton.IsServer)
					{
						currentShip2.Save(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(Respec message)
			{
				if (message.Type == Perk.Type.PLAYER)
				{
					Player player2 = AdvancedCompany.Network.Manager.Lobby.Player(message.ClientID);
					player2.Reset(message.Reset);
					if (message.ClientID == GameNetworkManager.Instance.localPlayerController.playerClientId)
					{
						player2.SaveLocal();
					}
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player2.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				else if (message.Type == Perk.Type.SHIP)
				{
					Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					currentShip.Reset(message.Reset);
					if (NetworkManager.Singleton.IsServer)
					{
						currentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(GrantPlayerXP message)
			{
				if (message.All)
				{
					foreach (KeyValuePair<ulong, Player> connectedPlayer in AdvancedCompany.Network.Manager.Lobby.ConnectedPlayers)
					{
						connectedPlayer.Value.XP += message.XP;
						if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
						{
							connectedPlayer.Value.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
						}
					}
				}
				else
				{
					Player player = AdvancedCompany.Network.Manager.Lobby.Player(message.ClientID);
					player.XP += message.XP;
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				if (message.All || message.ClientID == GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					AdvancedCompany.Network.Manager.Lobby.Player().SaveLocal();
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(GrantShipXP message)
			{
				Plugin.Log.LogMessage((object)("GrantShipXP Listener. " + message.XP));
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.XP += message.XP;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangeShip message)
			{
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota = message.TotalQuota;
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.ExtendedDeadline = message.ExtendedDeadline;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
				}
			});
		}

		public static void GameStarted()
		{
			AdvancedCompany.Patches.Terminal.UpdateMoonPrices();
			InventoryPatches.ArrangeHotbar(InventorySlotsOf(GameNetworkManager.Instance.localPlayerController));
		}

		public static void OnClientExtendDeadline(ulong clientId, FastBufferReader reader)
		{
			ExtendDeadline();
		}

		public static void OnDeadlineSync(ulong clientId, FastBufferReader reader)
		{
			//IL_0007: 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)
			float timeUntilDeadline = default(float);
			((FastBufferReader)(ref reader)).ReadValue<float>(ref timeUntilDeadline, default(ForPrimitives));
			TimeOfDay.Instance.timeUntilDeadline = timeUntilDeadline;
			TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		}

		public static void ExtendDeadline()
		{
			int extendDeadlinePrice = ExtendDeadlinePrice;
			if (extendDeadlinePrice <= AdvancedCompany.Patches.Terminal.Instance.groupCredits)
			{
				TimeOfDay instance = TimeOfDay.Instance;
				instance.timeUntilDeadline += TimeOfDay.Instance.totalTime;
				Terminal instance2 = AdvancedCompany.Patches.Terminal.Instance;
				instance2.groupCredits -= extendDeadlinePrice;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Patches.Terminal.Instance.SyncGroupCreditsServerRpc(AdvancedCompany.Patches.Terminal.Instance.groupCredits, AdvancedCompany.Patches.Terminal.Instance.numberOfItemsInDropship);
					AdvancedCompany.Network.Manager.SendToAll(new DeadlineChanged
					{
						NewDeadline = TimeOfDay.Instance.timeUntilDeadline
					});
					AdvancedCompany.Network.Manager.Send(new ChangeShip
					{
						TotalQuota = AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota,
						ExtendedDeadline = true
					}, 0uL);
				}
				else
				{
					AdvancedCompany.Network.Manager.Send(new AdvancedCompany.Network.Messages.ExtendDeadline(), 0uL);
				}
			}
		}

		public static float GetMultiplier(Perk perk)
		{
			if (AdvancedCompany.Network.Manager.Lobby != null)
			{
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					Player player = AdvancedCompany.Network.Manager.Lobby.Player();
					if (player != null)
					{
						return perk.GetMultiplier(player);
					}
				}
				else if (perk.PerkType == Perk.Type.SHIP)
				{
					Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					if (currentShip != null)
					{
						return perk.GetMultiplier(currentShip);
					}
				}
			}
			return 1f;
		}

		public static float GetMultiplier(string perkName)
		{
			if (Perk.Perks.ContainsKey(perkName))
			{
				return GetMultiplier(Perk.Perks[perkName]);
			}
			return 1f;
		}

		public static float GetMultiplier(ulong clientID, string perkName)
		{
			if (Perk.Perks.ContainsKey(perkName) && AdvancedCompany.Network.Manager.Lobby != null)
			{
				Perk perk = Perk.Perks[perkName];
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					Player player = AdvancedCompany.Network.Manager.Lobby.Player();
					if (player != null)
					{
						return Perk.Perks[perkName].GetMultiplier(player);
					}
				}
			}
			return 1f;
		}

		public static float GetMultiplier(PlayerControllerB controller, string perkName)
		{
			if ((Object)(object)controller != (Object)null)
			{
				return GetMultiplier(controller.playerClientId, perkName);
			}
			return 1f;
		}

		public static int InventorySlotsOf(PlayerControllerB controller)
		{
			if (Perk.Perks.ContainsKey("InventorySlots") && AdvancedCompany.Network.Manager.Lobby != null)
			{
				Player player = AdvancedCompany.Network.Manager.Lobby.Player(controller.playerClientId);
				if (player != null)
				{
					return (int)Math.Round(ServerConfiguration.Instance.PlayerPerks.InventorySlots.Base + (float)Perk.Perks["InventorySlots"].GetLevel(player));
				}
			}
			return 10;
		}
	}
	[LoadAssets]
	public class PlayerRocketBoots : MonoBehaviour
	{
		public GameObject LeftRocket;

		public GameObject RightRocket;

		private ParticleSystem LeftParticles;

		private ParticleSystem RightParticles;

		private bool Initialized = false;

		private static GameObject LeftRocketBootPrefab;

		private static GameObject RightRocketBootPrefab;

		public static void LoadAssets(AssetBundle assets)
		{
			LeftRocketBootPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/LeftRocketBoot.prefab");
			RightRocketBootPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/RightRocketBoot.prefab");
		}

		public void Awake()
		{
			//IL_00a5: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)this).transform.Find("ScavengerModel").Find("metarig").Find("spine");
			Transform val2 = val.Find("thigh.L").Find("shin.L").Find("foot.L");
			Transform val3 = val.Find("thigh.R").Find("shin.R").Find("foot.R");
			if ((Object)(object)LeftRocket == (Object)null)
			{
				LeftRocket = Object.Instantiate<GameObject>(LeftRocketBootPrefab, val2);
				LeftRocket.transform.localPosition = new Vector3(-0.0786f, -0.0302f, 0.0056f);
				LeftRocket.transform.localEulerAngles = new Vector3(-54.256f, -170.885f, 169.978f);
				LeftRocket.transform.localScale = new Vector3(0.5319018f, 0.5319018f, 0.5319018f);
				LeftParticles = ((Component)LeftRocket.transform.Find("Particles")).GetComponent<ParticleSystem>();
			}
			if ((Object)(object)RightRocket == (Object)null)
			{
				RightRocket = Object.Instantiate<GameObject>(RightRocketBootPrefab, val3);
				RightRocket.transform.localPosition = new Vector3(0.0833f, -0.0401f, 0.0086f);
				RightRocket.transform.localEulerAngles = new Vector3(-124.165f, 0.07899f, -0.55297f);
				RightRocket.transform.localScale = new Vector3(0.5319018f, 0.5319018f, 0.5319018f);
				RightParticles = ((Component)RightRocket.transform.Find("Particles")).GetComponent<ParticleSystem>();
			}
		}

		public void PlayParticles()
		{
			LeftParticles.Play();
			RightParticles.Play();
		}
	}
	[BepInPlugin("com.potatoepet.AdvancedCompany", "AdvancedCompany", "1.0.10")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Version = "1.0.10";

		private const string GUID = "com.potatoepet.AdvancedCompany";

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		private void Awake()
		{
			try
			{
				Log = ((BaseUnityPlugin)this).Logger;
				AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				Assembly[] array = assemblies;
				foreach (Assembly assembly in array)
				{
					CheckAssemblyPatches(assembly);
				}
				Instance = this;
				Log.LogInfo((object)"Booting");
				BootManager.Boot();
				Log.LogInfo((object)"Boot finished!");
				Log.LogInfo((object)"Patching with harmony...");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Network.Manager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(BulletProofVest), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(LightningRod), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Objects.NightVision), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(SwimmingFins), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AnimationPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(BalancingPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(DebugPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(EnemyAICollisionDetect), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Flavour), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(GameNetworkManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(GrabbableObject), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(HUDManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(InventoryPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(ItemDataHandling), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(ItemDropship), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Rocket), "AdvancedCompany");
				if (FileConfiguration.Instance.Lobby.Active.Value)
				{
					LobbySizePatches.MAX_PLAYERS = FileConfiguration.Instance.Lobby.MaxPlayers.Value;
					Harmony.CreateAndPatchAll(typeof(LobbySizePatches), "AdvancedCompany");
					LobbySizePatches.PatchAsync();
				}
				else
				{
					Harmony.CreateAndPatchAll(typeof(NoLobbyPatches), "AdvancedCompany");
				}
				Harmony.CreateAndPatchAll(typeof(PlayerControllerB), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(RoundManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(StartOfRound), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Patches.Terminal), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(TimeOfDay), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Endscreen), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Utils), "AdvancedCompany");
				Log.LogInfo((object)"Patching complete!");
			}
			catch (Exception ex)
			{
				Log.LogError((object)"Error while booting!");
				Log.LogError((object)ex);
			}
		}

		private void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
		{
			CheckAssemblyPatches(args.LoadedAssembly);
		}

		private static void CheckAssemblyPatches(Assembly assembly)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			if (!assembly.FullName.StartsWith("ReservedFlashlightSlot"))
			{
				return;
			}
			Harmony val = new Harmony("AdvancedCompany");
			Type[] types = assembly.GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				if (types[i].Name == "Keybinds")
				{
					MethodInfo method = types[i].GetMethod("OnActivateFlashlightPerformed", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
					HarmonyMethod val2 = new HarmonyMethod(typeof(Plugin).GetMethod("CheckFlashlight", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy));
					val.Patch((MethodBase)method, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					break;
				}
			}
		}

		private static bool CheckFlashlight()
		{
			if (ClientConfiguration.Instance.Keybinds.Flashlight != null && ClientConfiguration.Instance.Keybinds.Flashlight.Trim() != "")
			{
				return false;
			}
			return true;
		}

		public static bool ShouldSaveOutfits()
		{
			return (ServerConfiguration.Instance?.General?.SaveSuitsAfterDeath).GetValueOrDefault();
		}
	}
	public class Program
	{
		public static void Main(string[] args)
		{
			Console.WriteLine(AdvancedCompany.Terminal.Utils.WrapText("Ich bin ein Testtext der angezeigt werden soll, mal schauen, ob das auch wirklich funktioniert.", 30, "| ", " |"));
		}
	}
	[HarmonyPatch]
	public class Utils
	{
		private static List<GameObject> NetworkPrefabs = new List<GameObject>();

		private static bool NetworkManagerStarted = false;

		public static NetworkManager NetworkManager;

		public static void AddNetworkPrefab(GameObject go)
		{
			NetworkPrefabs.Add(go);
			if (NetworkManagerStarted)
			{
				NetworkManager.AddNetworkPrefab(go);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void Start(GameNetworkManager __instance)
		{
			NetworkManager = ((Component)__instance).GetComponent<NetworkManager>();
			for (int i = 0; i < NetworkPrefabs.Count; i++)
			{
				NetworkManager.AddNetworkPrefab(NetworkPrefabs[i]);
			}
			NetworkManagerStarted = true;
		}
	}
}
namespace AdvancedCompany.UI
{
	[LoadAssets]
	[HarmonyPatch]
	public class Endscreen
	{
		private static GameObject Container;

		public static Endscreen Instance;

		private static GameObject PerformanceReportPrefab;

		private static GameObject DeadContainerPrefab;

		private static GameObject MissingContainerPrefab;

		private static GameObject NoteContainerPrefab;

		private static Transform AllDead;

		private static Transform PlayerNoteContainer;

		private static Transform DeadNoteContainer;

		private static Transform MissingTitle;

		private static Transform MissingScrollBox;

		private static Transform MissingNoteContainer;

		private static Transform CollectedLabel;

		private static Transform CollectedLine;

		private static TextMeshProUGUI CollectedText;

		private static TextMeshProUGUI TotalText;

		private static Transform ScrapLost;

		private static TextMeshProUGUI ScrapLostText;

		private static TextMeshProUGUI GradeText;

		private static int CollectedScrap;

		private static int TotalScrap;

		private static string Grade;

		private static bool AreAllDead;

		private static MethodInfo OpenEndgameMenuMethod = typeof(Endscreen).GetMethod("Open", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		public static void LoadAssets(AssetBundle assets)
		{
			PerformanceReportPrefab = assets.LoadAsset<GameObject>("Assets/UI/PerformanceReport.prefab");
			DeadContainerPrefab = assets.LoadAsset<GameObject>("Assets/UI/DeadContainer.prefab");
			MissingContainerPrefab = assets.LoadAsset<GameObject>("Assets/UI/MissingContainer.prefab");
			NoteContainerPrefab = assets.LoadAsset<GameObject>("Assets/UI/NoteContainer.prefab");
		}

		private static string GetDeathReason(PlayerControllerB controller)
		{
			//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_0030: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected I4, but got Unknown
			if (Chainloader.PluginInfos.ContainsKey("com.elitemastereric.coroner"))
			{
				try
				{
					return CoronerDeathReason(controller);
				}
				catch (Exception)
				{
				}
			}
			CauseOfDeath causeOfDeath = controller.causeOfDeath;
			CauseOfDeath val = causeOfDeath;
			return (int)val switch
			{
				0 => "Uncertain circumstances", 
				9 => "Drowned", 
				4 => "Strangulated", 
				5 => "Suffocation", 
				6 => "Mauling", 
				3 => "Blast", 
				8 => "Crushed", 
				11 => "Electrocuted", 
				2 => "Gravity", 
				7 => "Gunshots", 
				12 => "Kicked", 
				_ => "Uncertain circumstances", 
			};
		}

		private static string CoronerDeathReason(PlayerControllerB controller)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return AdvancedDeathTracker.StringifyCauseOfDeath((AdvancedCauseOfDeath?)AdvancedDeathTracker.GetCauseOfDeath(controller));
		}

		public static void Open()
		{
			try
			{
				bool active = false;
				int childCount = PlayerNoteContainer.childCount;
				for (int num = childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)PlayerNoteContainer.GetChild(num)).gameObject);
				}
				childCount = DeadNoteContainer.childCount;
				for (int num2 = childCount - 1; num2 >= 0; num2--)
				{
					Object.Destroy((Object)(object)((Component)DeadNoteContainer.GetChild(num2)).gameObject);
				}
				childCount = MissingNoteContainer.childCount;
				for (int num3 = childCount - 1; num3 >= 0; num3--)
				{
					Object.Destroy((Object)(object)((Component)MissingNoteContainer.GetChild(num3)).gameObject);
				}
				for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
					string text = ((TMP_Text)HUDManager.Instance.statsUIElements.playerNamesText[i]).text;
					Texture2D avatar = PlayerControllerB.GetAvatar(val);
					string text2 = ((TMP_Text)HUDManager.Instance.statsUIElements.playerNotesText[i]).text;
					if (text2.StartsWith("Notes:"))
					{
						text2 = text2.Substring(6);
					}
					if (Chainloader.PluginInfos.ContainsKey("com.elitemastereric.coroner"))
					{
						int num4 = text2.IndexOf("Cause of Death");
						if (num4 > -1)
						{
							text2 = text2.Substring(0, num4);
						}
					}
					text2 = text2.Trim();
					string deathReason = GetDeathReason(val);
					if (text2 != "")
					{
						AddPlayerNote(avatar, text, text2);
					}
					if ((Object)(object)HUDManager.Instance.statsUIElements.playerStates[i].sprite == (Object)(object)HUDManager.Instance.statsUIElements.deceasedIcon)
					{
						AddDeceasedNote(avatar, text, deathReason);
					}
					if ((Object)(object)HUDManager.Instance.statsUIElements.playerStates[i].sprite == (Object)(object)HUDManager.Instance.statsUIElements.missingIcon)
					{
						active = true;
						AddMissingNote(avatar, text);
					}
				}
				((Component)MissingTitle).gameObject.SetActive(active);
				((Component)MissingScrollBox).gameObject.SetActive(active);
				CollectedScrap = RoundManager.Instance.scrapCollectedInLevel;
				TotalScrap = (int)RoundManager.Instance.totalScrapValueInLevel;
				AreAllDead = ((Behaviour)HUDManager.Instance.statsUIElements.allPlayersDeadOverlay).enabled;
				((Component)AllDead).gameObject.SetActive(AreAllDead);
				((TMP_Text)CollectedText).text = "";
				((TMP_Text)TotalText).text = "";
				((Component)CollectedText).gameObject.SetActive(true);
				((Component)TotalText).gameObject.SetActive(true);
				((Component)CollectedLine).gameObject.SetActive(true);
				((Component)CollectedLabel).gameObject.SetActive(true);
				((Component)ScrapLost).gameObject.SetActive(false);
				Grade = ((TMP_Text)HUDManager.Instance.statsUIElements.gradeLetter).text;
				((TMP_Text)GradeText).text = "";
				Container.SetActive(true);
				LayoutRebuilder.ForceRebuildLayoutImmediate(Container.GetComponent<RectTransform>());
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(AnimateMenu());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error occured while opening end screen!");
				Plugin.Log.LogError((object)ex);
			}
		}

		private static IEnumerator AnimateMenu()
		{
			Cursor.lockState = (CursorLockMode)2;
			Cursor.visible = true;
			yield return (object)new WaitForSeconds(1f);
			float p = 0f;
			((TMP_Text)TotalText).text = TotalScrap.ToString() ?? "";
			while (p < 1f)
			{
				((TMP_Text)CollectedText).text = CollectedScrap.ToString() ?? "";
				p += 0.05f;
				yield return (object)new WaitForEndOfFrame();
			}
			if (AreAllDead)
			{
				yield return (object)new WaitForSeconds(1f);
				((Component)CollectedText).gameObject.SetActive(false);
				((Component)TotalText).gameObject.SetActive(false);
				((Component)CollectedLine).gameObject.SetActive(false);
				((Component)CollectedLabel).gameObject.SetActive(false);
				((TMP_Text)ScrapLostText).text = "Lost " + Mathf.Round((1f - Perks.GetMultiplier("SaveLoot")) * 1000f) / 10f + "% scrap";
				((Component)ScrapLost).gameObject.SetActive(true);
			}
			yield return (object)new WaitForSeconds(1f);
			((TMP_Text)GradeText).text = Grade;
			yield return (object)new WaitForSeconds(6f - (AreAllDead ? 1f : 0f));
			Container.SetActive(false);
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}

		public static Texture2D GetTextureFromImage(Image? image)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_00ca: 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_003d: 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_0048: 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_0053: 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_006d: 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_0089: 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)
			if (image.HasValue)
			{
				Texture2D val = new Texture2D((int)image.Value.Width, (int)image.Value.Height);
				for (int i = 0; i < image.Value.Width; i++)
				{
					for (int j = 0; j < image.Value.Height; j++)
					{
						Image value = image.Value;
						Color pixel = ((Image)(ref value)).GetPixel(i, j);
						val.SetPixel(i, (int)image.Value.Height - j, new Color((float)(int)pixel.r / 255f, (float)(int)pixel.g / 255f, (float)(int)pixel.b / 255f, (float)(int)pixel.a / 255f));
					}
				}
				val.Apply();
				return val;
			}
			return null;
		}

		private static void AddPlayerNote(Texture2D image, string username, string notes)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(NoteContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			((TMP_Text)((Component)val.transform.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = notes;
			val.transform.parent = PlayerNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		private static void AddDeceasedNote(Texture2D image, string username, string deathReason)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(DeadContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			((TMP_Text)((Component)val.transform.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = deathReason;
			val.transform.parent = DeadNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		private static void AddMissingNote(Texture2D image, string username)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(MissingContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			val.transform.parent = MissingNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPostfix]
		public static void Attach(HUDManager __instance)
		{
			//IL_0039: 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)
			Container = Object.Instantiate<GameObject>(PerformanceReportPrefab, ((Component)__instance.endgameStatsAnimator).transform.parent);
			Container.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
			Container.GetComponent<RectTransform>().sizeDelta = new Vector2(823f, 717f);
			Transform child = Container.transform.GetChild(1);
			Transform child2 = child.GetChild(0);
			Transform child3 = child.GetChild(1);
			Transform child4 = Container.transform.GetChild(2);
			AllDead = child2.GetChild(1);
			PlayerNoteContainer = child2.GetChild(2).GetChild(0).GetChild(0);
			DeadNoteContainer = child3.GetChild(1).GetChild(0).GetChild(0);
			MissingTitle = child3.GetChild(2);
			MissingScrollBox = child3.GetChild(3);
			MissingNoteContainer = MissingScrollBox.GetChild(0).GetChild(0);
			Transform child5 = child4.GetChild(0);
			CollectedLabel = child5.GetChild(0);
			CollectedText = ((Component)child5.GetChild(1)).GetComponent<TextMeshProUGUI>();
			CollectedLine = child5.GetChild(2);
			TotalText = ((Component)child5.GetChild(3)).GetComponent<TextMeshProUGUI>();
			ScrapLost = child5.GetChild(4);
			ScrapLostText = ((Component)ScrapLost.GetChild(0)).GetComponent<TextMeshProUGUI>();
			GradeText = ((Component)child4.GetChild(1).GetChild(1)).GetComponent<TextMeshProUGUI>();
			Container.SetActive(false);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchHUDManagerEndOfGame(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogMessage((object)"Patching StartOfRound->EndOfGame...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldstr && list[i].operand.ToString() == "displayStats")
				{
					list[i + 1].opcode = OpCodes.Call;
					list[i + 1].operand = OpenEndgameMenuMethod;
					list.RemoveAt(i - 2);
					list.RemoveAt(i - 2);
					list.RemoveAt(i - 2);
				}
			}
			Plugin.Log.LogMessage((object)"Patched StartOfRound->EndOfGame!");
			return list.AsEnumerable();
		}
	}
}
namespace AdvancedCompany.Terminal
{
	public class BoxedScreen : IScreen, ITextElement
	{
		public string Title;

		public List<ITextElement> Content;

		public virtual string GetText(int availableWidth)
		{
			int num = availableWidth - Title.Length - 2;
			string text = "┌" + new string('─', availableWidth - 2) + "┐\n│" + new string(' ', (int)Math.Ceiling((float)num / 2f)) + Title + new string(' ', (int)Math.Ceiling((float)num / 2f) - ((num % 2 != 0) ? 1 : 0)) + "│\n├" + new string('─', availableWidth - 2) + "┤\n";
			foreach (ITextElement item in Content)
			{
				text += Utils.WrapText(item.GetText(availableWidth - 4), availableWidth, "│ ", " │");
			}
			return text + "└" + new string('─', availableWidth - 2) + "┘\n";
		}
	}
	public class Command
	{
		public string CommandText;

		public string Description;

		public bool IsActive = true;

		public bool IsCheat = false;

		public bool ServerOnly = false;

		public Action<string[]> Action;

		internal static List<Command> Commands = new List<Command>();

		public Command()
		{
			Commands.Add(this);
		}

		public static Command FindCommand(string commandText, bool isServer)
		{
			for (int i = 0; i < Commands.Count; i++)
			{
				if (Commands[i].IsActive && Commands[i].CommandText.Equals(commandText, StringComparison.OrdinalIgnoreCase) && (!Commands[i].ServerOnly || isServer))
				{
					return Commands[i];
				}
			}
			return null;
		}

		public void Execute(string[] @params)
		{
			Action(@params);
		}
	}
	public class CursorElement : ITextElement
	{
		public string Name;

		public string Description;

		public Action Action;

		public virtual string GetText(int availableWidth)
		{
			string text = Name;
			if (Description != null && Description != "")
			{
				text = text + "\n" + Utils.WrapText(Description, availableWidth, "  ");
			}
			return text;
		}
	}
	public class CursorMenu : IScrollable, ITextElement
	{
		private int _SelectedElement;

		public List<CursorElement> Elements;

		private int _ScrollPosStart = 0;

		private int _ScrollPosEnd = 0;

		private int _LastScrollPos = 0;

		public int SelectedElement
		{
			get
			{
				return _SelectedElement;
			}
			set
			{
				if (value >= Elements.Count)
				{
					_SelectedElement = 0;
				}
				else if (value < 0)
				{
					_SelectedElement = Elements.Count - 1;
				}
				else
				{
					_SelectedElement = value;
				}
			}
		}

		public void Execute()
		{
			Elements[SelectedElement].Action();
		}

		public virtual string GetText(int availableWidth)
		{
			string text = "";
			int num = 0;
			for (int i = 0; i < Elements.Count; i++)
			{
				if (_SelectedElement == i)
				{
					_ScrollPosStart = num;
				}
				string text2 = " " + ((_SelectedElement == i) ? ">" : " ") + " " + Utils.WrapText(Elements[i].GetText(availableWidth - 3), availableWidth, "   ", "", padLeftFirst: false);
				num += text2.Count((char c) => c.Equals('\n'));
				text += text2;
				if (_SelectedElement == i)
				{
					_ScrollPosEnd = num;
				}
			}
			return text;
		}

		public int GetScroll(int maxHeight)
		{
			int lastScrollPos = _LastScrollPos;
			int num = _LastScrollPos + maxHeight;
			int num2 = _LastScrollPos;
			if (_ScrollPosEnd > num)
			{
				num2 = _ScrollPosEnd - maxHeight;
			}
			if (_ScrollPosStart < lastScrollPos)
			{
				num2 = _ScrollPosStart;
			}
			_LastScrollPos = num2;
			return num2;
		}
	}
	public class Help
	{
		public static void Show()
		{
			List<string> list = new List<string>();
			TerminalKeyword[] allKeywords = AdvancedCompany.Patches.Terminal.Instance.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if (val.word == "help")
				{
					list.AddRange(val.specialKeywordResult.displayText.Split('\n'));
				}
				if (val.word == "other")
				{
					list.AddRange(val.specialKeywordResult.displayText.Split('\n'));
				}
			}
			string text = "";
			string text2 = "";
			List<(string, string)> list2 = new List<(string, string)>();
			for (int j = 0; j < list.Count; j++)
			{
				string text3 = list[j];
				if (text3.StartsWith(">"))
				{
					if (text != "")
					{
						if (!text.Equals("other", StringComparison.OrdinalIgnoreCase))
						{
							list2.Add((text, text2));
							text2 = "";
						}
						else
						{
							text2 = "";
						}
					}
					text = text3.Substring(1);
				}
				else if (text3.Trim() != "")
				{
					text2 = text2 + text3 + "\n";
				}
			}
			if (text != "")
			{
				list2.Add((text, text2));
			}
			string text4 = "";
			foreach (var item in list2)
			{
				text4 = text4 + "> " + item.Item1 + "\n" + Utils.WrapText(item.Item2, 51, "  ");
			}
			foreach (Command command in Command.Commands)
			{
				if (command.IsActive && !command.IsCheat && (!command.ServerOnly || NetworkManager.Singleton.IsServer))
				{
					text4 = text4 + "> " + command.CommandText.ToUpperInvariant() + "\n" + Utils.WrapText(command.Description, 51, "  ") + "\n";
				}
			}
			AdvancedCompany.Patches.Terminal.SetText(text4);
		}
	}
	internal interface IScreen : ITextElement
	{
	}
	public interface IScrollable : ITextElement
	{
		int GetScroll(int maxHeight);
	}
	public interface ITextElement
	{
		string GetText(int availableWidth);
	}
	public class PerkCursorElement : CursorElement
	{
		private Perk Perk;

		public PerkCursorElement(Perk perk)
		{
			Perk = perk;
		}

		public override string GetText(int availableWidth)
		{
			int num = 25;
			int num2 = 11;
			string text = ((Perk.Name.Length > num) ? Perk.Name.Substring(0, num) : (Perk.Name + new string(' ', num - Perk.Name.Length)));
			int num3 = 0;
			int num4 = 0;
			if (Perk.PerkType == Perk.Type.PLAYER)
			{
				num3 = AdvancedCompany.Network.Manager.Lobby.Player().GetLevel(Perk);
				num4 = Perk.GetNextPrice(AdvancedCompany.Network.Manager.Lobby.Player());
			}
			if (Perk.PerkType == Perk.Type.SHIP)
			{
				num3 = AdvancedCompany.Network.Manager.Lobby.CurrentShip.GetLevel(Perk);
				num4 = Perk.GetNextPrice(AdvancedCompany.Network.Manager.Lobby.CurrentShip);
			}
			string text2 = new string('◼', num3) + new string('□', Perk.Levels - num3) + new string(' ', num2 - Perk.Levels);
			string text3 = "";
			if (num4 > 0)
			{
				text3 = " " + num4 + "XP";
			}
			return text + text2 + text3;
		}
	}
	public class ScrollBox : ITextElement
	{
		public IScrollable Content;

		public int MaxHeight = 0;

		public int ScrollPos = 0;

		public ScrollBox(int maxHeight)
		{
			MaxHeight = maxHeight;
		}

		public string GetText(int availableWidth)
		{
			string text = Content.GetText(availableWidth);
			int num = text.Count((char c) => c.Equals('\n')) - 1;
			if (num > MaxHeight)
			{
				text = Content.GetText(availableWidth - 2);
				int scroll = Content.GetScroll(MaxHeight);
				Plugin.Log.LogMessage((object)("Scroll: " + scroll));
				string[] array = text.Split('\n');
				string text2 = "";
				int num2 = (int)Math.Floor((float)MaxHeight * ((float)MaxHeight / (float)array.Length));
				int num3 = (int)Math.Round((float)scroll / (float)(array.Length - MaxHeight) * (float)(MaxHeight - num2));
				for (int i = scroll; i < scroll + MaxHeight && i < array.Length; i++)
				{
					bool flag = i - scroll >= num3 && i - scroll <= num3 + num2;
					string text3 = array[i];
					text2 = text2 + text3 + " " + (flag ? "█" : "░") + "\n";
				}
				return text2;
			}
			return text;
		}
	}
	public class TextElement : ITextElement
	{
		public string Text;

		public string GetText(int availableWidth)
		{
			return Utils.WrapText(Text, availableWidth);
		}

		public static explicit operator TextElement(string text)
		{
			return new TextElement
			{
				Text = text
			};
		}
	}
	public class Utils
	{
		public static string WrapText(string text, int lineLength, string padLeft = "", string padRight = "", bool padLeftFirst = true)
		{
			bool flag = true;
			int num = lineLength - padLeft.Length - padRight.Length;
			string text2 = "";
			int num2 = 0;
			while (num2 < text.Length)
			{
				int num3 = ((num2 + num >= text.Length) ? (text.Length - 1) : (num2 + num));
				int num4 = text.LastIndexOf(' ', num3);
				int num5 = text.IndexOf('\n', num2);
				if (num5 != -1 && num5 <= num3)
				{
					num4 = num5;
				}
				if (num3 == text.Length - 1)
				{
					num4 = text.Length;
				}
				if (num4 < num2)
				{
					num4 = -1;
				}
				int num6 = ((num4 != -1) ? (num4 - num2) : ((text.Length - num2 < num) ? (text.Length - num2) : num));
				if (num6 > num)
				{
					num6 = num;
				}
				string text3 = text.Substring(num2, num6);
				string text4 = ((!padLeftFirst && flag) ? "" : padLeft) + text3 + ((text3.Length < num) ? new string(' ', num - text3.Length) : "") + padRight + "\n";
				text2 += text4;
				flag = false;
				num2 = num2 + num6 + ((num4 != -1) ? 1 : 0);
			}
			return text2;
		}
	}
}
namespace AdvancedCompany.Terminal.Applications
{
	public class ExtendDeadline
	{
		public static void Open()
		{
			string text = "";
			bool flag = false;
			int extendDeadlinePrice = AdvancedCompany.Perks.ExtendDeadlinePrice;
			if (AdvancedCompany.Network.Manager.Lobby.CurrentShip.ExtendedDeadline)
			{
				text = "The deadline was already extended during this quota.";
			}
			else if (extendDeadlinePrice > AdvancedCompany.Patches.Terminal.Instance.groupCredits)
			{
				text = "Insufficient funds.";
			}
			else
			{
				flag = true;
				text = "Do you really want to extend the deadline?";
			}
			List<CursorElement> list = new List<CursorElement>();
			if (flag)
			{
				list.Add(new CursorElement
				{
					Name = "CONFIRM",
					Action = delegate
					{
						AdvancedCompany.Perks.ExtendDeadline();
						AdvancedCompany.Patches.Terminal.ActiveScreen = null;
						AdvancedCompany.Patches.Terminal.ActiveCursorMenu = null;
						AdvancedCompany.Patches.Terminal.SetText("[ Deadline was extended by one day ]\n\n\n");
					}
				});
				list.Add(new CursorElement
				{
					Name = "DENY",
					Action = delegate
					{
						Close();
					}
				});
			}
			else
			{
				list.Add(new CursorElement
				{
					Name = "BACK",
					Action = delegate
					{
						Close();
					}
				});
			}
			CursorMenu cursorMenu = new CursorMenu
			{
				Elements = list
			};
			BoxedScreen box = new BoxedScreen
			{
				Title = "EXTEND DEADLINE",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = $"To extend the deadline you need {extendDeadlinePrice} credits."
					},
					new TextElement
					{
						Text = " "
					},
					new TextElement
					{
						Text = text
					},
					cursorMenu
				}
			};
			SwitchTo(box, cursorMenu, back: false);
		}

		public static void SwitchTo(BoxedScreen box, CursorMenu menu, bool back = true)
		{
			if ((Object)(object)AdvancedCompany.Patches.Terminal.Instance != (Object)null)
			{
				AdvancedCompany.Patches.Terminal.ActiveScreen = box;
				AdvancedCompany.Patches.Terminal.ActiveCursorMenu = menu;
				if (!back)
				{
					menu.SelectedElement = 0;
				}
			}
		}

		public static void Close()
		{
			if ((Object)(object)AdvancedCompany.Patches.Terminal.Instance != (Object)null)
			{
				AdvancedCompany.Patches.Terminal.ActiveCursorMenu = null;
				AdvancedCompany.Patches.Terminal.ActiveScreen = null;
				AdvancedCompany.Patches.Terminal.ClosingScreen = true;
			}
		}
	}
	public class Perks
	{
		private static BoxedScreen MainMenu;

		private static BoxedScreen RespecMenu;

		private static BoxedScreen PlayerPerksMenu;

		private static BoxedScreen ShipPerksMenu;

		private static BoxedScreen BuyPerkMenu;

		private static CursorMenu MainMenuCursorMenu;

		private static CursorMenu RespecCursorMenu;

		private static CursorMenu PlayerPerksCursorMenu;

		private static CursorMenu ShipPerksCursorMenu;

		private static CursorMenu BuyPerkCursorMenu;

		public static void Update()
		{
			MainMenuCursorMenu = new CursorMenu
			{
				Elements = new List<CursorElement>
				{
					new CursorElement
					{
						Name = "PLAYER",
						Description = "Upgrade your character.",
						Action = delegate
						{
							SwitchTo(PlayerPerksMenu, PlayerPerksCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "SHIP",
						Description = "Upgrade your ship.",
						Action = delegate
						{
							SwitchTo(ShipPerksMenu, ShipPerksCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "RESPEC",
						Description = "Reset your points.",
						Action = delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "CLOSE",
						Description = null,
						Action = delegate
						{
							Close();
						}
					}
				}
			};
			MainMenu = new BoxedScreen
			{
				Title = "PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select an action:"
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = MainMenuCursorMenu
					}
				}
			};
			List<CursorElement> list = new List<CursorElement>();
			foreach (Perk p2 in Perk.PerksByType(Perk.Type.PLAYER))
			{
				if (!p2.IsActive)
				{
					continue;
				}
				list.Add(new PerkCursorElement(p2)
				{
					Action = delegate
					{
						BuyPerk(p2, delegate
						{
							SwitchTo(PlayerPerksMenu, PlayerPerksCursorMenu);
						});
					}
				});
			}
			list.Add(new CursorElement
			{
				Name = "BACK",
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			PlayerPerksCursorMenu = new CursorMenu
			{
				Elements = list
			};
			PlayerPerksMenu = new BoxedScreen
			{
				Title = "PLAYER PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select a perk to level:"
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = PlayerPerksCursorMenu
					}
				}
			};
			List<CursorElement> list2 = new List<CursorElement>();
			foreach (Perk p in Perk.PerksByType(Perk.Type.SHIP))
			{
				if (!p.IsActive)
				{
					continue;
				}
				list2.Add(new PerkCursorElement(p)
				{
					Action = delegate
					{
						BuyPerk(p, delegate
						{
							SwitchTo(ShipPerksMenu, ShipPerksCursorMenu);
						});
					}
				});
			}
			list2.Add(new CursorElement
			{
				Name = "BACK",
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			ShipPerksCursorMenu = new CursorMenu
			{
				Elements = list2
			};
			ShipPerksMenu = new BoxedScreen
			{
				Title = "SHIP PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select a perk to level:"
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = ShipPerksCursorMenu
					}
				}
			};
			List<CursorElement> list3 = new List<CursorElement>();
			list3.Add(new CursorElement
			{
				Name = "RESPEC PLAYER",
				Description = "Respec your player.",
				Action = delegate
				{
					Confirm("RESPEC PLAYER", "Do you really want to respec your player?", delegate
					{
						AdvancedCompany.Network.Manager.Send(new Respec
						{
							ClientID = GameNetworkManager.Instance.localPlayerController.playerClientId,
							Type = Perk.Type.PLAYER,
							Reset = false
						}, 0uL);
						SwitchTo(RespecMenu, RespecCursorMenu);
						AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
					}, delegate
					{
						SwitchTo(RespecMenu, RespecCursorMenu);
					});
				}
			});
			list3.Add(new CursorElement
			{
				Name = "RESET PLAYER",
				Description = "Reset the progress of your player.",
				Action = delegate
				{
					Confirm("RESET PLAYER", "Do you really want to RESET your player?", delegate
					{
						AdvancedCompany.Network.Manager.Send(new Respec
						{
							ClientID = GameNetworkManager.Instance.localPlayerController.playerClientId,
							Type = Perk.Type.PLAYER,
							Reset = true
						}, 0uL);
						SwitchTo(RespecMenu, RespecCursorMenu);
						AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
					}, delegate
					{
						SwitchTo(RespecMenu, RespecCursorMenu);
					});
				}
			});
			if (NetworkManager.Singleton.IsServer)
			{
				list3.Add(new CursorElement
				{
					Name = "RESPEC SHIP",
					Description = "Respec your ship.",
					Action = delegate
					{
						Confirm("RESPEC SHIP", "Do you really want to respec your ship?", delegate
						{
							AdvancedCompany.Network.Manager.Send(new Respec
							{
								ClientID = GameNetworkManager.Instance.localPlayerController.playerClientId,
								Type = Perk.Type.SHIP,
								Reset = false
							}, 0uL);
							SwitchTo(RespecMenu, RespecCursorMenu);
							AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
							AdvancedCompany.Patches.Terminal.UpdateMoonPrices();
						}, delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu);
						});
					}
				});
				list3.Add(new CursorElement
				{
					Name = "RESET SHIP",
					Description = "Reset the progress of your ship.",
					Action = delegate
					{
						Confirm("RESET SHIP", "Do you really want to RESET your ship?", delegate
						{
							AdvancedCompany.Network.Manager.Send(new Respec
							{
								ClientID = GameNetworkManager.Instance.localPlayerController.playerClientId,
								Type = Perk.Type.SHIP,
								Reset = true
							}, 0uL);
							SwitchTo(RespecMenu, RespecCursorMenu);
							AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
							AdvancedCompany.Patches.Terminal.UpdateMoonPrices();
						}, delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu);
						});
					}
				});
			}
			list3.Add(new CursorElement
			{
				Name = "BACK",
				Description = null,
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			RespecCursorMenu = new CursorMenu
			{
				Elements = list3
			};
			RespecMenu = new BoxedScreen
			{
				Title = "RESPEC",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select an action:"
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = RespecCursorMenu
					}
				}
			};
		}

		public static void Confirm(string title, string text, Action confirmAction, Action declineAction)
		{
			CursorMenu cursorMenu = new CursorMenu
			{
				Elements = new List<CursorElement>
				{
					new CursorElement
					{
						Name = "CONFIRM",
						Action = delegate
						{
							confirmAction();
						}
					},
					new CursorElement
					{
						Name = "DECLINE",
						Action = delegate
						{
							declineAction();
						}
					}
				}
			};
			BoxedScreen box = new BoxedScreen
			{
				Title = title,
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = text
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = cursorMenu
					}
				}
			};
			SwitchTo(box, cursorMenu, back: false);
		}

		public static void BuyPerk(Perk perk, Action backAction)
		{
			int num = 0;
			string title = "";
			bool flag = false;
			bool flag2 = false;
			int level = 0;
			if (perk.PerkType == Perk.Type.PLAYER)
			{
				title = "PLAYER PERKS";
				Player player = AdvancedCompany.Network.Manager.Lobby.Player();
				level = perk.GetLevel(player);
				if (level < perk.Levels)
				{
					level++;
					num = perk.GetNextPrice(player);
					flag2 = player.RemainingXP >= num;
				}
				else
				{
					flag = true;
				}
			}
			if (perk.PerkType == Perk.Type.SHIP)
			{
				title = "SHIP PERKS";
				Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
				level = perk.GetLevel(currentShip);
				if (level < perk.Levels)
				{
					level++;
					num = perk.GetNextPrice(currentShip);
					flag2 = currentShip.RemainingXP >= num;
				}
				else
				{
					flag = true;
				}
			}
			if (flag)
			{
				CursorMenu cursorMenu = new CursorMenu
				{
					Elements = new List<CursorElement>
					{
						new CursorElement
						{
							Name = "BACK",
							Action = delegate
							{
								backAction();
							}
						}
					}
				};
				BoxedScreen box = new BoxedScreen
				{
					Title = title,
					Content = new List<ITextElement>
					{
						new TextElement
						{
							Text = perk.DisplayDescription
						},
						new TextElement
						{
							Text = " "
						},
						new TextElement
						{
							Text = "This perk is already maxed out!"
						},
						new TextElement
						{
							Text = " "
						},
						new ScrollBox(13)
						{
							Content = cursorMenu
						}
					}
				};
				SwitchTo(box, cursorMenu, back: false);
				return;
			}
			if (!flag2)
			{
				CursorMenu cursorMenu2 = new CursorMenu
				{
					Elements = new List<CursorElement>
					{
						new CursorElement
						{
							Name = "BACK",
							Action = delegate
							{
								backAction();
							}
						}
					}
				};
				BoxedScreen box2 = new BoxedScreen
				{
					Title = title,
					Content = new List<ITextElement>
					{
						new TextElement
						{
							Text = perk.DisplayDescription
						},
						new TextElement
						{
							Text = " "
						},
						new TextElement
						{
							Text = "You can't afford this perk. You need " + num + "XP!"
						},
						new TextElement
						{
							Text = " "
						},
						new ScrollBox(13)
						{
							Content = cursorMenu2
						}
					}
				};
				SwitchTo(box2, cursorMenu2, back: false);
				return;
			}
			CursorMenu cursorMenu3 = new CursorMenu
			{
				Elements = new List<CursorElement>
				{
					new CursorElement
					{
						Name = "CONFIRM",
						Action = delegate
						{
							AdvancedCompany.Network.Manager.Send(new ChangePerk
							{
								ClientID = GameNetworkManager.Instance.localPlayerController.playerClientId,
								ID = perk.ID,
								Level = level
							}, 0uL);
							AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
							AdvancedCompany.Patches.Terminal.UpdateMoonPrices();
							backAction();
						}
					},
					new CursorElement
					{
						Name = "DECLINE",
						Action = delegate
						{
							backAction();
						}
					}
				}
			};
			BoxedScreen box3 = new BoxedScreen
			{
				Title = title,
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = perk.DisplayDescription
					},
					new TextElement
					{
						Text = " "
					},
					new TextElement
					{
						Text = "Do you want to buy this perk for " + num + "XP?"
					},
					new TextElement
					{
						Text = " "
					},
					new ScrollBox(13)
					{
						Content = cursorMenu3
					}
				}
			};
			SwitchTo(box3, cursorMenu3, back: false);
		}

		public static void SwitchTo(BoxedScreen box, CursorMenu menu, bool back = true)
		{
			if ((Object)(object)AdvancedCompany.Patches.Terminal.Instance != (Object)null)
			{
				AdvancedCompany.Patches.Terminal.ActiveScreen = box;
				AdvancedCompany.Patches.Terminal.ActiveCursorMenu = menu;
				if (!back)
				{
					menu.SelectedElement = 0;
				}
			}
		}

		public static void Open()
		{
			Update();
			SwitchTo(MainMenu, MainMenuCursorMenu, back: false);
			AdvancedCompany.Patches.Terminal._playerXP.SetActive(true);
			AdvancedCompany.Patches.Terminal._shipXP.SetActive(true);
			AdvancedCompany.Patches.Terminal.UpdateTerminalValues();
		}

		public static void Close()
		{
			if ((Object)(object)AdvancedCompany.Patches.Terminal.Instance != (Object)null)
			{
				AdvancedCompany.Patches.Terminal.ActiveCursorMenu = null;
				AdvancedCompany.Patches.Terminal.ActiveScreen = null;
				AdvancedCompany.Patches.Terminal.ClosingScreen = true;
			}
		}
	}
}
namespace AdvancedCompany.PostProcessing
{
	[Serializable]
	[LoadAssets]
	[VolumeComponentMenu("Post-processing/Custom/NightVision")]
	public sealed class NightVision : CustomPostProcessVolumeComponent, IPostProcessComponent
	{
		[Tooltip("Controls the intensity of the effect.")]
		public ClampedFloatParameter intensity = new ClampedFloatParameter(0f, 0f, 1f, false);

		private static Material Material;

		private Material m_Material;

		public override CustomPostProcessInjectionPoint injectionPoint => (CustomPostProcessInjectionPoint)2;

		public bool IsActive()
		{
			return (Object)(object)m_Material != (Object)null && ((VolumeParameter<float>)(object)intensity).value > 0f;
		}

		public static void LoadAssets(AssetBundle assets)
		{
			Material = assets.LoadAsset<Material>("Assets/Shaders/NightVision.mat");
		}

		public override void Setup()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			m_Material = new Material(Material);
		}

		public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_Material == (Object)null))
			{
				m_Material.SetFloat("_Intensity", ((VolumeParameter<float>)(object)intensity).value);
				m_Material.SetTexture("_MainTex", RTHandle.op_Implicit(source));
				cmd.Blit(RTHandle.op_Implicit(source), RTHandle.op_Implicit(destination), m_Material, 0);
			}
		}

		public override void Cleanup()
		{
			CoreUtils.Destroy((Object)(object)m_Material);
		}
	}
	public sealed class NightVisionEffect
	{
		private static GameObject LightAndFog;

		private static bool Active;

		private static float Phase;

		private static NightVision Instance;

		public static void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00b5: 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_00f7: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("NightVisionRenderVolume");
			Volume val2 = val.AddComponent<Volume>();
			val2.isGlobal = true;
			val2.priority = 1000f;
			VolumeProfile val3 = ScriptableObject.CreateInstance<VolumeProfile>();
			((Object)val3).name = "NightVisionProfile";
			Instance = val3.Add<NightVision>(true);
			((Object)Instance).name = "NightVision";
			((VolumeComponent)Instance).active = true;
			val2.sharedProfile = val3;
			Player player = Player.GetPlayer(GameNetworkManager.Instance.localPlayerController);
			LightAndFog = new GameObject("NightVisionLight");
			LightAndFog.transform.parent = player.GetBone(Player.Bone.METARIG);
			LightAndFog.transform.localPosition = new Vector3(0f, 0f, 0.5f);
			LightAndFog.transform.localRotation = Quaternion.identity;
			LocalVolumetricFog val4 = LightAndFog.AddComponent<LocalVolumetricFog>();
			val4.parameters.size = new Vector3(50f, 50f, 50f);
			val4.parameters.falloffMode = (LocalVolumetricFogFalloffMode)1;
			val4.parameters.blendingMode = (LocalVolumetricFogBlendingMode)0;
			val4.parameters.anisotropy = 25f;
			val4.parameters.meanFreePath = 25f;
			GameObject val5 = new GameObject("Light1");
			val5.transform.parent = LightAndFog.transform;
			val5.transform.localPosition = new Vector3(8f, 9.1f, -1.5f);
			val5.transform.localRotation = Quaternion.Euler(50f, -61f, -68f);
			Light val6 = val5.AddComponent<Light>();
			val6.color = new Color(0f, 1f, 0f);
			val6.type = (LightType)0;
			val6.shape = (LightShape)2;
			val6.cullingMask = 2147483519;
			HDAdditionalLightData val7 = val5.AddComponent<HDAdditionalLightData>();
			val7.SetBoxSpotSize(new Vector2(500f, 500f));
			val7.SetIntensity(100f, (LightUnit)2);
			val7.spotLightShape = (SpotLightShape)2;
			val7.affectsVolumetric = true;
			val7.volumetricDimmer = 0.1f;
			val7.range = 1000f;
			val7.lightDimmer = 1f;
			val7.SetCullingMask(2147483519);
			GameObject val8 = new GameObject("Light2");
			val8.transform.parent = LightAndFog.transform;
			val8.transform.localPosition = new Vector3(8f, 6.5f, 8f);
			val8.transform.localRotation = Quaternion.Euler(56f, 114f, 110f);
			Light val9 = val8.AddComponent<Light>();
			val9.color = new Color(0f, 1f, 0f);
			val9.type = (LightType)0;
			val9.shape = (LightShape)2;
			val9.cullingMask = 2147483519;
			HDAdditionalLightData val10 = val8.AddComponent<HDAdditionalLightData>();
			val10.SetBoxSpotSize(new Vector2(500f, 500f));
			val10.SetIntensity(100f, (LightUnit)2);
			val10.spotLightShape = (SpotLightShape)2;
			val10.SetCullingMask(2147483519);
			val10.affectsVolumetric = true;
			val10.volumetricDimmer = 0.1f;
			val10.range = 1000f;
			val10.lightDimmer = 1f;
			LightAndFog.SetActive(false);
		}

		public static void Activate()
		{
			Active = true;
		}

		public static void Deactivate()
		{
			Active = false;
		}

		public static void Update()
		{
			if (Active)
			{
				Phase = Mathf.Clamp01(Phase + Time.deltaTime * 2f);
			}
			else
			{
				Phase = Mathf.Clamp01(Phase - Time.deltaTime * 5f);
			}
			if ((Object)(object)Instance != (Object)null)
			{
				if (((VolumeParameter<float>)(object)Instance.intensity).value != Phase)
				{
					((VolumeParameter<float>)(object)Instance.intensity).value = Phase;
				}
				if (Phase > 0f && !LightAndFog.activeSelf)
				{
					MeshRenderer component = ((Component)GameNetworkManager.Instance.localPlayerController.localVisor.GetChild(0)).GetComponent<MeshRenderer>();
					((Renderer)component).materials[2].SetFloat("_Metallic", 1f);
					((Renderer)component).materials[2].SetFloat("_Smoothness", 0f);
					LightAndFog.SetActive(true);
				}
				if (Phase <= 0f && LightAndFog.activeSelf)
				{
					MeshRenderer component2 = ((Component)GameNetworkManager.Instance.localPlayerController.localVisor.GetChild(0)).GetComponent<MeshRenderer>();
					((Renderer)component2).materials[2].SetFloat("_Metallic", 0.69f);
					((Renderer)component2).materials[2].SetFloat("_Smoothness", 0.5f);
					LightAndFog.SetActive(false);
				}
			}
		}
	}
}
namespace AdvancedCompany.Patches
{
	[LoadAssets]
	[HarmonyPatch]
	public class AnimationPatches
	{
		private static RuntimeAnimatorController PlayerAnimator;

		private static RuntimeAnimatorController OtherPlayerAnimator;

		public static void LoadAssets(AssetBundle assets)
		{
			PlayerAnimator = assets.LoadAsset<RuntimeAnimatorController>("Assets/Animators/metarig.controller");
			OtherPlayerAnimator = assets.LoadAsset<RuntimeAnimatorController>("Assets/Animators/metarigOtherPlayers.controller");
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPrefix]
		private static void Initialize(StartOfRound __instance)
		{
			__instance.otherClientsAnimatorController = OtherPlayerAnimator;
			__instance.localClientAnimatorController = PlayerAnimator;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Awake")]
		[HarmonyPostfix]
		public static void Awake(PlayerControllerB __instance)
		{
			__instance.playerBodyAnimator.runtimeAnimatorController = OtherPlayerAnimator;
		}
	}
	[HarmonyPatch]
	internal class BalancingPatches
	{
		public static float BaseValueMultiplier = 0.4f;

		[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
		[HarmonyPrefix]
		public static void ChangeMaxScrapValue(RoundManager __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Invalid comparison between Unknown and I4
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Invalid comparison between Unknown and I4
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Invalid comparison between Unknown and I4
			if (!ServerConfiguration.Instance.Moons.DeactivateWeatherMultipliers)
			{
				if ((int)__instance.currentLevel.currentWeather == 1)
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.RainyScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.RainyScrapValueMultiplier * BaseValueMultiplier;
				}
				else if ((int)__instance.currentLevel.currentWeather == 3)
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.FoggyScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.FoggyScrapValueMultiplier * BaseValueMultiplier;
				}
				else if ((int)__instance.currentLevel.currentWeather == 4)
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.FloodedScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.FloodedScrapValueMultiplier * BaseValueMultiplier;
				}
				else if ((int)__instance.currentLevel.currentWeather == 2)
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.StormyScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.StormyScrapValueMultiplier * BaseValueMultiplier;
				}
				else if ((int)__instance.currentLevel.currentWeather == 5)
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.EclipsedScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.EclipsedScrapValueMultiplier * BaseValueMultiplier;
				}
				else
				{
					__instance.scrapAmountMultiplier = ServerConfiguration.Instance.Moons.ClearScrapAmountMultiplier;
					__instance.scrapValueMultiplier = ServerConfiguration.Instance.Moons.ClearScrapValueMultiplier * BaseValueMultiplier;
				}
			}
		}
	}
	[HarmonyPatch]
	public class DebugPatches
	{
	}
	[HarmonyPatch]
	internal class EnemyAICollisionDetect
	{
		[HarmonyPatch(typeof(EnemyAICollisionDetect), "IHittable.Hit")]
		[HarmonyPrefix]
		private static void Hit(ref int force, Vector3 hitDirection, PlayerControllerB playerWhoHit, bool playHitSFX)
		{
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)playerWhoHit && Random.value < Perks.GetMultiplier("DealDamage"))
			{
				force += 100;
			}
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	public class Flavour
	{
		private static Sprite Logo;

		private static Image HeaderImage;

		private static Image LoadImage;

		[HarmonyPatch(typeof(MenuManager), "Update")]
		[HarmonyPostfix]
		public static void Update()
		{
			if ((Object)(object)HeaderImage == (Object)null)
			{
				GameObject obj = GameObject.Find("HeaderImage");
				HeaderImage = ((obj != null) ? obj.GetComponent<Image>() : null) ?? null;
			}
			if ((Object)(object)LoadImage == (Object)null)
			{
				GameObject val = GameObject.Find("MenuContainer");
				for (int i = 0; i < val.transform.childCount; i++)
				{
					Transform child = val.transform.GetChild(i);
					if (!(((Object)child).name == "LoadingScreen"))
					{
						continue;
					}
					for (int j = 0; j < ((Component)child).transform.childCount; j++)
					{
						Transform child2 = ((Component)child).transform.GetChild(j);
						if (((Object)child2).name == "Image")
						{
							LoadImage = ((Component)child2).GetComponent<Image>();
						}
					}
					break;
				}
			}
			if ((Object)(object)HeaderImage != (Object)null && (Object)(object)HeaderImage.sprite != (Object)(object)Logo)
			{
				HeaderImage.sprite = Logo;
			}
			if ((Object)(object)LoadImage != (Object)null && (Object)(object)LoadImage.sprite != (Object)(object)Logo)
			{
				LoadImage.sprite = Logo;
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			Logo = assets.LoadAsset<Sprite>("Assets/Icons/Logo.png");
		}
	}
	[HarmonyPatch]
	internal class GameNetworkManager
	{
		public static string KickReason;

		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientConnectedCallback")]
		[HarmonyPrefix]
		private static void Singleton_OnClientConnectedCallback(GameNetworkManager __instance, ulong clientId)
		{
			AdvancedCompany.Network.Manager.NetworkManager_OnClientConnectedCallback(clientId);
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void Start(GameNetworkManager __instance)
		{
			AdvancedCompany.Network.Manager.Initialize();
			AdvancedCompany.Network.Manager.OnKicked = (AdvancedCompany.Network.Manager.Kicked)Delegate.Combine(AdvancedCompany.Network.Manager.OnKicked, (AdvancedCompany.Network.Manager.Kicked)delegate(string reason)
			{
				KickReason = reason;
			});
			AdvancedCompany.Network.Manager.OnLobbyCreated = (AdvancedCompany.Network.Manager.LobbyCreated)Delegate.Combine(AdvancedCompany.Network.Manager.OnLobbyCreated, (AdvancedCompany.Network.Manager.LobbyCreated)delegate
			{
				Player player2 = Player.GetPlayer(GameNetworkManager.Instance.localPlayerController);
				player2.LoadLocal();
				ServerConfiguration.Instance.LoadFromPreset(FileConfiguration.Instance);
				Lobby lobby = (AdvancedCompany.Network.Manager.Lobby = new Lobby
				{
					CurrentShip = Ship.Load(GameNetworkManager.Instance.currentSaveFileName),
					ConnectedPlayers = new Dictionary<ulong, Player> { { 0uL, player2 } }
				});
				ApplyConfiguration();
				Handshake handshake2 = new Handshake
				{
					ModVersion = "1.0.10",
					Player = player2
				};
				lobby.PlayerConnected(handshake2);
			});
			AdvancedCompany.Network.Manager.OnConnected = (AdvancedCompany.Network.Manager.Connected)Delegate.Combine(AdvancedCompany.Network.Manager.OnConnected, (AdvancedCompany.Network.Manager.Connected)delegate
			{
				Player player = Player.GetPlayer(GameNetworkManager.Instance.localPlayerController);
				player.LoadLocal();
				Handshake handshake = new Handshake
				{
					Player = player
				};
				Plugin.Log.LogMessage((object)("Sending handshake (" + player.ClientID + "):"));
				AdvancedCompany.Network.Manager.SendHandshake(handshake);
			});
			AdvancedCompany.Network.Manager.OnReceivedLobby = (AdvancedCompany.Network.Manager.ReceivedLobby)Delegate.Combine(AdvancedCompany.Network.Manager.OnReceivedLobby, (AdvancedCompany.Network.Manager.ReceivedLobby)delegate
			{
				ApplyConfiguration();
			});
		}

		public static void ApplyConfiguration()
		{
			Player player = Player.GetPlayer(GameNetworkManager.Instance.localPlayerController);
			bool flag = player.RemainingXP < 0;
			if (!flag)
			{
				foreach (Perk item in Perk.PerksByType(Perk.Type.PLAYER))
				{
					if (player.Levels.ContainsKey(item.ID) && player.Levels[item.ID] > 0 && (!item.IsActive || player.Levels[item.ID] > item.Levels))
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				AdvancedCompany.Network.Manager.Send(new Respec
				{
					ClientID = player.ClientID,
					Reset = false,
					Type = Perk.Type.PLAYER
				}, 0uL);
			}
			InventoryPatches.ArrangeHotbar(Perks.InventorySlotsOf(GameNetworkManager.Instance.localPlayerController));
			Perks.GameStarted();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
		[HarmonyPostfix]
		public static void SaveItemsInShip(GameNetworkManager __instance)
		{
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		private static void Disconnect(GameNetworkManager __instance)
		{
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SaveGame")]
		[HarmonyPrefix]
		private static void Save(GameNetworkManager __instance)
		{
			try
			{
				AdvancedCompany.Network.Manager.Lobby.Player().SaveLocal();
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(__instance.currentSaveFileName);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "ResetUnlockablesListValues")]
		[HarmonyPrefix]
		private static bool ResetClone(GameNetworkManager __instance)
		{
			//IL_006f: 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_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)
			if (!((Object)(object)StartOfRound.Instance != (Object)null))
			{
				return true;
			}
			List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
			for (int i = 0; i < unlockables.Count; i++)
			{
				if (unlockables[i].unlockableType != 0)
				{
					unlockables[i].hasBeenUnlockedByPlayer = false;
				}
				if (unlockables[i].unlockableType == 1)
				{
					unlockables[i].placedPosition = Vector3.zero;
					unlockables[i].placedRotation = Vector3.zero;
					unlockables[i].hasBeenMoved = false;
					unlockables[i].inStorage = false;
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal class GrabbableObject
	{
		private static IEnumerable<CodeInstruction> PatchUpdate(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogMessage((object)"Patching GrabbableObject->Update...");
			PropertyInfo property = typeof(Perks).GetProperty("ExtraBatteryMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single batteryUsage")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ExtraBattery", list, i + 1);
					break;
				}
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(GrabbableObject), "Update")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase method)
		{
			if (method.Name == "Update")
			{
				return PatchUpdate(instructions);
			}
			return instructions;
		}
	}
	[HarmonyPatch]
	internal class HUDManager
	{
		[HarmonyPatch(typeof(HUDManager), "MeetsScanNodeRequirements")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMeetsScanNodeRequirements(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogMessage((object)"Patching HUDManager->MeetsScanNodeRequirements...");
			PropertyInfo property = typeof(Perks).GetProperty("ScanDistanceMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Int32 maxRange")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ScanDistance", list, i + 2);
					break;
				}
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	[Requires(typeof(ClientConfiguration))]
	[Bootable]
	public class InventoryPatches
	{
		public enum InventoryType
		{
			INVENTORY,
			HELMET,
			BODY,
			SHOES
		}

		private static InputAction InventorySlot1Action;

		private static InputAction InventorySlot2Action;

		private static InputAction InventorySlot3Action;

		private static InputAction InventorySlot4Action;

		private static InputAction InventorySlot5Action;

		private static InputAction InventorySlot6Action;

		private static InputAction InventorySlot7Action;

		private static InputAction InventorySlot8Action;

		private static InputAction InventorySlot9Action;

		private static InputAction InventorySlot10Action;

		private static InputAction FlashlightAction;

		private static InputAction NightVisionAction;

		public const int MAX_INVENTORY = 10;

		public static Image HelmetImage;

		public static Image BodyImage;

		public static Image ShoesImage;

		private static FieldInfo IsSendingItemRPCField = typeof(GrabbableObject).GetField("isSendingItemRPC", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static MethodInfo ActivateItemServerRpcMethod = typeof(GrabbableObject).GetMethod("ActivateItemServerRpc", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo FlashlightPreviousPlayerHeldBy = typeof(FlashlightItem).GetField("previousPlayerHeldBy", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static int OwnItemSlotResult;

		public static FieldInfo TimeSinceSwitchingSlotsField = AccessTools.Field(typeof(PlayerControllerB), "timeSinceSwitchingSlots");

		public static FieldInfo ThrowingObjectField = AccessTools.Field(typeof(PlayerControllerB), "throwingObject");

		public static MethodInfo NextItemMethod = AccessTools.Method(typeof(PlayerControllerB), "NextItemSlot", (Type[])null, (Type[])null);

		public static MethodInfo SwitchToItemSlotMethod = AccessTools.Method(typeof(PlayerControllerB), "SwitchToItemSlot", (Type[])null, (Type[])null);

		private static GameObject EnergyPrefab;

		private static AnimationClip EquipmentFrameAnimation;

		private static AnimationClip EquipmentFrameEnlargeAnimation;

		private static Sprite HelmetIcon;

		private static Sprite BodyIcon;

		private static Sprite ShoesIcon;

		private static GameObject[] EnergyBars = (GameObject[])(object)new GameObject[10];

		private static RectTransform[] EnergyInnerBars = (RectTransform[])(object)new RectTransform[10];

		private static GameObject ScaleCompensator;

		private static Transform Inventory;

		private static float PreviousAnchorMax = 0f;

		private static float PreviousWidth = 0f;

		private static bool UpdateNextFrame = false;

		private static FieldInfo CurrentlyGrabbingObjectField = typeof(PlayerControllerB).GetField("currentlyGrabbingObject", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static GrabbableObject HoveringObject;

		public static bool EquipmentSlotsAvailable => ServerConfiguration.Instance.Items.RocketBoots.Active || ServerConfiguration.Instance.Items.BulletProofVest.Active || ServerConfiguration.Instance.Items.NightVision.Active || ServerConfiguration.Instance.Items.SwimmingFins.Active;

		public static void Boot()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Expected O, but got Unknown
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Expected O, but got Unknown
			InventorySlot1Action = new InputAction("InventorySlot1", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot1, (string)null, (string)null, (string)null);
			InventorySlot1Action.performed += delegate
			{
				ChangeToInventorySlot(0);
			};
			InventorySlot1Action.Enable();
			InventorySlot2Action = new InputAction("InventorySlot2", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot2, (string)null, (string)null, (string)null);
			InventorySlot2Action.performed += delegate
			{
				ChangeToInventorySlot(1);
			};
			InventorySlot2Action.Enable();
			InventorySlot3Action = new InputAction("InventorySlot3", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot3, (string)null, (string)null, (string)null);
			InventorySlot3Action.performed += delegate
			{
				ChangeToInventorySlot(2);
			};
			InventorySlot3Action.Enable();
			InventorySlot4Action = new InputAction("InventorySlot4", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot4, (string)null, (string)null, (string)null);
			InventorySlot4Action.performed += delegate
			{
				ChangeToInventorySlot(3);
			};
			InventorySlot4Action.Enable();
			InventorySlot5Action = new InputAction("InventorySlot5", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot5, (string)null, (string)null, (string)null);
			InventorySlot5Action.performed += delegate
			{
				ChangeToInventorySlot(4);
			};
			InventorySlot5Action.Enable();
			InventorySlot6Action = new InputAction("InventorySlot6", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot6, (string)null, (string)null, (string)null);
			InventorySlot6Action.performed += delegate
			{
				ChangeToInventorySlot(5);
			};
			InventorySlot6Action.Enable();
			InventorySlot7Action = new InputAction("InventorySlot7", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot7, (string)null, (string)null, (string)null);
			InventorySlot7Action.performed += delegate
			{
				ChangeToInventorySlot(6);
			};
			InventorySlot7Action.Enable();
			InventorySlot8Action = new InputAction("InventorySlot8", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot8, (string)null, (string)null, (string)null);
			InventorySlot8Action.performed += delegate
			{
				ChangeToInventorySlot(7);
			};
			InventorySlot8Action.Enable();
			InventorySlot9Action = new InputAction("InventorySlot9", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot9, (string)null, (string)null, (string)null);
			InventorySlot9Action.performed += delegate
			{
				ChangeToInventorySlot(8);
			};
			InventorySlot9Action.Enable();
			InventorySlot10Action = new InputAction("InventorySlot10", (InputActionType)1, ClientConfiguration.Instance.Keybinds.InventorySlot10, (string)null, (string)null, (string)null);
			InventorySlot10Action.performed += delegate
			{
				ChangeToInventorySlot(9);
			};
			InventorySlot10Action.Enable();
			FlashlightAction = new InputAction("Flashlight", (InputActionType)1, ClientConfiguration.Instance.Keybinds.Flashlight, (string)null, (string)null, (string)null);
			if (ClientConfiguration.Instance.Keybinds.Flashlight != ClientConfiguration.Instance.Keybinds.NightVision)
			{
				NightVisionAction = new InputAction("NightVision", (InputActionType)1, ClientConfiguration.Instance.Keybinds.NightVision, (string)null, (string)null, (string)null);
				NightVisionAction.performed += delegate
				{
					ToggleNightVision();
				};
				NightVisionAction.Enable();
				FlashlightAction.performed += delegate
				{
					ToggleFlashlight(ignoreHead: true);
				};
			}
			else
			{
				FlashlightAction.performed += delegate
				{
					ToggleFlashlight();
				};
			}
			FlashlightAction.Enable();
			AdvancedCompany.Network.Manager.AddListener(delegate(SwitchItem msg)
			{
				try
				{
					PlayerControllerB[] allPlayerScripts2 = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val7 in allPlayerScripts2)
					{
						if (val7.playerClientId == msg.ClientID)
						{
							Plugin.Log.LogMessage((object)("Found client, switch to item " + msg.Slot));
							SwitchToItemSlotMethod.Invoke(val7, new object[2] { msg.Slot, null });
							break;
						}
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)ex2);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangeItemSlot msg)
			{
				try
				{
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val4 in allPlayerScripts)
					{
						if ((val4.isPlayerControlled || val4.isHostPlayerObject) && val4.playerClientId == msg.ClientID)
						{
							if ((Object)(object)val4.ItemSlots[msg.FromSlot] != (Object)null)
							{
								GrabbableObject val5 = val4.ItemSlots[msg.FromSlot];
								GrabbableObject val6 = val4.ItemSlots[msg.ToSlot];
								if ((Object)(object)val4 == (Object)(object)GameNetworkManager.Instance.localPlayerController)
								{
									Sprite sprite = HUDManager.Instance.itemSlotIcons[msg.ToSlot].sprite;
									bool enabled = ((Behaviour)HUDManager.Instance.itemSlotIcons[msg.ToSlot]).enabled;
									HUDManager.Instance.itemSlotIcons[msg.ToSlot].sprite = HUDManager.Instance.itemSlotIcons[msg.FromSlot].sprite;
									((Behaviour)HUDManager.Instance.itemSlotIcons[msg.ToSlot]).enabled = ((Behaviour)HUDManager.Instance.itemSlotIcons[msg.FromSlot]).enabled;
									HUDManager.Instance.itemSlotIcons[msg.FromSlot].sprite = sprite;
									((Behaviour)HUDManager.Instance.itemSlotIcons[msg.FromSlot]).enabled = enabled;
								}
								val4.ItemSlots[msg.FromSlot] = val6;
								val4.ItemSlots[msg.ToSlot] = val5;
								SwitchToItemSlotMethod.Invoke(val4, new object[2] { val4.currentItemSlot, null });
							}
							break;
						}
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)ex);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(UseFlashlight msg)
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				Player playerByClientID = Player.GetPlayerByClientID(msg.ClientID);
				if (playerByClientID != null)
				{
					Plugin.Log.LogMessage((object)"Flashlight: Found player");
					GrabbableObject val = playerByClientID.Controller.ItemSlots[msg.Slot];
					if ((Object)(object)val != (Object)null)
					{
						FlashlightItem val2 = (FlashlightItem)(object)((val is FlashlightItem) ? val : null);
						if (val2 != null)
						{
							Plugin.Log.LogMessage((object)("Flashlight: Found flashlight on slot " + msg.Slot));
							val2.flashlightAudio.PlayOneShot(val2.flashlightClips[Random.Range(0, val2.flashlightClips.Length)]);
							RoundManager.Instance.PlayAudibleNoise(((Component)val2).transform.position, 7f, 0.4f, 0, ((GrabbableObject)val2).isInElevator && StartOfRound.Instance.hangarDoorsClosed, 0);
							if (val2.flashlightInterferenceLevel < 2)
							{
								Plugin.Log.LogMessage((object)"Flashlight: Turning flashlight");
								if (!((GrabbableObject)val2).isBeingUsed)
								{
									for (int i = 0; i < playerByClientID.Controller.ItemSlots.Length; i++)
									{
										if (i != msg.Slot && (Object)(object)playerByClientID.Controller.ItemSlots[i] != (Object)null)
										{
											GrabbableObject obj2 = playerByClientID.Controller.ItemSlots[i];
											FlashlightItem val3 = (FlashlightItem)(object)((obj2 is FlashlightItem) ? obj2 : null);
											if (val3 != null)
											{
												if (((NetworkBehaviour)val3).IsOwner)
												{
													Plugin.Log.LogMessage((object)("Flashlight: Deactivating flashlight helmet light on " + i));
													if ((Object)(object)((GrabbableObject)val3).playerHeldBy != (Object)null)
													{
														((GrabbableObject)val3).playerHeldBy.ChangeHelmetLight(val3.flashlightTypeID, false);
													}
												}
												if (((GrabbableObject)val3).isBeingUsed)
												{
													Plugin.Log.LogMessage((object)("Flashlight: Deactivating flashlight on slot " + i));
													((GrabbableObject)val3).isBeingUsed = false;
													((Behaviour)val3.flashlightBulb).enabled = false;
													((Behaviour)val3.flashlightBulbGlow).enabled = false;
													if (val3.usingPlayerHelmetLight && (Object)(object)((GrabbableObject)val3).playerHeldBy != (Object)null)
													{
														((Behaviour)((GrabbableObject)val3).playerHeldBy.helmetLight).enabled = false;
													}
													if (val3.changeMaterial)
													{
														Material[] sharedMaterials = ((Renderer)val3.flashlightMesh).sharedMaterials;
														sharedMaterials[1] = val3.bulbDark;
														((Renderer)val3.flashlightMesh).sharedMaterials = sharedMaterials;
													}
												}
											}
										}
									}
								}
								if (!((GrabbableObject)val2).isBeingUsed && ((GrabbableObject)val2).insertedBattery != null && ((GrabbableObject)val2).insertedBattery.charge > 0f)
								{
									((GrabbableObject)val2).isBeingUsed = true;
								}
								else
								{
									((GrabbableObject)val2).isBeingUsed = false;
								}
								if (playerByClientID.Controller.currentItemSlot == msg.Slot)
								{
									Plugin.Log.LogMessage((object)"Flashlight: Flashlight is held");
									FlashlightPreviousPlayerHeldBy.SetValue(val2, ((GrabbableObject)val2).playerHeldBy);
									((GrabbableObject)val2).playerHeldBy.ChangeHelmetLight(val2.flashlightTypeID, true);
									((Behaviour)((GrabbableObject)val2).playerHeldBy.helmetLight).enabled = false;
									val2.usingPlayerHelmetLight = false;
									if (!((NetworkBehaviour)val2).IsOwner)
									{
										((GrabbableObject)val2).playerHeldBy.ChangeHelmetLight(val2.flashlightTypeID, ((GrabbableObject)val2).isBeingUsed);
										((Behaviour)val2.flashlightBulb).enabled = false;
										((Behaviour)val2.flashlightBulbGlow).enabled = false;
									}
									else
									{
										((Behaviour)val2.flashlightBulb).enabled = ((GrabbableObject)val2).isBeingUsed;
										((Behaviour)val2.flashlightBulbGlow).enabled = ((GrabbableObject)val2).isBeingUsed;
									}
									if (val2.changeMaterial)
									{
										Material[] sharedMaterials2 = ((Renderer)val2.flashlightMesh).sharedMaterials;
										if (((GrabbableObject)val2).isBeingUsed)
										{
											sharedMaterials2[1] = val2.bulbLight;
										}
										else
										{
											sharedMaterials2[1] = val2.bulbDark;
										}
										((Renderer)val2.flashlightMesh).sharedMaterials = sharedMaterials2;
									}
								}
								else
								{
									Plugin.Log.LogMessage((object)"Flashlight: Flashlight is pocketed");
									((Behaviour)val2.flashlightBulb).enabled = false;
									((Behaviour)val2.flashlightBulbGlow).enabled = false;
									((GrabbableObject)val2).playerHeldBy.ChangeHelmetLight(val2.flashlightTypeID, true);
									if (!((NetworkBehaviour)val2).IsOwn