using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CompetitiveCompany;
using CompetitiveCompany.Compat;
using CompetitiveCompany.Game;
using CompetitiveCompany.NetcodePatcher;
using CompetitiveCompany.UI;
using CompetitiveCompany.Util;
using FlowTween;
using GameNetcodeStuff;
using HarmonyLib;
using IL;
using IL.GameNetcodeStuff;
using LethalAPI.LibTerminal;
using LethalAPI.LibTerminal.Attributes;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using Newtonsoft.Json;
using On;
using On.GameNetcodeStuff;
using RuntimeNetcodeRPCValidator;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("CompetitiveCompany")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+cc25a41a846858a13b8048296e53c14accd96bfc")]
[assembly: AssemblyProduct("CompetitiveCompany")]
[assembly: AssemblyTitle("CompetitiveCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<Player.TeamRef>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<Player.TeamRef>();
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkedSettings>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<NetworkedSettings>();
		NetworkVariableSerializationTypes.InitializeSerializer_FixedString<FixedString128Bytes>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<FixedString128Bytes>();
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<Color>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<Color>();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CompetitiveCompany
{
	internal static class Assets
	{
		public static AssetBundle Bundle { get; }

		public static RoundReport RoundReportPrefab { get; }

		public static MatchEndScreen MatchEndScreenPrefab { get; }

		public static Material TeamSuitMaterial { get; }

		static Assets()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			location = Path.GetDirectoryName(location);
			location = Path.Combine(location, "competitive-company");
			Bundle = AssetBundle.LoadFromFile(location);
			GameObject val = Bundle.LoadAsset<GameObject>("Assets/CC2/Prefabs/RoundReport.prefab");
			RoundReportPrefab = val.GetComponent<RoundReport>();
			val = Bundle.LoadAsset<GameObject>("Assets/CC2/Prefabs/MatchEndScreen.prefab");
			MatchEndScreenPrefab = val.GetComponent<MatchEndScreen>();
			TeamSuitMaterial = Bundle.LoadAsset<Material>("Assets/CC2/Materials/TeamSuit.mat");
		}

		public static void Load()
		{
		}
	}
	public class Config
	{
		public Keybinds Keybinds { get; } = new Keybinds();


		public ConfigEntry<bool> ForceSuits { get; } = file.Bind<bool>("General", "ForceSuits", true, "Whether to force players to wear suits according to their team's color.");


		public ConfigEntry<bool> FriendlyFire { get; } = file.Bind<bool>("General", "FriendlyFire", false, "Whether players can damage their teammates.");


		public ConfigEntry<int> NumberOfRounds { get; } = file.Bind<int>("General", "NumberOfRounds", 3, new ConfigDescription("Number of rounds to play before the game ends.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 25), Array.Empty<object>()));


		public ConfigEntry<float> ShipSafeRadius { get; } = file.Bind<float>("General", "ShipSafeRadius", 20f, "The radius in meters around the ship's center where players can't damage eachother.\nBoth the attacker and the victim are required to be outside the radius for damage to be dealt.\nFor scale, the distance to the edge of the ship's balcony is about 13 meters.The entrance to Experimentation is approximately 100 meters away.");


		public ConfigEntry<bool> DisableAutoPilot { get; } = file.Bind<bool>("General", "DisableAutoPilot", true, "Whether to disable the \"vote-to-leave\" spectator vote.");


		public ConfigEntry<float> MinLeaveTime { get; } = file.Bind<float>("General", "MinimumLeaveTime", 15f, new ConfigDescription("The earliest in-game time a player can pull the lever to starting leaving the current moon.Specified in hours on a 24-hour clock (the ship arrives at 8 and leaves at 24).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(8f, 24f), Array.Empty<object>()));


		public ConfigEntry<float> TimeToLeave { get; } = file.Bind<float>("General", "TimeToLeave", 3f, new ConfigDescription("How many in-game hours it takes for the ship to leave after the lever is pulled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 16f), Array.Empty<object>()));


		public ConfigEntry<Permission> JoinTeamPerm { get; } = file.Bind<Permission>("Permissions", "JoinTeam", Permission.Everyone, "Who can use the 'join' command.");


		public ConfigEntry<Permission> EditTeamPerm { get; } = file.Bind<Permission>("Permissions", "EditTeam", Permission.Everyone, "Who can use the 'set-team-color' and 'set-team-name' commands.");


		public ConfigEntry<Permission> CreateAndDeleteTeamPerm { get; } = file.Bind<Permission>("Permissions", "CreateAndDeleteTeam", Permission.HostOnly, "Who can use the 'create-team' and 'delete-team' commands.");


		public ConfigEntry<bool> ShowMouseOnRoundReport { get; } = file.Bind<bool>("Client", "ShowMouseOnRoundReport", false, "If true, you can use the mouse while the round report is shown.If false, the mouse will be locked and hidden and the report will close after a set time.");


		public ConfigEntry<bool> ShowEndOfMatchCutscene { get; } = file.Bind<bool>("Client", "ShowEndOfMatchCutscene", true, "Whether to show a special cutscene after the last round of the match or just another round report.");


		public ConfigEntry<Emote> EndOfMatchEmote { get; } = file.Bind<Emote>("Client", "EndOfMatchEmote", Emote.Dance, "The emote to play at the end of the match. Only Dance and Point are available unless BetterEmotes by KlutzyBubbles is installed.");


		public Config(ConfigFile file)
		{
		}//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Expected O, but got Unknown

	}
	public enum Permission : byte
	{
		Everyone,
		HostOnly
	}
	internal class SpectatorController : MonoBehaviour
	{
		private const float CamMoveSpeed = 5f;

		private readonly Light[] _lights = (Light[])(object)new Light[4];

		private PlayerControllerB _localPlayer;

		private Camera _cam;

		private InputAction _upAction;

		private InputAction _downAction;

		private InputAction _sprintAction;

		private InputAction _moveAction;

		private bool _controlsHidden = true;

		public static SpectatorController Instance { get; private set; }

		public static void Spawn()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			GameObject val = new GameObject("SpectatorController", new Type[3]
			{
				typeof(Camera),
				typeof(SpectatorController),
				typeof(AudioListener)
			});
			Object.DontDestroyOnLoad((Object)(object)val);
		}

		private void Awake()
		{
			//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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			for (int i = 0; i < 4; i++)
			{
				Vector3 eulerAngles = (Vector3)(i switch
				{
					0 => new Vector3(50f, 0f, 0f), 
					1 => new Vector3(120f, 0f, 0f), 
					2 => new Vector3(50f, 90f, 0f), 
					3 => new Vector3(50f, -90f, 0f), 
					_ => default(Vector3), 
				});
				GameObject val = new GameObject("GhostLight" + i);
				Light val2 = val.AddComponent<Light>();
				HDAdditionalLightData val3 = val.AddComponent<HDAdditionalLightData>();
				val.transform.eulerAngles = eulerAngles;
				val2.type = (LightType)1;
				val2.shadows = (LightShadows)0;
				val2.intensity = 10f;
				((Object)val).hideFlags = (HideFlags)52;
				val3.affectsVolumetric = false;
				_lights[i] = val2;
			}
			InputActionAsset actions = IngamePlayerSettings.Instance.playerInput.actions;
			_upAction = actions.FindAction("Jump", false);
			_downAction = actions.FindAction("Crouch", false);
			_sprintAction = actions.FindAction("Sprint", false);
			_moveAction = actions.FindAction("Move", false);
			_cam = ((Component)this).GetComponent<Camera>();
			DisableCam();
		}

		public void EnableCam()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(true);
				((Component)this).transform.parent = null;
				StartOfRound instance = StartOfRound.Instance;
				Camera activeCamera = instance.activeCamera;
				_cam.CopyFrom(activeCamera);
				int num = LayerMask.NameToLayer("HelmetVisor");
				Camera cam = _cam;
				cam.cullingMask &= ~(1 << num);
				Camera cam2 = _cam;
				cam2.cullingMask |= 0x800000;
				((Component)this).transform.position = ((Component)activeCamera).transform.position;
				((Component)this).transform.rotation = ((Component)activeCamera).transform.rotation;
				instance.localPlayerController.ChangeAudioListenerToObject(((Component)this).gameObject);
				((Behaviour)instance.localPlayerController.gameplayCamera).enabled = false;
				instance.SwitchCamera(_cam);
				UpdateControlText();
				Log.Debug("Spectator camera enabled!");
			}
		}

		public void DisableCam()
		{
			if (((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(false);
				Light[] lights = _lights;
				foreach (Light val in lights)
				{
					((Behaviour)val).enabled = false;
				}
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.ClearControlTips();
				}
			}
		}

		private void UpdateControlText()
		{
			Keybinds keybinds = Plugin.Config.Keybinds;
			InputActionAsset actions = IngamePlayerSettings.Instance.playerInput.actions;
			if (_controlsHidden)
			{
				HUDManager.Instance.ChangeControlTip(0, "Show Spectator Controls : [" + _(keybinds.ToggleSpectatorControls) + "]", true);
				return;
			}
			HUDManager.Instance.ChangeControlTip(0, string.Format("Hide Spectator Controls : [{0}]\r\nUp : [{1}]\r\nDown : [{2}]\r\nToggle Light : [{3}]\r\nTeleport to Player : [0-{4}]\r\nExit Spectator Mode : [{5}]", _(keybinds.ToggleSpectatorControls), _(actions["Jump"]), _(actions["Crouch"]), _(keybinds.SpectatorToggleLight), StartOfRound.Instance.connectedPlayersAmount - 1, _(keybinds.ExitSpectator)), true);
			static string _(InputAction action)
			{
				return InputActionRebindingExtensions.GetBindingDisplayString(action, (DisplayStringOptions)0, (string)null);
			}
		}

		private void ToggleLight(CallbackContext context)
		{
			if (!((CallbackContext)(ref context)).performed)
			{
				return;
			}
			PlayerControllerB localPlayer = _localPlayer;
			if (localPlayer != null && localPlayer.isPlayerDead && !localPlayer.isTypingChat && !_localPlayer.quickMenuManager.isMenuOpen)
			{
				Light[] lights = _lights;
				foreach (Light val in lights)
				{
					((Behaviour)val).enabled = !((Behaviour)val).enabled;
				}
			}
		}

		public void TeleportToPlayer(PlayerControllerB player)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (player.isPlayerDead)
			{
				if ((Object)(object)player.deadBody != (Object)null && !player.deadBody.deactivated)
				{
					((Component)this).transform.position = ((Component)player.deadBody).transform.position + Vector3.up;
				}
				else
				{
					HUDManager.Instance.DisplayTip("Can't Teleport", "Specified player is dead with no body!", true, false, "LC_Tip1");
				}
			}
			if (!player.isPlayerControlled)
			{
				HUDManager.Instance.DisplayTip("Can't Teleport", "Specified player is not connected!", true, false, "LC_Tip1");
				return;
			}
			((Component)this).transform.position = ((Component)player.gameplayCamera).transform.position;
			((Component)this).transform.rotation = ((Component)player.gameplayCamera).transform.rotation;
			_localPlayer.spectatedPlayerScript = player;
			_localPlayer.SetSpectatedPlayerEffects(false);
		}

		private void ToggleControls(CallbackContext context)
		{
			if (!_localPlayer.isTypingChat && !_localPlayer.quickMenuManager.isMenuOpen)
			{
				_controlsHidden = !_controlsHidden;
				UpdateControlText();
			}
		}

		private void ExitSpectator(CallbackContext context)
		{
			if (!_localPlayer.isTypingChat && !_localPlayer.quickMenuManager.isMenuOpen)
			{
				if ((Object)(object)Player.Local.Team != (Object)null)
				{
					HUDManager.Instance.DisplayTip("Can't Exit", "Currently not allowed to leave spectator!", true, false, "LC_Tip1");
				}
				else
				{
					Player.Local.StopSpectatingServerRpc();
				}
			}
		}

		private void OnEnable()
		{
			Keybinds keybinds = Plugin.Config.Keybinds;
			keybinds.SpectatorToggleLight.performed += ToggleLight;
			keybinds.ToggleSpectatorControls.performed += ToggleControls;
			keybinds.ExitSpectator.performed += ExitSpectator;
		}

		private void OnDisable()
		{
			Keybinds keybinds = Plugin.Config.Keybinds;
			keybinds.SpectatorToggleLight.performed -= ToggleLight;
			keybinds.ToggleSpectatorControls.performed -= ToggleControls;
			keybinds.ExitSpectator.performed -= ExitSpectator;
		}

		private void OnDestroy()
		{
			Log.Debug("SpectatorController destroyed");
			Light[] lights = _lights;
			foreach (Light val in lights)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private void LateUpdate()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Invalid comparison between Unknown and I4
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected I4, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_localPlayer == (Object)null)
			{
				_localPlayer = StartOfRound.Instance.localPlayerController;
				if ((Object)(object)_localPlayer == (Object)null)
				{
					return;
				}
			}
			Vector2 val = _moveAction.ReadValue<Vector2>();
			MovementActions movement = _localPlayer.playerActions.Movement;
			Vector2 val2 = ((MovementActions)(ref movement)).Look.ReadValue<Vector2>() * 0.008f * (float)IngamePlayerSettings.Instance.settings.lookSensitivity;
			if (!IngamePlayerSettings.Instance.settings.invertYAxis)
			{
				val2.y *= -1f;
			}
			bool flag = _sprintAction.ReadValue<float>() > 0.3f;
			((Component)this).transform.Rotate(0f, val2.x, 0f, (Space)0);
			float num = ((Component)this).transform.eulerAngles.x % 360f + val2.y;
			if (num < 270f && num > 90f)
			{
				((Component)this).transform.eulerAngles = ((270f - num < num - 90f) ? new Vector3(270f, ((Component)this).transform.eulerAngles.y, 0f) : new Vector3(90f, ((Component)this).transform.eulerAngles.y, 0f));
			}
			else
			{
				((Component)this).transform.eulerAngles = new Vector3(num, ((Component)this).transform.eulerAngles.y, 0f);
			}
			float num2 = 5f;
			if (flag)
			{
				num2 *= 5f;
			}
			Vector3 val3 = ((Component)this).transform.right * val.x * num2 * Time.deltaTime;
			Vector3 val4 = ((Component)this).transform.forward * val.y * num2 * Time.deltaTime;
			Transform transform = ((Component)this).transform;
			transform.position += val3 + val4;
			float num3 = (_upAction.ReadValue<float>() - _downAction.ReadValue<float>()) * num2 * Time.deltaTime;
			Transform transform2 = ((Component)this).transform;
			transform2.position += Vector3.up * num3;
			int num4 = -1;
			for (Key val5 = (Key)41; (int)val5 <= 50; val5 = (Key)(val5 + 1))
			{
				if (((ButtonControl)Keyboard.current[val5]).wasPressedThisFrame)
				{
					num4 = val5 - 41;
					break;
				}
			}
			if (num4 != -1)
			{
				PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
				if (num4 >= allPlayerScripts.Length)
				{
					HUDManager.Instance.DisplayTip("Cannot Teleport", "Specified player index is invalid!", true, false, "LC_Tip1");
				}
				else
				{
					TeleportToPlayer(allPlayerScripts[num4]);
				}
			}
			PlayerControllerB[] allPlayerScripts2 = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val6 in allPlayerScripts2)
			{
				if (!((Object)(object)val6 == (Object)(object)_localPlayer) && val6.isPlayerControlled)
				{
					val6.ShowNameBillboard();
					val6.usernameBillboard.LookAt(((Component)this).transform.position);
				}
			}
			((Behaviour)_localPlayer.playerScreen).enabled = true;
		}
	}
	public class Keybinds : LcInputActions
	{
		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction ToggleSpectatorControls { get; private set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction SpectatorToggleLight { get; private set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction ExitSpectator { get; private set; }
	}
	internal static class Log
	{
		public static ManualLogSource Source { get; private set; }

		static Log()
		{
			Source = Logger.CreateLogSource("CompetitiveCompany");
		}

		public static void Fatal(string message)
		{
			Source.LogFatal((object)message);
		}

		public static void Error(string message)
		{
			Source.LogError((object)message);
		}

		public static void Warning(string message)
		{
			Source.LogWarning((object)message);
		}

		public static void Message(string message)
		{
			Source.LogMessage((object)message);
		}

		public static void Info(string message)
		{
			Source.LogInfo((object)message);
		}

		public static void Debug(string message)
		{
			Source.LogDebug((object)message);
		}
	}
	public struct NetworkedSettings : INetworkSerializable
	{
		public bool ForceSuits;

		public bool FriendlyFire;

		public int NumberOfRounds;

		public float ShipSafeRadius;

		public bool DisableAutoPilot;

		public float MinLeaveTime;

		public float TimeToLeave;

		public Permission JoinTeamPerm;

		public Permission CreateAndDeleteTeamPerm;

		public Permission EditTeamPerm;

		public NetworkedSettings(Config config)
		{
			ForceSuits = config.ForceSuits.Value;
			FriendlyFire = config.FriendlyFire.Value;
			NumberOfRounds = config.NumberOfRounds.Value;
			ShipSafeRadius = config.ShipSafeRadius.Value;
			DisableAutoPilot = config.DisableAutoPilot.Value;
			MinLeaveTime = config.MinLeaveTime.Value;
			TimeToLeave = config.TimeToLeave.Value;
			JoinTeamPerm = config.JoinTeamPerm.Value;
			CreateAndDeleteTeamPerm = config.CreateAndDeleteTeamPerm.Value;
			EditTeamPerm = config.EditTeamPerm.Value;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref ForceSuits, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref FriendlyFire, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref NumberOfRounds, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref ShipSafeRadius, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref DisableAutoPilot, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref MinLeaveTime, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref TimeToLeave, default(ForPrimitives));
			((BufferSerializer<Permission>*)(&serializer))->SerializeValue<Permission>(ref JoinTeamPerm, default(ForEnums));
			((BufferSerializer<Permission>*)(&serializer))->SerializeValue<Permission>(ref CreateAndDeleteTeamPerm, default(ForEnums));
			((BufferSerializer<Permission>*)(&serializer))->SerializeValue<Permission>(ref EditTeamPerm, default(ForEnums));
		}
	}
	internal static class NetworkPrefabs
	{
		public static Session Session { get; }

		public static Team Team { get; }

		static NetworkPrefabs()
		{
			Session = NetworkPrefabs.CreateNetworkPrefab("Session").AddComponent<Session>();
			Team = NetworkPrefabs.CreateNetworkPrefab("Team").AddComponent<Team>();
			Log.Debug("Created NetworkPrefabs");
		}

		public static void Initialize()
		{
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("ShaosilGaming.GeneralImprovements")]
	[BepInPlugin("com.kesomannen.competitivecompany", "CompetitiveCompany", "0.2.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.kesomannen.competitivecompany";

		private const string Name = "CompetitiveCompany";

		private const string Version = "0.2.0";

		public const int MinTeams = 2;

		public const int MaxTeams = 8;

		public static Config Config { get; private set; }

		private void Awake()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			Stopwatch stopwatch = Stopwatch.StartNew();
			Log.Debug("Loading config...");
			Config = new Config(((BaseUnityPlugin)this).Config);
			Log.Debug("Patching...");
			Harmony val = new Harmony("com.kesomannen.competitivecompany");
			val.PatchAll(typeof(ChatPatches));
			Player.Patch();
			MatchEndScreen.Patch();
			RoundReport.Patch();
			MiscPatches.Patch();
			Team.Patch();
			Session.Patch();
			LeverPatches.Patch();
			Log.Debug("Running InitializeOnLoad methods...");
			RunInitializeOnLoadMethods();
			Log.Debug("Initializing terminal commands...");
			TerminalCommands.Initialize();
			Log.Debug("Initializing prefabs...");
			NetworkPrefabs.Initialize();
			Log.Debug("Loading assets...");
			Assets.Load();
			Log.Debug("Checking for soft dependencies and compatibility patches...");
			SoftDependencyHelper.CheckFor("LethalConfig", "ainavt.lc.lethalconfig", LethalConfigCompat.Initialize);
			SoftDependencyHelper.CheckFor("BetterEmotes", "BetterEmotes", delegate
			{
			});
			NetcodeValidator val2 = new NetcodeValidator("com.kesomannen.competitivecompany");
			val2.BindToPreExistingObjectByBehaviour<Player, PlayerControllerB>();
			Session.OnSessionStarted += delegate
			{
				SpectatorController.Spawn();
			};
			Session.OnSessionEnded += delegate
			{
				SpectatorController instance = SpectatorController.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)instance).gameObject);
				}
			};
			Log.Info($"Plugin loaded in {stopwatch.ElapsedMilliseconds}ms");
		}

		private static void RunInitializeOnLoadMethods()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				try
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array2 = methods;
					foreach (MethodInfo methodInfo in array2)
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
						if (customAttributes.Length != 0)
						{
							methodInfo.Invoke(null, null);
						}
					}
				}
				catch (FileNotFoundException)
				{
				}
			}
		}
	}
	internal class TerminalCommands
	{
		private const string NoPermsMessage = "You do not have permission to use this command!";

		private const string AlreadyPlayingMessage = "You cannot use this command while a round is active!";

		private TerminalCommands()
		{
		}

		internal static void Initialize()
		{
			TerminalRegistry.CreateTerminalRegistry().RegisterFrom<TerminalCommands>(new TerminalCommands());
		}

		[TerminalCommand("settings", true)]
		[CommandInfo("Show the current game settings.", "")]
		private string SettingsCommand()
		{
			NetworkedSettings settings = Session.Current.Settings;
			return "Current game settings:\n\nFriendly fire: " + FormatBool(settings.FriendlyFire) + "\n" + $"Number of rounds: {settings.NumberOfRounds}\n" + $"Ship safe radius: {settings.ShipSafeRadius}m\n" + "Autopilot: " + FormatBool(!settings.DisableAutoPilot) + "\nEarliest ship start time: " + FormatTimeOfDay(settings.MinLeaveTime) + "\nShip leave time: " + FormatTimeSpan(settings.TimeToLeave);
			static string FormatBool(bool value)
			{
				if (!value)
				{
					return "Disabled";
				}
				return "Enabled";
			}
			static string FormatTimeOfDay(float hours)
			{
				TimeSpan timeSpan2 = TimeSpan.FromHours(hours);
				string arg = ((timeSpan2.Hours < 12) ? "AM" : "PM");
				hours = timeSpan2.Hours % 12;
				if (hours == 0f)
				{
					hours = 12f;
				}
				return $"{hours}:{timeSpan2.Minutes:D2} {arg}";
			}
			static string FormatTimeSpan(float hours)
			{
				TimeSpan timeSpan = TimeSpan.FromHours(hours);
				if (timeSpan.Minutes != 0)
				{
					return $"{timeSpan.Hours}h {timeSpan.Minutes}m";
				}
				return $"{timeSpan.Hours}h";
			}
		}

		[TerminalCommand("join", true)]
		[CommandInfo("Join a team. Host can join other players by specifying their username after the team name.", "<team> [player]")]
		private string JoinCommand([RemainingText] string input)
		{
			string input2 = input;
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!CheckPerms((NetworkedSettings settings) => settings.JoinTeamPerm))
			{
				return "You do not have permission to use this command!";
			}
			if (NetworkManager.Singleton.IsServer)
			{
				return Server();
			}
			return Client();
			string Client()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (!Session.Current.Teams.TryGet(input2, out Team team))
				{
					return "Team '" + input2 + "' not found!";
				}
				Player local = Player.Local;
				if ((Object)(object)local.Team == (Object)(object)team)
				{
					return "You are already in team " + team.ColoredName + "!";
				}
				local.SetTeamServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)team));
				return "Joined team " + team.ColoredName + ".";
			}
			string Server()
			{
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				int[] array = (from t in input2.Select((char c, int i) => (c, i))
					where t.c == ' '
					select t.i).Append(input2.Length).ToArray();
				string text = null;
				Player player = null;
				Team team2 = null;
				for (int j = 0; j < array.Length; j++)
				{
					string name = input2.Substring(0, array[j]);
					if (Session.Current.Teams.TryGet(name, out team2))
					{
						if (j == array.Length - 1)
						{
							player = Player.Local;
							break;
						}
						string text2 = input2;
						int num = array[j] + 1;
						text = text2.Substring(num, text2.Length - num);
						if (Session.Current.Players.TryGetByName(text, out player))
						{
							break;
						}
					}
				}
				if ((Object)(object)team2 == (Object)null || (Object)(object)player == (Object)null)
				{
					if (text != null)
					{
						return "Player '" + text + "' not found!";
					}
					return "Invalid team or player name!";
				}
				if ((Object)(object)player.Team == (Object)(object)team2)
				{
					if (!((NetworkBehaviour)player).IsOwner)
					{
						return "Player " + text + " is already in team " + team2.ColoredName + "!";
					}
					return "You are already in team " + team2.ColoredName + "!";
				}
				player.SetTeamFromServer(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)team2));
				if (!((NetworkBehaviour)player).IsOwner)
				{
					return "Moved " + text + " to team " + team2.ColoredName;
				}
				return "Joined team " + team2.ColoredName + ".";
			}
		}

		[TerminalCommand("scramble-teams", true)]
		[CommandInfo("Randomly assign players to teams. Host only.", "")]
		private string ScrambleTeams()
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!NetworkManager.Singleton.IsHost)
			{
				return "You do not have permission to use this command!";
			}
			Dictionary<Team, int> dictionary = new Dictionary<Team, int>();
			foreach (Team team in Session.Current.Teams)
			{
				dictionary[team] = 0;
			}
			foreach (Player player in Session.Current.Players)
			{
				if (!((Object)(object)player.Team == (Object)null))
				{
					KeyValuePair<Team, int>[] array = (from kvp in dictionary
						group kvp by kvp.Value into grouping
						orderby grouping.Key
						select grouping).First().ToArray();
					Team key = array[Random.Range(0, array.Length)].Key;
					player.SetTeamFromServer(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)key));
					dictionary[key]++;
				}
			}
			return "Teams scrambled!";
		}

		[TerminalCommand("create-team", true)]
		[CommandInfo("Create a new team with a name and random color.", "<name>")]
		private string CreateTeam([RemainingText] string teamName)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!CheckPerms((NetworkedSettings settings) => settings.CreateAndDeleteTeamPerm))
			{
				return "You do not have permission to use this command!";
			}
			if (Session.Current.Teams.Count >= 8)
			{
				return "Maximum number of teams reached!";
			}
			if (Session.Current.Teams.TryGet(teamName, out Team _))
			{
				return "Team " + teamName + " already exists!";
			}
			if (teamName.Length > 128)
			{
				return "Team name is too long!";
			}
			Color color = Random.ColorHSV(0f, 1f, 1f, 1f, 1f, 1f);
			Session.Current.CreateTeamServerRpc(FixedString128Bytes.op_Implicit(teamName), color);
			return "Created team " + teamName + ".";
		}

		[TerminalCommand("delete-team", true)]
		[CommandInfo("Delete an empty team.", "<team>")]
		private string DeleteTeam([RemainingText] string teamName)
		{
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!CheckPerms((NetworkedSettings settings) => settings.CreateAndDeleteTeamPerm))
			{
				return "You do not have permission to use this command!";
			}
			if (Session.Current.Teams.Count <= 2)
			{
				return "Minimum number of teams reached!";
			}
			if (!Session.Current.Teams.TryGet(teamName, out Team team))
			{
				return "Team " + teamName + " not found!";
			}
			if (team.Members.Any())
			{
				return "Team " + teamName + " still has members!";
			}
			team.DeleteServerRpc();
			return "Deleted team " + teamName + ".";
		}

		[TerminalCommand("teams", true)]
		[CommandInfo("Lists all teams and their scores.", "")]
		private string ListTeams()
		{
			return string.Join('\n', Session.Current.Teams.PrettyPrint(51, color: true));
		}

		[TerminalCommand("set-team-color", true)]
		[CommandInfo("Set the color of your current team.", "<color>")]
		private string ColorCommand([RemainingText] string input)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!CheckPerms((NetworkedSettings settings) => settings.EditTeamPerm))
			{
				return "You do not have permission to use this command!";
			}
			Team team = Player.Local.Team;
			if ((Object)(object)team == (Object)null)
			{
				return "You are not in a team!";
			}
			Color? val = ColorUtil.ParseColor(input);
			if (!val.HasValue)
			{
				string text = string.Join(", ", ColorUtil.ColorNames.Keys);
				return "Invalid color! Please use hex format (e.g. #FF0000) or one of the following: " + text + ".";
			}
			team.SetColorServerRpc(val.Value);
			string text2 = (input.StartsWith("#") ? input : ("#" + ColorUtility.ToHtmlStringRGB(val.Value)));
			return "Set color of team " + team.Name + " to <color=" + text2 + ">" + input + "</color>.";
		}

		[TerminalCommand("set-team-name", true)]
		[CommandInfo("Rename your current team.", "<name>")]
		private string RenameCommand([RemainingText] string name)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (Session.Current.IsRoundActive)
			{
				return "You cannot use this command while a round is active!";
			}
			if (!CheckPerms((NetworkedSettings settings) => settings.EditTeamPerm))
			{
				return "You do not have permission to use this command!";
			}
			Team team = Player.Local.Team;
			if ((Object)(object)team == (Object)null)
			{
				return "You are not in a team!";
			}
			if (Session.Current.Teams.TryGet(name, out Team _))
			{
				return "Team " + name + " already exists!";
			}
			if (name.Length > 64)
			{
				return "Team name is too long!";
			}
			team.SetNameServerRpc(FixedString128Bytes.op_Implicit(name));
			return "Renamed team to " + name + ".";
		}

		private static bool CheckPerms(Func<NetworkedSettings, Permission> getPerms)
		{
			NetworkedSettings settings = Session.Current.Settings;
			if (!NetworkManager.Singleton.IsHost)
			{
				return getPerms(settings) == Permission.Everyone;
			}
			return true;
		}
	}
	internal static class SuitUtil
	{
		public static UnlockableItem GetOriginalSuit()
		{
			return StartOfRound.Instance.unlockablesList.unlockables.Find((UnlockableItem item) => (Object)(object)item.suitMaterial != (Object)null && item.alreadyUnlocked);
		}

		public static UnlockableItem CreateSuit(string name)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			UnlockableItem originalSuit = GetOriginalSuit();
			return new UnlockableItem
			{
				unlockableName = name,
				prefabObject = originalSuit.prefabObject,
				unlockableType = originalSuit.unlockableType,
				shopSelectionNode = originalSuit.shopSelectionNode,
				alwaysInStock = originalSuit.alwaysInStock,
				IsPlaceable = originalSuit.IsPlaceable,
				hasBeenMoved = originalSuit.hasBeenMoved,
				placedPosition = originalSuit.placedPosition,
				placedRotation = originalSuit.placedRotation,
				inStorage = originalSuit.inStorage,
				canBeStored = originalSuit.canBeStored,
				maxNumber = originalSuit.maxNumber,
				hasBeenUnlockedByPlayer = originalSuit.hasBeenUnlockedByPlayer,
				suitMaterial = originalSuit.suitMaterial,
				headCostumeObject = originalSuit.headCostumeObject,
				lowerTorsoCostumeObject = originalSuit.lowerTorsoCostumeObject,
				alreadyUnlocked = originalSuit.alreadyUnlocked,
				unlockedInChallengeFile = originalSuit.unlockedInChallengeFile,
				spawnPrefab = originalSuit.spawnPrefab,
				jumpAudio = originalSuit.jumpAudio
			};
		}
	}
}
namespace CompetitiveCompany.Util
{
	public static class ColorUtil
	{
		private static readonly Dictionary<string, Color> _colorNames = new Dictionary<string, Color>
		{
			{
				"red",
				Color.red
			},
			{
				"green",
				Color.green
			},
			{
				"blue",
				Color.blue
			},
			{
				"yellow",
				Color.yellow
			},
			{
				"cyan",
				Color.cyan
			},
			{
				"magenta",
				Color.magenta
			},
			{
				"white",
				Color.white
			},
			{
				"black",
				Color.black
			}
		};

		public static IReadOnlyDictionary<string, Color> ColorNames => _colorNames;

		public static Color? ParseColor(string str)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (_colorNames.TryGetValue(str, out var value))
			{
				return value;
			}
			if (ColorUtility.TryParseHtmlString(str, ref value))
			{
				return value;
			}
			return null;
		}
	}
	public enum Emote
	{
		Dance = 1,
		Point,
		MiddleFinger,
		Clap,
		Shy,
		Griddy,
		Twerk,
		Salute,
		Prisyadka
	}
	public static class EmoteUtil
	{
		public static bool IsVanilla(int emoteID)
		{
			if ((uint)(emoteID - 1) <= 1u)
			{
				return true;
			}
			return false;
		}
	}
	public static class TerminalUtil
	{
		private static Terminal? _terminal;

		public static Terminal Instance
		{
			get
			{
				if ((Object)(object)_terminal != (Object)null)
				{
					return _terminal;
				}
				Terminal val = Object.FindObjectOfType<Terminal>();
				if ((Object)(object)val == (Object)null)
				{
					throw new Exception("Terminal not found in scene");
				}
				return _terminal = val;
			}
		}
	}
	public static class TimeUtil
	{
		public static TimeSpan NormalizedToGameTime(float normalizedTime)
		{
			TimeOfDay instance = TimeOfDay.Instance;
			return TimeSpan.FromHours(normalizedTime * (float)instance.numberOfHours + 6f);
		}

		public static TimeSpan GetCurrentGameTime()
		{
			return NormalizedToGameTime(TimeOfDay.Instance.normalizedTimeOfDay);
		}
	}
}
namespace CompetitiveCompany.UI
{
	internal class MatchEndScreen : MonoBehaviour
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnable <>9__23_0;

			public static hook_OnDisable <>9__23_1;

			internal void <Patch>b__23_0(orig_OnEnable orig, HUDManager self)
			{
				orig.Invoke(self);
				_instance = Object.Instantiate<MatchEndScreen>(Assets.MatchEndScreenPrefab);
			}

			internal void <Patch>b__23_1(orig_OnDisable orig, HUDManager self)
			{
				if ((Object)(object)_instance != (Object)null)
				{
					Object.Destroy((Object)(object)_instance);
					_instance = null;
				}
				orig.Invoke(self);
			}
		}

		[SerializeField]
		private Light _spotLight;

		[SerializeField]
		private Light _pointLight;

		[SerializeField]
		private GameObject _cameraContainer;

		[SerializeField]
		private Transform _playerPosition;

		[SerializeField]
		private float _playerRadius = 3f;

		[SerializeField]
		private float _playerSpacing = MathF.PI / 8f;

		[SerializeField]
		private float _showDuration;

		[SerializeField]
		private float _showDelay;

		[SerializeField]
		private GameObject _ui;

		[SerializeField]
		private TMP_Text _title;

		[SerializeField]
		private Image _titleBackground;

		private Camera _camera;

		private Camera _gameplayCamera;

		private readonly List<(GameObject, Player)> _playerModels = new List<(GameObject, Player)>();

		private readonly Dictionary<Light, bool> _lightStates = new Dictionary<Light, bool>();

		private static readonly int _emoteNumberID = Animator.StringToHash("emoteNumber");

		private static MatchEndScreen? _instance;

		private IEnumerator Start()
		{
			Session.Current.OnMatchEnded += OnMatchEnded;
			yield return null;
			_ui.transform.SetParent(RoundReport.GetVanillaElement().parent);
		}

		private void OnDestroy()
		{
			Session.Current.OnMatchEnded -= OnMatchEnded;
		}

		private void OnMatchEnded(MatchEndedContext ctx)
		{
			if (!Plugin.Config.ShowEndOfMatchCutscene.Value)
			{
				return;
			}
			ValueTweens.DelayedCall((Object)(object)this, _showDelay, (Action)delegate
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				if ((Object)(object)_camera == (Object)null)
				{
					CreateCamera();
				}
				Light[] array = Object.FindObjectsOfType<Light>();
				foreach (Light val in array)
				{
					_lightStates[val] = ((Component)val).gameObject.activeSelf;
					((Component)val).gameObject.SetActive(false);
				}
				_pointLight.color = ctx.WinningTeam.Color;
				_title.text = $"{ctx.WinningTeam.RawName} win!";
				int num = 0;
				IReadOnlyCollection<Player> members = ctx.WinningTeam.Members;
				SkinnedMeshRenderer val5 = default(SkinnedMeshRenderer);
				foreach (Player item3 in members)
				{
					Transform val2 = ((Component)item3).transform.Find("ScavengerModel");
					(Vector3, Quaternion) tuple = CalculatePlayerPosition(num, members.Count);
					Vector3 item = tuple.Item1;
					Quaternion item2 = tuple.Item2;
					Transform val3 = Object.Instantiate<Transform>(val2, item, item2);
					foreach (Transform item4 in val3)
					{
						Transform val4 = item4;
						((Component)val4).gameObject.SetActive(true);
						if (((Component)val4).TryGetComponent<SkinnedMeshRenderer>(ref val5))
						{
							((Renderer)val5).enabled = true;
							((Renderer)val5).shadowCastingMode = (ShadowCastingMode)1;
						}
					}
					Transform val6 = val3.Find("metarig");
					Animator component = ((Component)val6).GetComponent<Animator>();
					int endOfMatchEmoteChecked = item3.EndOfMatchEmoteChecked;
					Log.Debug($"Setting emote ID for {item3.DebugName} to {endOfMatchEmoteChecked}");
					component.SetInteger(_emoteNumberID, endOfMatchEmoteChecked);
					component.SetLayerWeight(component.GetLayerIndex("UpperBodyEmotes"), 0f);
					component.SetLayerWeight(component.GetLayerIndex("EmotesNoArms"), 1f);
					((Component)val6.Find("ScavengerModelArmsOnly")).gameObject.SetActive(false);
					((Component)val6.Find("CameraContainer")).gameObject.SetActive(false);
					_playerModels.Add((((Component)val3).gameObject, item3));
					num++;
				}
				foreach (Player player in Session.Current.Players)
				{
					if (player.IsControlled)
					{
						((Component)player.Controller).gameObject.SetActive(false);
					}
				}
				_cameraContainer.SetActive(true);
				((Component)_spotLight).gameObject.SetActive(true);
				((Component)_pointLight).gameObject.SetActive(true);
				_camera.fieldOfView = 65f;
				StartOfRound.Instance.SwitchCamera(_camera);
				HUDManager.Instance.HideHUD(true);
				((MonoBehaviour)this).StartCoroutine(WaitThenHide());
			});
			IEnumerator WaitThenHide()
			{
				yield return DisablingExtensions.SetObjectEnabledRoutine(_ui, true, true);
				yield return (object)new WaitForSeconds(_showDuration);
				yield return DisablingExtensions.SetObjectEnabledRoutine(_ui, false, true);
				Hide();
			}
		}

		private void Hide()
		{
			foreach (var (val2, active) in _lightStates)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					((Component)val2).gameObject.SetActive(active);
				}
			}
			_lightStates.Clear();
			foreach (var (val3, player) in _playerModels)
			{
				Object.Destroy((Object)(object)val3);
				((Component)player.Controller).gameObject.SetActive(true);
			}
			_playerModels.Clear();
			foreach (Player player2 in Session.Current.Players)
			{
				if (player2.IsControlled)
				{
					((Component)player2.Controller).gameObject.SetActive(true);
				}
			}
			_cameraContainer.SetActive(false);
			((Component)_spotLight).gameObject.SetActive(false);
			((Component)_pointLight).gameObject.SetActive(false);
			StartOfRound.Instance.SwitchCamera(_gameplayCamera);
			HUDManager.Instance.HideHUD(false);
		}

		private void CreateCamera()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			_gameplayCamera = Player.Local.Controller.gameplayCamera;
			_camera = _cameraContainer.AddComponent<Camera>();
			_camera.CopyFrom(_gameplayCamera);
			int num = LayerMask.NameToLayer("HelmetVisor");
			Camera camera = _camera;
			camera.cullingMask &= ~(1 << num);
			((Component)_camera).transform.rotation = Quaternion.Euler(0f, 270f, 0f);
			((Component)_camera).transform.localPosition = new Vector3(7.5f, 1.9f, -14.3f);
		}

		private (Vector3, Quaternion) CalculatePlayerPosition(int index, int totalPlayers)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = _playerPosition.position + new Vector3(_playerRadius, 0f, 0f);
			float num = (float)index - (float)(totalPlayers - 1) / 2f;
			float num2 = MathF.PI - num * _playerSpacing;
			float num3 = val.x + _playerRadius * Mathf.Cos(num2);
			float num4 = val.z + _playerRadius * Mathf.Sin(num2);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(num3, _playerPosition.position.y, num4);
			Quaternion item = Quaternion.LookRotation(val - val2);
			return (val2, item);
		}

		public static void Patch()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0038: 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_0043: Expected O, but got Unknown
			object obj = <>c.<>9__23_0;
			if (obj == null)
			{
				hook_OnEnable val = delegate(orig_OnEnable orig, HUDManager self)
				{
					orig.Invoke(self);
					_instance = Object.Instantiate<MatchEndScreen>(Assets.MatchEndScreenPrefab);
				};
				<>c.<>9__23_0 = val;
				obj = (object)val;
			}
			HUDManager.OnEnable += (hook_OnEnable)obj;
			object obj2 = <>c.<>9__23_1;
			if (obj2 == null)
			{
				hook_OnDisable val2 = delegate(orig_OnDisable orig, HUDManager self)
				{
					if ((Object)(object)_instance != (Object)null)
					{
						Object.Destroy((Object)(object)_instance);
						_instance = null;
					}
					orig.Invoke(self);
				};
				<>c.<>9__23_1 = val2;
				obj2 = (object)val2;
			}
			HUDManager.OnDisable += (hook_OnDisable)obj2;
		}
	}
	public class MockTeam : ITeam
	{
		private static readonly MockTeam[] _mockTeams = new MockTeam[4]
		{
			new MockTeam
			{
				Name = "Manticoils",
				Color = Color.red,
				RoundScore = 100,
				TotalScore = 1000
			},
			new MockTeam
			{
				Name = "Hoarding bugs",
				Color = Color.green,
				RoundScore = 200,
				TotalScore = 800
			},
			new MockTeam
			{
				Name = "Brackens",
				Color = Color.blue,
				RoundScore = 300,
				TotalScore = 1200
			},
			new MockTeam
			{
				Name = "Locust Bees",
				Color = Color.yellow,
				RoundScore = 400,
				TotalScore = 400
			}
		};

		public string Name { get; set; }

		public Color Color { get; set; }

		public int RoundScore { get; set; }

		public int TotalScore { get; set; }

		public static IReadOnlyList<MockTeam> Teams => _mockTeams;
	}
	internal class RoundReport : MonoBehaviour
	{
		[Serializable]
		private class Tab
		{
			public TabButton Button;

			public GameObject[] Content;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnEnable <>9__20_0;

			public static hook_OnDisable <>9__20_1;

			internal void <Patch>b__20_0(orig_OnEnable orig, HUDManager self)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				Transform vanillaElement = GetVanillaElement();
				_instance = Object.Instantiate<RoundReport>(Assets.RoundReportPrefab, vanillaElement.parent);
				((Component)_instance).transform.localScale = Vector3.one * 0.4f;
				Log.Debug("RoundReport mounted");
			}

			internal void <Patch>b__20_1(orig_OnDisable orig, HUDManager self)
			{
				if ((Object)(object)_instance != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_instance).gameObject);
					_instance = null;
					Log.Debug("RoundReport destroyed");
				}
				orig.Invoke(self);
			}
		}

		[SerializeField]
		private float _autoScrollDuration;

		[SerializeField]
		private RectTransform _autoScrollBar;

		[SerializeField]
		private GameObject _panel;

		[SerializeField]
		private Tab[] _tabs;

		[Space]
		[SerializeField]
		private RoundResultsPage _roundResultsPage;

		[SerializeField]
		private StandingsPage _standingsPage;

		[SerializeField]
		private TeamPerformancePage _teamPerformancePage;

		private Tab? _selectedTab;

		private Coroutine? _autoScrollCoroutine;

		private const float Scale = 0.4f;

		private static RoundReport? _instance;

		private void Start()
		{
			Tab[] tabs = _tabs;
			foreach (Tab tab in tabs)
			{
				tab.Button.OnClicked += OnTabButtonClicked;
			}
			if (Application.isEditor)
			{
				OnRoundEnded(default(RoundEndedContext));
			}
			else
			{
				Session.Current.OnRoundEnded += OnRoundEnded;
			}
		}

		private void OnDestroy()
		{
			Tab[] tabs = _tabs;
			foreach (Tab tab in tabs)
			{
				tab.Button.OnClicked -= OnTabButtonClicked;
			}
			if (!Application.isEditor)
			{
				Session.Current.OnRoundEnded -= OnRoundEnded;
			}
		}

		private void OnRoundEnded(RoundEndedContext ctx)
		{
			if (!Application.isEditor)
			{
				((Component)GetVanillaElement()).gameObject.SetActive(false);
			}
			if (!ctx.WasLastRound)
			{
				_roundResultsPage.Populate();
				_standingsPage.Populate();
				_teamPerformancePage.Populate();
				SwitchTab(_tabs[0]);
				if (Plugin.Config.ShowMouseOnRoundReport.Value)
				{
					Cursor.lockState = (CursorLockMode)0;
					Cursor.visible = true;
					Player.Local.Controller.quickMenuManager.isMenuOpen = true;
				}
				else
				{
					_autoScrollCoroutine = ((MonoBehaviour)this).StartCoroutine(AutoScroll());
				}
				_panel.SetActive(true);
			}
		}

		public void Hide()
		{
			if (Plugin.Config.ShowMouseOnRoundReport.Value)
			{
				Cursor.lockState = (CursorLockMode)1;
				Cursor.visible = false;
				Player.Local.Controller.quickMenuManager.isMenuOpen = false;
			}
			DisablingExtensions.DisableObject(_panel, true);
			StopCoroutineIfNotNull(ref _autoScrollCoroutine);
		}

		private void OnTabButtonClicked(TabButton tabButton)
		{
			StopCoroutineIfNotNull(ref _autoScrollCoroutine);
			((Component)_autoScrollBar).gameObject.SetActive(false);
			Tab[] tabs = _tabs;
			foreach (Tab tab in tabs)
			{
				if (!((Object)(object)tab.Button != (Object)(object)tabButton))
				{
					SwitchTab(tab);
					break;
				}
			}
		}

		private void SwitchTab(Tab tab)
		{
			if (_selectedTab == tab)
			{
				return;
			}
			if (_selectedTab != null)
			{
				_selectedTab.Button.Selected = false;
				GameObject[] content = _selectedTab.Content;
				foreach (GameObject val in content)
				{
					val.SetActive(false);
				}
			}
			_selectedTab = tab;
			_selectedTab.Button.Selected = true;
			GameObject[] content2 = _selectedTab.Content;
			foreach (GameObject val2 in content2)
			{
				val2.SetActive(true);
			}
		}

		private IEnumerator AutoScroll()
		{
			((Component)_autoScrollBar).gameObject.SetActive(true);
			for (int i = 1; i <= 3; i++)
			{
				float t = 0f;
				_autoScrollBar.anchorMax = Vector2.zero;
				for (; t < _autoScrollDuration; t += Time.deltaTime)
				{
					float num = Mathf.SmoothStep(0f, 1f, t / _autoScrollDuration);
					_autoScrollBar.anchorMax = new Vector2(num, 0f);
					yield return null;
				}
				if (i == 3)
				{
					Hide();
				}
				else
				{
					SwitchTab(_tabs[i]);
				}
			}
		}

		private void StopCoroutineIfNotNull(ref Coroutine? coroutine)
		{
			if (coroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(coroutine);
				coroutine = null;
			}
		}

		internal static Transform GetVanillaElement()
		{
			return ((Component)HUDManager.Instance.statsUIElements.allPlayersDeadOverlay).transform.parent.parent;
		}

		internal static void Patch()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0038: 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_0043: Expected O, but got Unknown
			object obj = <>c.<>9__20_0;
			if (obj == null)
			{
				hook_OnEnable val = delegate(orig_OnEnable orig, HUDManager self)
				{
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					Transform vanillaElement = GetVanillaElement();
					_instance = Object.Instantiate<RoundReport>(Assets.RoundReportPrefab, vanillaElement.parent);
					((Component)_instance).transform.localScale = Vector3.one * 0.4f;
					Log.Debug("RoundReport mounted");
				};
				<>c.<>9__20_0 = val;
				obj = (object)val;
			}
			HUDManager.OnEnable += (hook_OnEnable)obj;
			object obj2 = <>c.<>9__20_1;
			if (obj2 == null)
			{
				hook_OnDisable val2 = delegate(orig_OnDisable orig, HUDManager self)
				{
					if ((Object)(object)_instance != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)_instance).gameObject);
						_instance = null;
						Log.Debug("RoundReport destroyed");
					}
					orig.Invoke(self);
				};
				<>c.<>9__20_1 = val2;
				obj2 = (object)val2;
			}
			HUDManager.OnDisable += (hook_OnDisable)obj2;
		}
	}
	internal class RoundResultsPage : MonoBehaviour
	{
		[SerializeField]
		private TeamResultsPage _teamResultsPage;

		public void Populate()
		{
			_teamResultsPage.Reset();
			IReadOnlyList<ITeam> readOnlyList;
			if (!Application.isEditor)
			{
				IReadOnlyList<ITeam> teams = Session.Current.Teams;
				readOnlyList = teams;
			}
			else
			{
				IReadOnlyList<ITeam> teams = MockTeam.Teams;
				readOnlyList = teams;
			}
			IReadOnlyList<ITeam> teams2 = readOnlyList;
			_teamResultsPage.Populate(teams2, TeamMetric.RoundScore, showWinner: true);
		}
	}
	internal class StandingsPage : MonoBehaviour
	{
		[SerializeField]
		private TeamResultsPage _teamResultsPage;

		public void Populate()
		{
			_teamResultsPage.Reset();
			bool showWinner;
			IReadOnlyList<ITeam> teams;
			if (Application.isEditor)
			{
				showWinner = true;
				teams = MockTeam.Teams;
			}
			else
			{
				showWinner = Session.Current.RoundNumber == Session.Current.Settings.NumberOfRounds;
				teams = Session.Current.Teams;
			}
			_teamResultsPage.Populate(teams, TeamMetric.TotalScore, showWinner);
		}
	}
	internal class TabButton : MonoBehaviour, IPointerDownHandler, IEventSystemHandler, IPointerEnterHandler, IPointerExitHandler
	{
		[SerializeField]
		private TMP_Text _label;

		[SerializeField]
		private Image _background;

		[Space]
		[SerializeField]
		private Sprite _defaultBackground;

		[SerializeField]
		private Color _unselectedTextColor;

		[SerializeField]
		private Color _selectedTextColor;

		[Space]
		[SerializeField]
		private UnityEvent _onSelected;

		[SerializeField]
		private UnityEvent _onDeselected;

		private bool _selected;

		public bool Selected
		{
			get
			{
				return _selected;
			}
			set
			{
				_selected = value;
				SetState(value);
			}
		}

		public event Action<TabButton>? OnClicked;

		public void OnPointerDown(PointerEventData eventData)
		{
			this.OnClicked?.Invoke(this);
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!Selected)
			{
				SetState(selected: true, invokeEvents: false);
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if (!Selected)
			{
				SetState(selected: false, invokeEvents: false);
			}
		}

		private void SetState(bool selected, bool invokeEvents = true)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)_label).color = (selected ? _selectedTextColor : _unselectedTextColor);
			_background.sprite = (selected ? null : _defaultBackground);
			if (invokeEvents)
			{
				if (selected)
				{
					_onSelected.Invoke();
				}
				else
				{
					_onDeselected.Invoke();
				}
			}
		}
	}
	internal class TeamPerformanceMember : MonoBehaviour
	{
		[SerializeField]
		private TMP_Text _nameText;

		[SerializeField]
		private TMP_Text _notesText;

		[Space]
		[SerializeField]
		private Image _outcomeImage;

		[SerializeField]
		private Sprite _survivedIcon;

		[SerializeField]
		private Sprite _dieIcon;

		[SerializeField]
		private Sprite _missingIcon;

		public void Initialize(string name, IEnumerable<string> notes, Outcome outcome)
		{
			_nameText.text = name;
			StringBuilder stringBuilder = new StringBuilder("Notes:\n");
			foreach (string note in notes)
			{
				stringBuilder.Append("* ");
				stringBuilder.AppendLine(note);
			}
			_notesText.text = stringBuilder.ToString();
			Image outcomeImage = _outcomeImage;
			outcomeImage.sprite = (Sprite)(outcome switch
			{
				Outcome.Survived => _survivedIcon, 
				Outcome.Died => _dieIcon, 
				Outcome.Missing => _missingIcon, 
				_ => throw new ArgumentOutOfRangeException("outcome", outcome, null), 
			});
		}
	}
	public enum Outcome
	{
		Survived,
		Died,
		Missing
	}
	internal class TeamPerformancePage : MonoBehaviour
	{
		[SerializeField]
		private TeamPerformanceMember _memberPrefab;

		[SerializeField]
		private Transform _memberContainer;

		[SerializeField]
		private TMP_Text _gradeText;

		[SerializeField]
		private TMP_Text _collectedText;

		private readonly List<TeamPerformanceMember> _memberUIs = new List<TeamPerformanceMember>();

		public void Populate()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			if (Application.isEditor)
			{
				return;
			}
			foreach (TeamPerformanceMember memberUI in _memberUIs)
			{
				Object.Destroy((Object)(object)((Component)memberUI).gameObject);
			}
			_memberUIs.Clear();
			Team team = Player.Local.Team;
			if ((Object)(object)team == (Object)null)
			{
				return;
			}
			foreach (Player member in team.Members)
			{
				Outcome outcome = (member.Controller.isPlayerDead ? (((int)member.Controller.causeOfDeath != 10) ? Outcome.Died : Outcome.Missing) : Outcome.Survived);
				PlayerStats val = StartOfRound.Instance.gameStats.allPlayerStats[member.Controller.playerClientId];
				TeamPerformanceMember teamPerformanceMember = Object.Instantiate<TeamPerformanceMember>(_memberPrefab, _memberContainer);
				teamPerformanceMember.Initialize(member.Name, val.playerNotes, outcome);
				_memberUIs.Add(teamPerformanceMember);
			}
			_gradeText.text = CalculateGrade(team);
			_collectedText.text = $"{team.RoundScore}\n{RoundManager.Instance.totalScrapValueInLevel}";
		}

		private static string CalculateGrade(Team team)
		{
			if (team.Members.All((Player player) => player.Controller.isPlayerDead))
			{
				return "F";
			}
			float num = RoundManager.Instance.totalScrapValueInLevel / (float)Session.Current.Teams.Count;
			float num2 = (float)team.RoundScore / num;
			if (!(num2 > 2f))
			{
				if (!(num2 > 1.5f))
				{
					if (!(num2 > 1f))
					{
						if (!(num2 > 0.75f))
						{
							if (!(num2 > 0.5f))
							{
								if (num2 > 0.33f)
								{
									return "C";
								}
								return "D";
							}
							return "B";
						}
						return "A";
					}
					return "S";
				}
				return "S+";
			}
			return "SS";
		}
	}
	internal class TeamResultsPage : MonoBehaviour
	{
		[SerializeField]
		private TeamRoundResult _teamPrefab;

		[SerializeField]
		private Transform _teamContainer;

		private readonly List<TeamRoundResult> _teamUIs = new List<TeamRoundResult>();

		public void Populate(IEnumerable<ITeam> teams, TeamMetric metric, bool showWinner)
		{
			ITeam[] array = teams.OrderByDescending((ITeam team) => team.GetScore(metric)).ToArray();
			int score = array[0].GetScore(metric);
			ITeam[] array2 = array;
			foreach (ITeam team2 in array2)
			{
				TeamRoundResult teamRoundResult = Object.Instantiate<TeamRoundResult>(_teamPrefab, _teamContainer);
				int score2 = team2.GetScore(metric);
				teamRoundResult.Initialize(team2, score2, score, showWinner && score2 == score);
				_teamUIs.Add(teamRoundResult);
			}
		}

		public void Reset()
		{
			foreach (TeamRoundResult teamUI in _teamUIs)
			{
				Object.Destroy((Object)(object)((Component)teamUI).gameObject);
			}
			_teamUIs.Clear();
		}
	}
	internal class TeamRoundResult : MonoBehaviour
	{
		[SerializeField]
		private TMP_Text _nameText;

		[SerializeField]
		private Image _colorImage;

		[SerializeField]
		private Image _scoreBar;

		[SerializeField]
		private TMP_Text _scoreText;

		[SerializeField]
		private GameObject _winnerIcon;

		public void Initialize(ITeam team, int score, int maxScore, bool isWinner)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)_colorImage).color = team.Color;
			_winnerIcon.SetActive(isWinner);
			((Graphic)_nameText).color = team.Color;
			_nameText.text = team.Name;
			((Behaviour)_scoreText).enabled = score > 0;
			float num = team.Color.r + team.Color.g + team.Color.b;
			((Graphic)_scoreText).color = ((num > 1.5f) ? Color.black : Color.white);
			_scoreText.text = "$" + score;
			((Graphic)_scoreBar).color = team.Color;
			((Graphic)_scoreBar).rectTransform.anchorMax = new Vector2((float)score / (float)maxScore, 1f);
		}
	}
}
namespace CompetitiveCompany.Game
{
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class ChatPatches
	{
		private static readonly Color _noTeamColor = Color.red;

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			Log.Debug("Patching HUDManager.AddChatMessage...");
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldarg_2)
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
					yield return new CodeInstruction(OpCodes.Ldarg_2, (object)null);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ChatPatches), "HandleChatMessage", (Type[])null, (Type[])null));
					yield return new CodeInstruction(OpCodes.Ret, (object)null);
					yield break;
				}
				yield return instruction;
			}
			Log.Error("Failed to find target instruction in HUDManager.AddChatMessage!");
		}

		private static void HandleChatMessage(HUDManager instance, string chatMessage, string playerNameWhoSent)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			string item;
			if (string.IsNullOrEmpty(playerNameWhoSent))
			{
				item = "<color=#7069ff>" + chatMessage + "</color>";
			}
			else
			{
				Team team = Player.Local.Team;
				Team team2 = Session.Current.Players.GetByName(playerNameWhoSent)?.Team;
				if ((Object)(object)team != (Object)null && (Object)(object)team2 != (Object)null && (Object)(object)team != (Object)(object)team2)
				{
					return;
				}
				string text = ColorUtility.ToHtmlStringRGB(team2?.Color ?? _noTeamColor);
				string text2 = playerNameWhoSent;
				if ((Object)(object)team2 != (Object)null)
				{
					text2 = text2 + " (" + team2.Name + ")";
				}
				item = "<color=#" + text + ">" + text2 + "</color>: <color=#FFFF00>'" + chatMessage + "'</color>";
			}
			instance.ChatMessageHistory.Add(item);
			((TMP_Text)instance.chatText).text = string.Join('\n', instance.ChatMessageHistory);
		}
	}
	public class Combat
	{
		public delegate DamagePredicateResult DamagePredicate(Player attacker, Player victim);

		private readonly List<DamagePredicate> _predicates;

		public IReadOnlyList<DamagePredicate> Predicates => _predicates;

		public Combat()
		{
			_predicates = new List<DamagePredicate>();
		}

		public Combat(List<DamagePredicate> predicates)
		{
			_predicates = predicates;
		}

		public void AddPredicate(DamagePredicate predicate, int index = -1)
		{
			if (index < 0)
			{
				_predicates.Add(predicate);
			}
			else
			{
				_predicates.Insert(index, predicate);
			}
		}

		public bool RemovePredicate(DamagePredicate predicate)
		{
			return _predicates.Remove(predicate);
		}

		public DamagePredicateResult CanDamage(Player attacker, Player victim)
		{
			foreach (DamagePredicate predicate in _predicates)
			{
				DamagePredicateResult damagePredicateResult = predicate(attacker, victim);
				if (!damagePredicateResult)
				{
					return damagePredicateResult;
				}
			}
			return DamagePredicateResult.Allow();
		}
	}
	public readonly struct DamagePredicateResult
	{
		public readonly bool Result;

		public readonly string? Reason;

		private DamagePredicateResult(bool result, string? reason = null)
		{
			Result = result;
			Reason = reason;
		}

		public static DamagePredicateResult Allow()
		{
			return new DamagePredicateResult(result: true);
		}

		public static DamagePredicateResult Deny(string reason)
		{
			return new DamagePredicateResult(result: false, reason);
		}

		public static implicit operator bool(DamagePredicateResult predicateResult)
		{
			return predicateResult.Result;
		}
	}
	public static class DefaultTeams
	{
		private static readonly TeamDefinition[] _fallback = new TeamDefinition[2]
		{
			new TeamDefinition("Loot bugs", new Color(0.99f, 0.55f, 0.11f)),
			new TeamDefinition("Manticoils", new Color(0.2f, 0.57f, 0.16f))
		};

		private const string FileName = "default_teams.json";

		public static IReadOnlyList<TeamDefinition> Fallback => _fallback;

		public static IReadOnlyList<TeamDefinition> Get()
		{
			string text = Path.Join((ReadOnlySpan<char>)Paths.ConfigPath, (ReadOnlySpan<char>)"default_teams.json");
			Log.Debug("Looking for default_teams.json at " + text + ".");
			if (!File.Exists(text))
			{
				Log.Info("default_teams.json file not found, using fallback.");
				return _fallback;
			}
			try
			{
				string text2 = File.ReadAllText(text);
				TeamDefinition[] array = JsonConvert.DeserializeObject<TeamDefinition[]>(text2);
				int num = array.Length;
				if (num >= 2)
				{
					if (num > 8)
					{
						throw new Exception("Too many teams defined.");
					}
					return array;
				}
				throw new Exception("Too few teams defined.");
			}
			catch (Exception ex)
			{
				Log.Error("Failed to read default_teams.json: " + ex.Message + ", using fallback.");
				return _fallback;
			}
		}
	}
	public class TeamDefinition
	{
		public string Name { get; }

		public Color Color { get; }

		public string[] Players { get; }

		public TeamDefinition(string name, Color color, string[]? players = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Name = name;
			Color = color;
			Players = players ?? Array.Empty<string>();
		}

		[JsonConstructor]
		public TeamDefinition(string name, string color, string[]? players = null)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Name = name;
			Color = ColorUtil.ParseColor(color) ?? throw new Exception("Invalid color: " + color);
			Players = players ?? Array.Empty<string>();
		}
	}
	public readonly struct MatchEndedContext
	{
		public readonly Team WinningTeam;

		public readonly Session Session;

		internal MatchEndedContext(Session session, Team winningTeam)
		{
			WinningTeam = winningTeam;
			Session = session;
		}
	}
	public readonly struct MatchStartedContext
	{
		public readonly Session Session;

		internal MatchStartedContext(Session session)
		{
			Session = session;
		}
	}
	public readonly struct RoundEndedContext
	{
		public readonly bool WasLastRound;

		public readonly int RoundNumber;

		public readonly Session Session;

		internal RoundEndedContext(Session session, bool wasLastRound, int roundNumber)
		{
			Session = session;
			WasLastRound = wasLastRound;
			RoundNumber = roundNumber;
		}
	}
	public readonly struct RoundStartedContext
	{
		public readonly int RoundNumber;

		public readonly Session Session;

		internal RoundStartedContext(Session session, int roundNumber)
		{
			Session = session;
			RoundNumber = roundNumber;
		}
	}
	internal static class LeverPatches
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__0_4;

			public static Func<Instruction, bool> <>9__0_5;

			public static Func<Instruction, bool> <>9__0_6;

			public static Func<Instruction, bool> <>9__0_7;

			public static Func<Instruction, bool> <>9__0_8;

			public static Action<StartMatchLever> <>9__0_9;

			public static Manipulator <>9__0_0;

			public static hook_DisplaySpectatorVoteTip <>9__0_1;

			public static hook_Update <>9__0_2;

			public static hook_EndGame <>9__0_3;

			internal void <Patch>b__0_0(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				ILCursor val = new ILCursor(il);
				val.GotoNext(new Func<Instruction, bool>[5]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<StartMatchLever>(x, "triggerScript"),
					(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "Start ship : [LMB]"),
					(Instruction x) => ILPatternMatchingExt.MatchStfld<InteractTrigger>(x, "hoverTip"),
					(Instruction x) => ILPatternMatchingExt.MatchRet(x)
				});
				val.GotoNext(Array.Empty<Func<Instruction, bool>>());
				val.RemoveRange(4);
				val.EmitDelegate<Action<StartMatchLever>>((Action<StartMatchLever>)delegate(StartMatchLever self)
				{
					bool flag = TimeUtil.GetCurrentGameTime().TotalHours >= (double)Session.Current.Settings.MinLeaveTime;
					self.triggerScript.hoverTip = (flag ? "Start ship : [LMB]" : "[Too early to start ship]");
					self.triggerScript.interactable = flag;
				});
			}

			internal bool <Patch>b__0_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 0);
			}

			internal bool <Patch>b__0_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<StartMatchLever>(x, "triggerScript");
			}

			internal bool <Patch>b__0_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdstr(x, "Start ship : [LMB]");
			}

			internal bool <Patch>b__0_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchStfld<InteractTrigger>(x, "hoverTip");
			}

			internal bool <Patch>b__0_8(Instruction x)
			{
				return ILPatternMatchingExt.MatchRet(x);
			}

			internal void <Patch>b__0_9(StartMatchLever self)
			{
				bool flag = TimeUtil.GetCurrentGameTime().TotalHours >= (double)Session.Current.Settings.MinLeaveTime;
				self.triggerScript.hoverTip = (flag ? "Start ship : [LMB]" : "[Too early to start ship]");
				self.triggerScript.interactable = flag;
			}

			internal void <Patch>b__0_1(orig_DisplaySpectatorVoteTip orig, HUDManager self)
			{
				if (!Session.Current.Settings.DisableAutoPilot)
				{
					orig.Invoke(self);
				}
			}

			internal void <Patch>b__0_2(orig_Update orig, HUDManager self)
			{
				orig.Invoke(self);
				if (Session.Current.Settings.DisableAutoPilot)
				{
					self.holdButtonToEndGameEarlyHoldTime = 0f;
				}
			}

			internal void <Patch>b__0_3(orig_EndGame orig, StartMatchLever self)
			{
				StartOfRound instance = StartOfRound.Instance;
				if ((!Player.Local.Controller.isPlayerDead && !instance.shipHasLanded) || instance.shipIsLeaving || instance.shipLeftAutomatically)
				{
					return;
				}
				Session current = Session.Current;
				if (current.Settings.TimeToLeave <= 0f)
				{
					Log.Info("TimeToLeave is 0, starting ship immediately.");
					orig.Invoke(self);
					return;
				}
				if (current.Teams.GetLiving().Count() == 1)
				{
					Log.Info("Only one team left, starting ship immediately.");
					orig.Invoke(self);
					return;
				}
				Team team = Player.Local.Team;
				if ((Object)(object)team == (Object)null)
				{
					Log.Warning("Player without a team pulled the lever!");
				}
				else
				{
					team.StartLeavingServerRpc();
				}
			}
		}

		public static void Patch()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0038: 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_0043: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Expected O, but got Unknown
					ILCursor val5 = new ILCursor(il);
					val5.GotoNext(new Func<Instruction, bool>[5]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<StartMatchLever>(x, "triggerScript"),
						(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "Start ship : [LMB]"),
						(Instruction x) => ILPatternMatchingExt.MatchStfld<InteractTrigger>(x, "hoverTip"),
						(Instruction x) => ILPatternMatchingExt.MatchRet(x)
					});
					val5.GotoNext(Array.Empty<Func<Instruction, bool>>());
					val5.RemoveRange(4);
					val5.EmitDelegate<Action<StartMatchLever>>((Action<StartMatchLever>)delegate(StartMatchLever self)
					{
						bool flag = TimeUtil.GetCurrentGameTime().TotalHours >= (double)Session.Current.Settings.MinLeaveTime;
						self.triggerScript.hoverTip = (flag ? "Start ship : [LMB]" : "[Too early to start ship]");
						self.triggerScript.interactable = flag;
					});
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			StartMatchLever.Update += (Manipulator)obj;
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				hook_DisplaySpectatorVoteTip val2 = delegate(orig_DisplaySpectatorVoteTip orig, HUDManager self)
				{
					if (!Session.Current.Settings.DisableAutoPilot)
					{
						orig.Invoke(self);
					}
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			HUDManager.DisplaySpectatorVoteTip += (hook_DisplaySpectatorVoteTip)obj2;
			object obj3 = <>c.<>9__0_2;
			if (obj3 == null)
			{
				hook_Update val3 = delegate(orig_Update orig, HUDManager self)
				{
					orig.Invoke(self);
					if (Session.Current.Settings.DisableAutoPilot)
					{
						self.holdButtonToEndGameEarlyHoldTime = 0f;
					}
				};
				<>c.<>9__0_2 = val3;
				obj3 = (object)val3;
			}
			HUDManager.Update += (hook_Update)obj3;
			object obj4 = <>c.<>9__0_3;
			if (obj4 == null)
			{
				hook_EndGame val4 = delegate(orig_EndGame orig, StartMatchLever self)
				{
					StartOfRound instance = StartOfRound.Instance;
					if ((Player.Local.Controller.isPlayerDead || instance.shipHasLanded) && !instance.shipIsLeaving && !instance.shipLeftAutomatically)
					{
						Session current = Session.Current;
						if (current.Settings.TimeToLeave <= 0f)
						{
							Log.Info("TimeToLeave is 0, starting ship immediately.");
							orig.Invoke(self);
						}
						else if (current.Teams.GetLiving().Count() == 1)
						{
							Log.Info("Only one team left, starting ship immediately.");
							orig.Invoke(self);
						}
						else
						{
							Team team = Player.Local.Team;
							if ((Object)(object)team == (Object)null)
							{
								Log.Warning("Player without a team pulled the lever!");
							}
							else
							{
								team.StartLeavingServerRpc();
							}
						}
					}
				};
				<>c.<>9__0_3 = val4;
				obj4 = (object)val4;
			}
			StartMatchLever.EndGame += (hook_EndGame)obj4;
		}
	}
	internal static class MiscPatches
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_UpdateProfitQuotaCurrentTime <>9__0_0;

			public static Func<Instruction, bool> <>9__2_1;

			public static Func<Instruction, bool> <>9__2_2;

			public static Func<Instruction, bool> <>9__2_3;

			public static Func<Instruction, bool> <>9__2_4;

			public static Func<Instruction, bool> <>9__2_5;

			public static Func<Instruction, bool> <>9__2_6;

			public static Manipulator <>9__2_0;

			internal void <Patch>b__0_0(orig_UpdateProfitQuotaCurrentTime _, TimeOfDay _)
			{
				StartOfRound instance = StartOfRound.Instance;
				if (!((Object)(object)instance.localPlayerController == (Object)null))
				{
					Session current = Session.Current;
					int num = current.Settings.NumberOfRounds - Mathf.Max(current.RoundNumber, 0);
					((TMP_Text)instance.deadlineMonitorText).text = ((num == 1) ? "DEADLINE: LAST ROUND!" : $"DEADLINE: {num} ROUNDS LEFT");
					Team team = Player.Local.Team;
					((TMP_Text)instance.profitQuotaMonitorText).text = (((Object)(object)team == (Object)null) ? "TEAM CREDITS: N/A" : $"TEAM CREDITS: ${team.Credits}");
				}
			}

			internal void <NoCompanyMoonPatch>b__2_0(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				val.GotoNext(new Func<Instruction, bool>[6]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<TerminalNode>(x, "buyRerouteToMoon"),
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
					(Instruction x) => ILPatternMatchingExt.MatchLdfld<Terminal>(x, "groupCredits"),
					(Instruction x) => ILPatternMatchingExt.MatchCallvirt<StartOfRound>(x, "ChangeLevelServerRpc")
				});
				Instruction next = val.Next;
				val.Emit(OpCodes.Ldarg_1);
				val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(TerminalNode), "buyRerouteToMoon"));
				val.Emit(OpCodes.Ldc_I4_3);
				val.Emit(OpCodes.Bne_Un_S, next);
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldsfld, AccessTools.Field(typeof(MiscPatches), "_refuseCompanyMoonNode"));
				val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(Terminal), "LoadNewNode", (Type[])null, (Type[])null));
				val.Emit(OpCodes.Ret);
			}

			internal bool <NoCompanyMoonPatch>b__2_1(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 0);
			}

			internal bool <NoCompanyMoonPatch>b__2_2(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 1);
			}

			internal bool <NoCompanyMoonPatch>b__2_3(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<TerminalNode>(x, "buyRerouteToMoon");
			}

			internal bool <NoCompanyMoonPatch>b__2_4(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdarg(x, 0);
			}

			internal bool <NoCompanyMoonPatch>b__2_5(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdfld<Terminal>(x, "groupCredits");
			}

			internal bool <NoCompanyMoonPatch>b__2_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallvirt<StartOfRound>(x, "ChangeLevelServerRpc");
			}
		}

		private static TerminalNode? _refuseCompanyMoonNode;

		public static void Patch()
		{
			//IL_0019: 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_0024: Expected O, but got Unknown
			NoCompanyMoonPatch();
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_UpdateProfitQuotaCurrentTime val = delegate
				{
					StartOfRound instance = StartOfRound.Instance;
					if (!((Object)(object)instance.localPlayerController == (Object)null))
					{
						Session current = Session.Current;
						int num = current.Settings.NumberOfRounds - Mathf.Max(current.RoundNumber, 0);
						((TMP_Text)instance.deadlineMonitorText).text = ((num == 1) ? "DEADLINE: LAST ROUND!" : $"DEADLINE: {num} ROUNDS LEFT");
						Team team = Player.Local.Team;
						((TMP_Text)instance.profitQuotaMonitorText).text = (((Object)(object)team == (Object)null) ? "TEAM CREDITS: N/A" : $"TEAM CREDITS: ${team.Credits}");
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			TimeOfDay.UpdateProfitQuotaCurrentTime += (hook_UpdateProfitQuotaCurrentTime)obj;
		}

		private static void NoCompanyMoonPatch()
		{
			//IL_0038: 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_0043: Expected O, but got Unknown
			_refuseCompanyMoonNode = ScriptableObject.CreateInstance<TerminalNode>();
			_refuseCompanyMoonNode.displayText = "Company moon is disabled by CompetitiveCompany.";
			_refuseCompanyMoonNode.clearPreviousText = true;
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				Manipulator val = delegate(ILContext il)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Expected O, but got Unknown
					//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_0114: Unknown result type (might be due to invalid IL or missing references)
					//IL_0120: Unknown result type (might be due to invalid IL or missing references)
					//IL_012d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0139: Unknown result type (might be due to invalid IL or missing references)
					//IL_0159: Unknown result type (might be due to invalid IL or missing references)
					//IL_017b: Unknown result type (might be due to invalid IL or missing references)
					ILCursor val2 = new ILCursor(il);
					val2.GotoNext(new Func<Instruction, bool>[6]
					{
						(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<TerminalNode>(x, "buyRerouteToMoon"),
						(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
						(Instruction x) => ILPatternMatchingExt.MatchLdfld<Terminal>(x, "groupCredits"),
						(Instruction x) => ILPatternMatchingExt.MatchCallvirt<StartOfRound>(x, "ChangeLevelServerRpc")
					});
					Instruction next = val2.Next;
					val2.Emit(OpCodes.Ldarg_1);
					val2.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(TerminalNode), "buyRerouteToMoon"));
					val2.Emit(OpCodes.Ldc_I4_3);
					val2.Emit(OpCodes.Bne_Un_S, next);
					val2.Emit(OpCodes.Ldarg_0);
					val2.Emit(OpCodes.Ldsfld, AccessTools.Field(typeof(MiscPatches), "_refuseCompanyMoonNode"));
					val2.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(Terminal), "LoadNewNode", (Type[])null, (Type[])null));
					val2.Emit(OpCodes.Ret);
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			Terminal.LoadNewNodeIfAffordable += (Manipulator)obj;
		}
	}
	public class Player : NetworkBehaviour
	{
		private struct TeamRef : INetworkSerializable
		{
			public bool HasValue;

			public NetworkBehaviourReference Ref;

			public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: 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: Unknown result type (might be due to invalid IL or missing references)
				((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref HasValue, default(ForPrimitives));
				if (HasValue)
				{
					((BufferSerializer<NetworkBehaviourReference>*)(&serializer))->SerializeValue<NetworkBehaviourReference>(ref Ref, default(ForNetworkSerializable));
				}
			}

			public bool TryGet([NotNullWhen(true)] out Team? team)
			{
				if (!HasValue)
				{
					team = null;
					return false;
				}
				NetworkBehaviour val = default(NetworkBehaviour);
				if (((NetworkBehaviourReference)(ref Ref)).TryGet(ref val, (NetworkManager)null) && val is Team team2)
				{
					team = team2;
					return true;
				}
				Log.Warning("Invalid team reference");
				team = null;
				return false;
			}

			public override string ToString()
			{
				if (!HasValue)
				{
					return "[NONE]";
				}
				NetworkBehaviour val = default(NetworkBehaviour);
				if (!((NetworkBehaviourReference)(ref Ref)).TryGet(ref val, (NetworkManager)null))
				{
					return "[INVALID]";
				}
				return ((object)val).ToString();
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_SetItemInElevator <>9__57_0;

			public static hook_SendNewPlayerValuesClientRpc <>9__57_1;

			public static Func<Instruction, bool> <>9__57_3;

			public static Func<Instruction, bool> <>9__57_4;

			public static Func<Instruction, bool> <>9__57_5;

			public static Action<PlayerControllerB, GrabbableObject> <>9__57_6;

			public static Manipulator <>9__57_2;

			internal void <Patch>b__57_0(orig_SetItemInElevator orig, PlayerControllerB self, bool inShip, bool inElevator, GrabbableObject item)
			{
				orig.Invoke(self, inShip, inElevator, item);
				if (((NetworkBehaviour)self).IsServer)
				{
					((Component)self).GetComponent<Player>().SetItemInElevator(item, inShip);
				}
			}

			internal void <Patch>b__57_1(orig_SendNewPlayerValuesClientRpc orig, PlayerControllerB self, ulong[] playerIds)
			{
				orig.Invoke(self, playerIds);
				((Component)self).GetComponent<Player>().RefreshUsernameText();
			}

			internal void <Patch>b__57_2(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				val.GotoNext(new Func<Instruction, bool>[3]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCall(x, typeof(RoundManager), "get_Instance")