using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using JetBrains.Annotations;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using LobbyControl.API;
using LobbyControl.Dependency;
using LobbyControl.Networking;
using LobbyControl.Patches;
using LobbyControl.PopUp;
using LobbyControl.TerminalCommands;
using LobbyControl.Utils;
using LobbyControl.Utils.IL;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using Netcode.Transports.Facepunch;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using Unity.Netcode.Transports.UTP;
using Unity.Networking.Transport;
using UnityEngine;
using UnityEngine.Pool;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.ASPP")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.UnityNav")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.CoreUtils")]
[assembly: IgnoresAccessChecksTo("Unity.XR.Management")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.ConformanceAutomation")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MetaQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MockRuntime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.OculusQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.RuntimeDebugger")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.SpatialTracking")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("UnityEngine.XR.LegacyInputHelpers")]
[assembly: AssemblyCompany("mattymatty")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.5.12")]
[assembly: AssemblyInformationalVersion("2.5.12+71c015f4c339daeda77c450162c119fd8080f7dd")]
[assembly: AssemblyProduct("LobbyControl")]
[assembly: AssemblyTitle("LobbyControl - Plugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.5.12.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[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 LobbyControl
{
	[BepInPlugin("mattymatty.LobbyControl", "LobbyControl", "2.5.12")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class LobbyControl : BaseUnityPlugin
	{
		public const string GUID = "mattymatty.LobbyControl";

		public const string NAME = "LobbyControl";

		public const string VERSION = "2.5.12";

		public static LobbyControl Instance;

		internal static ManualLogSource Log;

		public static bool CanModifyLobby = true;

		public static bool CanSave = true;

		public static bool AutoSaveEnabled = true;

		private static readonly string[] IncompatibleGUIDs = new string[4] { "com.github.tinyhoot.ShipLobby", "twig.latecompany", "McBowie.VeryLateCompany", "com.potatoepet.AdvancedCompany" };

		internal static readonly List<PluginInfo> FoundIncompatibilities = new List<PluginInfo>();

		internal static Harmony Harmony { get; private set; }

		internal static HashSet<Hook> Hooks { get; } = new HashSet<Hook>();

		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			try
			{
				Harmony = new Harmony("mattymatty.LobbyControl");
				PluginInfo[] array = Chainloader.PluginInfos.Values.Where((PluginInfo p) => IncompatibleGUIDs.Contains(p.Metadata.GUID)).ToArray();
				if (array.Length != 0)
				{
					StringBuilder stringBuilder = new StringBuilder("LOBBY CONTROL was DISABLED!\nIncompatible:");
					FoundIncompatibilities.AddRange(array);
					PluginInfo[] array2 = array;
					foreach (PluginInfo val in array2)
					{
						Log.LogWarning((object)(val.Metadata.Name + " is incompatible!"));
						stringBuilder.Append("\n").Append(val.Metadata.Name);
					}
					Log.LogError((object)$"{array.Length} incompatible mods found! Disabling!");
					PopUpPatch.PopUps.Add(("LC_Incompatibility", stringBuilder.ToString()));
					Harmony.PatchAll(typeof(PopUpPatch));
					return;
				}
				if (LobbyCompatibilityChecker.Enabled)
				{
					LobbyCompatibilityChecker.Init("mattymatty.LobbyControl", Version.Parse("2.5.12"), 1, 2);
				}
				Log.LogInfo((object)"Initializing Configs");
				PluginConfig.Init((BaseUnityPlugin)(object)this);
				CommandManager.Initialize();
				LobbyCommand.Init();
				Log.LogInfo((object)"Patching Methods");
				Harmony.PatchAll(typeof(PopUpPatch));
				Harmony.PatchAll(typeof(FacepunchTransportPatches));
				Harmony.PatchAll(typeof(JoinQueuePatches));
				JoinQueuePatches.Init();
				Harmony.PatchAll(typeof(LateJoinPatches));
				Harmony.PatchAll(typeof(LimitPatcher));
				Harmony.PatchAll(typeof(LobbyPatcher));
				Harmony.PatchAll(typeof(LogSpamPatches));
				Harmony.PatchAll(typeof(NetworkManagerPatch));
				Harmony.PatchAll(typeof(SavePatches));
				Harmony.PatchAll(typeof(TerminalPatch));
				Log.LogInfo((object)"LobbyControl v2.5.12 Loaded!");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Exception while initializing: \n" + ex));
			}
		}
	}
	internal static class PluginConfig
	{
		internal static class SteamLobby
		{
			internal static ConfigEntry<bool> AutoLobby;
		}

		internal static class SaveLimit
		{
			internal static ConfigEntry<bool> Enabled;
		}

		internal static class LogSpam
		{
			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<bool> CalculatePolygonPath;
		}

		internal static class JoinQueue
		{
			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<int> MaxSize;

			internal static ConfigEntry<int> ConnectionTimeout;

			internal static ConfigEntry<bool> TimeoutPopup;

			internal static ConfigEntry<bool> ConnectionPopup;

			internal static ConfigEntry<int> PreLobbyChannel;
		}

		internal static class Networking
		{
			internal static ConfigEntry<bool> Enabled;

			internal static ConfigEntry<bool> SyncRadarNames;

			internal static ConfigEntry<bool> ResetPlayerValues;
		}

		internal static void Init(BaseUnityPlugin plugin)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			ConfigFile config = plugin.Config;
			config.SaveOnConfigSet = false;
			SaveLimit.Enabled = config.Bind<bool>("SaveLimit", "enabled", true, "remove the limit to the amount of items that can be saved");
			SteamLobby.AutoLobby = config.Bind<bool>("SteamLobby", "auto_lobby", false, "automatically reopen the lobby as soon as you reach orbit");
			LogSpam.Enabled = config.Bind<bool>("LogSpam", "enabled", true, "prevent some annoying log spam");
			LogSpam.CalculatePolygonPath = config.Bind<bool>("LogSpam", "CalculatePolygonPath", true, "stop pathfinding for dead Enemies");
			JoinQueue.Enabled = config.Bind<bool>("JoinQueue", "enabled", true, "handle joining players as a queue instead of at the same time");
			JoinQueue.MaxSize = config.Bind<int>("JoinQueue", "max_size", 3, new ConfigDescription("max number of players in queue ( if queue is full extra connections will be refused )", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 65535), Array.Empty<object>()));
			JoinQueue.ConnectionTimeout = config.Bind<int>("JoinQueue", "connection_timeout_ms", 40000, new ConfigDescription("After how much time discard a hanging connection", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10000, int.MaxValue), Array.Empty<object>()));
			JoinQueue.TimeoutPopup = config.Bind<bool>("JoinQueue", "timeout_notification", true, "show a popup when a client fails to join before the timeout");
			JoinQueue.ConnectionPopup = config.Bind<bool>("JoinQueue", "connection_notification", false, "show a popup when a client tries to join");
			JoinQueue.PreLobbyChannel = config.Bind<int>("JoinQueue", "pre-lobby_channel", 28, new ConfigDescription("channel to use for pre-lobby connections", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 255), Array.Empty<object>()));
			Networking.Enabled = config.Bind<bool>("Networking", "enabled", true, "handle extra actions requested by host");
			Networking.SyncRadarNames = config.Bind<bool>("Networking", "sync_radar_names", false, "allow host to reorder radar names to align clients\nWARNING: all clients need to have the mod installed or desyncs might will happen");
			Networking.ResetPlayerValues = config.Bind<bool>("Networking", "reset_player_values", true, "allow host to force clients to reset most fields of a playerObject ( fix for invisible players )");
			JoinQueue.ConnectionTimeout.SettingChanged += delegate
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton != null)
				{
					singleton.NetworkConfig.ClientConnectionBufferTimeout = JoinQueue.ConnectionTimeout.Value / 1000 * 4;
				}
			};
			if (LethalConfigProxy.Enabled)
			{
				LethalConfigProxy.AddConfig(SaveLimit.Enabled);
				LethalConfigProxy.AddConfig(SteamLobby.AutoLobby);
				LethalConfigProxy.AddConfig(LogSpam.Enabled);
				LethalConfigProxy.AddConfig(LogSpam.CalculatePolygonPath);
				LethalConfigProxy.AddConfig(JoinQueue.Enabled);
				LethalConfigProxy.AddConfig(JoinQueue.MaxSize);
				LethalConfigProxy.AddConfig(JoinQueue.ConnectionTimeout);
				LethalConfigProxy.AddConfig(JoinQueue.TimeoutPopup);
				LethalConfigProxy.AddConfig(JoinQueue.ConnectionPopup);
				LethalConfigProxy.AddConfig(JoinQueue.PreLobbyChannel);
				LethalConfigProxy.AddConfig(Networking.Enabled);
				LethalConfigProxy.AddConfig(Networking.SyncRadarNames);
				LethalConfigProxy.AddConfig(Networking.ResetPlayerValues);
			}
			PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
			dictionary.Clear();
			config.Save();
			config.SaveOnConfigSet = true;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "mattymatty.LobbyControl";

		public const string PLUGIN_NAME = "LobbyControl";

		public const string PLUGIN_VERSION = "2.5.12";
	}
}
namespace LobbyControl.Utils
{
	public class FreeRunningTimer
	{
		private readonly Stopwatch _stopwatch = new Stopwatch();

		private TimeSpan _timeout = TimeSpan.Zero;

		public bool Enabled => _stopwatch.IsRunning;

		public bool TimedOut => _stopwatch.Elapsed > _timeout;

		public TimeSpan Elapsed => _stopwatch.Elapsed;

		public TimeSpan Remaining
		{
			get
			{
				if (!TimedOut)
				{
					return _timeout - _stopwatch.Elapsed;
				}
				return TimeSpan.Zero;
			}
		}

		public void Start(TimeSpan timeout)
		{
			_timeout = timeout;
			_stopwatch.Restart();
		}

		public void Stop()
		{
			_stopwatch.Stop();
		}
	}
	public static class HudUtils
	{
		private static readonly WaitUntil WaitForAnimation = new WaitUntil((Func<bool>)delegate
		{
			//IL_000b: 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)
			AnimatorStateInfo currentAnimatorStateInfo = HUDManager.Instance.tipsPanelAnimator.GetCurrentAnimatorStateInfo(0);
			return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime >= 1f;
		});

		internal static IEnumerator ShowMessageAfterDelay(string title, string text, float delay = 0f, bool isWarning = false)
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			yield return WaitForAnimation;
			HUDManager.Instance.DisplayTip(title, text, isWarning, false, "LC_Tip1");
		}

		internal static IEnumerator ShowTipAfterDelay(string title, string text, float delay, string saveKey)
		{
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			yield return WaitForAnimation;
			HUDManager.Instance.DisplayTip(title, text, false, true, saveKey);
		}
	}
	public static class RPCUtils
	{
		private static readonly MethodInfo BeginSendClientRpc = AccessTools.Method(typeof(NetworkBehaviour), "__beginSendClientRpc", (Type[])null, (Type[])null);

		private static readonly MethodInfo BeginSendServerRpc = AccessTools.Method(typeof(NetworkBehaviour), "__beginSendServerRpc", (Type[])null, (Type[])null);

		internal static bool TryGetRpcID(MethodInfo methodInfo, out uint rpcID)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Collection<Instruction> instructions = PatchManager.GetMethodPatcher((MethodBase)methodInfo).CopyOriginal().Definition.Body.Instructions;
			rpcID = 0u;
			for (int i = 0; i < instructions.Count; i++)
			{
				if (instructions[i].OpCode == OpCodes.Ldc_I4 && instructions[i - 1].OpCode == OpCodes.Ldarg_0)
				{
					rpcID = (uint)(int)instructions[i].Operand;
				}
				if (!(instructions[i].OpCode != OpCodes.Call))
				{
					object operand = instructions[i].Operand;
					MethodReference val = (MethodReference)((operand is MethodReference) ? operand : null);
					if (val != null && (Extensions.Is((MemberReference)(object)val, (MemberInfo)BeginSendClientRpc) || Extensions.Is((MemberReference)(object)val, (MemberInfo)BeginSendServerRpc)))
					{
						LobbyControl.Log.LogDebug((object)$"Rpc Id found for {methodInfo.Name}: {rpcID}U");
						return true;
					}
				}
			}
			LobbyControl.Log.LogFatal((object)("Cannot find Rpc ID for " + methodInfo.Name));
			return false;
		}
	}
}
namespace LobbyControl.Utils.IL
{
	internal class ILInjector
	{
		private const string INVALID = "Injector is invalid";

		private List<CodeInstruction> instructions = instructions.ToList();

		private ILGenerator generator;

		private int index;

		private int matchEnd;

		public int Index
		{
			get
			{
				return index;
			}
			set
			{
				index = value;
			}
		}

		public bool IsValid
		{
			get
			{
				if (instructions != null)
				{
					return IsIndexValid(index);
				}
				return false;
			}
		}

		public CodeInstruction Instruction
		{
			get
			{
				if (!IsIndexInRange(index))
				{
					return null;
				}
				return instructions[index];
			}
			set
			{
				if (!IsIndexInRange(index))
				{
					throw new InvalidOperationException($"Current index {index} is out of range of instruction count {instructions.Count}");
				}
				instructions[index] = value;
			}
		}

		public CodeInstruction LastMatchedInstruction
		{
			get
			{
				int num = matchEnd - 1;
				if (!IsIndexInRange(num))
				{
					return null;
				}
				return instructions[num];
			}
			set
			{
				int num = matchEnd - 1;
				if (!IsIndexInRange(num))
				{
					throw new InvalidOperationException($"Last matched index {index} is out of range of instruction count {instructions.Count}");
				}
				instructions[num] = value;
			}
		}

		public ICollection<CodeInstruction> Instructions => instructions.AsReadOnly();

		public ILInjector(IEnumerable<CodeInstruction> instructions, ILGenerator generator = null)
		{
			this.generator = generator;
			matchEnd = -1;
			base..ctor();
		}

		public ILInjector GoToStart()
		{
			matchEnd = index;
			index = 0;
			return this;
		}

		public ILInjector GoToEnd()
		{
			matchEnd = index;
			index = instructions.Count;
			return this;
		}

		public ILInjector Forward(int offset)
		{
			if (!IsValid)
			{
				return this;
			}
			matchEnd = index;
			index = Math.Clamp(index + offset, -1, instructions.Count);
			return this;
		}

		public ILInjector Back(int offset)
		{
			return Forward(-offset);
		}

		private void MarkInvalid()
		{
			index = -1;
			matchEnd = -1;
		}

		private void Search(bool forward, ILMatcher[] predicates)
		{
			if (!IsValid)
			{
				return;
			}
			int num = 1;
			if (!forward)
			{
				num = -1;
				index--;
			}
			while (forward ? (index < instructions.Count) : (index >= 0))
			{
				if (forward && index + predicates.Length > instructions.Count)
				{
					index = instructions.Count;
					break;
				}
				int i;
				for (i = 0; i < predicates.Length && predicates[i].Matches(instructions[index + i]); i++)
				{
				}
				if (i == predicates.Length)
				{
					matchEnd = index + i;
					return;
				}
				index += num;
			}
			MarkInvalid();
		}

		public ILInjector Find(params ILMatcher[] predicates)
		{
			Search(forward: true, predicates);
			return this;
		}

		public ILInjector ReverseFind(params ILMatcher[] predicates)
		{
			Search(forward: false, predicates);
			return this;
		}

		public ILInjector GoToPush(int popIndex)
		{
			if (!IsValid)
			{
				return this;
			}
			matchEnd = index;
			index--;
			int num = 0;
			while (index >= 0)
			{
				CodeInstruction instruction = instructions[index];
				num += instruction.PushCount();
				num -= instruction.PopCount();
				if (num >= popIndex)
				{
					return this;
				}
				index--;
			}
			return this;
		}

		public ILInjector SkipBranch()
		{
			if (Instruction == null)
			{
				return this;
			}
			if (!(Instruction.operand is Label label))
			{
				throw new InvalidOperationException($"Current instruction is not a branch: {Instruction}");
			}
			return FindLabel(label);
		}

		public ILInjector FindLabel(Label label)
		{
			if (label == default(Label))
			{
				return this;
			}
			matchEnd = index;
			for (index = 0; index < instructions.Count; index++)
			{
				if (instructions[index].labels.Contains(label))
				{
					return this;
				}
			}
			MarkInvalid();
			return this;
		}

		public ILInjector GoToMatchEnd()
		{
			index = matchEnd;
			return this;
		}

		public ILInjector GoToLastMatchedInstruction()
		{
			if (!IsIndexValid(matchEnd))
			{
				return this;
			}
			index = matchEnd - 1;
			return this;
		}

		private bool IsIndexValid(int index)
		{
			return index != -1;
		}

		private bool IsIndexInRange(int index)
		{
			if (index >= 0)
			{
				return index < instructions.Count;
			}
			return false;
		}

		public CodeInstruction GetRelativeInstruction(int offset)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			int num = index + offset;
			if (!IsIndexInRange(num))
			{
				throw new IndexOutOfRangeException($"Offset {offset} would read out of bounds at index {num}");
			}
			return instructions[num];
		}

		public ILInjector SetRelativeInstruction(int offset, CodeInstruction instruction)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			int num = index + offset;
			if (!IsIndexInRange(num))
			{
				throw new IndexOutOfRangeException($"Offset {offset} would write out of bounds at index {num}");
			}
			instructions[num] = instruction;
			return this;
		}

		public IEnumerable<CodeInstruction> GetRelativeInstructions(int offset, int size)
		{
			for (int i = 0; i < size; i++)
			{
				yield return instructions[index + offset + i];
			}
		}

		public IEnumerable<CodeInstruction> GetRelativeInstructions(int size)
		{
			return GetRelativeInstructions(0, size);
		}

		private void GetLastMatchRangeAbsolute(out int start, out int end)
		{
			start = index;
			end = matchEnd;
			if (start > end)
			{
				int num = end;
				int num2 = start;
				start = num;
				end = num2;
			}
		}

		private void GetLastMatchRange(out int start, out int size)
		{
			GetLastMatchRangeAbsolute(out start, out var end);
			if (start < 0 || start >= instructions.Count)
			{
				throw new InvalidOperationException($"Last match range starts at invalid index {start}");
			}
			if (end < 0 || end > instructions.Count)
			{
				throw new InvalidOperationException($"Last match range ends at invalid index {end}");
			}
			size = end - start;
		}

		public List<CodeInstruction> GetLastMatch()
		{
			GetLastMatchRange(out var start, out var size);
			return instructions.GetRange(start, size);
		}

		public ILInjector DefineLabel(out Label label)
		{
			if (generator == null)
			{
				throw new InvalidOperationException("No ILGenerator was provided");
			}
			label = generator.DefineLabel();
			return this;
		}

		public ILInjector AddLabel(out Label label)
		{
			DefineLabel(out label);
			return AddLabel(label);
		}

		public ILInjector AddLabel(Label label)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Instruction = new CodeInstruction(Instruction);
			Instruction.labels.Add(label);
			return this;
		}

		public ILInjector InsertInPlace(params CodeInstruction[] instructions)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			this.instructions.InsertRange(index, instructions);
			if (matchEnd >= index)
			{
				matchEnd += instructions.Length;
			}
			return this;
		}

		public ILInjector Insert(params CodeInstruction[] instructions)
		{
			InsertInPlace(instructions);
			index += instructions.Length;
			return this;
		}

		public ILInjector InsertInPlaceAfterBranch(params CodeInstruction[] instructions)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			List<Label> labels = Instruction.labels;
			Instruction = new CodeInstruction(Instruction);
			Instruction.labels.Clear();
			this.instructions.InsertRange(index, instructions);
			Instruction.labels.AddRange(labels);
			if (matchEnd >= index)
			{
				matchEnd += instructions.Length;
			}
			return this;
		}

		public ILInjector InsertAfterBranch(params CodeInstruction[] instructions)
		{
			InsertInPlaceAfterBranch(instructions);
			index += instructions.Length;
			return this;
		}

		public ILInjector RemoveAllPreviousInstructions()
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			instructions.RemoveRange(0, index);
			matchEnd -= index;
			if (matchEnd < 0)
			{
				matchEnd = 0;
			}
			index = 0;
			return this;
		}

		public ILInjector Remove(int count = 1)
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid");
			}
			instructions.RemoveRange(index, count);
			if (matchEnd > index)
			{
				matchEnd = Math.Max(index, matchEnd - count);
			}
			return this;
		}

		public ILInjector RemoveLastMatch()
		{
			GetLastMatchRange(out var start, out var size);
			List<Label> labels = instructions[start].labels;
			instructions.RemoveRange(start, size);
			index = start;
			matchEnd = start;
			instructions[start].labels.AddRange(labels);
			return this;
		}

		public ILInjector ReplaceLastMatch(params CodeInstruction[] replacementInstructions)
		{
			if (replacementInstructions.Length == 0)
			{
				throw new ArgumentException("Cannot replace a match with an empty array.");
			}
			GetLastMatchRange(out var start, out var size);
			List<Label> labels = instructions[start].labels;
			instructions.RemoveRange(start, size);
			instructions.InsertRange(start, replacementInstructions);
			index = start;
			matchEnd = start + replacementInstructions.Length;
			instructions[start].labels.AddRange(labels);
			return this;
		}

		public List<CodeInstruction> ReleaseInstructions()
		{
			List<CodeInstruction> result = instructions;
			instructions = null;
			return result;
		}

		public ILInjector PrintContext(int context, string header = "")
		{
			if (!IsValid)
			{
				throw new InvalidOperationException("Injector is invalid (" + header + ")");
			}
			StringBuilder stringBuilder = new StringBuilder(header);
			if (header.Length > 0)
			{
				stringBuilder.Append(':');
			}
			stringBuilder.AppendLine();
			GetLastMatchRangeAbsolute(out var start, out var end);
			int num = Math.Min(end + 1 + context, instructions.Count);
			for (int i = Math.Max(start - context, 0); i < num; i++)
			{
				if (end == -1 && i == index)
				{
					stringBuilder.Append("╶> ");
				}
				else
				{
					if (i >= start && i < end)
					{
						stringBuilder.Append("│");
					}
					else
					{
						stringBuilder.Append(" ");
					}
					if (i == index)
					{
						stringBuilder.Append("╶> ");
					}
					else
					{
						stringBuilder.Append("   ");
					}
				}
				stringBuilder.AppendLine($"{i}: {instructions[i]}");
			}
			LobbyControl.Log.LogFatal((object)stringBuilder);
			return this;
		}

		public ILInjector PrintContext(string header = "")
		{
			return PrintContext(4, header);
		}
	}
	internal interface ILMatcher
	{
		bool Matches(CodeInstruction instruction);

		ILMatcher CaptureAs(out CodeInstruction variable)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			variable = new CodeInstruction(OpCodes.Nop, (object)null);
			return new InstructionCapturingMatcher(this, variable);
		}

		unsafe ILMatcher CaptureOperandAs<T>(out T operand) where T : unmanaged
		{
			operand = default(T);
			fixed (T* operand2 = &operand)
			{
				return new OperandCapturingMatcher<T>(this, operand2);
			}
		}

		static ILMatcher Not(ILMatcher matcher)
		{
			return new NotMatcher(matcher);
		}

		static ILMatcher Opcode(OpCode opcode)
		{
			return new OpcodeMatcher(opcode);
		}

		static ILMatcher Opcodes(params OpCode[] opcodes)
		{
			return new OpcodesMatcher(opcodes);
		}

		static ILMatcher OpcodeOperand(OpCode opcode, object operand)
		{
			return new OpcodeOperandMatcher(opcode, operand);
		}

		static ILMatcher Instruction(CodeInstruction instruction)
		{
			return new InstructionMatcher(instruction);
		}

		static ILMatcher Ldarg(int? arg = null)
		{
			return new LdargMatcher(arg);
		}

		static ILMatcher Ldloc(int? loc = null)
		{
			return new LdlocMatcher(loc);
		}

		static ILMatcher Stloc(int? loc = null)
		{
			return new StlocMatcher(loc);
		}

		static ILMatcher Ldc(int? value = null)
		{
			return new LdcI32Matcher(value);
		}

		static ILMatcher Branch()
		{
			return new BranchMatcher();
		}

		static ILMatcher Ldfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				LobbyControl.Log.LogWarning((object)$"Field passed to ILMatcher.Ldfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Ldfld, field);
		}

		static ILMatcher Ldsfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				LobbyControl.Log.LogWarning((object)$"Field passed to ILMatcher.Ldsfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Ldsfld, field);
		}

		static ILMatcher Stfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				LobbyControl.Log.LogWarning((object)$"Field passed to ILMatcher.Stfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Stfld, field);
		}

		static ILMatcher Stsfld(FieldInfo field, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (field == null)
			{
				LobbyControl.Log.LogWarning((object)$"Field passed to ILMatcher.Stsfld() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return new OpcodeOperandMatcher(OpCodes.Stsfld, field);
		}

		static ILMatcher Callvirt(MethodBase method, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (method == null)
			{
				LobbyControl.Log.LogWarning((object)$"Method passed to ILMatcher.Callvirt() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return OpcodeOperand(OpCodes.Callvirt, method);
		}

		static ILMatcher Call(MethodBase method, [CallerMemberName] string callerName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
		{
			if (method == null)
			{
				LobbyControl.Log.LogWarning((object)$"Method passed to ILMatcher.Call() was null at {sourceFilePath}#{sourceLineNumber} ({callerName})");
			}
			return OpcodeOperand(OpCodes.Call, method);
		}

		static ILMatcher Predicate(Func<CodeInstruction, bool> predicate)
		{
			return new PredicateMatcher(predicate);
		}

		static ILMatcher Predicate(Func<FieldInfo, bool> predicate)
		{
			return new PredicateMatcher((CodeInstruction insn) => insn.operand is FieldInfo arg && predicate(arg));
		}
	}
	internal class NotMatcher(ILMatcher matcher) : ILMatcher
	{
		private readonly ILMatcher matcher = matcher;

		public bool Matches(CodeInstruction instruction)
		{
			return !matcher.Matches(instruction);
		}
	}
	internal class OpcodeMatcher(OpCode opcode) : ILMatcher
	{
		private readonly OpCode opcode = opcode;

		public bool Matches(CodeInstruction instruction)
		{
			return instruction.opcode == opcode;
		}
	}
	internal class OpcodesMatcher(OpCode[] opcodes) : ILMatcher
	{
		private readonly OpCode[] opcodes = opcodes;

		public bool Matches(CodeInstruction instruction)
		{
			return opcodes.Contains(instruction.opcode);
		}
	}
	internal class OpcodeOperandMatcher(OpCode opcode, object operand) : ILMatcher
	{
		private readonly OpCode opcode = opcode;

		private readonly object operand = operand;

		public bool Matches(CodeInstruction instruction)
		{
			if (instruction.opcode == opcode)
			{
				return instruction.operand == operand;
			}
			return false;
		}
	}
	internal class InstructionMatcher : ILMatcher
	{
		private readonly OpCode opcode = instruction.opcode;

		private readonly object operand = instruction.operand;

		private readonly Label[] labels = instruction.labels.ToArray();

		public InstructionMatcher(CodeInstruction instruction)
		{
		}

		public bool Matches(CodeInstruction instruction)
		{
			if (instruction.opcode != opcode)
			{
				return false;
			}
			if (instruction.operand != operand)
			{
				return false;
			}
			if (instruction.labels.Count != labels.Length)
			{
				return false;
			}
			for (int i = 0; i < labels.Length; i++)
			{
				if (labels[i] != instruction.labels[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	internal class LdargMatcher(int? arg) : ILMatcher
	{
		private readonly int? arg = arg;

		public bool Matches(CodeInstruction instruction)
		{
			if (!arg.HasValue)
			{
				return instruction.GetLdargIndex().HasValue;
			}
			return instruction.GetLdargIndex() == arg;
		}
	}
	internal class LdlocMatcher(int? loc) : ILMatcher
	{
		private readonly int? loc = loc;

		public bool Matches(CodeInstruction instruction)
		{
			if (!loc.HasValue)
			{
				return instruction.GetLdlocIndex().HasValue;
			}
			return instruction.GetLdlocIndex() == loc;
		}
	}
	internal class StlocMatcher(int? loc) : ILMatcher
	{
		private readonly int? loc = loc;

		public bool Matches(CodeInstruction instruction)
		{
			if (!loc.HasValue)
			{
				return instruction.GetStlocIndex().HasValue;
			}
			return instruction.GetStlocIndex() == loc;
		}
	}
	internal class LdcI32Matcher(int? value) : ILMatcher
	{
		private readonly int? value = value;

		public bool Matches(CodeInstruction instruction)
		{
			if (!value.HasValue)
			{
				return instruction.GetLdcI32().HasValue;
			}
			return instruction.GetLdcI32() == value;
		}
	}
	internal class BranchMatcher : ILMatcher
	{
		public bool Matches(CodeInstruction instruction)
		{
			Label? label = default(Label?);
			return CodeInstructionExtensions.Branches(instruction, ref label);
		}
	}
	internal class PredicateMatcher(Func<CodeInstruction, bool> predicate) : ILMatcher
	{
		private readonly Func<CodeInstruction, bool> predicate = predicate;

		public bool Matches(CodeInstruction instruction)
		{
			return predicate(instruction);
		}
	}
	internal class InstructionCapturingMatcher(ILMatcher matcher, CodeInstruction variable) : ILMatcher
	{
		private readonly ILMatcher matcher = matcher;

		private readonly CodeInstruction variable = variable;

		public bool Matches(CodeInstruction instruction)
		{
			bool flag = matcher.Matches(instruction);
			if (flag)
			{
				variable.opcode = instruction.opcode;
				variable.operand = instruction.operand;
				variable.blocks = instruction.blocks.ToList();
				variable.labels = instruction.labels.ToList();
			}
			return flag;
		}
	}
	internal unsafe class OperandCapturingMatcher<T>(ILMatcher matcher, T* operand) : ILMatcher where T : unmanaged
	{
		private readonly ILMatcher matcher = matcher;

		private unsafe readonly T* operand = operand;

		public unsafe bool Matches(CodeInstruction instruction)
		{
			bool flag = matcher.Matches(instruction);
			if (flag)
			{
				*operand = (T)instruction.operand;
			}
			return flag;
		}
	}
	internal static class InstructionUtilities
	{
		public static CodeInstruction MakeLdarg(int index)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if (index < 256)
			{
				return (CodeInstruction)(index switch
				{
					0 => (object)new CodeInstruction(OpCodes.Ldarg_0, (object)null), 
					1 => (object)new CodeInstruction(OpCodes.Ldarg_1, (object)null), 
					2 => (object)new CodeInstruction(OpCodes.Ldarg_2, (object)null), 
					3 => (object)new CodeInstruction(OpCodes.Ldarg_3, (object)null), 
					_ => (object)new CodeInstruction(OpCodes.Ldarg_S, (object)index), 
				});
			}
			return new CodeInstruction(OpCodes.Ldarg, (object)index);
		}

		public static int PopCount(this CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Call || instruction.opcode == OpCodes.Callvirt || instruction.opcode == OpCodes.Newobj)
			{
				MethodBase methodBase = (MethodBase)instruction.operand;
				int num = methodBase.GetParameters().Length;
				if (!methodBase.IsStatic)
				{
					num++;
				}
				return num;
			}
			if (instruction.opcode == OpCodes.Ret)
			{
				return 1;
			}
			return instruction.opcode.StackBehaviourPop switch
			{
				StackBehaviour.Pop0 => 0, 
				StackBehaviour.Pop1 => 1, 
				StackBehaviour.Pop1_pop1 => 2, 
				StackBehaviour.Popi => 1, 
				StackBehaviour.Popi_pop1 => 2, 
				StackBehaviour.Popi_popi => 2, 
				StackBehaviour.Popi_popi8 => 2, 
				StackBehaviour.Popi_popi_popi => 3, 
				StackBehaviour.Popi_popr4 => 2, 
				StackBehaviour.Popi_popr8 => 2, 
				StackBehaviour.Popref => 1, 
				StackBehaviour.Popref_pop1 => 2, 
				StackBehaviour.Popref_popi => 2, 
				StackBehaviour.Popref_popi_popi => 3, 
				StackBehaviour.Popref_popi_popi8 => 3, 
				StackBehaviour.Popref_popi_popr4 => 3, 
				StackBehaviour.Popref_popi_popr8 => 3, 
				StackBehaviour.Popref_popi_popref => 3, 
				StackBehaviour.Varpop => throw new NotImplementedException($"Variable pop on non-call instruction '{instruction}'"), 
				StackBehaviour.Popref_popi_pop1 => 3, 
				_ => throw new NotSupportedException($"StackBehaviourPop of {instruction.opcode.StackBehaviourPop} was not a pop for instruction '{instruction}'"), 
			};
		}

		public static int PushCount(this CodeInstruction instruction)
		{
			if (instruction.opcode == OpCodes.Call || instruction.opcode == OpCodes.Callvirt || instruction.opcode == OpCodes.Newobj)
			{
				if (instruction.operand is MethodInfo methodInfo && methodInfo.ReturnType == typeof(void))
				{
					return 0;
				}
				return 1;
			}
			return instruction.opcode.StackBehaviourPush switch
			{
				StackBehaviour.Push0 => 0, 
				StackBehaviour.Push1 => 1, 
				StackBehaviour.Push1_push1 => 2, 
				StackBehaviour.Pushi => 1, 
				StackBehaviour.Pushi8 => 1, 
				StackBehaviour.Pushr4 => 1, 
				StackBehaviour.Pushr8 => 1, 
				StackBehaviour.Pushref => 1, 
				StackBehaviour.Varpush => throw new NotImplementedException($"Variable push on non-call instruction '{instruction}'"), 
				_ => throw new NotSupportedException($"StackBehaviourPush of {instruction.opcode.StackBehaviourPush} was not a push for instruction '{instruction}'"), 
			};
		}

		public static int? GetLdargIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldarg_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldarg_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldarg_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldarg_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldarg || opcode == OpCodes.Ldarg_S)
			{
				return instruction.operand as int?;
			}
			return null;
		}

		public static int? GetLdlocIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldloc_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldloc_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldloc_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldloc_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldloc || opcode == OpCodes.Ldloc_S)
			{
				return (instruction.operand as LocalBuilder)?.LocalIndex;
			}
			return null;
		}

		public static int? GetStlocIndex(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Stloc_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Stloc_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Stloc_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Stloc_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Stloc || opcode == OpCodes.Stloc_S)
			{
				return (instruction.operand as LocalBuilder)?.LocalIndex;
			}
			return null;
		}

		public static CodeInstruction LdlocToStloc(this CodeInstruction instruction)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldloc_0)
			{
				return new CodeInstruction(OpCodes.Stloc_0, (object)null);
			}
			if (opcode == OpCodes.Ldloc_1)
			{
				return new CodeInstruction(OpCodes.Stloc_1, (object)null);
			}
			if (opcode == OpCodes.Ldloc_2)
			{
				return new CodeInstruction(OpCodes.Stloc_2, (object)null);
			}
			if (opcode == OpCodes.Ldloc_3)
			{
				return new CodeInstruction(OpCodes.Stloc_3, (object)null);
			}
			if (opcode == OpCodes.Ldloc || opcode == OpCodes.Ldloc_S)
			{
				return new CodeInstruction(OpCodes.Stloc, instruction.operand);
			}
			return null;
		}

		public static CodeInstruction StlocToLdloc(this CodeInstruction instruction)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Stloc_0)
			{
				return new CodeInstruction(OpCodes.Ldloc_0, (object)null);
			}
			if (opcode == OpCodes.Stloc_1)
			{
				return new CodeInstruction(OpCodes.Ldloc_1, (object)null);
			}
			if (opcode == OpCodes.Stloc_2)
			{
				return new CodeInstruction(OpCodes.Ldloc_2, (object)null);
			}
			if (opcode == OpCodes.Stloc_3)
			{
				return new CodeInstruction(OpCodes.Ldloc_3, (object)null);
			}
			if (opcode == OpCodes.Stloc || opcode == OpCodes.Stloc_S)
			{
				return new CodeInstruction(OpCodes.Ldloc, instruction.operand);
			}
			return null;
		}

		public static int? GetLdcI32(this CodeInstruction instruction)
		{
			OpCode opcode = instruction.opcode;
			if (opcode == OpCodes.Ldc_I4_M1)
			{
				return -1;
			}
			if (opcode == OpCodes.Ldc_I4_0)
			{
				return 0;
			}
			if (opcode == OpCodes.Ldc_I4_1)
			{
				return 1;
			}
			if (opcode == OpCodes.Ldc_I4_2)
			{
				return 2;
			}
			if (opcode == OpCodes.Ldc_I4_3)
			{
				return 3;
			}
			if (opcode == OpCodes.Ldc_I4_4)
			{
				return 4;
			}
			if (opcode == OpCodes.Ldc_I4_5)
			{
				return 5;
			}
			if (opcode == OpCodes.Ldc_I4_6)
			{
				return 6;
			}
			if (opcode == OpCodes.Ldc_I4_7)
			{
				return 7;
			}
			if (opcode == OpCodes.Ldc_I4_8)
			{
				return 8;
			}
			if (opcode == OpCodes.Ldc_I4_S)
			{
				return instruction.operand as sbyte?;
			}
			if (opcode == OpCodes.Ldc_I4)
			{
				return instruction.operand as int?;
			}
			return null;
		}
	}
	public static class ReflectionExtensions
	{
		public static MethodInfo GetGenericMethod(this Type type, string name, Type[] parameters, Type[] genericArgs)
		{
			MethodInfo[] methods = type.GetMethods();
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo in array)
			{
				if (!(methodInfo.Name != name) && methodInfo.IsGenericMethodDefinition)
				{
					return methodInfo.MakeGenericMethod(genericArgs);
				}
			}
			return null;
		}
	}
}
namespace LobbyControl.TerminalCommands
{
	public class Command
	{
		public TerminalNode previousTerminalNode;

		public bool awaitingConfirmation
		{
			get
			{
				return CommandManager.awaitingConfirmationCommand == this;
			}
			set
			{
				CommandManager.awaitingConfirmationCommand = (value ? this : null);
			}
		}

		public virtual bool IsCommand(string[] args)
		{
			return false;
		}

		public virtual TerminalNode Execute(string[] args)
		{
			return TerminalPatch.CreateTerminalNode("Execute override was not found.\n\n");
		}

		public virtual TerminalNode ExecuteConfirmation(string[] args)
		{
			string text = args[0].ToLower();
			if ("confirm".Contains(text) && text.Length > 0)
			{
				return OnConfirm(args);
			}
			if ("deny".Contains(text) && text.Length > 0)
			{
				return OnDeny(args);
			}
			return OnInvalidInput(args);
		}

		protected virtual TerminalNode OnConfirm(string[] args)
		{
			return TerminalPatch.CreateTerminalNode("OnConfirm override was not found.\n\n");
		}

		protected virtual TerminalNode OnDeny(string[] args)
		{
			return TerminalPatch.CreateTerminalNode("OnDeny override was not found.\n\n");
		}

		protected virtual TerminalNode OnInvalidInput(string[] args)
		{
			return previousTerminalNode;
		}
	}
	internal class CommandManager
	{
		private static List<Command> commands = new List<Command>();

		public static Command awaitingConfirmationCommand;

		public static void Initialize()
		{
			commands = new List<Command>
			{
				new LobbyCommand()
			};
			awaitingConfirmationCommand = null;
		}

		public static bool TryExecuteCommand(string[] array, out TerminalNode terminalNode)
		{
			terminalNode = null;
			if (awaitingConfirmationCommand != null)
			{
				Command command = awaitingConfirmationCommand;
				terminalNode = command.ExecuteConfirmation(array);
				command.previousTerminalNode = terminalNode;
				return true;
			}
			Command command2 = GetCommand(array);
			if (command2 == null)
			{
				return false;
			}
			terminalNode = command2.Execute(array);
			command2.previousTerminalNode = terminalNode;
			return true;
		}

		public static void OnLocalDisconnect()
		{
			awaitingConfirmationCommand = null;
		}

		public static void OnTerminalQuit()
		{
			awaitingConfirmationCommand = null;
		}

		private static Command GetCommand(string[] args)
		{
			Command result = null;
			commands.ForEach(delegate(Command command)
			{
				if (result == null && command.IsCommand(args))
				{
					result = command;
				}
			});
			return result;
		}
	}
	public class LobbyCommand : Command
	{
		private const string DefaultText = "- status        : prints the current lobby status\r\n\r\nSteam:\r\n- open          : open the lobby\r\n- close         : close the lobby\r\n- private       : set lobby to Invite Only\r\n- friend        : set lobby to Friends Only\r\n- public        : set lobby to Public\r\n- rename [name] : change the name of the lobby\r\n\r\nSaving:\r\n- autosave      : toggle autosave for the savefile\r\n- save (name)   : save the lobby\r\n- load (name)   : load a savefile\r\n- switch (name) : swap savefile without loading it\r\n- clear         : reset the current lobby to empty\r\n\r\nExtra:\r\n- dropall       : drop all items to the ground\r\n";

		private const string DefaultTextLAN = "- status        : prints the current lobby status\r\n\r\nLAN:\r\n- open          : set the lobby to be discoverable\r\n- close         : set the lobby to be non-discoverable\r\n- rename [name] : change the name of the lobby\r\n\r\nSaving:\r\n- autosave      : toggle autosave for the savefile\r\n- save (name)   : save the lobby\r\n- load (name)   : load a savefile\r\n- switch (name) : swap savefile without loading it\r\n- clear         : reset the current lobby to empty\r\n\r\nExtra:\r\n- dropall       : drop all items to the ground\r\n";

		private static uint? _returnUnlockableFromStorageServerRpcID;

		private static uint? _onPlayerConnectedClientRpcID;

		public override bool IsCommand(string[] args)
		{
			if (GameNetworkManager.Instance.isHostingGame)
			{
				return args[0].Trim().ToLower() == "lobby";
			}
			return false;
		}

		public override TerminalNode Execute(string[] args)
		{
			TerminalNode node = ScriptableObject.CreateInstance<TerminalNode>();
			try
			{
				if (Utility.IsNullOrWhiteSpace(args[1]))
				{
					return HelpNode();
				}
				switch (args[1])
				{
				case "status":
					StatusCommand(ref node, args);
					break;
				case "open":
				{
					if (PerformOrbitCheck(node, out var errorText10))
					{
						return errorText10;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						OpenCommand(ref node, args);
					}
					break;
				}
				case "close":
				{
					if (PerformOrbitCheck(node, out var errorText7))
					{
						return errorText7;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						CloseCommand(ref node, args);
					}
					break;
				}
				case "private":
				{
					if (PerformOrbitCheck(node, out var errorText3))
					{
						return errorText3;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						PrivateCommand(ref node, args);
					}
					break;
				}
				case "friend":
				{
					if (PerformOrbitCheck(node, out var errorText11))
					{
						return errorText11;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						FriendCommand(ref node, args);
					}
					break;
				}
				case "public":
				{
					if (PerformOrbitCheck(node, out var errorText2))
					{
						return errorText2;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						PublicCommand(ref node, args);
					}
					break;
				}
				case "rename":
				{
					if (PerformOrbitCheck(node, out var errorText6))
					{
						return errorText6;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						RenameCommand(ref node, args);
					}
					break;
				}
				case "autosave":
					AutoSaveCommand(ref node, args);
					break;
				case "save":
				{
					if (PerformOrbitCheck(node, out var errorText8))
					{
						return errorText8;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						SaveCommand(ref node, args);
					}
					break;
				}
				case "load":
				{
					if (PerformOrbitCheck(node, out var errorText4))
					{
						return errorText4;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						LoadCommand(ref node, args);
					}
					break;
				}
				case "switch":
				{
					if (PerformOrbitCheck(node, out var errorText9))
					{
						return errorText9;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						SwitchCommand(ref node, args);
					}
					break;
				}
				case "clear":
				{
					if (PerformOrbitCheck(node, out var errorText5))
					{
						return errorText5;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						ClearCommand(ref node, args);
					}
					break;
				}
				case "dropall":
				{
					if (PerformOrbitCheck(node, out var errorText))
					{
						return errorText;
					}
					if (!LobbyControl.CanModifyLobby)
					{
						node.displayText = "Lobby cannot be changed at the moment\n\n";
					}
					else
					{
						DropAllCommand(ref node, args);
					}
					break;
				}
				case "help":
					node = HelpNode();
					break;
				default:
					node = HelpNode();
					node.displayText = "Invalid Command, options:\n" + node.displayText;
					break;
				}
			}
			catch (Exception ex)
			{
				LobbyControl.Log.LogError((object)("Exception:\n\n" + ex));
				node.displayText = "Exception!\n\n";
			}
			return node;
		}

		private static bool StatusCommand(ref TerminalNode node, string[] args)
		{
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder;
			if (args.Length > 2 && args[2].ToLower().Equals("queue"))
			{
				stringBuilder = new StringBuilder("Lobby Queue Status:");
				if (JoinQueuePatches.ConnectingClient != null)
				{
					stringBuilder.Append("\n┬ Connecting client is '").Append(JoinQueuePatches.ConnectingClient.Name).Append("'");
					stringBuilder.Append("\n└ Remaining time: ").Append(JoinQueuePatches.ConnectionTimer.Remaining.TotalMilliseconds).Append(" ms");
				}
				else
				{
					stringBuilder.Append("\n─ No client is currently connecting");
				}
				stringBuilder.Append("\n┬ Queued clients: ").Append(JoinQueuePatches.ConnectionQueue.Count);
				foreach (JoinQueuePatches.ConnectionQueueEntry item in JoinQueuePatches.ConnectionQueue.Take(7))
				{
					stringBuilder.Append("\n├ ").Append(item.Name);
				}
				stringBuilder.Append("\n└ [...]");
			}
			else
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				bool flag = false;
				string value = instance.steamLobbyName;
				string value2;
				if (instance.disableSteam)
				{
					UnityTransport component = ((Component)NetworkManager.Singleton).GetComponent<UnityTransport>();
					value2 = ((component.ConnectionData.ServerListenAddress == "0.0.0.0") ? "Public" : "Private");
				}
				else
				{
					if (!instance.currentLobby.HasValue)
					{
						node.displayText = "Failed to fetch lobby ( was null )\n\n";
						return false;
					}
					Lobby value3 = instance.currentLobby.Value;
					flag = LobbyPatcher.IsOpen(value3);
					value2 = ((object)LobbyPatcher.GetVisibility(value3)/*cast due to .constrained prefix*/).ToString();
					value = ((Lobby)(ref value3)).GetData("name");
				}
				bool canSave = LobbyControl.CanSave;
				stringBuilder = new StringBuilder("Lobby Status:");
				stringBuilder.Append("\n- File is '").Append(instance.currentSaveFileName).Append("'");
				stringBuilder.Append("\n- Name is '").Append(value).Append("'");
				if (!instance.disableSteam)
				{
					stringBuilder.Append("\n- Status is ").Append(flag ? "Open" : "Closed");
				}
				stringBuilder.Append("\n- Visibility is ").Append(value2);
				stringBuilder.Append("\n- Saving is ").Append(canSave ? "Automatic" : "Manual");
				if (PluginConfig.JoinQueue.Enabled.Value)
				{
					stringBuilder.Append("\n");
					stringBuilder.Append("\n- ").Append(JoinQueuePatches.QueuedClients).Append(" Players are waiting in queue");
					stringBuilder.Append("\n Type 'lobby status queue' for more details");
				}
			}
			stringBuilder.Append("\n\n");
			node.displayText = stringBuilder.ToString();
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool OpenCommand(ref TerminalNode node, string[] args)
		{
			LobbyControl.Log.LogDebug((object)"Reopening lobby, setting to joinable.");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (instance.disableSteam)
			{
				UnityTransport component = ((Component)NetworkManager.Singleton).GetComponent<UnityTransport>();
				if (component.ConnectionData.ServerListenAddress != "0.0.0.0")
				{
					node.displayText = "Server is limited to local connections\n\n";
					return false;
				}
				instance.lobbyHostSettings.isLobbyPublic = true;
				ES3.Save<bool>("HostSettings_Public", instance.lobbyHostSettings.isLobbyPublic, "LCGeneralSaveData");
			}
			else if (!instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			instance.SetLobbyJoinable(true);
			Object.FindObjectOfType<QuickMenuManager>().inviteFriendsTextAlpha.alpha = 1f;
			string text = "Lobby is now Open";
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool CloseCommand(ref TerminalNode node, string[] args)
		{
			LobbyControl.Log.LogDebug((object)"Closing lobby, setting to not joinable.");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (instance.disableSteam)
			{
				UnityTransport component = ((Component)NetworkManager.Singleton).GetComponent<UnityTransport>();
				if (component.ConnectionData.ServerListenAddress != "0.0.0.0")
				{
					node.displayText = "Server is limited to local connections\n\n";
					return false;
				}
				instance.lobbyHostSettings.isLobbyPublic = false;
				ES3.Save<bool>("HostSettings_Public", instance.lobbyHostSettings.isLobbyPublic, "LCGeneralSaveData");
			}
			else if (!instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			instance.SetLobbyJoinable(false);
			Object.FindObjectOfType<QuickMenuManager>().inviteFriendsTextAlpha.alpha = 0f;
			string text = "Lobby is now Closed";
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool PrivateCommand(ref TerminalNode node, string[] args)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			LobbyControl.Log.LogDebug((object)"Locking lobby, setting to Private.");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			ES3.Save<bool>("HostSettings_Public", false, "LCGeneralSaveData");
			Lobby value = instance.currentLobby.Value;
			((Lobby)(ref value)).SetPrivate();
			string text = "Lobby is now Private";
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool FriendCommand(ref TerminalNode node, string[] args)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			LobbyControl.Log.LogDebug((object)"Locking lobby, setting to Friends Only.");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			ES3.Save<bool>("HostSettings_Public", false, "LCGeneralSaveData");
			Lobby value = instance.currentLobby.Value;
			((Lobby)(ref value)).SetFriendsOnly();
			string text = "Lobby is now Friends Only";
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool PublicCommand(ref TerminalNode node, string[] args)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			LobbyControl.Log.LogDebug((object)"Unlocking lobby, setting to Public.");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			ES3.Save<bool>("HostSettings_Public", true, "LCGeneralSaveData");
			Lobby value = instance.currentLobby.Value;
			((Lobby)(ref value)).SetPublic();
			string text = "Lobby is now Public";
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool RenameCommand(ref TerminalNode node, string[] args)
		{
			//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)
			if (Utility.IsNullOrWhiteSpace(args[2]))
			{
				node.displayText = "Lobby name cannot be null\n\n";
				return false;
			}
			string text = args[2];
			if (text.Length > 40)
			{
				text = text.Substring(0, 40);
			}
			LobbyControl.Log.LogDebug((object)("Renaming lobby: \"" + text + "\""));
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!instance.disableSteam && !instance.currentLobby.HasValue)
			{
				node.displayText = "Failed to fetch lobby ( was null )\n\n";
				return false;
			}
			instance.lobbyHostSettings.lobbyName = text;
			instance.steamLobbyName = instance.lobbyHostSettings.lobbyName;
			if (instance.currentLobby.HasValue)
			{
				Lobby value = instance.currentLobby.Value;
				((Lobby)(ref value)).SetData("name", instance.steamLobbyName);
			}
			ES3.Save<string>("HostSettings_Name", instance.steamLobbyName, "LCGeneralSaveData");
			string text2 = "Lobby renamed to \"" + text + "\"";
			LobbyControl.Log.LogInfo((object)text2);
			node.displayText = text2 + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool AutoSaveCommand(ref TerminalNode node, string[] args)
		{
			LobbyControl.Log.LogDebug((object)"Toggling AutoSave");
			LobbyControl.CanSave = (LobbyControl.AutoSaveEnabled = !LobbyControl.AutoSaveEnabled);
			string text = "AutoSaving is now " + (LobbyControl.CanSave ? "On" : "Off");
			LobbyControl.Log.LogInfo((object)text);
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool SaveCommand(ref TerminalNode node, string[] args)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				node.displayText = "Cannot Edit Challenge Save\n\n";
				return false;
			}
			LobbyControl.Log.LogDebug((object)"Saving Lobby");
			GameNetworkManager instance = GameNetworkManager.Instance;
			string currentSaveFileName = instance.currentSaveFileName;
			if (!Utility.IsNullOrWhiteSpace(args[2]))
			{
				string text = args[2];
				if (text.Length > 20)
				{
					text = text.Substring(0, 20);
				}
				instance.currentSaveFileName = text;
			}
			if (currentSaveFileName != instance.currentSaveFileName)
			{
				ES3.CopyFile(currentSaveFileName, instance.currentSaveFileName);
			}
			LobbyControl.CanSave = true;
			HUDManager.Instance.saveDataIconAnimatorB.SetTrigger("save");
			instance.SaveGameValues();
			string text2 = "Lobby Saved to " + instance.currentSaveFileName;
			LobbyControl.CanSave = LobbyControl.AutoSaveEnabled;
			instance.currentSaveFileName = currentSaveFileName;
			LobbyControl.Log.LogInfo((object)text2);
			node.displayText = text2 + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool LoadCommand(ref TerminalNode node, string[] args)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				node.displayText = "Cannot Edit Challenge Save\n\n";
				return false;
			}
			LobbyControl.Log.LogDebug((object)"Reloading Lobby");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (!Utility.IsNullOrWhiteSpace(args[2]))
			{
				string text = args[2];
				if (text.Length > 20)
				{
					text = text.Substring(0, 20);
				}
				instance.currentSaveFileName = text;
			}
			string text2 = "Lobby '" + instance.currentSaveFileName + "' loaded";
			((MonoBehaviour)StartOfRound.Instance).StartCoroutine(LoadLobbyCoroutine());
			LobbyControl.AutoSaveEnabled = (LobbyControl.CanSave = ES3.Load<bool>("LC_SavingMethod", GameNetworkManager.Instance.currentSaveFileName, true));
			LobbyControl.Log.LogInfo((object)text2);
			node.displayText = text2 + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool SwitchCommand(ref TerminalNode node, string[] args)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				node.displayText = "Cannot Edit Challenge Save\n\n";
				return false;
			}
			LobbyControl.Log.LogDebug((object)"Switching Lobby");
			GameNetworkManager instance = GameNetworkManager.Instance;
			if (Utility.IsNullOrWhiteSpace(args[2]))
			{
				node.displayText = "You need to specify a destination for the swap!";
				return false;
			}
			string text = args[2];
			if (text.Length > 20)
			{
				text = text.Substring(0, 20);
			}
			instance.currentSaveFileName = text;
			string text2 = "Lobby is now saving to '" + instance.currentSaveFileName + "'";
			node.displayText = text2 + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool ClearCommand(ref TerminalNode node, string[] args)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				node.displayText = "Cannot Edit Challenge Save\n\n";
				return false;
			}
			LobbyControl.Log.LogDebug((object)"Clearing Lobby");
			LobbyControl.CanSave = true;
			GameNetworkManager.Instance.ResetSavedGameValues();
			ES3.DeleteFile(GameNetworkManager.Instance.currentSaveFileName);
			LobbyControl.CanSave = LobbyControl.AutoSaveEnabled;
			bool flag = LoadCommand(ref node, new string[3]);
			if (flag)
			{
				node.displayText = "Lobby is now Empty!";
			}
			return flag;
		}

		private static bool DropAllCommand(ref TerminalNode node, string[] args)
		{
			LobbyControl.Log.LogDebug((object)"Dropping all Items");
			string text = "All Items Dropped";
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				val.DropAllHeldItemsAndSyncNonexact();
			}
			node.displayText = text + "\n\n";
			node.maxCharactersToType = node.displayText.Length + 2;
			return true;
		}

		private static bool PerformOrbitCheck(TerminalNode terminalNode, out TerminalNode errorText)
		{
			if (!StartOfRound.Instance.inShipPhase)
			{
				terminalNode.displayText = "Can only be used while in Orbit\n\n";
				errorText = terminalNode;
				return true;
			}
			errorText = null;
			return false;
		}

		private static TerminalNode HelpNode()
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.displayText = (GameNetworkManager.Instance.disableSteam ? "- status        : prints the current lobby status\r\n\r\nLAN:\r\n- open          : set the lobby to be discoverable\r\n- close         : set the lobby to be non-discoverable\r\n- rename [name] : change the name of the lobby\r\n\r\nSaving:\r\n- autosave      : toggle autosave for the savefile\r\n- save (name)   : save the lobby\r\n- load (name)   : load a savefile\r\n- switch (name) : swap savefile without loading it\r\n- clear         : reset the current lobby to empty\r\n\r\nExtra:\r\n- dropall       : drop all items to the ground\r\n" : "- status        : prints the current lobby status\r\n\r\nSteam:\r\n- open          : open the lobby\r\n- close         : close the lobby\r\n- private       : set lobby to Invite Only\r\n- friend        : set lobby to Friends Only\r\n- public        : set lobby to Public\r\n- rename [name] : change the name of the lobby\r\n\r\nSaving:\r\n- autosave      : toggle autosave for the savefile\r\n- save (name)   : save the lobby\r\n- load (name)   : load a savefile\r\n- switch (name) : swap savefile without loading it\r\n- clear         : reset the current lobby to empty\r\n\r\nExtra:\r\n- dropall       : drop all items to the ground\r\n");
			val.clearPreviousText = true;
			val.maxCharactersToType = val.displayText.Length + 2;
			return val;
		}

		private static IEnumerator LoadLobbyCoroutine()
		{
			StartOfRound startOfRound = StartOfRound.Instance;
			Terminal terminal = Object.FindObjectOfType<Terminal>();
			startOfRound.ResetShip();
			VehicleController[] array = Object.FindObjectsOfType<VehicleController>();
			VehicleController[] array2 = array;
			foreach (VehicleController val in array2)
			{
				if ((Object)(object)((NetworkBehaviour)val).NetworkObject != (Object)null)
				{
					((NetworkBehaviour)val).NetworkObject.Despawn(false);
				}
			}
			bool mem = GameNetworkManager.Instance.gameHasStarted;
			GameNetworkManager.Instance.gameHasStarted = false;
			foreach (KeyValuePair<int, GameObject> item in StartOfRound.Instance.SpawnedShipUnlockables.ToList())
			{
				UnlockableItem val2 = startOfRound.unlockablesList.unlockables[item.Key];
				if (val2.alreadyUnlocked && val2.spawnPrefab && !((Object)(object)item.Value == (Object)null))
				{
					NetworkObject component = item.Value.GetComponent<NetworkObject>();
					if ((Object)(object)component != (Object)null && component.IsSpawned)
					{
						component.Despawn(true);
					}
				}
			}
			startOfRound.SpawnedShipUnlockables.Clear();
			startOfRound.suitsPlaced = 0;
			GameNetworkManager.Instance.ResetUnlockablesListValues(false);
			yield return (object)new WaitForSeconds(0.2f);
			startOfRound.SetTimeAndPlanetToSavedSettings();
			startOfRound.SetMapScreenInfoToCurrentLevel();
			terminal.Start();
			if (startOfRound.connectedPlayersAmount >= 1)
			{
				RefreshLobby();
			}
			ReloadUnlockables();
			yield return (object)new WaitForSeconds(0.2f);
			startOfRound.LoadAttachedVehicle();
			yield return (object)new WaitForSeconds(0.1f);
			startOfRound.LoadShipGrabbableItems();
			yield return (object)new WaitForSeconds(0.1f);
			if (startOfRound.connectedPlayersAmount >= 1)
			{
				startOfRound.SyncShipUnlockablesServerRpc();
			}
			GameNetworkManager.Instance.gameHasStarted = mem;
		}

		private static void ReloadUnlockables()
		{
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: 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_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: 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_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			instance.LoadUnlockables();
			try
			{
				for (int i = 0; i < instance.unlockablesList.unlockables.Count; i++)
				{
					UnlockableItem val = instance.unlockablesList.unlockables[i];
					if (val.unlockableType == 0 || !val.alreadyUnlocked)
					{
						continue;
					}
					LobbyControl.Log.LogDebug((object)(val.unlockableName + " starting"));
					if (!instance.SpawnedShipUnlockables.ContainsKey(i))
					{
						instance.SpawnUnlockable(i, true);
					}
					PlaceableShipObject val2 = instance.SpawnedShipUnlockables[i].GetComponent<PlaceableShipObject>();
					if (val2 == null)
					{
						val2 = instance.SpawnedShipUnlockables[i].GetComponentInChildren<PlaceableShipObject>();
					}
					if (val2 != null)
					{
						LobbyControl.Log.LogDebug((object)(val.unlockableName + " continuing"));
						Quaternion val4;
						if (Object.op_Implicit((Object)(object)val2.parentObjectSecondary))
						{
							Quaternion rotation = ((Component)val2.parentObjectSecondary).transform.rotation;
							Quaternion rotation2 = ((Component)val2.parentObjectSecondary).transform.rotation;
							Quaternion rotation3 = ((Component)val2.mainMesh).transform.rotation;
							Quaternion val3 = rotation * Quaternion.Inverse(rotation2);
							val4 = val3 * rotation3;
							val.placedRotation = ((Quaternion)(ref val4)).eulerAngles;
							Vector3 position = val2.parentObjectSecondary.position;
							Vector3 val5 = ((Component)val2.parentObjectSecondary).transform.position - ((Component)val2.mainMesh).transform.position;
							Vector3 val6 = ((Component)val2.mainMesh).transform.position - ((Component)val2.placeObjectCollider).transform.position;
							val.placedPosition = position - val5 - val6;
						}
						else
						{
							Quaternion val7 = Quaternion.Euler(val2.parentObject.rotationOffset);
							Quaternion rotation4 = ((Component)val2.parentObject).transform.rotation;
							Quaternion rotation5 = ((Component)val2.mainMesh).transform.rotation;
							Quaternion val8 = val7 * Quaternion.Inverse(rotation4);
							val4 = val8 * rotation5;
							val.placedRotation = ((Quaternion)(ref val4)).eulerAngles;
							Vector3 val9 = ((Component)val2.parentObject).transform.position - ((Component)val2.mainMesh).transform.position;
							Vector3 val10 = ((Component)val2.mainMesh).transform.position - ((Component)val2.placeObjectCollider).transform.position;
							val.placedPosition = StartOfRound.Instance.elevatorTransform.TransformPoint(val2.parentObject.positionOffset) - val9 - val10;
						}
					}
				}
				if (instance.connectedPlayersAmount < 1)
				{
					return;
				}
				List<ulong> targetClientIds = instance.ClientPlayerList.Keys.ToList();
				ClientRpcParams val11 = new ClientRpcParams
				{
					Send = new ClientRpcSendParams
					{
						TargetClientIds = targetClientIds
					}
				};
				for (int j = 0; j < instance.unlockablesList.unlockables.Count; j++)
				{
					UnlockableItem val12 = instance.unlockablesList.unlockables[j];
					if (val12.alreadyUnlocked && !val12.inStorage && _returnUnlockableFromStorageServerRpcID.HasValue)
					{
						uint value = _returnUnlockableFromStorageServerRpcID.Value;
						FastBufferWriter val13 = ((NetworkBehaviour)instance).__beginSendClientRpc(value, val11, (RpcDelivery)0);
						BytePacker.WriteValueBitPacked(val13, j);
						((NetworkBehaviour)instance).__endSendClientRpc(ref val13, value, val11, (RpcDelivery)0);
					}
				}
				instance.SyncShipUnlockablesServerRpc();
			}
			catch (Exception ex)
			{
				LobbyControl.Log.LogError((object)ex);
			}
		}

		private static void RefreshLobby()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			List<ulong> list = new List<ulong>();
			List<ulong> list2 = new List<ulong>();
			for (int i = 0; i < instance.allPlayerObjects.Length; i++)
			{
				NetworkObject component = instance.allPlayerObjects[i].GetComponent<NetworkObject>();
				if (!component.IsOwnedByServer)
				{
					list.Add(component.OwnerClientId);
					list2.Add(component.OwnerClientId);
				}
				else if (i == 0)
				{
					list.Add(NetworkManager.Singleton.LocalClientId);
				}
				else
				{
					list.Add(999uL);
				}
			}
			ClientRpcParams val = new ClientRpcParams
			{
				Send = new ClientRpcSendParams
				{
					TargetClientIds = list2
				}
			};
			int groupCredits = Object.FindObjectOfType<Terminal>().groupCredits;
			int profitQuota = TimeOfDay.Instance.profitQuota;
			int quotaFulfilled = TimeOfDay.Instance.quotaFulfilled;
			int num = (int)TimeOfDay.Instance.timeUntilDeadline;
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (_onPlayerConnectedClientRpcID.HasValue)
			{
				uint value = _onPlayerConnectedClientRpcID.Value;
				FastBufferWriter val2 = ((NetworkBehaviour)instance).__beginSendClientRpc(value, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, localPlayerController.actualClientId);
				BytePacker.WriteValueBitPacked(val2, instance.connectedPlayersAmount - 1);
				bool flag = true;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<ulong>(list.ToArray(), default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, instance.ClientPlayerList[localPlayerController.actualClientId]);
				BytePacker.WriteValueBitPacked(val2, groupCredits);
				BytePacker.WriteValueBitPacked(val2, instance.currentLevelID);
				BytePacker.WriteValueBitPacked(val2, profitQuota);
				BytePacker.WriteValueBitPacked(val2, num);
				BytePacker.WriteValueBitPacked(val2, quotaFulfilled);
				BytePacker.WriteValueBitPacked(val2, instance.randomMapSeed);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref instance.isChallengeFile, default(ForPrimitives));
				((NetworkBehaviour)instance).__endSendClientRpc(ref val2, value, val, (RpcDelivery)0);
			}
		}

		internal static void Init()
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(StartOfRound), "ReturnUnlockableFromStorageClientRpc", (Type[])null, (Type[])null);
			if (RPCUtils.TryGetRpcID(methodInfo, out var rpcID))
			{
				_returnUnlockableFromStorageServerRpcID = rpcID;
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(StartOfRound), "OnPlayerConnectedClientRpc", (Type[])null, (Type[])null);
			if (RPCUtils.TryGetRpcID(methodInfo2, out var rpcID2))
			{
				_onPlayerConnectedClientRpcID = rpcID2;
			}
		}
	}
}
namespace LobbyControl.PopUp
{
	[HarmonyPatch]
	public class PopUpPatch
	{
		public static readonly List<(string objectName, string text)> PopUps = new List<(string, string)>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MenuManager), "Awake")]
		private static void AddPopups(MenuManager __instance)
		{
			foreach (var (objectName, text) in PopUps)
			{
				AppendPopup(objectName, text);
			}
		}

		private static void AppendPopup(string objectName, string text)
		{
			GameObject val = GameObject.Find("/Canvas/MenuContainer/");
			GameObject val2 = GameObject.Find("Canvas/MenuContainer/LANWarning/");
			if (!((Object)(object)val2 == (Object)null))
			{
				GameObject val3 = Object.Instantiate<GameObject>(val2, val.transform);
				((Object)val3).name = objectName;
				val3.SetActive(true);
				Transform val4 = val3.transform.Find("Panel/NotificationText");
				TextMeshProUGUI component = ((Component)val4).GetComponent<TextMeshProUGUI>();
				((TMP_Text)component).text = text;
			}
		}
	}
}
namespace LobbyControl.Patches
{
	[HarmonyPatch]
	public static class FacepunchTransportPatches
	{
		internal static readonly Dictionary<ulong, (Connection connection, ConnectionInfo connectionInfo)> Connections = new Dictionary<ulong, (Connection, ConnectionInfo)>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FacepunchTransport), "Steamworks.ISocketManager.OnConnected")]
		private static void TrackNewConnection(FacepunchTransport __instance, Connection connection, ConnectionInfo info)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			Connections[((Connection)(ref connection)).Id] = (connection, info);
			LobbyControl.Log.LogDebug((object)$"(FacepunchTransport) New connection: {((Connection)(ref connection)).Id} from SteamID {((NetIdentity)(ref info.identity)).SteamId}");
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(FacepunchTransport), "Steamworks.ISocketManager.OnDisconnected")]
		private static void TrackDisconnection(FacepunchTransport __instance, Connection connection, ConnectionInfo info)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Connections.Remove(((Connection)(ref connection)).Id);
			LobbyControl.Log.LogDebug((object)$"(FacepunchTransport) Disconnected: {((Connection)(ref connection)).Id} at SteamID {((NetIdentity)(ref info.identity)).SteamId}");
		}

		internal static bool TryGetConnection(ulong connectionId, out (Connection connection, ConnectionInfo connectionInfo) connection)
		{
			ulong key = NetworkManager.Singleton.ConnectionManager.ClientIdToTransportId(connectionId);
			return Connections.TryGetValue(key, out connection);
		}
	}
	[HarmonyPatch]
	internal class JoinQueuePatches
	{
		public class ConnectionQueueEntry
		{
			private ConnectionType _type;

			public SteamId SteamId { get; }

			public ulong? ClientId => UnityConnection?.request.ClientNetworkId;

			public string Name
			{
				get
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: 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_0067: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					switch (_type)
					{
					case ConnectionType.Steam:
					{
						SteamId steamId = SteamId;
						object obj;
						if (!((SteamId)(ref steamId)).IsValid)
						{
							obj = "????";
						}
						else
						{
							Friend val = new Friend(SteamId.op_Implicit(SteamId.Value));
							obj = ((Friend)(ref val)).Name;
						}
						return (string?)obj + $"({ClientId})";
					}
					case ConnectionType.IP:
					{
						NetworkEndPoint endPoint = EndPoint;
						return $"{((NetworkEndPoint)(ref endPoint)).Address}({ClientId})";
					}
					default:
						throw new ArgumentOutOfRangeException();
					}
				}
			}

			public ushort QueuePosition
			{
				get
				{
					if (_connectingClient == this)
					{
						return 1;
					}
					int num = Array.IndexOf(ConnectionQueue.ToArray(), this);
					return (ushort)((num >= 0) ? ((uint)(num + 1)) : 0u);
				}
			}

			public NetworkEndPoint EndPoint { get; }

			public (ConnectionApprovalRequest request, ConnectionApprovalResponse response)? UnityConnection { get; internal set; }

			public Connection? PreLobbyConnection { get; private set; }

			internal ConnectionQueueEntry(ConnectionApprovalRequest request, ConnectionApprovalResponse response, SteamId identity)
			{
				//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)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				_type = ConnectionType.Steam;
				SteamId = identity;
				UnityConnection = (request, response);
			}

			internal ConnectionQueueEntry(ConnectionApprovalRequest request, ConnectionApprovalResponse response, NetworkEndPoint identity)
			{
				//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)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				_type = ConnectionType.IP;
				EndPoint = identity;
				UnityConnection = (request, response);
			}

			internal ConnectionQueueEntry(Connection preLobbyConnection, SteamId identity)
			{
				//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)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				_type = ConnectionType.Steam;
				SteamId = identity;
				PreLobbyConnection = preLobbyConnection;
			}

			internal void DropConnection()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				if (UnityConnection.HasValue)
				{
					ForcefullyDisconnectClient(ClientId.Value);
				}
				if (PreLobbyConnection.HasValue)
				{
					Connection value = PreLobbyConnection.Value;
					((Connection)(ref value)).Close(false, 0, "Closing Connection");
					PreLobbyConnection = null;
				}
			}

			internal void RefuseConnection([NotNull] string reason)
			{
				if (UnityConnection.HasValue)
				{
					UnityConnection.Value.response.Approved = false;
					UnityConnection.Value.response.Reason = reason;
					UnityConnection.Value.response.Pending = false;
				}
				else
				{
					DropConnection();
				}
			}

			internal void AcceptConnection()
			{
				if (UnityConnection.HasValue)
				{
					UnityConnection.Value.response.Approved = true;
					UnityConnection.Value.response.Pending = false;
				}
			}

			public override string ToString()
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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)
				StringBuilder stringBuilder = new StringBuilder("{Name: ");
				switch (_type)
				{
				case ConnectionType.Steam:
				{
					SteamId steamId = SteamId;
					if (((SteamId)(ref steamId)).IsValid)
					{
						Friend val = new Friend(SteamId.op_Implicit(SteamId.Value));
						stringBuilder.Append(((Friend)(ref val)).Name);
						stringBuilder.Append(", SteamID:").Append(SteamId.Value);
					}
					else
					{
						stringBuilder.Append("-");
					}
					break;
				}
				case ConnectionType.IP:
				{
					StringBuilder stringBuilder2 = stringBuilder.Append(", Endpoint: ");
					NetworkEndPoint endPoint = EndPoint;
					stringBuilder2.Append(((NetworkEndPoint)(ref endPoint)).Address);
					break;
				}
				default:
					throw new ArgumentOutOfRangeException();
				}
				stringBuilder.Append(", ClientId: ").Append(ClientId);
				stringBuilder.Append("}");
				return stringBuilder.ToString();
			}
		}

		public enum ConnectionType
		{
			Steam,
			IP
		}

		private static bool _checkpointsInitialized;

		private static ConnectionCheckpoint _syncAlreadyHeldObjectsCheckpoint;

		private static ConnectionCheckpoint _sendNewPlayerValuesCheckpoint;

		private static ConnectionCheckpoint _syncAllPlayerLevelsCheckpoint;

		private static ConnectionQueueEntry _connectingClient;

		internal static readonly ConcurrentQueue<ConnectionQueueEntry> ConnectionQueue = new ConcurrentQueue<ConnectionQueueEntry>();

		internal static readonly FreeRunningTimer ConnectionTimer = new FreeRunningTimer();

		private static readonly Stopwatch ConnectionStopwatch = new Stopwatch();

		[CanBeNull]
		internal static ConnectionQueueEntry ConnectingClient
		{
			get
			{
				return _connectingClient;
			}
			private set
			{
				_connectingClient = value;
				ConnectionEvents.ResetCheckpoints();
			}
		}

		internal static int QueuedClients => ConnectionQueue.Count + ((ConnectingClient != null) ? 1 : 0);

		internal static void Init()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(StartOfRound), "SyncAlreadyHeldObjectsServerRpc", (Type[])null, (Type[])null);
			if (RPCUtils.TryGetRpcID(methodInfo, out var rpcID))
			{
				MethodInfo methodInfo2 = AccessTools.Method(typeof(StartOfRound), $"__rpc_handler_{rpcID}", (Type[])null, (Type[])null);
				MethodInfo methodInfo3 = AccessTools.Method(typeof(JoinQueuePatches), "OnSyncAlreadyHeldObjectsServerRpc", (Type[])null, (Type[])null);
				LobbyControl.Harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(methodInfo3), (HarmonyMethod)null);
			}
			else
			{
				LobbyControl.Log.LogFatal((object)"Could not find RPC id for SyncAlreadyHeldObjectsServerRpc");
			}
			methodInfo = AccessTools.Method(typeof(PlayerControllerB), "SendNewPlayerValuesServerRpc", (Type[])null, (Type[])null);
			if (RPCUtils.TryGetRpcID(methodInfo, out rpcID))
			{
				MethodInfo methodInfo4 = AccessTools.Method(typeof(PlayerControllerB), $"__rpc_handler_{rpcID}", (Type[])null, (Type[])null);
				MethodInfo methodInfo5 = AccessTools.Method(typeof(JoinQueuePatches), "OnSendNewPlayerValuesServerRpc", (Type[])null, (Type[])null);
				LobbyControl.Harmony.Patch((MethodBase)methodInfo4, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(methodInfo5), (HarmonyMethod)null);
			}
			else
			{
				LobbyControl.Log.LogFatal((object)"Could not find RPC id for SendNewPlayerValuesServerRpc");
			}
			methodInfo = AccessTools.Method(typeof(HUDManager), "SyncAllPlayerLevelsServerRpc", new Type[2]
			{
				typeof(int),
				typeof(int)
			}, (Type[])null);
			if (RPCUtils.TryGetRpcID(methodInfo, out rpcID))
			{
				MethodInfo methodInfo6 = AccessTools.Method(typeof(HUDManager), $"__rpc_handler_{rpcID}", (Type[])null, (Type[])null);
				MethodInfo methodInfo7 = AccessTools.Method(typeof(JoinQueuePatches), "OnSyncAllPlayerLevelsServerRpc", (Type[])null, (Type[])null);
				LobbyControl.Harmony.Patch((MethodBase)methodInfo6, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(methodInfo7), (HarmonyMethod)null);
			}
			else
			{
				LobbyControl.Log.LogFatal((object)"Could not find RPC id for SyncAllPlayerLevelsServerRpc");
			}
			ConnectionEvents.OnConnectionCompletedServer += OnConnectionCompletedServer;
			MethodInfo methodInfo8 = AccessTools.Method(typeof(StartOfRound), "StartGame", (Type[])null, (Type[])null);
			if (methodInfo8 != null)
			{
				LobbyControl.Hooks.Add(new Hook((MethodBase)methodInfo8, (Delegate)new Action<Action<StartOfRound>, StartOfRound>(CheckValidStart), new HookConfig
				{
					Priority = 999
				}));
			}
			else
			{
				LobbyControl.Log.LogFatal((object)"Cannot apply patch to StartGame");
			}
		}

		private static void ForcefullyDisconnectClient(ulong clientId)
		{
			if (clientId == NetworkManager.Singleton.LocalClientId)
			{
				return;
			}
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				ulong num = singleton.ConnectionManager.ClientIdToTransportId(clientId);
				NetworkManager.Singleton.NetworkConfig.NetworkTransport.DisconnectRemoteClient(num);
			}
			catch (Exception ex)
			{
				LobbyControl.Log.LogError((object)ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "Awake")]
		private static void OnStartup(GameNetworkManager __instance)
		{
			if (!_checkpointsInitialized)
			{
				_checkpointsInitialized = true;
				_syncAlreadyHeldObjectsCheckpoint = ConnectionCheckpoint.RegisterCheckpoint((BaseUnityPlugin)(object)LobbyControl.Instance, "SyncAlreadyHeldObjects");
				_syncAllPlayerLevelsCheckpoint = ConnectionCheckpoint.RegisterCheckpoint((BaseUnityPlugin)(object)LobbyControl.Instance, "SyncAllPlayerLevels");
				if (!__instance.disableSteam)
				{
					_sendNewPlayerValuesCheckpoint = ConnectionCheckpoint.RegisterCheckpoint((BaseUnityPlugin)(object)LobbyControl.Instance, "SendNewPlayerValues");
				}
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		[HarmonyPriority(10)]
		private static Exception ThrottleApprovals(GameNetworkManager __instance, ConnectionApprovalRequest request, ConnectionApprovalResponse response, Exception __exception)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			if (__exception != null)
			{
				return __exception;
			}
			if (!PluginConfig.JoinQueue.Enabled.Value)
			{
				return null;
			}
			if (!response.Approved)
			{
				return null;
			}
			try
			{
				LobbyControl.Log.LogDebug((object)$"Connection request from {request.ClientNetworkId}. Current queue size: {QueuedClients}");
				int value = PluginConfig.JoinQueue.MaxSize.Value;
				if (QueuedClients >= value)
				{
					LobbyControl.Log.LogWarning((object)$"Connection refused, Queue full! count:{QueuedClients}");
					if (PluginConfig.JoinQueue.ConnectionPopup.Value)
					{
						((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Connection refused", $"Client {request.ClientNetworkId} requested a connection but queue was full!"));
					}
					StringBuilder stringBuilder = new StringBuilder();
					if (value == 1)
					{
						stringBuilder.Append("Another player is connecting\n");
					}
					else
					{
						stringBuilder.Append("Join Queue is Full !\n");
						stringBuilder.AppendFormat("Queued connections: {0}\n", QueuedClients);
					}
					stringBuilder.Append("Please Wait a bit before retrying");
					response.Approved = false;
					response.Reason = stringBuilder.ToString();
					return null;
				}
				NetworkManager singleton = NetworkManager.Singleton;
				response.Pending = true;
				NetworkTransport networkTransport = singleton.NetworkConfig.NetworkTransport;
				ConnectionQueueEntry connectionQueueEntry;
				if (!(networkTransport is FacepunchTransport))
				{
					UnityTransport val = (UnityTransport)(object)((networkTransport is UnityTransport) ? networkTransport : null);
					if (val != null)
					{
						NetworkEndPoint endpoint = val.GetEndpoint(request.ClientNetworkId);
						LobbyControl.Log.LogDebug((object)("Request was from IP " + ((NetworkEndPoint)(ref endpoint)).Address));
						connectionQueueEntry = new ConnectionQueueEntry(request, response, endpoint);
						if (PluginConfig.JoinQueue.ConnectionPopup.Value)
						{
							((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Connection request", $"Client {request.ClientNetworkId} requested a connection"));
						}
						goto IL_03a6;
					}
					response.Approved = true;
					response.Pending = false;
					return null;
				}
				if (FacepunchTransportPatches.TryGetConnection(request.ClientNetworkId, out (Connection, ConnectionInfo) connection))
				{
					SteamId steamId = ((NetIdentity)(ref connection.Item2.identity)).SteamId;
					if (((SteamId)(ref steamId)).IsValid)
					{
						SteamId steamID = ((NetIdentity)(ref connection.Item2.identity)).SteamId;
						LobbyControl.Log.LogDebug((object)$"Request was from SteamID {steamID}");
						if (StartOfRound.Instance.KickedClientIds.Contains(steamID.Value))
						{
							response.Approved = false;
							response.Reason = "You tried to bypass the kick!";
							response.Pending = false;
							return null;
						}
						Task.Run(() => SteamFriends.RequestUserInformation(steamID, true));
						SteamId? val2 = ConnectingClient?.SteamId;
						if ((val2.HasValue ? new ulong?(SteamId.op_Implicit(val2.GetValueOrDefault())) : ((ulong?)null)) == SteamId.op_Implicit(steamID))
						{
							connectionQueueEntry = ConnectingClient;
							connectionQueueEntry.UnityConnection = (request, response);
							response.Pending = false;
						}
						else
						{
							connectionQueueEntry = new ConnectionQueueEntry(request, response, steamID);
						}
						if (PluginConfig.JoinQueue.ConnectionPopup.Value)
						{
							((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Connection request", $"Player {connectionQueueEntry} requested a connection"));
						}
						goto IL_03a6;
					}
				}
				LobbyControl.Log.LogWarning((object)$"Connection refused, Failed to get SteamID for {request.ClientNetworkId}");
				response.Approved = false;
				response.Reason = "Failed to get SteamID";
				response.Pending = false;
				return null;
				IL_03a6:
				if (connectionQueueEntry.UnityConnection.Value.response.Pending)
				{
					ConnectionQueue.Enqueue(connectionQueueEntry);
				}
				LobbyControl.Log.LogWarning((object)$"Connection request Enqueued! count:{QueuedClients}");
				return null;
			}
			catch (Exception arg)
			{
				LobbyControl.Log.LogError((object)$"Exception while processing connection request:\n{arg}");
				response.Approved = true;
				response.Pending = false;
				return null;
			}
		}

		private static void OnConnectionCompletedServer(ulong clientId)
		{
			if (PluginConfig.JoinQueue.Enabled.Value)
			{
				int playerIndex = StartOfRound.Instance.ClientPlayerList[clientId];
				List<ulong> list = NetworkManager.Singleton.ConnectedClientsIds.ToList();
				list.Remove(clientId);
				NamedMessages.ResetPlayerValuesClientRpc(playerIndex, list.ToArray());
				NamedMessages.ReorderRadarClientRpc();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		private static void OnClientConnect(StartOfRound __instance, ulong clientId)
		{
			if (((NetworkBehaviour)__instance).IsServer && PluginConfig.JoinQueue.Enabled.Value)
			{
				if (ConnectingClient != null && ConnectingClient.ClientId != clientId)
				{
					LobbyControl.Log.LogError((object)$"client {clientId} connected while '{ConnectingClient.Name}' was still being processed!");
					return;
				}
				ConnectionTimer.Stop();
				ConnectionTimer.Start(TimeSpan.FromMilliseconds(PluginConfig.JoinQueue.ConnectionTimeout.Value));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
		private static void OnClientConnect2(StartOfRound __instance, ulong clientId)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
			if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening && (int)((NetworkBehaviour)__instance).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviour)__instance).IsServer && !PluginConfig.JoinQueue.Enabled.Value)
			{
				ConnectionEvents.RaiseConnectionCompleteServerEvent(clientId);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientDisconnectCallback")]
		private static void OnClientDisconnect(GameNetworkManager __instance, ulong clientId)
		{
			if (!__instance.isHostingGame)
			{
				return;
			}
			LobbyControl.Log.LogInfo((object)$"{clientId} disconnected");
			ConnectionQueueEntry connectingClient = ConnectingClient;
			if (connectingClient != null && connectingClient.ClientId == clientId)
			{
				ConnectingClient = null;
				ConnectionTimer.Stop();
				return;
			}
			foreach (ConnectionQueueEntry item in ConnectionQueue.Where((ConnectionQueueEntry e) => e.ClientId == clientId))
			{
				item.RefuseConnection("You disconnected!");
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientConnectedCallback")]
		private static void OnClientConnect(GameNetworkManager __instance, ulong clientId)
		{
			if (__instance.isHostingGame)
			{
				LobbyControl.Log.LogInfo((object)$"{clientId} connected");
			}
		}

		private static void OnSyncAlreadyHeldObjectsServerRpc(NetworkBehaviour target, __RpcParams rpcParams)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (target.IsServer && ConnectingClient != null)
			{
				ulong senderClientId = rpcParams.Server.Receive.SenderClientId;
				_syncAlreadyHeldObjectsCheckpoint.Set(senderClientId);
			}
		}

		private static void OnSendNewPlayerValuesServerRpc(NetworkBehaviour target, __RpcParams rpcParams)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (target.IsServer && ConnectingClient != null)
			{
				ulong senderClientId = rpcParams.Server.Receive.SenderClientId;
				_sendNewPlayerValuesCheckpoint.Set(senderClientId);
			}
		}

		private static void OnSyncAllPlayerLevelsServerRpc(NetworkBehaviour target, __RpcParams rpcParams)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (target.IsServer && ConnectingClient != null)
			{
				ulong senderClientId = rpcParams.Server.Receive.SenderClientId;
				_syncAllPlayerLevelsCheckpoint.Set(senderClientId);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "LateUpdate")]
		private static void ProcessConnectionQueue(StartOfRound __instance)
		{
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return;
			}
			try
			{
				if (ConnectionEvents.HasCompletedAllCheckpoints && ConnectingClient != null)
				{
					ConnectionQueueEntry connectingClient = ConnectingClient;
					ConnectingClient = null;
					LobbyControl.Log.LogDebug((object)(connectingClient.Name + " completed all the checkpoints"));
					ConnectionTimer.Stop();
					LobbyControl.Log.LogWarning((object)(connectingClient.Name + " completed the connection"));
					ConnectionEvents.RaiseConnectionCompleteServerEvent(connectingClient.ClientId.Value);
				}
				if (ConnectingClient != null)
				{
					if (!ConnectionTimer.TimedOut)
					{
						return;
					}
					if (ConnectingClient != null)
					{
						ConnectionCheckpoint[] missingCheckpoints = ConnectionEvents.MissingCheckpoints;
						LobbyControl.Log.LogWarning((object)("missing checkpoints for " + ConnectingClient.Name + ": [" + string.Join(",", (IEnumerable<ConnectionCheckpoint>)missingCheckpoints) + "]"));
						if (PluginConfig.JoinQueue.TimeoutPopup.Value)
						{
							((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Connection Timeout", "Player " + ConnectingClient.Name + "\n has been disconnected"));
						}
						((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowTipAfterDelay("Connection Timeout", "If clients frequently fail to connect maybe consider increasing \"connection_timeout_ms\" in LobbyControl config", 5f, "LCTip_LCTimeout"));
						LobbyControl.Log.LogError((object)("Connection to " + ConnectingClient.Name + " expired, Disconnecting!"));
						ConnectingClient.DropConnection();
					}
					ConnectingClient = null;
				}
				if (LateJoinPatches._allowNewConnection)
				{
					if (ConnectingClient != null || !ConnectionQueue.TryDequeue(out var result))
					{
						return;
					}
					if ((!(result.UnityConnection?.response.Approved)) ?? true)
					{
						LobbyControl.Log.LogWarning((object)$"Connection request Skipped! remaining: {ConnectionQueue.Count}");
						return;
					}
					LobbyControl.Log.LogWarning((object)$"Connection request Resumed! remaining: {ConnectionQueue.Count}");
					result.AcceptConnection();
					if (!PluginConfig.JoinQueue.Enabled.Value)
					{
						return;
					}
					ConnectingClient = result;
					ConnectionTimer.Start(TimeSpan.FromMilliseconds(PluginConfig.JoinQueue.ConnectionTimeout.Value));
					if (PluginConfig.JoinQueue.ConnectionPopup.Value)
					{
						SteamId steamId = result.SteamId;
						if (((SteamId)(ref steamId)).IsValid)
						{
							((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Connection resumed", "Player " + result.Name + " is now connecting"));
						}
					}
				}
				else
				{
					ConnectionQueueEntry result2;
					while (ConnectionQueue.TryDequeue(out result2))
					{
						result2.RefuseConnection("Ship has landed!");
					}
				}
			}
			catch (Exception ex)
			{
				LobbyControl.Log.LogError((object)ex);
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(StartOfRound), "OnLocalDisconnect")]
		private static void FlushConnectionQueue()
		{
			ConnectingClient = null;
			ConnectionTimer.Stop();
			if (ConnectionQueue.Count > 0)
			{
				LobbyControl.Log.LogWarning((object)$"Disconnecting with {ConnectionQueue.Count} pending connection, Flushing!");
			}
			ConnectionQueueEntry result;
			while (ConnectionQueue.TryDequeue(out result))
			{
				result.RefuseConnection("Host has disconnected!");
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void OnHostStartLoad()
		{
			if (NetworkManager.Singleton.IsServer && PluginConfig.JoinQueue.Enabled.Value)
			{
				ConnectionStopwatch.Restart();
			}
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> PatchStartSpatialVoiceChat(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			ILInjector iLInjector = new ILInjector(list, ilGenerator);
			iLInjector.Find(ILMatcher.Callvirt(typeof(HUDManager).GetMethod("SyncAllPlayerLevelsServerRpc", new Type[2]
			{
				typeof(int),
				typeof(int)
			}), "PatchStartSpatialVoiceChat", "./Plugin/src/Patches/JoinQueuePatches.cs", 591));
			if (!iLInjector.IsValid)
			{
				LobbyControl.Log.LogFatal((object)"Failed to find HUDManager.SyncPlayerLevelServerRpc in StartOfRound.StartSpatialVoiceChat!");
				return list;
			}
			iLInjector.GoToMatchEnd().Insert(new CodeInstruction(OpCodes.Call, (object)typeof(JoinQueuePatches).GetMethod("OnHostLoaded", BindingFlags.Static | BindingFlags.NonPublic)));
			return iLInjector.ReleaseInstructions();
		}

		private static void OnHostLoaded()
		{
			if (NetworkManager.Singleton.IsServer && PluginConfig.JoinQueue.Enabled.Value)
			{
				ConnectionStopwatch.Stop();
				long elapsedMilliseconds = ConnectionStopwatch.ElapsedMilliseconds;
				int value = PluginConfig.JoinQueue.ConnectionTimeout.Value;
				LobbyControl.Log.LogDebug((object)$"Lobby took {elapsedMilliseconds}ms to load");
				if (value < elapsedMilliseconds)
				{
					LobbyControl.Log.LogWarning((object)$"Lobby took {elapsedMilliseconds}ms to load but the configured connectionTimeout is only {value}ms !");
					((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("Low Connection Timeout!", $"Lobby took {elapsedMilliseconds}ms to load but the configured connectionTimeout is only {value}ms", 5f));
				}
			}
		}

		private static bool CanStartGame()
		{
			if (ConnectingClient == null)
			{
				return ConnectionQueue.IsEmpty;
			}
			return false;
		}

		private static void CheckValidStart(Action<StartOfRound> orig, StartOfRound @this)
		{
			if (!((NetworkBehaviour)@this).IsServer || !@this.inShipPhase)
			{
				orig(@this);
			}
			else if (!CanStartGame())
			{
				int num = ConnectionQueue.Count + ((ConnectingClient != null) ? 1 : 0);
				StartMatchLever val = Object.FindAnyObjectByType<StartMatchLever>();
				val.CancelStartGame();
				val.CancelStartGameClientRpc();
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowMessageAfterDelay("GAME START CANCELLED", $"{num} Players Connecting!!", 0f, isWarning: true));
				HUDManager.Instance.AddTextMessageServerRpc($"there are still {num} Players connecting!!\n");
			}
			else
			{
				LateJoinPatches._allowNewConnection = false;
				orig(@this);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartMatchLever), "CancelStartGame")]
		private static void FixUnusableLever(StartMatchLever __instance)
		{
			__instance.triggerScript.interactable = true;
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		private static void OnReadyToLand()
		{
			LateJoinPatches._allowNewConnection = true;
		}
	}
	[HarmonyPatch]
	internal class LateJoinPatches
	{
		public static bool _allowNewConnection;

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		private static IEnumerable<CodeInstruction> FixConnectionApprovalPrefix(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = instructions.ToList();
			Label operand;
			ILInjector iLInjector = new ILInjector(list).Find(ILMatcher.Call(typeof(GameNetworkManager).GetProperty("Instance")?.GetMethod, "FixConnectionApprovalPrefix", "./Plugin/src/Patches/LateJoinPatches.cs", 36), ILMatcher.Ldfld(typeof(GameNetworkManager).GetField("gameHasStarted", BindingFlags.Instance | BindingFlags.Public), "FixConnectionApprovalPrefix", "./Plugin/src/Patches/LateJoinPatches.cs", 37), ILMatcher.Opcode(OpCodes.Brfalse).CaptureOperandAs<Label>(out operand));
			if (!iLInjector.IsValid)
			{
				LobbyControl.Log.LogWarning((object)"ConnectionApproval patch failed!!");
				LobbyControl.Log.LogDebug((object)string.Join("\n", iLInjector.ReleaseInstructions()));
				return list;
			}
			return iLInjector.RemoveLastMatch().FindLabel(operand).RemoveLastMatch()
				.ReleaseInstructions();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		private static void HandleLateJoin(GameNetworkManager __instance, ConnectionApprovalRequest request, ConnectionApprovalResponse response)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (response.Approved)
			{
				if (!_allowNewConnection)
				{
					LobbyControl.Log.LogDebug((object)"connection refused ( ship was landed ).");
					response.Reason = "Ship has already landed!";
					response.Approved = false;
				}
				else if (!__instance.disableSteam && (!__instance.currentLobby.HasValue || !LobbyPatcher.IsOpen(__instance.currentLobby.Value)))
				{
					LobbyControl.Log.LogDebug((object)"connection refused ( lobby was closed ).");
					response.Reason = "Lobby has been closed!";
					response.Approved = false;
				}
				else if (__instance.gameHasStarted)
				{
					LobbyControl.Log.LogDebug((object)"Incoming late connection.");
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(QuickMenuManager), "InviteFriendsButton")]
		private static void FixFriendInviteButton(bool __runOriginal)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (__runOriginal)
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if (GameNetworkManager.Instance.gameHasStarted && instance.currentLobby.HasValue && LobbyPatcher.IsOpen(instance.currentLobby.Value))
				{
					GameNetworkManager.Instance.InviteFriendsUI();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "LeaveLobbyAtGameStart")]
		private static bool PreventSteamLobbyLeaving(GameNetworkManager __instance)
		{
			LobbyControl.Log.LogDebug((object)"Preventing the closing of Steam lobby.");
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(StartOfRound), "StartGame")]
		private static void CloseSteamLobby(StartOfRound __instance, bool __runOriginal)
		{
			if (__runOriginal && ((NetworkBehaviour)__instance).IsServer && __instance.inShipPhase)
			{
				LobbyControl.Log.LogDebug((object)"Setting lobby to not joinable.");
				LobbyControl.CanModifyLobby = false;
				GameNetworkManager.Instance.SetLobbyJoinable(false);
				Object.FindObjectOfType<QuickMenuManager>().inviteFriendsTextAlpha.alpha = 0f;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		private static void ResetStatus(StartOfRound __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				LobbyControl.CanModifyLobby = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
		[HarmonyPriority(0)]
		private static void ReopenSteamLobby(StartOfRound __instance, bool __runOriginal)
		{
			if (!__runOriginal)
			{
				return;
			}
			LobbyControl.Log.LogDebug((object)"Lobby can be re-opened");
			LobbyControl.CanModifyLobby = true;
			if (PluginConfig.SteamLobby.AutoLobby.Value)
			{
				Object.FindObjectOfType<QuickMenuManager>().inviteFriendsTextAlpha.alpha = 1f;
				GameNetworkManager instance = GameNetworkManager.Instance;
				if (instance.currentLobby.HasValue)
				{
					instance.SetLobbyJoinable(true);
				}
			}
			else
			{
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(HudUtils.ShowTipAfterDelay("Late-Join SYSTEM", "To allow new players to join the lobby use \"lobby open\" in Terminal or \"auto_lobby\" in config", 7f, "LCTip_LCAutoLobby"));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
		private static void ResetDcFlags(StartOfRound __instance, ulong clientId, int assignedPlayerObjectId)
		{
			PlayerControllerB val = __instance.allPlayerScripts[assignedPlayerObjectId];
			val.disconnectedMidGame = false;
			val.DisablePlayerModel(((Component)val).gameObject, true, true);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(NetworkObject), "GetCachedParent")]
		public static void FixGetCachedParentNullRef(NetworkObject __instance)
		{
			if (!Object.op_Implicit((Object)(object)__instance.m_CachedParent))
			{
				__instance.m_CachedParent = null;
			}
		}
	}
	[HarmonyPatch]
	internal class LimitPatcher
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesClientRpc")]
		private static IEnumerable<CodeInstruction> PacketSizePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			if (!PluginConfig.SaveLimit.Enabled.Value)
			{
				return instructions;
			}
			List<CodeInstruction> list = instructions.ToList();
			ILInjector iLInjector = new ILInjector(list).Find(ILMatcher.Ldarg(), ILMatcher.Ldc(), ILMatcher.Ldloc(), ILMatcher.Ldc(), ILMatcher.Call(typeof(NetworkBehaviour).GetMethod("__beginSendClientRpc", BindingFlags.Instance | BindingFlags.NonPublic), "PacketSizePatch", "./Plugin/src/Patches/LimitPatcher.cs", 32), ILMatcher.Stloc());
			if (!iLInjector.IsValid)
			{
				LobbyControl.Log.LogWarning((object)"SyncShipUnlockablesClientRpc patch failed!!");
				LobbyControl.Log.LogDebug((object)string.Join("\n", iLInjector.ReleaseInstructions()));
				return list;
			}
			return iLInjector.GoToMatchEnd().Back(1).Insert(new CodeInstruction(OpCodes.Call, (object)typeof(LimitPatcher).GetMethod("BiggerBuffer", BindingFlags.Static | BindingFlags.NonPublic)))
				.ReleaseInstructions();
		}

		private static FastBufferWriter BiggerBuffer(FastBufferWriter bufferWriter)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref bufferWriter)).Dispose();
			return new FastBufferWriter(1024, (Allocator)2, 536870912);
		}

		[HarmonyTranspiler]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesServerRpc")]
		private static IEnumerable<CodeInstruction> SyncUnlockablesPatch(IEnumerable<CodeInstruction> instructions)
		{
			if (!PluginConfig.SaveLimit.Enabled.Value)
			{
				return instructions;
			}
			List<CodeInstruction> list = instructions.ToList();
			ILInjector iLInjector = new ILInjector(list);
			iLInjector.Find(ILMatcher.Ldfld(typeof(GrabbableObject).GetField("itemProperties"), "SyncUnlockablesPatch", "./Plugin/src/Patches/LimitPatcher.cs", 79), ILMatcher.Ldfld(typeof(Item).GetField("saveItemVariable"), "SyncUnlockablesPatch", "./Plugin/src/Patches/LimitPatcher.cs", 80)).ReverseFind(ILMatcher.Ldloc(), ILMatcher.Ldc(), ILMatcher.Opcode(OpCodes.Ble).CaptureOperandAs<Label>(out var operand));
			if (!iLInjector.IsValid)
			{
				LobbyControl.Log.LogWarning((object)"SyncShipUnlockablesServerRpc patch failed 1!!");
				LobbyControl.Log.LogDebug((object)string.Join("\n", iLInjector.ReleaseInstructions()));
				return list;
			}
			return iLInjector.RemoveLastMatch().FindLabel(operand).RemoveLastMatch()
				.ReleaseInstructions();
		}

		[HarmonyTranspiler]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
		private static IEnumerable<CodeInstruction> SaveItemsInShipPatch(IEnumerable<CodeInstruction> instructions)
		{
			if (!PluginConfig.SaveLimit.Enabled.Value)
			{
				return instructions;
			}
			List<CodeInstruction> list = instructions.ToList();
			ILInjector iLInjector = new ILInjector(list).Find(ILMatcher.Ldloc(), ILMatcher.Call(typeof(StartOfRound).GetProperty("Instance")?.GetMethod, "SaveItemsInShipPatch", "./Plugin/src/Patches/LimitPatcher.cs", 118), ILMatcher.Ldfld(typeof(StartOfRound).GetField("maxShipItemCapacity"), "SaveItemsInShipPatch", "./Plugin/src/Patches/LimitPatcher.cs", 119), ILMatcher.Opcode(OpCodes.Bgt));
			if (!iLInjector.IsValid)
			{
				LobbyControl.Log.LogWarning((object)"SaveItemsInShip patch failed 1!!");
				LobbyControl.Log.LogDebug((object)string.Join("\n", iLInjector.ReleaseInstructions()));
				return list;
			}
			return iLInjector.RemoveLastMatch().ReleaseInstructions();
		}
	}
	[HarmonyPatch]
	internal class LobbyPatcher
	{
		private static readonly Dictionary<Lobby, LobbyType> Visibility = new Dictionary<Lobby, LobbyType>();

		private static readonly Dictionary<Lobby, bool> Open = new Dictionary<Lobby, bool>();

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Lobby), "SetJoinable")]
		private static void TrackOpenStatus(Lobby __instance, object[] __args, bool __runOriginal)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (__runOriginal)
			{
				Open[__instance] = (bool)__args[0];
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Lobby), "SetPublic")]
		private static void TrackPublicStatus(Lobby __instance, bool __runOriginal)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (__runOriginal)
			{
				Visibility[__instance] = (LobbyType)2;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Lobby), "SetPrivate")]
		private static void TrackPrivateStatus(Lobby __instance, bool __runOriginal)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (__runOriginal)
			{
				Visibility[__instance] = (LobbyType)0;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Lobby), "SetFriendsOnly")]
		private static void trackFriendsOnly(Lobby __instance, bool __runOriginal)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (__runOriginal)
			{
				Visibility[__instance] = (LobbyType)1;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Lobby), "SetData")]
		private static void trackData(Lobby __instance, bool __runOriginal, string key, string value)
		{
		}

		public static LobbyType GetVisibility(Lobby lobby)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!Visibility.ContainsKey(lobby))
			{
				return (LobbyType)0;
			}
			return Visibility[lobby];
		}

		public static bool IsOpen(Lobby lobby)
		{
			//IL_0005: 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)
			if (Open.ContainsKey(lobby))
			{
				return GeneralExtensions.GetValueSafe<Lobby, bool>(Open, lobby);
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal class LogSpamPatches
	{
		[HarmonyPatch(typeof(EnemyAI))]
		internal class EnemyAIPatch
		{
			[HarmonyPrefix]
			[HarmonyPatch("SetDestinationToPosition")]
			private static bool StopIfDead1(EnemyAI __instance)
			{
				if (!PluginConfig.LogSpam.Enabled.Value || !PluginConfig.LogSpam.CalculatePolygonPath.Value)
				{
					return true;
				}
				return !__instance.isEnemyDead;
			}

			[HarmonyPrefix]
			[HarmonyPatch("DoAIInterval")]
			private static void StopIfDead2(EnemyAI __instance)
			{
				if (PluginConfig.LogSpam.Enabled.Value && PluginConfig.LogSpam.CalculatePolygonPath.Value && __instance.isEnemyDead)
				{
					__instance.moveTowardsDestination = false;
				}
			}

			[HarmonyPrefix]
			[HarmonyPatch("PathIsIntersectedByLineOfSight")]
			private static bool StopIfDead3(EnemyAI __instance)
			{
				if (!PluginConfig.LogSpam.Enabled.Value || !PluginConfig.LogSpam.CalculatePolygonPath.Value)
				{
					return true;
				}
				return !__instance.isEnemyDead;
			}
		}
	}
	[HarmonyPatch]
	internal class NetworkManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(NetworkManager), "Initialize")]
		private static void AfterInitialize()
		{
			LobbyControl.Log.LogInfo((object)"Registering Named Messages!");
			NamedMessages.RegisterNamedMessages();
			ConnectionEvents.RegisterNamedMessages();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "SetInstanceValuesBackToDefault")]
		public static void SetInstanceValuesBackToDefault()
		{
			if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.CustomMessagingManager != null)
			{
				LobbyControl.Log.LogInfo((object)"Unregistering Named Messages!");
				NamedMessages.UnregisterNamedMessages();
				ConnectionEvents.UnregisterNamedMessages();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NetworkManager), "SetSingleton")]
		public static void SetClientTimeout(NetworkManager __instance)
		{
			__instance.NetworkConfig.ClientConnectionBufferTimeout = PluginConfig.JoinQueue.ConnectionTimeout.Value / 1000 * 4;
		}
	}
	[HarmonyPatch]
	internal class SavePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "SaveGameValues")]
		private static bool PreventSave(GameNetworkManager __instance)
		{
			if (LobbyControl.CanSave && __instance.isHostingGame)
			{
				ES3.Save<bool>("LC_SavingMethod", LobbyControl.AutoSaveEnabled, __instance.currentSaveFileName);
			}
			return LobbyControl.CanSave;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameNetworkManager), "ResetSavedGameValues")]
		private static bool PreventSaveFileReset(GameNetworkManager __instance)
		{
			return LobbyControl.CanSave;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		private static void ReadCustomLobbyStatus(StartOfRound __instance, bool __runOriginal)
		{
			if (__runOriginal && ((NetworkBehaviour)__instance).IsServer)
			{
				LobbyControl.AutoSaveEnabled = (LobbyControl.CanSave = ES3.Load<bool>("LC_SavingMethod", GameNetworkManager.Instance.currentSaveFileName, true));
			}
		}
	}
	[HarmonyPatch]
	internal class TerminalPatch
	{
		private const string COMMAND = "\n\n>LOBBY [command] (lobby name)\ntype lobby help for more info.\n\n";

		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPrefix]
		private static void StartPatch(ref TerminalNodesList ___terminalNodes)
		{
			OverrideTerminalNodes(___terminalNodes);
		}

		private static void OverrideTerminalNodes(TerminalNodesList terminalNodes)
		{
			OverrideHelpTerminalNode(terminalNodes);
		}

		private static void OverrideHelpTerminalNode(TerminalNodesList terminalNodes)
		{
			TerminalNode val = null;
			TerminalKeyword[] allKeywords = terminalNodes.allKeywords;
			foreach (TerminalKeyword val2 in allKeywords)
			{
				if (val2.word == "other")
				{
					val = val2.specialKeywordResult;
				}
			}
			if (val != null)
			{
				string displayText = val.displayText;
				string text = displayText.Replace("\n\n>LOBBY [command] (lobby name)\ntype lobby help for more info.\n\n", "").Trim();
				text = ((!GameNetworkManager.Instance.isHostingGame) ? (text + "\n\n") : (text + "\n\n>LOBBY [command] (lobby name)\ntype lobby help for more info.\n\n"));
				val.displayText = text;
			}
		}

		[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
		[HarmonyPrefix]
		private static bool ParsePlayerSentencePatch(ref Terminal __instance, ref TerminalNode __result, bool __runOriginal)
		{
			if (!__runOriginal)
			{
				return false;
			}
			List<string> list = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded).Split(' ', 3).ToList();
			while (list.Count < 3)
			{
				list.Add("");
			}
			string[] array = list.ToArray();
			if (CommandManager.TryExecuteCommand(array, out var terminalNode))
			{
				if ((Object)(object)terminalNode == (Object)null)
				{
					__result = CreateTerminalNode("Error: terminalNode is null!\n\n");
					return false;
				}
				__result = terminalNode;
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
		private static void QuitTerminalPatch()
		{
			CommandManager.OnTerminalQuit();
		}

		[HarmonyPatch(typeof(StartOfRound), "OnLocalDisconnect")]
		[HarmonyPrefix]
		private static void OnLocalDisconnectPatch()
		{
			CommandManager.OnLocalDisconnect();
		}

		internal static TerminalNode CreateTerminalNode(string message, bool clearPreviousText = true)
		{
			TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
			val.displayText = message;
			val.clearPreviousText = clearPreviousText;
			val.maxCharactersToType = 50;
			return val;
		}
	}
}
namespace LobbyControl.Networking
{
	internal static class NamedMessages
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnReorderRadarClientRpc;

			public static HandleNamedMessageDelegate <1>__OnResetPlayerValuesClientRpc;
		}

		private static readonly string BaseName = typeof(NamedMessages).FullName;

		private static readonly string ReorderRadarClientRpcMessage = BaseName + "|ReorderRadarClientRpc";

		private static readonly string ResetPlayerValuesClientRpcMessage = BaseName + "|ResetPlayerValuesClientRpc";

		internal static void RegisterNamedMessages()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
			string reorderRadarClientRpcMessage = ReorderRadarClientRpcMessage;
			object obj = <>O.<0>__OnReorderRadarClientRpc;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = OnReorderRadarClientRpc;
				<>O.<0>__OnReorderRadarClientRpc = val;
				obj = (object)val;
			}
			customMessagingManager.RegisterNamedMessageHandler(reorderRadarClientRpcMessage, (HandleNamedMessageDelegate)obj);
			CustomMessagingManager customMessagingManager2 = NetworkManager.Singleton.CustomMessagingManager;
			string resetPlayerValuesClientRpcMessage = ResetPlayerValuesClientRpcMessage;
			object obj2 = <>O.<1>__OnResetPlayerValuesClientRpc;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = OnResetPlayerValuesClientRpc;
				<>O.<1>__OnResetPlayerValuesClientRpc = val2;
				obj2 = (object)val2;
			}
			customMessagingManager2.RegisterNamedMessageHandler(resetPlayerValuesClientRpcMessage, (HandleNamedMessageDelegate)obj2);
		}

		internal static void UnregisterNamedMessages()
		{
			NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(ReorderRadarClientRpcMessage);
			NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(ResetPlayerValuesClientRpcMessage);
		}

		internal static void ReorderRadarClientRpc(IReadOnlyList<ulong> targets = null)
		{
			//IL_005a: 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)
			if (NetworkManager.Singleton.IsServer && PluginConfig.Networking.Enabled.Value && PluginConfig.Networking.SyncRadarNames.Value)
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(0, (Allocator)2, -1);
				if (targets == null)
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(ReorderRadarClientRpcMessage, val, (NetworkDelivery)3);
				}
				else
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(ReorderRadarClientRpcMessage, targets, val, (NetworkDelivery)3);
				}
			}
		}

		private static void OnReorderRadarClientRpc(ulong senderId, FastBufferReader data)
		{
			if (senderId == 0L && PluginConfig.Networking.Enabled.Value && PluginConfig.Networking.SyncRadarNames.Value)
			{
				if (!Object.op_Implicit((Object)(object)StartOfRound.Instance) || !Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController) || !Object.op_Implicit((Object)(object)StartOfRound.Instance.mapScreen))
				{
					LobbyControl.Log.LogError((object)"Received ReorderRadarClientRpc while not connected to a lobby!");
				}
				else
				{
					StartOfRound.Instance.mapScreen.SyncOrderOfRadarBoostersInList();
				}
			}
		}

		internal static void ResetPlayerValuesClientRpc(int playerIndex, IReadOnlyList<ulong> targets = null)
		{
			//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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer && PluginConfig.Networking.Enabled.Value && PluginConfig.Networking.ResetPlayerValues.Value)
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
				((FastBufferWriter)(ref val)).WriteValue<int>(ref playerIndex, default(ForPrimitives));
				if (targets == null)
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(ReorderRadarClientRpcMessage, val, (NetworkDelivery)3);
				}
				else
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(ReorderRadarClientRpcMessage, targets, val, (NetworkDelivery)3);
				}
			}
		}

		private static void OnResetPlayerValuesClientRpc(ulong senderId, FastBufferReader data)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			if (senderId != 0L || !PluginConfig.Networking.Enabled.Value || !PluginConfig.Networking.ResetPlayerValues.Value)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)GameNetworkManager.Instance) || !Object.op_Implicit((Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				LobbyControl.Log.LogError((object)"Received ResetPlayerValuesClientRpc while not connected to a lobby!");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref data)).ReadValue<int>(ref num, default(ForPrimitives));
			StartOfRound instance = StartOfRound.Instance;
			PlayerControllerB val = instance.allPlayerScripts[num];
			GameObject val2 = instance.allPlayerObjects[num];
			if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				return;
			}
			val.ResetPlayerBloodObjects(val.isPlayerDead);
			val.isClimbingLadder = false;
			val.clampLooking = false;
			val.inVehicleAnimation = false;
			val.disableMoveInput = false;
			val.ResetZAndXRotation();
			((Collider)val.thisController).enabled = true;
			val.health = 100;
			val.hasBeenCriticallyInjured = false;
			val.disableLookInput = false;
			val.disableInteract = false;
			Debug.Log((object)"Reviving players B");
			val.isPlayerDead = false;
			val.overrideGameOverSpectatePivot = null;
			instance.SetPlayerObjectExtrapolate(false);
			val.setPositionOfDeadPlayer = false;
			val.DisablePlayerModel(val2, true, true);
			((Behaviour)val.helmetLight).enabled = false;
			val.Crouch(false);
			val.criticallyInjured = false;
			if ((Object)(object)val.playerBodyAnimator != (Object)null)
			{
				val.playerBodyAnimator.SetBool("Limp", false);
			}
			val.bleedingHeavily = false;
			val.activatingItem = false;
			val.twoHanded = false;
			val.inShockingMinigame = false;
			val.inSpecialInteractAnimation = false;
			val.freeRotationInInteractAnimation = false;
			val.disableSyncInAnimation = false;
			val.inAnimationWithEnemy = null;
			val.holdingWalkieTalkie = false;
			val.speakingToWalkieTalkie = false;
			val.isSinking = false;
			val.isUnderwater = false;
			val.sinkingValue = 0f;
			val.statusEffectAudio.Stop();
			val.DisableJetpackControlsLocally();
			val.health = 100;
			val.mapRadarDotAnimator.SetBool("dead", false);
			val.externalForceAutoFade = Vector3.zero;
			val.voiceMuffledByEnemy = false;
			SoundManager.Instance.playerVoicePitchTargets[num] = 1f;
			SoundManager.Instance.SetPlayerPitch(1f, num);
			if ((Object)(object)val.currentVoiceChatIngameSettings == (Object)null)
			{
				instance.RefreshPlayerVoicePlaybackObjects();
			}
			if ((Object)(object)val.currentVoiceChatIngameSettings != (Object)null)
			{
				if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
				{
					val.currentVoiceChatIngameSettings.InitializeComponents();
				}
				if (!((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null))
				{
					((Component)val.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
			}
		}
	}
}
namespace LobbyControl.Dependency
{
	public static class LethalConfigProxy
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c__7<T> where T : Enum
		{
			public static readonly <>c__7<T> <>9 = new <>c__7<T>();

			public static CanModifyDelegate <>9__7_0;

			internal CanModifyResult <AddConfig>b__7_0()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return CanModifyResult.op_Implicit((false, "THIS IS A FLAG TYPE ENUM, EDITING CURRENTLY NOT SUPPORTED!"));
			}
		}

		private static bool? _enabled;

		public static bool Enabled
		{
			get
			{
				bool valueOrDefault = _enabled == true;
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig");
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddConfig(ConfigEntry<string> entry, bool requiresRestart = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(entry, new TextInputFieldOptions
			{
				RequiresRestart = requiresRestart,
				Name = GetPrettyConfigName<string>(entry)
			}));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddConfig(ConfigEntry<bool> entry, bool requiresRestart = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(entry, new BoolCheckBoxOptions
			{
				RequiresRestart = requiresRestart,
				Name = GetPrettyConfigName<bool>(entry)
			}));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddConfig(ConfigEntry<float> entry, bool requiresRestart = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new FloatInputFieldConfigItem(entry, new FloatInputFieldOptions
			{
				RequiresRestart = requiresRestart,
				Name = GetPrettyConfigName<float>(entry)
			}));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddConfig(ConfigEntry<int> entry, bool requiresRestart = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new IntInputFieldConfigItem(entry, new IntInputFieldOptions
			{
				RequiresRestart = requiresRestart,
				Name = GetPrettyConfigName<int>(entry)
			}));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddConfig<T>(ConfigEntry<T> entry, bool requiresRestart = false) where T : Enum
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			EnumDropDownOptions val = new EnumDropDownOptions
			{
				RequiresRestart = requiresRestart
			};
			object obj = <>c__7<T>.<>9__7_0;
			if (obj == null)
			{
				CanModifyDelegate val2 = () => CanModifyResult.op_Implicit((false, "THIS IS A FLAG TYPE ENUM, EDITING CURRENTLY NOT SUPPORTED!"));
				<>c__7<T>.<>9__7_0 = val2;
				obj = (object)val2;
			}
			((BaseOptions)val).CanModifyCallback = (CanModifyDelegate)obj;
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<T>(entry, val));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void AddButton(string section, string name, string description, string buttonText, Action callback)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem(section, name, description, buttonText, (GenericButtonHandler)delegate
			{
				callback?.Invoke();
			}));
		}

		private static string GetPrettyConfigName<T>(ConfigEntry<T> entry)
		{
			return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(((ConfigEntryBase)entry).Definition.Key.Replace("_", " "));
		}
	}
	public static class LethalLevelLoaderDependency
	{
		private static bool? _enabled;

		private static PluginInfo _pluginInfo;

		public static bool Enabled
		{
			get
			{
				bool valueOrDefault = _enabled == true;
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.TryGetValue("imabatby.lethallevelloader", out _pluginInfo);
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}
	}
	public static class LobbyCompatibilityChecker
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init(string GUID, Version version, int Level, int strictness)
		{
			PluginHelper.RegisterPlugin(GUID, version, (CompatibilityLevel)Level, (VersionStrictness)strictness);
		}
	}
}
namespace LobbyControl.API
{
	public class ConnectionCheckpoint : IDisposable
	{
		internal static readonly Dictionary<(BepInPlugin plugin, string name), WeakReference<ConnectionCheckpoint>> RegisteredCheckpoints = new Dictionary<(BepInPlugin, string), WeakReference<ConnectionCheckpoint>>();

		public string Name { get; }

		public BepInPlugin Plugin { get; }

		public long Mask { get; private set; }

		public bool IsDisposed => Mask == 0;

		internal static long CheckpointMask { get; private set; }

		public static ConnectionCheckpoint RegisterCheckpoint(BaseUnityPlugin source, string name)
		{
			return RegisterCheckpoint(source.Info, name);
		}

		public static ConnectionCheckpoint RegisterCheckpoint(PluginInfo source, string name)
		{
			return RegisterCheckpoint(source.Metadata, name);
		}

		public static ConnectionCheckpoint RegisterCheckpoint(BepInPlugin source, string name)
		{
			(BepInPlugin, string) key = (source, name);
			if (RegisteredCheckpoints.TryGetValue(key, out var value) && value.TryGetTarget(out var target) && !target.IsDisposed)
			{
				return target;
			}
			target = new ConnectionCheckpoint(source, name);
			RegisteredCheckpoints[key] = new WeakReference<ConnectionCheckpoint>(target);
			return target;
		}

		public bool Set(ulong clientId)
		{
			if (IsDisposed)
			{
				throw new InvalidOperationException("This ConnectionCheckpoint has already been disposed");
			}
			if (!ConnectionEvents.ConnectingClientId.HasValue && !PluginConfig.JoinQueue.Enabled.Value)
			{
				return true;
			}
			if (ConnectionEvents.ConnectingClientId != clientId)
			{
				LobbyControl.Log.LogWarning((object)$"CompleteCheckpoint ('{Name}' from '{Plugin.Name}') was called for client '{clientId}' but '{ConnectionEvents.ConnectingClientId}' was expected");
				return false;
			}
			ConnectionEvents.CurrentCheckpoints |= Mask;
			LobbyControl.Log.LogDebug((object)("client " + ConnectionEvents.ConnectingName + " completed checkpoint '" + Name + "' from '" + Plugin.Name + "'"));
			ConnectionEvents.RaiseConnectionCheckpointServerEvent(clientId, this);
			return true;
		}

		public bool Reset(ulong clientId)
		{
			if (IsDisposed)
			{
				throw new InvalidOperationException("This ConnectionCheckpoint has already been disposed");
			}
			if (!ConnectionEvents.ConnectingClientId.HasValue && !PluginConfig.JoinQueue.Enabled.Value)
			{
				return true;
			}
			if (ConnectionEvents.ConnectingClientId != clientId)
			{
				LobbyControl.Log.LogWarning((object)$"ResetCheckpoint ('{Name}' from '{Plugin.Name}') was called for client '{clientId}' but '{ConnectionEvents.ConnectingClientId}' was expected");
				return false;
			}
			LobbyControl.Log.LogDebug((object)("'" + Plugin.Name + "' reset checkpoint '" + Name + "' for client " + ConnectionEvents.ConnectingName));
			ConnectionEvents.CurrentCheckpoints &= ~Mask;
			return true;
		}

		public void Dispose()
		{
			if (IsDisposed)
			{
				throw new InvalidOperationException("This ConnectionCheckpoint has already been disposed");
			}
			CheckpointMask &= ~Mask;
			ConnectionEvents.CurrentCheckpoints &= ~Mask;
			Mask = 0L;
		}

		~ConnectionCheckpoint()
		{
			if (!IsDisposed)
			{
				Dispose();
			}
		}

		public override string ToString()
		{
			return "{" + Name + " from " + Plugin.Name + "}";
		}

		private ConnectionCheckpoint(BepInPlugin source, string name)
		{
			Name = name;
			Plugin = source;
			if (!GetNewMask(out var mask))
			{
				throw new IndexOutOfRangeException("Too many checkpoints");
			}
			LobbyControl.Log.LogDebug((object)("Checkpoint '" + name + "' from '" + source.Name + "' created with mask '" + Convert.ToString(mask, 2) + "'"));
			Mask = mask;
			CheckpointMask |= Mask;
		}

		private static bool GetNewMask(out long mask)
		{
			uint num = 0u;
			mask = 1L;
			LobbyControl.Log.LogDebug((object)(Convert.ToString(CheckpointMask, 2) + " & " + Convert.ToString(mask, 2) + " = " + Convert.ToString(CheckpointMask & mask, 2)));
			while ((CheckpointMask & mask) != 0L)
			{
				num++;
				if (num >= 64)
				{
					return false;
				}
				mask <<= 1;
				LobbyControl.Log.LogDebug((object)(Convert.ToString(CheckpointMask, 2) + " & " + Convert.ToString(mask, 2) + " = " + Convert.ToString(CheckpointMask & mask, 2) + "b"));
			}
			return true;
		}
	}
	public static class ConnectionEvents
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnRaiseConnectionCompleteEventClientRpc;
		}

		private static readonly string BaseName = typeof(ConnectionEvents).FullName;

		private static readonly string RaiseConnectionCompleteEventClientRpcMessage = BaseName + "|RaiseConnectionCompleteEvent";

		internal static long CurrentCheckpoints;

		public static ulong? ConnectingClientId => JoinQueuePatches.ConnectingClient?.ClientId;

		public static SteamId? ConnectingSteamId => JoinQueuePatches.ConnectingClient?.SteamId;

		public static string ConnectingName => JoinQueuePatches.ConnectingClient?.Name;

		public static ConnectionCheckpoint[] MissingCheckpoints
		{
			get
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				List<ConnectionCheckpoint> list = default(List<ConnectionCheckpoint>);
				PooledObject<List<ConnectionCheckpoint>> val = CollectionPool<List<ConnectionCheckpoint>, ConnectionCheckpoint>.Get(ref list);
				try
				{
					foreach (WeakReference<ConnectionCheckpoint> value in ConnectionCheckpoint.RegisteredCheckpoints.Values)
					{
						if (value.TryGetTarget(out var target) && !target.IsDisposed && (CurrentCheckpoints & target.Mask) == 0L)
						{
							list.Add(target);
						}
					}
					return list.ToArray();
				}
				finally
				{
					((IDisposable)val/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		internal static bool HasCompletedAllCheckpoints => ConnectionCheckpoint.CheckpointMask == CurrentCheckpoints;

		internal static long MissingCheckpointMask => ~CurrentCheckpoints & ConnectionCheckpoint.CheckpointMask;

		public static event Action<ulong> OnConnectionCompletedServer;

		public static event Action<ulong> OnClientConnectionCompletedClient;

		public static event Action<ulong, ConnectionCheckpoint> OnConnectionCheckpointServer;

		internal static void RaiseConnectionCheckpointServerEvent(ulong clientId, ConnectionCheckpoint checkpoint)
		{
			try
			{
				ConnectionEvents.OnConnectionCheckpointServer?.Invoke(clientId, checkpoint);
			}
			catch (Exception arg)
			{
				LobbyControl.Log.LogError((object)$"Exception while processing ConnectionCheckpointServerEvent: {arg}");
			}
		}

		internal static void RaiseConnectionCompleteServerEvent(ulong clientId)
		{
			try
			{
				RaiseConnectionCompleteEventClientRpc(clientId);
				ConnectionEvents.OnConnectionCompletedServer?.Invoke(clientId);
			}
			catch (Exception arg)
			{
				LobbyControl.Log.LogError((object)$"Exception while processing ConnectionCompleteServerEvent: {arg}");
			}
		}

		internal static void RegisterNamedMessages()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
			string raiseConnectionCompleteEventClientRpcMessage = RaiseConnectionCompleteEventClientRpcMessage;
			object obj = <>O.<0>__OnRaiseConnectionCompleteEventClientRpc;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = OnRaiseConnectionCompleteEventClientRpc;
				<>O.<0>__OnRaiseConnectionCompleteEventClientRpc = val;
				obj = (object)val;
			}
			customMessagingManager.RegisterNamedMessageHandler(raiseConnectionCompleteEventClientRpcMessage, (HandleNamedMessageDelegate)obj);
		}

		internal static void UnregisterNamedMessages()
		{
			NetworkManager.Singleton.CustomMessagingManager.UnregisterNamedMessageHandler(RaiseConnectionCompleteEventClientRpcMessage);
		}

		internal static void RaiseConnectionCompleteEventClientRpc(ulong clientId, IReadOnlyList<ulong> targets = null)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
				((FastBufferWriter)(ref val)).WriteValue<ulong>(ref clientId, default(ForPrimitives));
				if (targets == null)
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessageToAll(RaiseConnectionCompleteEventClientRpcMessage, val, (NetworkDelivery)3);
				}
				else
				{
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage(RaiseConnectionCompleteEventClientRpcMessage, targets, val, (NetworkDelivery)3);
				}
			}
		}

		private static void OnRaiseConnectionCompleteEventClientRpc(ulong senderId, FastBufferReader data)
		{
			//IL_0037: 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)
			if (senderId != 0L)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)GameNetworkManager.Instance) || !Object.op_Implicit((Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				LobbyControl.Log.LogError((object)"Received RaiseConnectionCompleteEventClientRpc while not connected to a lobby!");
				return;
			}
			ulong obj = default(ulong);
			((FastBufferReader)(ref data)).ReadValue<ulong>(ref obj, default(ForPrimitives));
			try
			{
				ConnectionEvents.OnClientConnectionCompletedClient?.Invoke(obj);
			}
			catch (Exception arg)
			{
				LobbyControl.Log.LogError((object)$"Exception while processing ConnectionCompleteClientEvent: {arg}");
			}
		}

		internal static void ResetCheckpoints()
		{
			CurrentCheckpoints = 0L;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}