using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Entiffo.UEXPDedicatedClient.Config;
using Entiffo.UEXPDedicatedClient.Patches;
using Entiffo.UEXPDedicatedClient.Util;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("UEXP_Dedicated_Client")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3")]
[assembly: AssemblyProduct("UEXP_Dedicated_Client")]
[assembly: AssemblyTitle("UEXP_Dedicated_Client")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 Entiffo.UEXPDedicatedClient
{
	[BepInPlugin("Entiffo.UEXP_Dedicated_Client", "UEXP_Dedicated_Client", "1.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string ModGuid = "Entiffo.UEXP_Dedicated_Client";

		public const string MoreCompanyGuid = "me.swipez.melonloader.morecompany";

		private readonly Harmony _harmony = new Harmony("Entiffo.UEXP_Dedicated_Client");

		private static bool _moreCompanyResizePatched;

		private static bool _moreCompanyUpdateBoxPatched;

		internal static Plugin Instance { get; private set; }

		internal static ModConfig Config { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		private static bool MoreCompanyGuardsFullyPatched
		{
			get
			{
				if (_moreCompanyResizePatched)
				{
					return _moreCompanyUpdateBoxPatched;
				}
				return false;
			}
		}

		internal static bool IsEnabled => Config.Enabled.Value;

		private void Awake()
		{
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Config = new ModConfig(((BaseUnityPlugin)this).Config);
			try
			{
				GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
				foreach (GameObject val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string name = ((Object)val).name;
						switch (name)
						{
						case "UEXP_PasswordPrompt":
						case "UEXP_ModsModal":
						case "UEXP_OrbitQueue":
						case "UEXP_EventSystem":
						case "UEXP_GameplayInputRestore":
							Log.LogWarning((object)("Destroying leftover UI object from older build: " + name));
							Object.Destroy((Object)(object)val);
							break;
						}
					}
				}
			}
			catch
			{
			}
			if (!IsEnabled)
			{
				Log.LogInfo((object)"UEXP_Dedicated_Client 1.0.3 is DISABLED (General.Enabled=false). Vanilla menus/join. Set Enabled=true and restart for dedicated client features.");
				return;
			}
			Type[] types = typeof(Plugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (Attribute.GetCustomAttribute(type, typeof(HarmonyPatch)) != null)
				{
					try
					{
						_harmony.CreateClassProcessor(type).Patch();
					}
					catch (Exception ex)
					{
						Log.LogWarning((object)("Harmony skip " + type.Name + ": " + ex.Message));
					}
				}
			}
			TryPatchMoreCompanyGuards();
			if (Config.EnableQuatSpamProbe.Value)
			{
				QuatSpamProbe.EnsureHooked();
			}
			QuatUnityLogFilter.TryPatch(_harmony);
			OpenBodyCamsGhostGuard.TryPatch(_harmony);
			try
			{
				SteamMatchmaking.OnLobbyEntered += MoreCompanyLobbyMatch.OnSteamLobbyEntered;
				SteamFriends.OnGameLobbyJoinRequested += delegate(Lobby lobby, SteamId _)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					MoreCompanyLobbyMatch.OnSteamLobbyEntered(lobby);
				};
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Steam lobby crew hooks failed: " + ex2.Message));
			}
			Log.LogInfo((object)"UEXP_Dedicated_Client 1.0.3 loaded. Install on every joiner of a UEXP dedicated lobby.");
		}

		private void TryPatchMoreCompanyGuards()
		{
			TryPatchMoreCompanyGuardsRetry("Awake");
		}

		internal static void TryPatchMoreCompanyGuardsRetry(string reason)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			if (MoreCompanyGuardsFullyPatched || (Object)(object)Instance == (Object)null)
			{
				return;
			}
			try
			{
				Type type = AccessTools.TypeByName("MoreCompany.MainClass");
				if (type == null)
				{
					if (reason == "Awake")
					{
						Log.LogInfo((object)"MoreCompany not loaded yet — ResizeGuard will retry on dedicated join.");
					}
					return;
				}
				if (!_moreCompanyResizePatched)
				{
					MethodBase methodBase = AccessTools.Method(type, "ResizePlayerCache", (Type[])null, (Type[])null);
					if (methodBase != null)
					{
						Instance._harmony.Patch(methodBase, new HarmonyMethod(typeof(MoreCompanyResizeGuardPatch), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						_moreCompanyResizePatched = true;
						Log.LogInfo((object)("MoreCompany ResizePlayerCache guard patched (" + reason + ")."));
					}
					else
					{
						Log.LogWarning((object)("MoreCompany ResizePlayerCache not found (" + reason + ")."));
					}
				}
				if (!_moreCompanyUpdateBoxPatched)
				{
					Type type2 = AccessTools.TypeByName("MoreCompany.MenuManagerHost");
					MethodBase methodBase2 = ((type2 == null) ? null : AccessTools.Method(type2, "UpdateTextBox", new Type[2]
					{
						typeof(TMP_InputField),
						typeof(string)
					}, (Type[])null));
					if (methodBase2 != null)
					{
						Instance._harmony.Patch(methodBase2, new HarmonyMethod(typeof(MoreCompanyCrewCountUiGuardPatch), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						_moreCompanyUpdateBoxPatched = true;
						Log.LogInfo((object)("MoreCompany UpdateTextBox guard patched (" + reason + ")."));
					}
					else if (type2 != null)
					{
						Log.LogWarning((object)("MoreCompany UpdateTextBox not found (" + reason + ") — will retry on dedicated join."));
					}
				}
				if (!MoreCompanyGuardsFullyPatched && reason != "Awake")
				{
					Log.LogWarning((object)("MoreCompany guards incomplete (" + reason + "): " + $"resize={_moreCompanyResizePatched} updateBox={_moreCompanyUpdateBoxPatched}"));
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("MoreCompany manual guards failed (" + reason + "): " + ex.Message));
			}
		}

		internal static void DebugLog(string message)
		{
			if (Config.DebugLogging.Value)
			{
				Log.LogInfo((object)message);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Entiffo.UEXP_Dedicated_Client";

		public const string PLUGIN_NAME = "UEXP_Dedicated_Client";

		public const string PLUGIN_VERSION = "1.0.3";
	}
}
namespace Entiffo.UEXPDedicatedClient.Util
{
	public static class DedicatedLobby
	{
		public const string FlagKey = "uexpDedicated";

		public const string FlagValue = "1";

		public const string VerKey = "uexpDedicatedVer";

		public const string ReqClientKey = "uexpReqClient";

		public const string MaxKey = "uexpMax";

		public const string HumansKey = "uexpHumans";

		public const string ModCountKey = "uexpModN";

		public const string ModsKey = "uexpMods";

		public const string ModsKey2 = "uexpMods2";

		public const string HasPassKey = "uexpHasPass";

		public const string PassHashKey = "uexpPassHash";

		public const string ProfileCodeKey = "uexpProfile";

		public const string PhaseKey = "uexpPhase";

		public const string MoonKey = "uexpMoon";

		public const string RiskKey = "uexpRisk";

		public const string WeatherKey = "uexpWeather";

		public const string DayKey = "uexpDay";

		public const string QuotaKey = "uexpQuota";

		public const string TipKey = "uexpTip";

		public const string MotdKey = "uexpMotd";

		public const string TimeKey = "uexpTime";

		public const string QueueableKey = "uexpQueueable";

		public const string QueueCountKey = "uexpQueueN";

		public const string AdmitKey = "uexpAdmit";

		public const string MemberQueueKey = "uexpQ";

		public const string QueueDenyKey = "uexpQDeny";

		public const string BanHintsKey = "uexpBanHints";

		public const string MinLeaveKey = "uexpMinLeave";

		private static bool _sessionDedicated;

		private const string RoleSyncLobbyKey = "uexpRoles";

		public static bool SessionLatched => _sessionDedicated;

		public static bool IsCurrentLobbyDedicated()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (_sessionDedicated)
			{
				return true;
			}
			try
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if ((Object)(object)instance == (Object)null || instance.disableSteam || !instance.currentLobby.HasValue)
				{
					return false;
				}
				if (!IsDedicatedLobby(instance.currentLobby.Value))
				{
					return false;
				}
				MarkSessionDedicated("lobby data");
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static void MarkSessionDedicated(string reason = "")
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			if (_sessionDedicated)
			{
				return;
			}
			_sessionDedicated = true;
			Plugin.DebugLog("Dedicated session latched" + (string.IsNullOrEmpty(reason) ? "" : (" (" + reason + ")")) + ".");
			try
			{
				if (Plugin.Config != null && Plugin.Config.EnableQuatSpamProbe.Value)
				{
					QuatSpamProbe.EnsureHooked();
					QuatSpamProbe.Arm("dedicated latch" + (string.IsNullOrEmpty(reason) ? "" : (":" + reason)));
				}
				OpenBodyCamsGhostGuard.TryPatch(new Harmony("Entiffo.UEXP_Dedicated_Client.obc-retry"));
			}
			catch
			{
			}
		}

		public static void ClearSessionDedicated(string reason = "")
		{
			if (!_sessionDedicated)
			{
				return;
			}
			_sessionDedicated = false;
			Plugin.DebugLog("Dedicated session cleared" + (string.IsNullOrEmpty(reason) ? "" : (" (" + reason + ")")) + ".");
			try
			{
				QuatSpamProbe.ClearSession();
				HostBodyHidePatches.ResetHideLatch();
				GhostSeatLateJoinEnforcer.ResetSession();
			}
			catch
			{
			}
		}

		public static bool IsDedicatedLobby(Lobby lobby)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData("uexpDedicated") == "1";
			}
			catch
			{
				return false;
			}
		}

		public static bool TryGetClientVersionMismatch(Lobby lobby, out string message)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			message = "";
			try
			{
				if (!IsDedicatedLobby(lobby))
				{
					return false;
				}
				try
				{
					((Lobby)(ref lobby)).Refresh();
				}
				catch
				{
				}
				string text = ReadData(lobby, "uexpReqClient").Trim();
				if (string.IsNullOrEmpty(text))
				{
					return false;
				}
				string text2 = "1.0.3";
				string text3 = ReadData(lobby, "uexpDedicatedVer").Trim();
				string text4 = (string.IsNullOrEmpty(text3) ? "" : (" (host " + text3 + ")"));
				if (!TryCompareVersions(text2, text, out var cmp))
				{
					message = "UEXP Dedicated Client version unreadable.\nYou have v" + text2 + ". This server needs v" + text + text4 + ".\nUpdate the client from the UEXP site (lethal.uexp.org), then rejoin.";
					return true;
				}
				if (cmp < 0)
				{
					message = "UEXP Dedicated Client is outdated.\nYou have v" + text2 + ". This server needs v" + text + text4 + ".\nUpdate the client from the UEXP site (lethal.uexp.org), then rejoin.";
					return true;
				}
				if (cmp > 0)
				{
					message = "This dedicated host is outdated.\nServer expects client v" + text + text4 + "; you have v" + text2 + ".\nWait until the host administrator updates the server.";
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		public static string FormatBrowserHostVersionBadge(Lobby lobby)
		{
			//IL_0000: 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)
			try
			{
				string text = ReadData(lobby, "uexpDedicatedVer").Trim();
				if (string.IsNullOrEmpty(text))
				{
					return "";
				}
				string text2 = "host " + text;
				string text3 = ReadData(lobby, "uexpReqClient").Trim();
				string a = "1.0.3";
				if (string.IsNullOrEmpty(text3))
				{
					return "<color=#E8A04A>" + text2 + "</color>";
				}
				if (!TryCompareVersions(a, text3, out var cmp))
				{
					return "<color=#C84A3A>" + text2 + "</color>";
				}
				if (cmp == 0)
				{
					return "<color=#6FBF4A>" + text2 + "</color>";
				}
				return "<color=#C84A3A>" + text2 + "</color>";
			}
			catch
			{
				return "";
			}
		}

		private static bool TryCompareVersions(string a, string b, out int cmp)
		{
			cmp = 0;
			try
			{
				if (!Version.TryParse(NormalizeVersion(a), out Version result) || !Version.TryParse(NormalizeVersion(b), out Version result2) || result == null || result2 == null)
				{
					return false;
				}
				cmp = result.CompareTo(result2);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string NormalizeVersion(string v)
		{
			string text = (v ?? "").Trim();
			int num = 0;
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] == '.')
				{
					num++;
				}
			}
			return num switch
			{
				0 => text + ".0", 
				1 => text + ".0", 
				_ => text, 
			};
		}

		public static bool IsQueueableLobby(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return IsDedicatedLobby(lobby) && ((Lobby)(ref lobby)).GetData("uexpQueueable") == "1";
			}
			catch
			{
				return false;
			}
		}

		public static bool IsJoinableListing(Lobby lobby)
		{
			//IL_0000: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!IsDedicatedLobby(lobby))
				{
					return false;
				}
				if (((Lobby)(ref lobby)).GetData("started") == "1")
				{
					return false;
				}
				if (((Lobby)(ref lobby)).GetData("joinable") == "false")
				{
					return false;
				}
				if (IsQueueableLobby(lobby))
				{
					return true;
				}
				int num = DisplayMemberCount(lobby);
				int num2 = ReadHumanCapacity(lobby);
				if (num2 > 0 && num >= num2)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		public static int DisplayMemberCount(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return DisplayMemberCountExcludingQueue(lobby);
		}

		public static int DisplayMemberCountExcludingQueue(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!IsDedicatedLobby(lobby))
				{
					return ((Lobby)(ref lobby)).MemberCount;
				}
				string data = ((Lobby)(ref lobby)).GetData("uexpHumans");
				if (!string.IsNullOrEmpty(data) && int.TryParse(data, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result >= 0)
				{
					return result;
				}
				SteamId id = ((Lobby)(ref lobby)).Owner.Id;
				int num = 0;
				foreach (Friend member in ((Lobby)(ref lobby)).Members)
				{
					if (SteamId.op_Implicit(member.Id) != SteamId.op_Implicit(id))
					{
						string value = null;
						try
						{
							value = ((Lobby)(ref lobby)).GetMemberData(member, "uexpQ");
						}
						catch
						{
						}
						if (string.IsNullOrEmpty(value))
						{
							num++;
						}
					}
				}
				return num;
			}
			catch
			{
				try
				{
					string data2 = ((Lobby)(ref lobby)).GetData("uexpHumans");
					if (!string.IsNullOrEmpty(data2) && int.TryParse(data2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && result2 >= 0)
					{
						return result2;
					}
				}
				catch
				{
				}
				int memberCount = ((Lobby)(ref lobby)).MemberCount;
				return (memberCount > 0) ? (memberCount - 1) : 0;
			}
		}

		public static int ReadHumanCapacity(Lobby lobby)
		{
			try
			{
				string data = ((Lobby)(ref lobby)).GetData("uexpMax");
				if (!string.IsNullOrEmpty(data) && int.TryParse(data, out var result) && result > 0)
				{
					return result;
				}
			}
			catch
			{
			}
			return 3;
		}

		public static int ReadQueueCount(Lobby lobby)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string data = ((Lobby)(ref lobby)).GetData("uexpQueueN");
				if (!string.IsNullOrEmpty(data) && int.TryParse(data, out var result) && result >= 0)
				{
					return result;
				}
			}
			catch
			{
			}
			return CountQueuedMembers(lobby);
		}

		public static int CountQueuedMembers(Lobby lobby)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				SteamId id = ((Lobby)(ref lobby)).Owner.Id;
				foreach (Friend member in ((Lobby)(ref lobby)).Members)
				{
					if (SteamId.op_Implicit(member.Id) != SteamId.op_Implicit(id))
					{
						string text = null;
						try
						{
							text = ((Lobby)(ref lobby)).GetMemberData(member, "uexpQ");
						}
						catch
						{
							continue;
						}
						if (!string.IsNullOrEmpty(text))
						{
							num++;
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		public static void ReadLocalQueuePosition(Lobby lobby, long localStamp, out int position, out int total)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			position = 0;
			total = 0;
			try
			{
				SteamId self = SteamClient.SteamId;
				SteamId id = ((Lobby)(ref lobby)).Owner.Id;
				List<(SteamId, long, int)> list = new List<(SteamId, long, int)>();
				foreach (Friend member in ((Lobby)(ref lobby)).Members)
				{
					if (SteamId.op_Implicit(member.Id) == SteamId.op_Implicit(id))
					{
						continue;
					}
					string text = null;
					try
					{
						text = ((Lobby)(ref lobby)).GetMemberData(member, "uexpQ");
					}
					catch
					{
						continue;
					}
					if (!string.IsNullOrWhiteSpace(text))
					{
						if (!long.TryParse(text.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
						{
							result = 0L;
						}
						list.Add((member.Id, result, QueuePriorityRank(lobby, SteamId.op_Implicit(member.Id))));
					}
				}
				list = (from s in list
					orderby s.Prio, s.Ts, s.Id.Value
					select s).ToList();
				total = list.Count;
				for (int num = 0; num < list.Count; num++)
				{
					if (SteamId.op_Implicit(list[num].Item1) == SteamId.op_Implicit(self))
					{
						position = num + 1;
						return;
					}
				}
				if (localStamp > 0)
				{
					int myPrio = QueuePriorityRank(lobby, SteamId.op_Implicit(self));
					int num2 = list.Count<(SteamId, long, int)>(((SteamId Id, long Ts, int Prio) s) => s.Prio < myPrio || (s.Prio == myPrio && (s.Ts < localStamp || (s.Ts == localStamp && s.Id.Value < self.Value))));
					position = num2 + 1;
					total = Math.Max(total + 1, position);
				}
			}
			catch
			{
				position = 0;
				total = 0;
			}
		}

		public static int QueuePriorityRank(Lobby lobby, ulong steamId)
		{
			if (steamId == 0L)
			{
				return 3;
			}
			if (DeveloperRoster.IsDeveloper(steamId))
			{
				return 0;
			}
			try
			{
				string text = ((Lobby)(ref lobby)).GetData("uexpRoles") ?? "";
				if (!string.IsNullOrWhiteSpace(text))
				{
					string[] array = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
					for (int i = 0; i < array.Length; i++)
					{
						string text2 = array[i].Trim();
						int num = text2.IndexOf('=');
						if (num > 0 && ulong.TryParse(text2.Substring(0, num).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result == steamId)
						{
							string text3 = text2.Substring(num + 1).Trim().ToLowerInvariant();
							if (text3.StartsWith("a"))
							{
								return 1;
							}
							if (text3.StartsWith("m"))
							{
								return 2;
							}
						}
					}
				}
			}
			catch
			{
			}
			return 3;
		}

		public static int ReadModCount(Lobby lobby)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string data = ((Lobby)(ref lobby)).GetData("uexpModN");
				if (!string.IsNullOrEmpty(data) && int.TryParse(data, out var result))
				{
					return result;
				}
			}
			catch
			{
			}
			string text = ReadModList(lobby);
			if (string.IsNullOrWhiteSpace(text))
			{
				return 0;
			}
			return text.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries).Length;
		}

		public static string ReadModList(Lobby lobby)
		{
			try
			{
				string text = ((Lobby)(ref lobby)).GetData("uexpMods") ?? "";
				string text2 = ((Lobby)(ref lobby)).GetData("uexpMods2") ?? "";
				if (string.IsNullOrEmpty(text))
				{
					return text2 ?? "";
				}
				if (string.IsNullOrEmpty(text2))
				{
					return text;
				}
				return text + ";" + text2;
			}
			catch
			{
				return "";
			}
		}

		public static string ReadData(Lobby lobby, string key)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData(key) ?? "";
			}
			catch
			{
				return "";
			}
		}

		public static string ReadProfileCode(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ReadData(lobby, "uexpProfile");
		}

		public static string ReadMotd(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ReadData(lobby, "uexpMotd").Trim();
		}

		public static bool TryGetLocalBanRemaining(Lobby lobby, out TimeSpan remaining, out bool permanent)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			remaining = TimeSpan.Zero;
			permanent = false;
			try
			{
				string text = ReadData(lobby, "uexpBanHints");
				if (string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				ulong num = SteamId.op_Implicit(SteamClient.SteamId);
				if (num == 0L)
				{
					return false;
				}
				string value = num.ToString(CultureInfo.InvariantCulture);
				string[] array = text.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Trim().Split(':');
					if (array2.Length == 2 && array2[0].Equals(value, StringComparison.OrdinalIgnoreCase) && long.TryParse(array2[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						if (result < 0)
						{
							permanent = true;
							remaining = TimeSpan.MaxValue;
							return true;
						}
						DateTimeOffset dateTimeOffset = new DateTimeOffset(result, TimeSpan.Zero);
						remaining = dateTimeOffset - DateTimeOffset.UtcNow;
						if (remaining <= TimeSpan.Zero)
						{
							return false;
						}
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		public static string FormatBanCountdown(TimeSpan remaining)
		{
			if (remaining == TimeSpan.MaxValue || remaining.TotalDays > 3650.0)
			{
				return "permanently";
			}
			int num = (int)Math.Ceiling(remaining.TotalMinutes);
			if (num < 1)
			{
				num = 1;
			}
			int num2 = num / 60;
			int num3 = num % 60;
			if (num2 <= 0)
			{
				if (num3 != 1)
				{
					return $"{num3} minutes";
				}
				return "1 minute";
			}
			if (num3 == 0)
			{
				if (num2 != 1)
				{
					return $"{num2} hours";
				}
				return "1 hour";
			}
			return $"{num2}h {num3}m";
		}

		public static string ReadSessionTip(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			string text = ReadData(lobby, "uexpTip").Trim();
			string text2 = ReadData(lobby, "uexpPhase");
			string text3 = ReadData(lobby, "uexpMoon");
			string text4 = ReadData(lobby, "uexpRisk");
			string text5 = ReadData(lobby, "uexpWeather");
			string text6 = ReadData(lobby, "uexpDay");
			string text7 = ReadData(lobby, "uexpQuota");
			string text8 = ReadData(lobby, "uexpTime");
			bool flag = text.Equals("starting up", StringComparison.OrdinalIgnoreCase) || text.Equals("hosting…", StringComparison.OrdinalIgnoreCase) || text.Equals("hosting...", StringComparison.OrdinalIgnoreCase);
			bool flag2 = (!string.IsNullOrEmpty(text2) && text2 != "boot") || !string.IsNullOrEmpty(text3) || !string.IsNullOrEmpty(text6) || !string.IsNullOrEmpty(text7) || !string.IsNullOrEmpty(text8);
			bool flag3 = !string.IsNullOrEmpty(ReadData(lobby, "uexpMax")) || !string.IsNullOrEmpty(ReadData(lobby, "uexpHumans"));
			if (!string.IsNullOrWhiteSpace(text) && (!flag || !(flag2 || flag3)))
			{
				return text;
			}
			List<string> list = new List<string>(6);
			if (text2 == "orbit" || (string.IsNullOrEmpty(text2) && flag3 && !flag2))
			{
				list.Add(string.IsNullOrEmpty(text3) ? "in orbit" : ("orbit · " + text3));
			}
			else if (text2 == "landing")
			{
				list.Add(string.IsNullOrEmpty(text3) ? "landing…" : ("landing · " + text3));
				if (!string.IsNullOrEmpty(text4))
				{
					list.Add(text4);
				}
			}
			else if (text2 == "moon")
			{
				if (!string.IsNullOrEmpty(text3))
				{
					list.Add(text3);
				}
				else
				{
					list.Add("on moon");
				}
				if (!string.IsNullOrEmpty(text4))
				{
					list.Add(text4);
				}
				if (!string.IsNullOrEmpty(text5))
				{
					list.Add(text5);
				}
			}
			else
			{
				if (flag && !flag2 && !flag3)
				{
					if (text.Length <= 0)
					{
						return "starting up";
					}
					return text;
				}
				if (flag3)
				{
					list.Add("in orbit");
				}
			}
			if (!string.IsNullOrEmpty(text6))
			{
				list.Add(text6);
			}
			if (!string.IsNullOrEmpty(text8))
			{
				list.Add(text8);
			}
			if (!string.IsNullOrEmpty(text7))
			{
				list.Add("quota " + text7);
			}
			string text9 = string.Join(" · ", list);
			if (!string.IsNullOrEmpty(text9))
			{
				return text9;
			}
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "in orbit";
		}

		public static bool RequiresPassword(Lobby lobby)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData("uexpHasPass") == "1" && !string.IsNullOrEmpty(((Lobby)(ref lobby)).GetData("uexpPassHash"));
			}
			catch
			{
				return false;
			}
		}

		public static string ExpectedPasswordHash(Lobby lobby)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData("uexpPassHash") ?? "";
			}
			catch
			{
				return "";
			}
		}
	}
	internal static class DeveloperRoster
	{
		public const ulong EntiffoSteamId = 76561198051556575uL;

		private static readonly HashSet<ulong> Ids = new HashSet<ulong> { 76561198051556575uL };

		public static bool IsDeveloper(ulong steamId)
		{
			if (steamId != 0L)
			{
				return Ids.Contains(steamId);
			}
			return false;
		}

		public static IReadOnlyCollection<ulong> Snapshot()
		{
			return Ids;
		}
	}
}
namespace Entiffo.UEXPDedicatedClient.Patches
{
	internal static class AdminOpsClient
	{
		public const string HealPrefix = "[UEXP]heal:";

		public const string TpPrefix = "[UEXP]tp:";

		public const string MutePrefix = "[UEXP]mute:";

		public const string WeatherPrefix = "[UEXP]weather:";

		public const string QuotaPrefix = "[UEXP]quota:";

		private static readonly HashSet<ulong> MutedSteamIds = new HashSet<ulong>();

		public static bool TryHandleSystemMessage(string? chatMessage)
		{
			if (string.IsNullOrEmpty(chatMessage))
			{
				return false;
			}
			if (chatMessage.StartsWith("[UEXP]heal:", StringComparison.Ordinal))
			{
				ApplyHeal(chatMessage.Substring("[UEXP]heal:".Length).Trim());
				return true;
			}
			if (chatMessage.StartsWith("[UEXP]tp:", StringComparison.Ordinal))
			{
				ApplyTp(chatMessage.Substring("[UEXP]tp:".Length).Trim());
				return true;
			}
			if (chatMessage.StartsWith("[UEXP]mute:", StringComparison.Ordinal))
			{
				ApplyMute(chatMessage.Substring("[UEXP]mute:".Length).Trim());
				return true;
			}
			if (chatMessage.StartsWith("[UEXP]weather:", StringComparison.Ordinal))
			{
				ApplyWeather(chatMessage.Substring("[UEXP]weather:".Length).Trim());
				return true;
			}
			if (chatMessage.StartsWith("[UEXP]quota:", StringComparison.Ordinal))
			{
				ApplyQuota(chatMessage.Substring("[UEXP]quota:".Length).Trim());
				return true;
			}
			return false;
		}

		public static bool TryHandleWarnWhisper(string? chatMessage)
		{
			if (string.IsNullOrEmpty(chatMessage))
			{
				return false;
			}
			if (!chatMessage.StartsWith("[WARN]@", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text = chatMessage.Substring("[WARN]@".Length);
			int num = text.IndexOf('|');
			if (num <= 0)
			{
				return true;
			}
			string s = text.Substring(0, num).Trim();
			string text2 = text.Substring(num + 1).Trim();
			if (!ulong.TryParse(s, out var result) || result == 0L)
			{
				return true;
			}
			try
			{
				ulong num2 = LocalSteam();
				if (num2 != 0L && num2 == result && !string.IsNullOrEmpty(text2))
				{
					HUDManager instance = HUDManager.Instance;
					if (instance != null)
					{
						instance.DisplayTip("Warning", Truncate(text2, 120), true, false, "UEXP_Warn");
					}
				}
			}
			catch
			{
			}
			return true;
		}

		public static bool IsSteamMuted(ulong steam)
		{
			if (steam != 0L)
			{
				return MutedSteamIds.Contains(steam);
			}
			return false;
		}

		private static void ApplyHeal(string rest)
		{
			string[] array = rest.Split(':');
			if (array.Length < 1 || !int.TryParse(array[0].Trim(), out var result))
			{
				return;
			}
			int num = 100;
			if (array.Length >= 2 && int.TryParse(array[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && result2 > 0)
			{
				num = result2;
			}
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts == null || result < 0 || result >= instance.allPlayerScripts.Length)
			{
				return;
			}
			PlayerControllerB val = instance.allPlayerScripts[result];
			if ((Object)(object)val == (Object)null || val.isPlayerDead)
			{
				return;
			}
			try
			{
				val.health = num;
				val.criticallyInjured = false;
				val.hasBeenCriticallyInjured = false;
				val.bleedingHeavily = false;
				try
				{
					val.MakeCriticallyInjured(false);
				}
				catch
				{
				}
				if ((Object)(object)val.playerBodyAnimator != (Object)null)
				{
					val.playerBodyAnimator.SetBool("Limp", false);
				}
				if (((NetworkBehaviour)val).IsOwner)
				{
					HUDManager instance2 = HUDManager.Instance;
					if (instance2 != null)
					{
						instance2.UpdateHealthUI(num, false);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Client heal: " + ex.Message);
			}
		}

		private static void ApplyTp(string rest)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			string[] array = rest.Split(':');
			if (array.Length < 7 || !int.TryParse(array[0], out var result) || !float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || !float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) || !float.TryParse(array[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
			{
				return;
			}
			bool isInElevator = array[4] == "1";
			bool isInHangarShipRoom = array[5] == "1";
			bool isInsideFactory = array[6] == "1";
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts == null || result < 0 || result >= instance.allPlayerScripts.Length)
			{
				return;
			}
			PlayerControllerB val = instance.allPlayerScripts[result];
			if ((Object)(object)val == (Object)null || val.isPlayerDead)
			{
				return;
			}
			try
			{
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(result2, result3, result4);
				val.isInElevator = isInElevator;
				val.isInHangarShipRoom = isInHangarShipRoom;
				val.isInsideFactory = isInsideFactory;
				val.TeleportPlayer(val2, false, 0f, false, true);
				val.teleportingThisFrame = true;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Client tp: " + ex.Message);
			}
		}

		private static void ApplyMute(string rest)
		{
			string[] array = rest.Split(':');
			if (array.Length >= 2 && ulong.TryParse(array[0].Trim(), out var result) && result != 0L)
			{
				if (array[1].Trim() == "1")
				{
					MutedSteamIds.Add(result);
				}
				else
				{
					MutedSteamIds.Remove(result);
				}
				ApplyVoiceMuteState();
			}
		}

		private static void ApplyWeather(string rest)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected I4, but got Unknown
			if (!Enum.TryParse<LevelWeatherType>(rest, ignoreCase: true, out LevelWeatherType result))
			{
				return;
			}
			TimeOfDay instance = TimeOfDay.Instance;
			StartOfRound instance2 = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null)
			{
				return;
			}
			try
			{
				DisableAllWeatherFully(instance);
				instance.currentWeatherVariable = 0f;
				instance.currentWeatherVariable2 = 0f;
				instance.currentLevelWeather = result;
				if ((Object)(object)instance2.currentLevel != (Object)null)
				{
					instance2.currentLevel.currentWeather = result;
				}
				if ((int)result == -1)
				{
					StopStormyLightningResidue();
					return;
				}
				int num = (int)result;
				if (instance.effects == null || num < 0 || num >= instance.effects.Length)
				{
					return;
				}
				WeatherEffect val = instance.effects[num];
				if (val != null)
				{
					val.effectEnabled = true;
					val.transitioning = false;
					if ((Object)(object)val.effectObject != (Object)null)
					{
						val.effectObject.SetActive(true);
					}
					if ((Object)(object)val.effectPermanentObject != (Object)null)
					{
						val.effectPermanentObject.SetActive(true);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Client weather: " + ex.Message);
			}
		}

		private static void DisableAllWeatherFully(TimeOfDay tod)
		{
			if (tod?.effects == null)
			{
				return;
			}
			try
			{
				tod.DisableAllWeather(true);
			}
			catch
			{
			}
			for (int i = 0; i < tod.effects.Length; i++)
			{
				WeatherEffect val = tod.effects[i];
				if (val == null)
				{
					continue;
				}
				try
				{
					val.effectEnabled = false;
					val.transitioning = false;
					if ((Object)(object)val.effectObject != (Object)null)
					{
						val.effectObject.SetActive(false);
					}
					if ((Object)(object)val.effectPermanentObject != (Object)null)
					{
						val.effectPermanentObject.SetActive(false);
					}
				}
				catch
				{
				}
			}
		}

		private static void StopStormyLightningResidue()
		{
			try
			{
				StormyWeather val = Object.FindObjectOfType<StormyWeather>(true);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				try
				{
					if ((Object)(object)val.staticElectricityParticle != (Object)null)
					{
						val.staticElectricityParticle.Stop(true, (ParticleSystemStopBehavior)0);
						AudioSource component = ((Component)val.staticElectricityParticle).GetComponent<AudioSource>();
						if ((Object)(object)component != (Object)null)
						{
							component.Stop();
						}
					}
				}
				catch
				{
				}
				if ((Object)(object)((Component)val).gameObject != (Object)null && ((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("StopStormyLightningResidue: " + ex.Message);
			}
		}

		private static void ApplyQuota(string rest)
		{
			if (!int.TryParse(rest, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return;
			}
			TimeOfDay instance = TimeOfDay.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				instance.profitQuota = result;
				try
				{
					instance.UpdateProfitQuotaCurrentTime();
				}
				catch
				{
				}
			}
			catch
			{
			}
		}

		internal static void ApplyVoiceMuteState()
		{
			StartOfRound instance = StartOfRound.Instance;
			SoundManager instance2 = SoundManager.Instance;
			if (instance?.allPlayerScripts == null || instance2?.playerVoiceVolumes == null)
			{
				return;
			}
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = instance.allPlayerScripts[i];
				if (!((Object)(object)val == (Object)null) && val.playerSteamId != 0L && MutedSteamIds.Contains(val.playerSteamId) && i >= 0 && i < instance2.playerVoiceVolumes.Length)
				{
					instance2.playerVoiceVolumes[i] = 0f;
				}
			}
		}

		private static ulong LocalSteam()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)GameNetworkManager.Instance?.localPlayerController != (Object)null)
				{
					return GameNetworkManager.Instance.localPlayerController.playerSteamId;
				}
			}
			catch
			{
			}
			try
			{
				return SteamId.op_Implicit(SteamClient.SteamId);
			}
			catch
			{
				return 0uL;
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class AdminOpsSignalPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(string chatMessage, string nameOfUserWhoTyped)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(nameOfUserWhoTyped))
			{
				return true;
			}
			if (AdminOpsClient.TryHandleWarnWhisper(chatMessage))
			{
				return false;
			}
			if (AdminOpsClient.TryHandleSystemMessage(chatMessage))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SoundManager), "SetPlayerVoiceFilters")]
	internal static class MuteVoiceFilterPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			if (Plugin.IsEnabled)
			{
				AdminOpsClient.ApplyVoiceMuteState();
			}
		}
	}
	[HarmonyPatch]
	internal static class AutoOnlineLaunchPatches
	{
		private static bool _chose;

		private static bool _settingsLoaded;

		[HarmonyPatch(typeof(IngamePlayerSettings), "LoadSettingsFromPrefs")]
		[HarmonyPostfix]
		private static void LoadSettingsFromPrefs_Postfix(IngamePlayerSettings __instance)
		{
			if (!Plugin.IsEnabled || !Plugin.Config.AutoSelectOnlineMode.Value)
			{
				return;
			}
			_settingsLoaded = true;
			try
			{
				if (__instance.unsavedSettings != null && __instance.settings != null)
				{
					__instance.unsavedSettings.CopySettings(__instance.settings);
				}
			}
			catch
			{
			}
			TrySafeOnline("LoadSettingsFromPrefs");
		}

		[HarmonyPatch(typeof(PreInitSceneScript), "Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(PreInitSceneScript __instance)
		{
			if (Plugin.IsEnabled && Plugin.Config.AutoSelectOnlineMode.Value)
			{
				HideLaunchOptionUi(__instance);
				TrySafeOnline("Start");
			}
		}

		[HarmonyPatch(typeof(PreInitSceneScript), "SkipToFinalSetting")]
		[HarmonyPostfix]
		private static void SkipToFinalSetting_Postfix(PreInitSceneScript __instance)
		{
			if (Plugin.IsEnabled && Plugin.Config.AutoSelectOnlineMode.Value)
			{
				TrySafeOnline("SkipToFinalSetting");
			}
		}

		[HarmonyPatch(typeof(PreInitSceneScript), "PressContinueButton")]
		[HarmonyPostfix]
		private static void PressContinue_Postfix(PreInitSceneScript __instance)
		{
			if (Plugin.IsEnabled && Plugin.Config.AutoSelectOnlineMode.Value)
			{
				TrySafeOnline("PressContinue");
			}
		}

		[HarmonyPatch(typeof(PreInitSceneScript), "ChooseLaunchOption")]
		[HarmonyPrefix]
		private static bool ChooseLaunchOption_Prefix(PreInitSceneScript __instance, bool online)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			return !TryChooseLaunchWithoutSavingSettings(__instance, online, "vanilla-click");
		}

		private static void TrySafeOnline(string reason)
		{
			if (_chose)
			{
				return;
			}
			PreInitSceneScript val = Object.FindObjectOfType<PreInitSceneScript>();
			if (!((Object)(object)val == (Object)null))
			{
				HideLaunchOptionUi(val);
				if (_settingsLoaded && TryChooseLaunchWithoutSavingSettings(val, online: true, reason))
				{
					_chose = true;
				}
			}
		}

		private static bool TryChooseLaunchWithoutSavingSettings(PreInitSceneScript pre, bool online, string reason)
		{
			if ((Object)(object)pre == (Object)null || pre.choseLaunchOption)
			{
				return false;
			}
			try
			{
				IngamePlayerSettings instance = IngamePlayerSettings.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					if (_settingsLoaded && instance.unsavedSettings != null && instance.settings != null)
					{
						instance.unsavedSettings.CopySettings(instance.settings);
					}
					try
					{
						instance.SetLaunchInOnlineMode(online);
					}
					catch
					{
					}
					try
					{
						instance.SetPlayerFinishedLaunchOptions();
					}
					catch
					{
					}
				}
				pre.choseLaunchOption = true;
				try
				{
					if ((Object)(object)pre.mainAudio != (Object)null && (Object)(object)pre.selectSFX != (Object)null)
					{
						pre.mainAudio.PlayOneShot(pre.selectSFX);
					}
				}
				catch
				{
				}
				Plugin.Log.LogInfo((object)("UEXP_Dedicated_Client: online launch without SaveChangedSettings (" + reason + ")."));
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(LoadSceneDelayed(online));
				}
				else
				{
					SceneManager.LoadScene(online ? "InitScene" : "InitSceneLANMode");
				}
				HideLaunchOptionUi(pre);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Safe online launch failed: " + ex.Message));
				return false;
			}
		}

		private static IEnumerator LoadSceneDelayed(bool online)
		{
			yield return (object)new WaitForSecondsRealtime(0.2f);
			SceneManager.LoadScene(online ? "InitScene" : "InitSceneLANMode");
		}

		private static void HideLaunchOptionUi(PreInitSceneScript pre)
		{
			try
			{
				if ((Object)(object)pre.OnlineModeButton != (Object)null)
				{
					pre.OnlineModeButton.SetActive(false);
				}
				if (pre.LaunchSettingsPanels != null)
				{
					GameObject[] launchSettingsPanels = pre.LaunchSettingsPanels;
					foreach (GameObject val in launchSettingsPanels)
					{
						if ((Object)(object)val != (Object)null)
						{
							val.SetActive(false);
						}
					}
				}
				if ((Object)(object)pre.launchSettingsPanelsContainer != (Object)null)
				{
					pre.launchSettingsPanelsContainer.SetActive(false);
				}
			}
			catch
			{
			}
		}
	}
	internal static class ChatCommandHide
	{
		public static bool ShouldHidePlayerMessage(string? chatMessage)
		{
			if (string.IsNullOrWhiteSpace(chatMessage))
			{
				return false;
			}
			string text = chatMessage.Trim();
			if (text.Length == 0 || text[0] != '/')
			{
				return false;
			}
			string text2 = text.ToLowerInvariant();
			if (text2 == "/login" || text2.StartsWith("/login "))
			{
				return true;
			}
			bool flag;
			switch (text2)
			{
			case "/help":
			case "/commands":
			case "/?":
				flag = true;
				break;
			default:
				flag = false;
				break;
			}
			if (flag)
			{
				return true;
			}
			if (text2 == "/logout" || text2 == "/admin" || text2.StartsWith("/admin "))
			{
				return true;
			}
			if (text2 == "/kick" || text2.StartsWith("/kick "))
			{
				return true;
			}
			if (text2 == "/ban" || text2.StartsWith("/ban "))
			{
				return true;
			}
			if (text2 == "/unban" || text2.StartsWith("/unban "))
			{
				return true;
			}
			switch (text2)
			{
			case "/list":
			case "/bans":
			case "/mods":
				return true;
			default:
				if (!text2.StartsWith("/reset "))
				{
					if (text2 == "/save" || text2.StartsWith("/save "))
					{
						return true;
					}
					switch (text2)
					{
					case "/motd":
					case "/rules":
					case "/ping":
					case "/pong":
						return true;
					case "/when":
						return true;
					default:
						if (!text2.StartsWith("/report "))
						{
							if (text2 == "/announce" || text2.StartsWith("/announce "))
							{
								return true;
							}
							if (text2 == "/door" || text2.StartsWith("/door "))
							{
								return true;
							}
							if (text2 == "/id" || text2.StartsWith("/id ") || text2 == "/ids" || text2.StartsWith("/ids "))
							{
								return true;
							}
							if (text2 == "/tp" || text2.StartsWith("/tp ") || text2 == "/bring" || text2.StartsWith("/bring "))
							{
								return true;
							}
							if (text2 == "/heal" || text2.StartsWith("/heal ") || text2 == "/healall")
							{
								return true;
							}
							if (text2 == "/credits" || text2.StartsWith("/credits ") || text2 == "/setquota" || text2.StartsWith("/setquota ") || text2 == "/quota" || text2.StartsWith("/quota "))
							{
								return true;
							}
							if (text2 == "/weather" || text2.StartsWith("/weather "))
							{
								return true;
							}
							if (text2 == "/mute" || text2.StartsWith("/mute ") || text2 == "/unmute" || text2.StartsWith("/unmute "))
							{
								return true;
							}
							if (text2 == "/warn" || text2.StartsWith("/warn ") || text2 == "/warns" || text2.StartsWith("/warns ") || text2 == "/clearwarns" || text2.StartsWith("/clearwarns "))
							{
								return true;
							}
							if (text2 == "/mod" || text2.StartsWith("/mod ") || text2 == "/unmod" || text2.StartsWith("/unmod "))
							{
								return true;
							}
							if (text2 == "/vote" || text2.StartsWith("/vote "))
							{
								return true;
							}
							if (text2 == "/votekick" || text2.StartsWith("/votekick ") || text2 == "/vk" || text2.StartsWith("/vk "))
							{
								return true;
							}
							switch (text2)
							{
							case "/yes":
							case "/y":
							case "/no":
							case "/n":
								flag = true;
								break;
							default:
								flag = false;
								break;
							}
							if (flag)
							{
								return true;
							}
							if (text2 == "/dev" || text2.StartsWith("/dev"))
							{
								return true;
							}
							return false;
						}
						goto case "/report";
					case "/report":
						return true;
					}
				}
				goto case "/reset";
			case "/reset":
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class HideSlashCommandLocalEchoPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(string chatMessage, string nameOfUserWhoTyped)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			if (string.IsNullOrEmpty(nameOfUserWhoTyped))
			{
				return true;
			}
			if (ChatCommandHide.ShouldHidePlayerMessage(chatMessage))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageClientRpc")]
	internal static class HideSlashCommandClientRpcPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(string chatMessage)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			if (ChatCommandHide.ShouldHidePlayerMessage(chatMessage))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "SetConnectionDataBeforeConnecting")]
	internal static class ConnectionDataHandshakePatch
	{
		public const string Token = "uexpC1";

		public const string VersionPrefix = "uexpCv";

		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!Plugin.IsEnabled)
			{
				return;
			}
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton?.NetworkConfig == null)
				{
					return;
				}
				byte[] connectionData = singleton.NetworkConfig.ConnectionData;
				if (connectionData == null || connectionData.Length == 0)
				{
					return;
				}
				string text = Encoding.ASCII.GetString(connectionData);
				string[] array = text.Split(',');
				bool flag = false;
				bool flag2 = false;
				for (int i = 0; i < array.Length; i++)
				{
					string text2 = array[i].Trim();
					if (string.Equals(text2, "uexpC1", StringComparison.Ordinal))
					{
						flag = true;
					}
					if (text2.StartsWith("uexpCv", StringComparison.Ordinal))
					{
						flag2 = true;
					}
				}
				string text3 = text;
				if (!flag)
				{
					text3 += ",uexpC1";
				}
				if (!flag2)
				{
					text3 += ",uexpCv1.0.3";
				}
				if (!string.Equals(text3, text, StringComparison.Ordinal))
				{
					singleton.NetworkConfig.ConnectionData = Encoding.ASCII.GetBytes(text3);
					Plugin.DebugLog("ConnectionData handshake appended (uexpC1, uexpCv1.0.3).");
				}
				LogConfigHash(singleton);
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("ConnectionData handshake failed: " + ex.Message);
			}
		}

		private static void LogConfigHash(NetworkManager nm)
		{
			try
			{
				ulong config = nm.NetworkConfig.GetConfig(false);
				int num = nm.NetworkConfig.Prefabs?.NetworkPrefabOverrideLinks?.Count ?? (-1);
				Plugin.DebugLog($"NGO config hash for this join: {config} prefabLinks={num}.");
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Config hash log failed: " + ex.Message);
			}
		}
	}
	internal static class DedicatedLobbySoftRefresh
	{
		private const float IntervalSeconds = 3f;

		private static Coroutine? _loop;

		private static SteamLobbyManager? _slm;

		private static bool _hookedDataChanged;

		public static void EnsureStarted(SteamLobbyManager slm)
		{
			if (Plugin.Config.DedicatedBrowserOnly.Value)
			{
				_slm = slm;
				EnsureDataChangedHook();
				if (_loop == null && !((Object)(object)Plugin.Instance == (Object)null))
				{
					_loop = ((MonoBehaviour)Plugin.Instance).StartCoroutine(Loop());
					Plugin.DebugLog("Dedicated lobby soft-refresh started (3s).");
				}
			}
		}

		public static void Stop()
		{
			if (_loop != null && (Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_loop);
			}
			_loop = null;
			_slm = null;
		}

		private static void EnsureDataChangedHook()
		{
			if (_hookedDataChanged)
			{
				return;
			}
			try
			{
				SteamMatchmaking.OnLobbyDataChanged += OnLobbyDataChanged;
				_hookedDataChanged = true;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("OnLobbyDataChanged hook failed: " + ex.Message);
			}
		}

		private static void OnLobbyDataChanged(Lobby lobby)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Plugin.IsEnabled || !Plugin.Config.DedicatedBrowserOnly.Value || !DedicatedLobby.IsDedicatedLobby(lobby))
				{
					return;
				}
				SteamLobbyManager val = _slm ?? Object.FindObjectOfType<SteamLobbyManager>();
				if ((Object)(object)val?.levelListContainer == (Object)null)
				{
					return;
				}
				LobbySlot[] componentsInChildren = ((Component)val.levelListContainer).GetComponentsInChildren<LobbySlot>(true);
				foreach (LobbySlot val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					try
					{
						if (SteamId.op_Implicit(((Lobby)(ref val2.thisLobby)).Id) == SteamId.op_Implicit(((Lobby)(ref lobby)).Id))
						{
							val2.thisLobby = lobby;
							if ((Object)(object)val2.LobbyName != (Object)null)
							{
								((TMP_Text)val2.LobbyName).text = "";
							}
						}
					}
					catch
					{
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("OnLobbyDataChanged: " + ex.Message);
			}
		}

		private static IEnumerator Loop()
		{
			WaitForSecondsRealtime wait = new WaitForSecondsRealtime(3f);
			while (true)
			{
				yield return wait;
				if (!Plugin.Config.DedicatedBrowserOnly.Value || !MenuOverlayLifecycle.MenuUiAllowed)
				{
					break;
				}
				SteamLobbyManager val = _slm;
				if ((Object)(object)val == (Object)null)
				{
					val = Object.FindObjectOfType<SteamLobbyManager>();
				}
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.levelListContainer == (Object)null) && ((Component)val.levelListContainer).gameObject.activeInHierarchy)
				{
					try
					{
						RefreshVisibleSlots(val);
					}
					catch (Exception ex)
					{
						Plugin.DebugLog("Soft refresh: " + ex.Message);
					}
				}
			}
			_loop = null;
		}

		private static void RefreshVisibleSlots(SteamLobbyManager slm)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			LobbySlot[] componentsInChildren = ((Component)slm.levelListContainer).GetComponentsInChildren<LobbySlot>(true);
			int num = 0;
			int num2 = 0;
			LobbySlot[] array = componentsInChildren;
			foreach (LobbySlot val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					Lobby thisLobby = val.thisLobby;
					if (!DedicatedLobby.IsDedicatedLobby(thisLobby))
					{
						continue;
					}
					((Lobby)(ref thisLobby)).Refresh();
					num++;
					if (DedicatedLobby.IsJoinableListing(thisLobby))
					{
						continue;
					}
					try
					{
						GameObject gameObject = ((Component)val).gameObject;
						if ((Object)(object)gameObject != (Object)null)
						{
							gameObject.SetActive(false);
							Object.Destroy((Object)(object)gameObject);
							num2++;
						}
					}
					catch
					{
					}
				}
				catch
				{
				}
			}
			if (num > 0)
			{
				Plugin.DebugLog($"Soft-refreshed {num} dedicated lobby card(s); dropped {num2}.");
			}
			if (num2 > 0)
			{
				try
				{
					DedicatedServerListReplacePatch.FitListContentHeight(slm);
				}
				catch
				{
				}
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobbyManager), "LoadServerList")]
	internal static class DedicatedSoftRefreshOnLoadPatch
	{
		[HarmonyPostfix]
		private static void Postfix(SteamLobbyManager __instance)
		{
			if (Plugin.Config.DedicatedBrowserOnly.Value)
			{
				DedicatedLobbySoftRefresh.EnsureStarted(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager), "ClickJoinButton")]
	internal static class DedicatedSoftRefreshOnOpenPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (Plugin.Config.DedicatedBrowserOnly.Value)
			{
				SteamLobbyManager val = Object.FindObjectOfType<SteamLobbyManager>();
				if ((Object)(object)val != (Object)null)
				{
					DedicatedLobbySoftRefresh.EnsureStarted(val);
				}
			}
		}
	}
	internal static class DedicatedModsModal
	{
		private sealed class ModsModalStatusPump : MonoBehaviour
		{
			private void Update()
			{
				PumpPendingStatus();
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ForceClose;

			public static UnityAction <1>__CopyProfileCode;

			public static UnityAction <2>__DownloadModList;
		}

		private static GameObject? _root;

		private static TextMeshProUGUI? _title;

		private static TextMeshProUGUI? _status;

		private static RectTransform? _content;

		private static ScrollRect? _scroll;

		private static TMP_FontAsset? _font;

		private static string _serverName = "";

		private static string _modsCsv = "";

		private static string _profileCode = "";

		private static string? _pendingStatus;

		private static readonly Color PanelBg = new Color(0.07f, 0.075f, 0.08f, 0.98f);

		private static readonly Color Accent = new Color(0.91f, 0.62f, 0.12f, 1f);

		private static readonly Color Text = new Color(0.95f, 0.93f, 0.86f, 1f);

		private static readonly Color Muted = new Color(0.72f, 0.74f, 0.7f, 1f);

		private static readonly Color RowBg = new Color(0.1f, 0.105f, 0.11f, 1f);

		private static readonly Color BtnBg = new Color(0.16f, 0.14f, 0.09f, 1f);

		private static readonly Color ScrollBg = new Color(0.04f, 0.04f, 0.045f, 1f);

		public static void Show(string serverName, string modsCsv, string profileCode)
		{
			if (!MenuOverlayLifecycle.MenuUiAllowed)
			{
				Plugin.Log.LogWarning((object)"Mods modal blocked — menu UI not active.");
				return;
			}
			JoinPasswordPrompt.ForceClose();
			ForceClose();
			_serverName = serverName ?? "";
			_modsCsv = modsCsv ?? "";
			_profileCode = (profileCode ?? "").Trim();
			Build();
			if ((Object)(object)_root == (Object)null || (Object)(object)_title == (Object)null || (Object)(object)_content == (Object)null || (Object)(object)_scroll == (Object)null)
			{
				return;
			}
			((TMP_Text)_title).text = (string.IsNullOrWhiteSpace(serverName) ? "SERVER MODS" : serverName);
			ClearContent();
			List<string> list = new List<string>();
			if (!string.IsNullOrWhiteSpace(modsCsv))
			{
				string[] array = modsCsv.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length > 0)
					{
						list.Add(text);
					}
				}
			}
			if (!string.IsNullOrEmpty(_profileCode))
			{
				AddRow("r2modman: Import/Update → From code → paste the profile code.", isEmpty: true);
				AddRow("Code: " + _profileCode, isEmpty: false);
			}
			else
			{
				AddRow("No profile code yet — host may still be exporting.", isEmpty: true);
				AddRow("Install the same mods manually, or ask the host for an r2modman code.", isEmpty: true);
			}
			if (list.Count == 0)
			{
				AddRow("No display mod names published by this host.", isEmpty: true);
			}
			else
			{
				AddRow($"Installed packages ({list.Count}):", isEmpty: true);
				for (int j = 0; j < list.Count; j++)
				{
					AddRow($"{j + 1}.  {list[j]}", isEmpty: false);
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
			Canvas.ForceUpdateCanvases();
			_scroll.verticalNormalizedPosition = 1f;
			_root.SetActive(true);
			SetStatus(string.IsNullOrEmpty(_profileCode) ? "Download saves a JSON checklist. Prefer a profile code when available." : "Copy code → r2modman Import/Update → From code. Or download .r2z.");
			Plugin.DebugLog($"Mods modal shown ({list.Count} mods, code={!string.IsNullOrEmpty(_profileCode)}).");
		}

		public static void ForceClose()
		{
			_title = null;
			_status = null;
			_content = null;
			_scroll = null;
			_font = null;
			_serverName = "";
			_modsCsv = "";
			_profileCode = "";
			if (!((Object)(object)_root != (Object)null))
			{
				return;
			}
			GameObject root = _root;
			_root = null;
			try
			{
				GraphicRaycaster[] componentsInChildren = root.GetComponentsInChildren<GraphicRaycaster>(true);
				foreach (GraphicRaycaster val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Behaviour)val).enabled = false;
					}
				}
				root.SetActive(false);
			}
			catch
			{
			}
			Object.Destroy((Object)(object)root);
		}

		public static void DestroyIfAny()
		{
			ForceClose();
		}

		private static void ClearContent()
		{
			if (!((Object)(object)_content == (Object)null))
			{
				for (int num = ((Transform)_content).childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)((Transform)_content).GetChild(num)).gameObject);
				}
			}
		}

		private static void AddRow(string text, bool isEmpty)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_content == (Object)null))
			{
				GameObject val = new GameObject("ModRow", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(LayoutElement)
				});
				val.transform.SetParent((Transform)(object)_content, false);
				((Graphic)val.GetComponent<Image>()).color = (isEmpty ? ScrollBg : RowBg);
				((Graphic)val.GetComponent<Image>()).raycastTarget = false;
				LayoutElement component = val.GetComponent<LayoutElement>();
				component.minHeight = 34f;
				component.preferredHeight = 34f;
				component.flexibleWidth = 1f;
				TextMeshProUGUI obj = CreateTmp(val.transform, "Label", text, 16f, isEmpty ? Muted : Text, _font, (FontStyles)0);
				((TMP_Text)obj).enableWordWrapping = false;
				((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
				((TMP_Text)obj).alignment = (TextAlignmentOptions)4097;
				RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = new Vector2(12f, 2f);
				rectTransform.offsetMax = new Vector2(-12f, -2f);
			}
		}

		private static void Build()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Expected O, but got Unknown
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Expected O, but got Unknown
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Expected O, but got Unknown
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Expected O, but got Unknown
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06af: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Expected O, but got Unknown
			//IL_0708: Unknown result type (might be due to invalid IL or missing references)
			//IL_0723: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_0759: Expected O, but got Unknown
			//IL_0774: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			_font = FindMenuFont();
			_root = ((Component)MenuOverlayLifecycle.CreateOverlayCanvas("UEXP_ModsModal", 6100)).gameObject;
			Image obj = CreateImage(_root.transform, "Dim", new Color(0.01f, 0.01f, 0.015f, 0.82f));
			Stretch(((Graphic)obj).rectTransform);
			Button obj2 = ((Component)obj).gameObject.AddComponent<Button>();
			((Selectable)obj2).transition = (Transition)0;
			ButtonClickedEvent onClick = obj2.onClick;
			object obj3 = <>O.<0>__ForceClose;
			if (obj3 == null)
			{
				UnityAction val = ForceClose;
				<>O.<0>__ForceClose = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			Image val2 = CreateImage(_root.transform, "Panel", PanelBg);
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(820f, 600f);
			RectTransform rectTransform2 = ((Graphic)CreateImage(((Component)val2).transform, "Accent", Accent)).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(0f, 1f);
			rectTransform2.pivot = new Vector2(0f, 0.5f);
			rectTransform2.sizeDelta = new Vector2(6f, 0f);
			SetRect(((TMP_Text)CreateTmp(((Component)val2).transform, "Header", "MOD LIST", 24f, Accent, _font, (FontStyles)1)).rectTransform, 28f, -22f, 420f, 32f);
			_title = CreateTmp(((Component)val2).transform, "Title", "", 18f, Text, _font, (FontStyles)0);
			SetRect(((TMP_Text)_title).rectTransform, 28f, -56f, 520f, 28f);
			Button obj4 = CreateButton(((Component)val2).transform, "Close", "CLOSE", _font);
			SetRect(((Component)obj4).GetComponent<RectTransform>(), -28f, -20f, 120f, 38f, fromRight: true);
			ButtonClickedEvent onClick2 = obj4.onClick;
			object obj5 = <>O.<0>__ForceClose;
			if (obj5 == null)
			{
				UnityAction val3 = ForceClose;
				<>O.<0>__ForceClose = val3;
				obj5 = (object)val3;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj5);
			Button obj6 = CreateButton(((Component)val2).transform, "CopyCode", "COPY CODE", _font);
			SetRect(((Component)obj6).GetComponent<RectTransform>(), 28f, -92f, 150f, 36f);
			ButtonClickedEvent onClick3 = obj6.onClick;
			object obj7 = <>O.<1>__CopyProfileCode;
			if (obj7 == null)
			{
				UnityAction val4 = CopyProfileCode;
				<>O.<1>__CopyProfileCode = val4;
				obj7 = (object)val4;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj7);
			Button obj8 = CreateButton(((Component)val2).transform, "Download", "DOWNLOAD LIST", _font);
			SetRect(((Component)obj8).GetComponent<RectTransform>(), 190f, -92f, 180f, 36f);
			ButtonClickedEvent onClick4 = obj8.onClick;
			object obj9 = <>O.<2>__DownloadModList;
			if (obj9 == null)
			{
				UnityAction val5 = DownloadModList;
				<>O.<2>__DownloadModList = val5;
				obj9 = (object)val5;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj9);
			_status = CreateTmp(((Component)val2).transform, "Status", "", 14f, Muted, _font, (FontStyles)0);
			SetRect(((TMP_Text)_status).rectTransform, 386f, -92f, 400f, 36f);
			((TMP_Text)_status).enableWordWrapping = true;
			((TMP_Text)_status).alignment = (TextAlignmentOptions)4097;
			GameObject val6 = new GameObject("Scroll", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ScrollRect)
			});
			val6.transform.SetParent(((Component)val2).transform, false);
			Image component = val6.GetComponent<Image>();
			((Graphic)component).color = ScrollBg;
			((Graphic)component).raycastTarget = true;
			RectTransform component2 = val6.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.offsetMin = new Vector2(24f, 24f);
			component2.offsetMax = new Vector2(-48f, -140f);
			GameObject val7 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(RectMask2D)
			});
			val7.transform.SetParent(val6.transform, false);
			Image component3 = val7.GetComponent<Image>();
			((Graphic)component3).color = new Color(1f, 1f, 1f, 0.02f);
			((Graphic)component3).raycastTarget = true;
			Stretch(val7.GetComponent<RectTransform>());
			GameObject val8 = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val8.transform.SetParent(val7.transform, false);
			_content = val8.GetComponent<RectTransform>();
			_content.anchorMin = new Vector2(0f, 1f);
			_content.anchorMax = new Vector2(1f, 1f);
			_content.pivot = new Vector2(0.5f, 1f);
			_content.anchoredPosition = Vector2.zero;
			_content.sizeDelta = new Vector2(0f, 0f);
			VerticalLayoutGroup component4 = val8.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component4).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 6f;
			((LayoutGroup)component4).padding = new RectOffset(8, 8, 8, 8);
			ContentSizeFitter component5 = val8.GetComponent<ContentSizeFitter>();
			component5.verticalFit = (FitMode)2;
			component5.horizontalFit = (FitMode)0;
			GameObject val9 = new GameObject("Scrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val9.transform.SetParent(((Component)val2).transform, false);
			((Graphic)val9.GetComponent<Image>()).color = new Color(0.12f, 0.12f, 0.13f, 1f);
			RectTransform component6 = val9.GetComponent<RectTransform>();
			component6.anchorMin = new Vector2(1f, 0f);
			component6.anchorMax = new Vector2(1f, 1f);
			component6.pivot = new Vector2(1f, 0.5f);
			component6.offsetMin = new Vector2(-40f, 24f);
			component6.offsetMax = new Vector2(-24f, -140f);
			GameObject val10 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) });
			val10.transform.SetParent(val9.transform, false);
			Stretch(val10.GetComponent<RectTransform>());
			val10.GetComponent<RectTransform>().offsetMin = new Vector2(2f, 2f);
			val10.GetComponent<RectTransform>().offsetMax = new Vector2(-2f, -2f);
			GameObject val11 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val11.transform.SetParent(val10.transform, false);
			((Graphic)val11.GetComponent<Image>()).color = Accent;
			Stretch(val11.GetComponent<RectTransform>());
			Scrollbar component7 = val9.GetComponent<Scrollbar>();
			component7.direction = (Direction)2;
			component7.handleRect = val11.GetComponent<RectTransform>();
			((Selectable)component7).targetGraphic = (Graphic)(object)val11.GetComponent<Image>();
			_scroll = val6.GetComponent<ScrollRect>();
			_scroll.viewport = val7.GetComponent<RectTransform>();
			_scroll.content = _content;
			_scroll.horizontal = false;
			_scroll.vertical = true;
			_scroll.movementType = (MovementType)2;
			_scroll.scrollSensitivity = 55f;
			_scroll.verticalScrollbar = component7;
			_scroll.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			_scroll.inertia = true;
			if ((Object)(object)_root.GetComponent<ModsModalStatusPump>() == (Object)null)
			{
				_root.AddComponent<ModsModalStatusPump>();
			}
		}

		internal static void PumpPendingStatus()
		{
			string text = Interlocked.Exchange(ref _pendingStatus, null);
			if (text != null)
			{
				SetStatus(text);
			}
		}

		private static void CopyProfileCode()
		{
			if (string.IsNullOrEmpty(_profileCode))
			{
				SetStatus("No profile code on this lobby yet.");
				return;
			}
			try
			{
				GUIUtility.systemCopyBuffer = _profileCode;
				SetStatus("Copied. r2modman → Import/Update → From code.");
				Plugin.Log.LogInfo((object)("Copied r2modman profile code for \"" + _serverName + "\"."));
			}
			catch (Exception ex)
			{
				SetStatus("Copy failed: " + ex.Message);
			}
		}

		private static void DownloadModList()
		{
			string safeName = SanitizeFileName(string.IsNullOrWhiteSpace(_serverName) ? "dedicated" : _serverName);
			string folder = GetDownloadsFolder();
			Directory.CreateDirectory(folder);
			if (!string.IsNullOrEmpty(_profileCode))
			{
				SetStatus("Downloading r2modman profile…");
				string code = _profileCode;
				string path = Path.Combine(folder, safeName + "-mods.r2z");
				ThreadPool.QueueUserWorkItem(delegate
				{
					try
					{
						byte[] array = DownloadProfileBytes(code);
						if (array == null || array.Length == 0)
						{
							QueueStatus("Download failed — try Copy code instead.");
							return;
						}
						byte[] bytes = DecodeProfilePayload(array);
						File.WriteAllBytes(path, bytes);
						WriteCompanionJson(folder, safeName);
						QueueStatus("Saved " + Path.GetFileName(path) + " — import in r2modman (From file).");
						try
						{
							Process.Start("explorer.exe", "/select,\"" + path + "\"");
						}
						catch
						{
						}
					}
					catch (Exception ex2)
					{
						QueueStatus("Download failed: " + ex2.Message);
					}
				});
				return;
			}
			try
			{
				string text = Path.Combine(folder, safeName + "-mods.json");
				File.WriteAllText(text, BuildFallbackJson(), Encoding.UTF8);
				SetStatus("Saved " + Path.GetFileName(text) + " (names only — no profile code).");
				try
				{
					Process.Start("explorer.exe", "/select,\"" + text + "\"");
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				SetStatus("Save failed: " + ex.Message);
			}
		}

		private static void WriteCompanionJson(string folder, string safeName)
		{
			try
			{
				File.WriteAllText(Path.Combine(folder, safeName + "-mods.json"), BuildFallbackJson(), Encoding.UTF8);
			}
			catch
			{
			}
		}

		private static string BuildFallbackJson()
		{
			List<string> list = new List<string>();
			string[] array = (_modsCsv ?? "").Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					list.Add(text);
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("{");
			stringBuilder.AppendLine("  \"schema\": \"uexp-r2modman-modlist-v1\",");
			stringBuilder.AppendLine("  \"game\": \"LethalCompany\",");
			stringBuilder.AppendLine("  \"serverName\": \"" + EscapeJson(_serverName) + "\",");
			stringBuilder.AppendLine("  \"profileCode\": \"" + EscapeJson(_profileCode) + "\",");
			stringBuilder.AppendLine("  \"instructions\": \"Prefer profile code in r2modman Import/Update → From code. JSON display names are not full Thunderstore dependency strings.\",");
			stringBuilder.AppendLine("  \"displayNames\": [");
			for (int j = 0; j < list.Count; j++)
			{
				stringBuilder.Append("    \"");
				stringBuilder.Append(EscapeJson(list[j]));
				stringBuilder.Append('"');
				if (j + 1 < list.Count)
				{
					stringBuilder.Append(',');
				}
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("  ]");
			stringBuilder.AppendLine("}");
			return stringBuilder.ToString();
		}

		private static byte[]? DownloadProfileBytes(string code)
		{
			HttpWebRequest obj = (HttpWebRequest)WebRequest.Create("https://thunderstore.io/api/experimental/legacyprofile/get/" + Uri.EscapeDataString(code.Trim()) + "/");
			obj.Method = "GET";
			obj.Timeout = 120000;
			obj.ReadWriteTimeout = 120000;
			using HttpWebResponse httpWebResponse = (HttpWebResponse)obj.GetResponse();
			using MemoryStream memoryStream = new MemoryStream();
			httpWebResponse.GetResponseStream().CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		private static byte[] DecodeProfilePayload(byte[] raw)
		{
			if (raw.Length >= 2 && raw[0] == 80 && raw[1] == 75)
			{
				return raw;
			}
			string text = Encoding.UTF8.GetString(raw).Trim();
			if (text.StartsWith("#r2modman\n", StringComparison.Ordinal))
			{
				text = text.Substring("#r2modman\n".Length).Trim();
			}
			else if (text.StartsWith("#r2modman\r\n", StringComparison.Ordinal))
			{
				text = text.Substring("#r2modman\r\n".Length).Trim();
			}
			return Convert.FromBase64String(text);
		}

		private static string GetDownloadsFolder()
		{
			try
			{
				string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads");
				if (Directory.Exists(text))
				{
					return text;
				}
			}
			catch
			{
			}
			return Path.GetTempPath();
		}

		private static string SanitizeFileName(string name)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				name = name.Replace(oldChar, '_');
			}
			if (name.Length > 40)
			{
				name = name.Substring(0, 40);
			}
			if (!string.IsNullOrWhiteSpace(name))
			{
				return name.Trim();
			}
			return "dedicated";
		}

		private static string EscapeJson(string s)
		{
			return (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"");
		}

		private static void QueueStatus(string msg)
		{
			_pendingStatus = msg;
			Plugin.Log.LogInfo((object)("Mods download: " + msg));
		}

		private static void SetStatus(string msg)
		{
			if ((Object)(object)_status != (Object)null)
			{
				((TMP_Text)_status).text = msg ?? "";
			}
			Plugin.DebugLog("Mods modal: " + msg);
		}

		private static TMP_FontAsset? FindMenuFont()
		{
			try
			{
				TextMeshProUGUI val = Object.FindObjectOfType<TextMeshProUGUI>();
				if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
				{
					return ((TMP_Text)val).font;
				}
			}
			catch
			{
			}
			return TMP_Settings.defaultFontAsset;
		}

		private static Image CreateImage(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			return component;
		}

		private static TextMeshProUGUI CreateTmp(Transform parent, string name, string text, float size, Color color, TMP_FontAsset? font, FontStyles style)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val2).font = font;
			}
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = size;
			((Graphic)val2).color = color;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).raycastTarget = false;
			return val2;
		}

		private static Button CreateButton(Transform parent, string name, string label, TMP_FontAsset? font)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0050: 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)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = BtnBg;
			Button component = val.GetComponent<Button>();
			TextMeshProUGUI obj = CreateTmp(val.transform, "Label", label, 14f, Accent, font, (FontStyles)1);
			Stretch(((TMP_Text)obj).rectTransform);
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			return component;
		}

		private static void Stretch(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		private static void SetRect(RectTransform rt, float x, float y, float w, float h, bool fromRight = false)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (fromRight)
			{
				rt.anchorMin = new Vector2(1f, 1f);
				rt.anchorMax = new Vector2(1f, 1f);
				rt.pivot = new Vector2(1f, 1f);
			}
			else
			{
				rt.anchorMin = new Vector2(0f, 1f);
				rt.anchorMax = new Vector2(0f, 1f);
				rt.pivot = new Vector2(0f, 1f);
			}
			rt.anchoredPosition = new Vector2(x, y);
			rt.sizeDelta = new Vector2(w, h);
		}
	}
	[HarmonyPatch(typeof(SteamLobbyManager), "LoadServerList")]
	internal static class DedicatedServerListReplacePatch
	{
		private static float _savedScrollHeight = -1f;

		[HarmonyPrefix]
		private static bool Prefix(SteamLobbyManager __instance)
		{
			if (!Plugin.Config.DedicatedBrowserOnly.Value)
			{
				return true;
			}
			try
			{
				if (__instance.loadLobbyListCoroutine != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(__instance.loadLobbyListCoroutine);
				}
			}
			catch
			{
			}
			__instance.refreshServerListTimer = 0f;
			__instance.loadLobbyListCoroutine = ((MonoBehaviour)__instance).StartCoroutine(LoadDedicatedRoutine(__instance));
			return false;
		}

		private static IEnumerator LoadDedicatedRoutine(SteamLobbyManager slm)
		{
			ClearExistingSlots(slm);
			if ((Object)(object)slm.serverListBlankText != (Object)null)
			{
				((Component)slm.serverListBlankText).gameObject.SetActive(true);
				((TMP_Text)slm.serverListBlankText).text = "Scanning dedicated servers…";
			}
			Task<Lobby[]> publicTask = null;
			try
			{
				LobbyQuery val = SteamMatchmaking.LobbyList;
				val = ((LobbyQuery)(ref val)).WithKeyValue("uexpDedicated", "1");
				val = ((LobbyQuery)(ref val)).FilterDistanceWorldwide();
				val = ((LobbyQuery)(ref val)).WithMaxResults(50);
				publicTask = ((LobbyQuery)(ref val)).RequestAsync();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Dedicated lobby query failed: " + ex.Message));
			}
			float startedAt = Time.realtimeSinceStartup;
			while (publicTask != null && !publicTask.IsCompleted)
			{
				if (Time.realtimeSinceStartup - startedAt > 20f)
				{
					Plugin.Log.LogWarning((object)"Dedicated lobby Steam query timed out after 20s.");
					if ((Object)(object)slm.serverListBlankText != (Object)null)
					{
						((TMP_Text)slm.serverListBlankText).text = "Steam query timed out — try Refresh.";
					}
					slm.loadLobbyListCoroutine = null;
					yield break;
				}
				yield return null;
			}
			Dictionary<ulong, Lobby> dictionary = new Dictionary<ulong, Lobby>();
			try
			{
				Lobby[] array = publicTask?.Result;
				if (array != null)
				{
					Lobby[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						Lobby value = array2[i];
						dictionary[((Lobby)(ref value)).Id.Value] = value;
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.DebugLog("Dedicated query result: " + ex2.Message);
			}
			foreach (Lobby item in EnumerateFriendDedicatedLobbies())
			{
				Lobby current = item;
				dictionary[((Lobby)(ref current)).Id.Value] = current;
			}
			List<Lobby> list = (from l in dictionary.Values.Where(IsJoinableDedicatedListing)
				orderby (!IsPinnedOfficial(l)) ? 1 : 0
				select l).ThenBy<Lobby, string>((Lobby l) => SafeName(l), StringComparer.OrdinalIgnoreCase).ToList();
			Plugin.DebugLog($"Dedicated browser: {list.Count} lobby(s) after public+friends merge" + ((list.Count > 0 && IsPinnedOfficial(list[0])) ? " (official pinned first)." : "."));
			if (list.Count == 0)
			{
				if ((Object)(object)slm.serverListBlankText != (Object)null)
				{
					((Component)slm.serverListBlankText).gameObject.SetActive(true);
					((TMP_Text)slm.serverListBlankText).text = "No dedicated servers online.\nFriends-only hosts show when that Steam friend is in the lobby.";
				}
				FitListContentHeight(slm, 0);
				slm.loadLobbyListCoroutine = null;
				yield break;
			}
			if ((Object)(object)slm.serverListBlankText != (Object)null)
			{
				((TMP_Text)slm.serverListBlankText).text = "";
				((Component)slm.serverListBlankText).gameObject.SetActive(false);
			}
			slm.lobbySlotPositionOffset = 0f;
			MethodInfo methodInfo = AccessTools.Method(typeof(SteamLobbyManager), "loadLobbyListAndFilter", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogWarning((object)"loadLobbyListAndFilter missing — cannot fill dedicated list.");
				slm.loadLobbyListCoroutine = null;
				yield break;
			}
			if (methodInfo.Invoke(slm, new object[1] { list.ToArray() }) is IEnumerator enumerator2)
			{
				yield return ((MonoBehaviour)slm).StartCoroutine(enumerator2);
			}
			yield return null;
			FitListContentHeight(slm, list.Count);
			slm.loadLobbyListCoroutine = null;
		}

		internal static void FitListContentHeight(SteamLobbyManager slm, int lobbyCount = -1)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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)
			try
			{
				if ((Object)(object)slm.levelListContainer == (Object)null)
				{
					return;
				}
				Transform levelListContainer = slm.levelListContainer;
				RectTransform val = (RectTransform)(((object)((levelListContainer is RectTransform) ? levelListContainer : null)) ?? ((object)((Component)slm.levelListContainer).GetComponent<RectTransform>()));
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				float num = 72f;
				int num2 = lobbyCount;
				if (num2 < 0)
				{
					num2 = 0;
					for (int i = 0; i < ((Transform)val).childCount; i++)
					{
						Transform child = ((Transform)val).GetChild(i);
						if ((Object)(object)child != (Object)null && (Object)(object)((Component)child).GetComponentInChildren<LobbySlot>(true) != (Object)null)
						{
							num2++;
						}
					}
				}
				float num3 = ((num2 <= 0) ? num : ((float)num2 * num + 4f));
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(1f, 1f);
				val.pivot = new Vector2(0.5f, 1f);
				val.SetSizeWithCurrentAnchors((Axis)1, num3);
				float num4 = 0f;
				for (int j = 0; j < ((Transform)val).childCount; j++)
				{
					Transform child2 = ((Transform)val).GetChild(j);
					if (!((Object)(object)child2 == (Object)null) && !((Object)(object)((Component)child2).GetComponentInChildren<LobbySlot>(true) == (Object)null))
					{
						RectTransform val2 = (RectTransform)(((object)((child2 is RectTransform) ? child2 : null)) ?? ((object)((Component)child2).GetComponent<RectTransform>()));
						if (!((Object)(object)val2 == (Object)null))
						{
							val2.anchorMin = new Vector2(0f, 1f);
							val2.anchorMax = new Vector2(1f, 1f);
							val2.pivot = new Vector2(0.5f, 1f);
							val2.SetSizeWithCurrentAnchors((Axis)1, DedicatedLobbySlotPatches.CardHeight);
							val2.anchoredPosition = new Vector2(0f, num4);
							num4 -= num;
						}
					}
				}
				ScrollRect componentInParent = ((Component)val).GetComponentInParent<ScrollRect>();
				if (!((Object)(object)componentInParent != (Object)null))
				{
					return;
				}
				componentInParent.verticalNormalizedPosition = 1f;
				RectTransform component = ((Component)componentInParent).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Rect rect;
					if (_savedScrollHeight < 0f)
					{
						rect = component.rect;
						_savedScrollHeight = ((Rect)(ref rect)).height;
					}
					else if (_savedScrollHeight > 10f)
					{
						rect = component.rect;
						if (((Rect)(ref rect)).height + 0.5f < _savedScrollHeight)
						{
							component.SetSizeWithCurrentAnchors((Axis)1, _savedScrollHeight);
						}
					}
				}
				Canvas.ForceUpdateCanvases();
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("FitListContentHeight: " + ex.Message);
			}
		}

		private static bool IsJoinableDedicatedListing(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return DedicatedLobby.IsJoinableListing(lobby);
		}

		private static IEnumerable<Lobby> EnumerateFriendDedicatedLobbies()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			List<Lobby> list = new List<Lobby>();
			try
			{
				foreach (Friend friend in SteamFriends.GetFriends())
				{
					Friend current = friend;
					try
					{
						if (((Friend)(ref current)).IsMe || !((Friend)(ref current)).IsPlayingThisGame)
						{
							continue;
						}
						FriendGameInfo? gameInfo = ((Friend)(ref current)).GameInfo;
						if (!gameInfo.HasValue)
						{
							continue;
						}
						FriendGameInfo value = gameInfo.Value;
						Lobby? lobby = ((FriendGameInfo)(ref value)).Lobby;
						if (lobby.HasValue)
						{
							Lobby value2 = lobby.Value;
							try
							{
								((Lobby)(ref value2)).Refresh();
							}
							catch
							{
							}
							if (DedicatedLobby.IsDedicatedLobby(value2))
							{
								list.Add(value2);
							}
						}
					}
					catch
					{
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Friend lobby scan: " + ex.Message);
			}
			return list;
		}

		private static void ClearExistingSlots(SteamLobbyManager slm)
		{
			DedicatedLobbySlotPatches.ClearExtras();
			try
			{
				if ((Object)(object)slm.levelListContainer == (Object)null)
				{
					return;
				}
				for (int num = slm.levelListContainer.childCount - 1; num >= 0; num--)
				{
					Transform child = slm.levelListContainer.GetChild(num);
					if ((Object)(object)child != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
			}
			catch
			{
			}
		}

		private static string SafeName(Lobby lobby)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData("name") ?? "";
			}
			catch
			{
				return "";
			}
		}

		private static bool IsPinnedOfficial(Lobby lobby)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = SafeName(lobby).Trim();
				foreach (string item in PinnedNameNeedles())
				{
					if (text.Equals(item, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
				string text2 = DedicatedLobby.ReadProfileCode(lobby);
				if (!string.IsNullOrWhiteSpace(text2))
				{
					foreach (string item2 in PinnedProfileCodes())
					{
						if (text2.Equals(item2, StringComparison.OrdinalIgnoreCase))
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static IEnumerable<string> PinnedNameNeedles()
		{
			string text = Plugin.Config.PinnedOfficialNames.Value ?? "";
			if (string.IsNullOrWhiteSpace(text))
			{
				yield break;
			}
			string[] array = text.Split(new char[2] { ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					yield return text2;
				}
			}
		}

		private static IEnumerable<string> PinnedProfileCodes()
		{
			string text = Plugin.Config.PinnedOfficialProfileCodes.Value ?? "";
			if (string.IsNullOrWhiteSpace(text))
			{
				yield break;
			}
			string[] array = text.Split(new char[3] { ';', ',', '|' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					yield return text2;
				}
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobbyManager), "RefreshServerListButton")]
	internal static class DedicatedRefreshButtonPatch
	{
		[HarmonyPrefix]
		private static void Prefix(SteamLobbyManager __instance)
		{
			if (Plugin.Config.DedicatedBrowserOnly.Value)
			{
				__instance.refreshServerListTimer = 1f;
			}
		}
	}
	internal static class EarlyLeaveLockClient
	{
		public const int DefaultMinLeaveHour = 10;

		public static int MinLeaveHour
		{
			get
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					GameNetworkManager instance = GameNetworkManager.Instance;
					if ((Object)(object)instance != (Object)null && !instance.disableSteam && instance.currentLobby.HasValue)
					{
						string text = DedicatedLobby.ReadData(instance.currentLobby.Value, "uexpMinLeave");
						if (!string.IsNullOrEmpty(text) && int.TryParse(text, out var result) && result >= 0 && result <= 23)
						{
							return result;
						}
					}
				}
				catch
				{
				}
				return 10;
			}
		}

		public static bool Want()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		public static bool IsLeaveBlocked(out string tip)
		{
			tip = "";
			if (!Want())
			{
				return false;
			}
			StartOfRound instance = StartOfRound.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null)
			{
				return false;
			}
			if (instance.inShipPhase || !instance.shipHasLanded)
			{
				return false;
			}
			if (instance.shipLeftAutomatically || instance.shipIsLeaving)
			{
				return false;
			}
			try
			{
				if ((Object)(object)instance.currentLevel != (Object)null && !instance.currentLevel.planetHasTime)
				{
					return false;
				}
			}
			catch
			{
			}
			int minLeaveHour = MinLeaveHour;
			float num = HourToNormalized(instance2, minLeaveHour);
			if (instance2.normalizedTimeOfDay + 0.0001f >= num)
			{
				return false;
			}
			tip = "Ship leaves after " + FormatHour(minLeaveHour) + ". Wait for the clock.";
			return true;
		}

		public static float HourToNormalized(TimeOfDay tod, int hour)
		{
			float num = (float)Mathf.Clamp(hour, 0, 23) * 60f;
			float num2 = 60f * (float)Mathf.Max(1, tod.numberOfHours);
			return Mathf.Clamp01((num - 360f) / num2);
		}

		public static string FormatHour(int hour)
		{
			int num = Mathf.Clamp(hour, 0, 23);
			if (num == 0)
			{
				return "12:00 AM";
			}
			if (num < 12)
			{
				return $"{num}:00 AM";
			}
			if (num == 12)
			{
				return "12:00 PM";
			}
			return $"{num - 12}:00 PM";
		}

		public static void ShowTip(string tip)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Too early", tip, true, false, "UEXP_LeaveLock");
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartMatchLever), "LeverAnimation")]
	internal static class EarlyLeaveLeverAnimationClientPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(StartMatchLever __instance)
		{
			if (!Plugin.IsEnabled || !EarlyLeaveLockClient.Want())
			{
				return true;
			}
			StartOfRound val = __instance.playersManager ?? StartOfRound.Instance;
			if ((Object)(object)val == (Object)null || !val.shipHasLanded || val.inShipPhase)
			{
				return true;
			}
			if (!EarlyLeaveLockClient.IsLeaveBlocked(out string tip))
			{
				return true;
			}
			EarlyLeaveLockClient.ShowTip(tip);
			if ((Object)(object)__instance.triggerScript != (Object)null)
			{
				__instance.triggerScript.hoverTip = "[ Leave after " + EarlyLeaveLockClient.FormatHour(EarlyLeaveLockClient.MinLeaveHour) + " ]";
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(StartMatchLever), "EndGame")]
	internal static class EarlyLeaveEndGameClientPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(StartMatchLever __instance)
		{
			if (!Plugin.IsEnabled || !EarlyLeaveLockClient.Want())
			{
				return true;
			}
			if (!EarlyLeaveLockClient.IsLeaveBlocked(out string tip))
			{
				return true;
			}
			EarlyLeaveLockClient.ShowTip(tip);
			if ((Object)(object)__instance.triggerScript != (Object)null)
			{
				__instance.triggerScript.interactable = true;
				__instance.triggerScript.hoverTip = "[ Leave after " + EarlyLeaveLockClient.FormatHour(EarlyLeaveLockClient.MinLeaveHour) + " ]";
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(StartMatchLever), "Update")]
	internal static class EarlyLeaveLeverHoverClientPatch
	{
		[HarmonyPostfix]
		private static void Postfix(StartMatchLever __instance)
		{
			if (Plugin.IsEnabled && EarlyLeaveLockClient.Want() && !((Object)(object)__instance.triggerScript == (Object)null) && !__instance.leverHasBeenPulled)
			{
				StartOfRound val = __instance.playersManager ?? StartOfRound.Instance;
				if (!((Object)(object)val == (Object)null) && val.shipHasLanded && !val.inShipPhase && !val.shipIsLeaving && EarlyLeaveLockClient.IsLeaveBlocked(out string _))
				{
					__instance.triggerScript.hoverTip = "[ Leave after " + EarlyLeaveLockClient.FormatHour(EarlyLeaveLockClient.MinLeaveHour) + " ]";
				}
			}
		}
	}
	[HarmonyPatch(typeof(GrabbableObject), "PlayDropSFX")]
	internal static class GhostDropSfxPatches
	{
		private static float _suppressUntil;

		private static bool SuppressActive => Time.realtimeSinceStartup < _suppressUntil;

		internal static void ArmOrbitSettleSuppress(float seconds = 3.5f)
		{
			float num = Time.realtimeSinceStartup + seconds;
			if (num > _suppressUntil)
			{
				_suppressUntil = num;
			}
		}

		internal static void ClearSuppress()
		{
			_suppressUntil = 0f;
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(GrabbableObject __instance)
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return true;
			}
			if (SuppressActive)
			{
				return false;
			}
			try
			{
				PlayerControllerB val = (((Object)(object)__instance != (Object)null) ? __instance.playerHeldBy : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				if (val.isHostPlayerObject || val.playerClientId == 0L)
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
	internal static class GhostDropSfxReviveArmPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			if (DedicatedLobby.IsCurrentLobbyDedicated())
			{
				GhostDropSfxPatches.ArmOrbitSettleSuppress(4f);
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class GhostDropSfxDisconnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			GhostDropSfxPatches.ClearSuppress();
		}
	}
	[HarmonyPatch]
	internal static class GhostSeatLateJoinEnforcer
	{
		private static float _nextTickRealtime;

		private static bool _didInitialHide;

		internal static void ResetSession()
		{
			_didInitialHide = false;
			_nextTickRealtime = 0f;
		}

		[HarmonyPatch(typeof(StartOfRound), "Update")]
		[HarmonyPostfix]
		private static void StartOfRoundUpdate_Postfix(StartOfRound __instance)
		{
			if (!(Time.realtimeSinceStartup < _nextTickRealtime))
			{
				_nextTickRealtime = Time.realtimeSinceStartup + 1f;
				EnforceNow(__instance, "tick");
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		[HarmonyPostfix]
		private static void ReviveDeadPlayers_Postfix(StartOfRound __instance)
		{
			EnforceNow(__instance, "revive");
		}

		internal static void EnforceNow(StartOfRound? sor, string reason)
		{
			if (!Plugin.IsEnabled || (Object)(object)sor == (Object)null || !DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				if (sor.allPlayerScripts == null || sor.allPlayerScripts.Length == 0)
				{
					return;
				}
				PlayerControllerB val = sor.allPlayerScripts[0];
				if ((Object)(object)val == (Object)null || ((NetworkBehaviour)val).IsOwner)
				{
					return;
				}
				bool flag = false;
				if (val.isPlayerControlled)
				{
					val.isPlayerControlled = false;
					flag = true;
				}
				if (!val.isPlayerDead)
				{
					val.isPlayerDead = true;
					val.setPositionOfDeadPlayer = true;
					flag = true;
				}
				if (flag)
				{
					Plugin.DebugLog("Ghost seat flags forced (" + reason + ").");
				}
				if (!_didInitialHide)
				{
					HostBodyHidePatches.HideGhostVisuals(val, force: true);
					_didInitialHide = true;
				}
				else
				{
					HostBodyHidePatches.SoftRehideIfNeeded(val);
				}
				MapScreenGhostGuard.RetargetLocal(sor, val);
				try
				{
					if ((Object)(object)sor.mapScreen != (Object)null)
					{
						MapScreenGhostGuard.RetargetCameraLocal(sor.mapScreen);
					}
				}
				catch
				{
				}
				LivingPlayersClient.Ensure(reason);
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("GhostSeatLateJoinEnforcer(" + reason + "): " + ex.Message);
			}
		}
	}
	internal static class GhostSeat
	{
		internal static bool WantHide()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		internal static bool IsGhost(PlayerControllerB? p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return false;
			}
			if (p.isHostPlayerObject || p.playerClientId == 0L)
			{
				return true;
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts != null && instance.allPlayerScripts.Length != 0 && (Object)(object)instance.allPlayerScripts[0] == (Object)(object)p)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		internal static PlayerControllerB? FindSpectateTarget(PlayerControllerB self, bool getClosest)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts == null || instance.allPlayerScripts.Length == 0)
			{
				return null;
			}
			PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
			if (getClosest)
			{
				Vector3 val = self.positionOfDeath;
				try
				{
					if ((Object)(object)self.deadBody != (Object)null && self.deadBody.bodyParts != null && self.deadBody.bodyParts.Length != 0)
					{
						val = ((Component)self.deadBody.bodyParts[0]).transform.position;
					}
				}
				catch
				{
				}
				PlayerControllerB result = null;
				float num = float.MaxValue;
				PlayerControllerB[] array = allPlayerScripts;
				foreach (PlayerControllerB val2 in array)
				{
					if (IsValidSpectateTarget(self, val2))
					{
						float num2 = Vector3.Distance(val, ((Component)val2).transform.position);
						if (num2 < num)
						{
							num = num2;
							result = val2;
						}
					}
				}
				return result;
			}
			PlayerControllerB spectatedPlayerScript = self.spectatedPlayerScript;
			int num3 = 0;
			if ((Object)(object)spectatedPlayerScript != (Object)null)
			{
				for (int j = 0; j < allPlayerScripts.Length; j++)
				{
					if ((Object)(object)allPlayerScripts[j] == (Object)(object)spectatedPlayerScript)
					{
						num3 = j + 1;
						break;
					}
				}
			}
			for (int k = 0; k < allPlayerScripts.Length; k++)
			{
				PlayerControllerB val3 = allPlayerScripts[(num3 + k) % allPlayerScripts.Length];
				if (IsValidSpectateTarget(self, val3))
				{
					return val3;
				}
			}
			return null;
		}

		internal static bool IsValidSpectateTarget(PlayerControllerB self, PlayerControllerB? other)
		{
			if ((Object)(object)other == (Object)null || (Object)(object)other == (Object)(object)self || IsGhost(other))
			{
				return false;
			}
			if (other.isPlayerControlled)
			{
				return !other.isPlayerDead;
			}
			return false;
		}

		internal static void ApplySpectate(PlayerControllerB self, PlayerControllerB target)
		{
			if (IsGhost(target))
			{
				return;
			}
			self.spectatedPlayerScript = target;
			try
			{
				self.SetSpectatedPlayerEffects(false);
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("ApplySpectate effects: " + ex.Message);
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance != null)
				{
					instance.SetPlayerSafeInShip();
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "WritePlayerNotes")]
	internal static class HideHostWritePlayerNotesPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(StartOfRound __instance)
		{
			try
			{
				if (GhostSeat.WantHide() && !((Object)(object)__instance == (Object)null))
				{
					RebuildNotesExcludingGhost(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("WritePlayerNotes rebuild: " + ex.Message);
			}
		}

		private static void RebuildNotesExcludingGhost(StartOfRound sor)
		{
			EndOfGameStats gameStats = sor.gameStats;
			PlayerControllerB[] allPlayerScripts = sor.allPlayerScripts;
			if (gameStats?.allPlayerStats == null || allPlayerScripts == null)
			{
				return;
			}
			PlayerStats[] allPlayerStats = gameStats.allPlayerStats;
			int num = Math.Min(allPlayerStats.Length, allPlayerScripts.Length);
			for (int i = 0; i < allPlayerStats.Length; i++)
			{
				allPlayerStats[i].playerNotes?.Clear();
			}
			int num2 = 0;
			for (int j = 0; j < num; j++)
			{
				PlayerControllerB val = allPlayerScripts[j];
				bool flag = !GhostSeat.IsGhost(val) && (Object)(object)val != (Object)null && (val.disconnectedMidGame || val.isPlayerDead || val.isPlayerControlled);
				allPlayerStats[j].isActivePlayer = flag;
				if (flag)
				{
					num2++;
				}
			}
			bool flag2 = sor.connectedPlayersAmount > 0 || num2 >= 2;
			int num3 = 0;
			int num4 = -1;
			for (int k = 0; k < num; k++)
			{
				if (allPlayerStats[k].isActivePlayer && (num4 < 0 || allPlayerStats[k].stepsTaken < num3))
				{
					num3 = allPlayerStats[k].stepsTaken;
					num4 = k;
				}
			}
			if (flag2 && num4 >= 0 && num3 > 10)
			{
				allPlayerStats[num4].playerNotes.Add("The laziest employee.");
			}
			num3 = -1;
			num4 = -1;
			for (int l = 0; l < num; l++)
			{
				if (allPlayerStats[l].isActivePlayer && allPlayerStats[l].turnAmount > num3)
				{
					num3 = allPlayerStats[l].turnAmount;
					num4 = l;
				}
			}
			if (flag2 && num4 >= 0)
			{
				allPlayerStats[num4].playerNotes.Add("The most paranoid employee.");
			}
			num3 = -1;
			num4 = -1;
			for (int m = 0; m < num; m++)
			{
				if (allPlayerStats[m].isActivePlayer && !allPlayerScripts[m].isPlayerDead && allPlayerStats[m].damageTaken > num3)
				{
					num3 = allPlayerStats[m].damageTaken;
					num4 = m;
				}
			}
			if (flag2 && num4 >= 0)
			{
				allPlayerStats[num4].playerNotes.Add("Sustained the most injuries.");
			}
			num3 = -1;
			num4 = -1;
			for (int n = 0; n < num; n++)
			{
				if (allPlayerStats[n].isActivePlayer && allPlayerStats[n].profitable > num3)
				{
					num3 = allPlayerStats[n].profitable;
					num4 = n;
				}
			}
			if (!flag2 || num4 < 0 || num3 <= 50)
			{
				return;
			}
			try
			{
				if ((Object)(object)GameNetworkManager.Instance?.localPlayerController != (Object)null && num4 == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					sor.localPlayerWasMostProfitableThisRound = true;
				}
			}
			catch
			{
			}
			allPlayerStats[num4].playerNotes.Add("Most profitable");
		}
	}
	[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
	[HarmonyAfter(new string[] { "com.elitemastereric.coroner" })]
	internal static class HideHostEndGameStatsPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(HUDManager __instance)
		{
			ApplyPerformanceReportFix(__instance, "postfix");
		}

		[HarmonyFinalizer]
		private static Exception? Finalizer(HUDManager __instance, Exception? __exception)
		{
			if (__exception != null)
			{
				Plugin.DebugLog("FillEndGameStats threw: " + __exception.Message);
			}
			ApplyPerformanceReportFix(__instance, "finalizer");
			return null;
		}

		internal static void ApplyPerformanceReportFix(HUDManager? hud, string stage)
		{
			try
			{
				if (GhostSeat.WantHide() && !((Object)(object)hud == (Object)null))
				{
					EndOfGameStatUIElements statsUIElements = hud.statsUIElements;
					if (statsUIElements != null)
					{
						CompactStatsUi(statsUIElements);
						FixGradeExcludingGhost(statsUIElements);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("HideHostEndGameStats (" + stage + "): " + ex.Message);
			}
		}

		internal static void CompactStatsUi(EndOfGameStatUIElements ui)
		{
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Invalid comparison between Unknown and I4
			int num = SeatCount(ui);
			if (num <= 0)
			{
				return;
			}
			PlayerControllerB[] array = null;
			try
			{
				array = StartOfRound.Instance?.allPlayerScripts;
			}
			catch
			{
			}
			if (array == null || array.Length == 0)
			{
				return;
			}
			string text = null;
			try
			{
				if ((Object)(object)array[0] != (Object)null && GhostSeat.IsGhost(array[0]))
				{
					text = array[0].playerUsername;
				}
			}
			catch
			{
			}
			string[] array2 = new string[num];
			bool[] array3 = new bool[num];
			Color[] array4 = (Color[])(object)new Color[num];
			bool[] array5 = new bool[num];
			bool[] array6 = new bool[num];
			Sprite[] array7 = (Sprite[])(object)new Sprite[num];
			Color[] array8 = (Color[])(object)new Color[num];
			string[] array9 = new string[num];
			bool[] array10 = new bool[num];
			Color[] array11 = (Color[])(object)new Color[num];
			for (int i = 0; i < num; i++)
			{
				ReadSeat(ui, i, ref array2[i], ref array3[i], ref array4[i], ref array5[i], ref array6[i], ref array7[i], ref array8[i], ref array9[i], ref array10[i], ref array11[i]);
			}
			int num2 = 0;
			int num3 = Math.Min(num, array.Length);
			for (int j = 0; j < num3; j++)
			{
				PlayerControllerB val = array[j];
				if (!ShouldShowInPerformanceReview(val))
				{
					continue;
				}
				string text2 = val.playerUsername ?? "";
				if (string.IsNullOrWhiteSpace(text2) && !string.IsNullOrWhiteSpace(array2[j]))
				{
					text2 = array2[j];
				}
				if (!string.IsNullOrWhiteSpace(text2) && (string.IsNullOrWhiteSpace(text) || !string.Equals(text2.Trim(), text.Trim(), StringComparison.OrdinalIgnoreCase)))
				{
					string notes = ResolveNotes(val, text2, array2, array9, text, j);
					Color nameColor = PickColorForName(text2, array2, array4, j);
					Color notesColor = PickColorForName(text2, array2, array11, j);
					Color stateColor = PickColorForName(text2, array2, array8, j);
					Sprite sprite;
					try
					{
						sprite = ((!val.isPlayerDead) ? ui.aliveIcon : (((int)val.causeOfDeath == 10) ? ui.missingIcon : ui.deceasedIcon));
					}
					catch
					{
						sprite = array7[j] ?? ui.aliveIcon;
					}
					WriteSeat(ui, num2, text2, nameActive: true, nameColor, stateOn: true, stateEnabled: true, sprite, stateColor, notes, notesActive: true, notesColor);
					num2++;
				}
			}
			for (int k = num2; k < num; k++)
			{
				ClearSeat(ui, k);
			}
		}

		private static bool ShouldShowInPerformanceReview(PlayerControllerB? p)
		{
			if ((Object)(object)p == (Object)null || GhostSeat.IsGhost(p))
			{
				return false;
			}
			if (!p.disconnectedMidGame && !p.isPlayerDead)
			{
				return p.isPlayerControlled;
			}
			return true;
		}

		private static bool IsNotesHeaderOnly(string notes)
		{
			return (notes ?? "").Replace("Notes:", "").Replace("\n", "").Trim()
				.Length == 0;
		}

		private static bool HasUsefulNotes(string notes)
		{
			if (!string.IsNullOrEmpty(notes))
			{
				return !IsNotesHeaderOnly(notes);
			}
			return false;
		}

		private static Color PickColorForName(string playerName, string[] allNames, Color[] colors, int fallbackIndex)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < allNames.Length && i < colors.Length; i++)
			{
				if (!string.IsNullOrWhiteSpace(allNames[i]) && string.Equals(allNames[i].Trim(), playerName.Trim(), StringComparison.OrdinalIgnoreCase))
				{
					return colors[i];
				}
			}
			if (fallbackIndex >= 0 && fallbackIndex < colors.Length)
			{
				return colors[fallbackIndex];
			}
			return Color.white;
		}

		private static string ResolveNotes(PlayerControllerB script, string playerName, string[] allNames, string[] allNotes, string? ghostName, int scriptIndex)
		{
			for (int i = 0; i < allNames.Length; i++)
			{
				if (!string.IsNullOrWhiteSpace(allNames[i]) && string.Equals(allNames[i].Trim(), playerName.Trim(), StringComparison.OrdinalIgnoreCase) && HasUsefulNotes(allNotes[i]))
				{
					return allNotes[i];
				}
			}
			if (scriptIndex >= 0 && scriptIndex < allNotes.Length)
			{
				string text = allNotes[scriptIndex];
				if (HasUsefulNotes(text))
				{
					string text2 = ((scriptIndex < allNames.Length) ? allNames[scriptIndex] : "");
					if (string.IsNullOrWhiteSpace(text2) || string.Equals(text2.Trim(), playerName.Trim(), StringComparison.OrdinalIgnoreCase))
					{
						return text;
					}
				}
			}
			if (scriptIndex >= 0 && scriptIndex < allNotes.Length && HasUsefulNotes(allNotes[scriptIndex]) && (scriptIndex >= allNames.Length || string.IsNullOrWhiteSpace(allNames[scriptIndex])))
			{
				return allNotes[scriptIndex];
			}
			int num = -1;
			int num2 = 0;
			for (int j = 0; j < allNotes.Length; j++)
			{
				if (HasUsefulNotes(allNotes[j]) && string.IsNullOrWhiteSpace(allNames[j]) && (string.IsNullOrWhiteSpace(ghostName) || allNotes[j].IndexOf(ghostName, StringComparison.OrdinalIgnoreCase) < 0))
				{
					num = j;
					num2++;
				}
			}
			if (num2 == 1)
			{
				return allNotes[num];
			}
			string text3 = NotesFromGameStats(scriptIndex);
			if (HasUsefulNotes(text3))
			{
				return text3;
			}
			string text4 = BuildDeathNoteLine(script);
			if (!string.IsNullOrWhiteSpace(text4))
			{
				return "Notes: \n* " + text4 + "\n";
			}
			return "Notes: \n";
		}

		private static string NotesFromGameStats(int scriptIndex)
		{
			try
			{
				EndOfGameStats val = StartOfRound.Instance?.gameStats;
				if (val?.allPlayerStats == null || scriptIndex < 0 || scriptIndex >= val.allPlayerStats.Length)
				{
					return "Notes: \n";
				}
				List<string> playerNotes = val.allPlayerStats[scriptIndex].playerNotes;
				if (playerNotes == null || playerNotes.Count == 0)
				{
					return "Notes: \n";
				}
				StringBuilder stringBuilder = new StringBuilder("Notes: \n");
				for (int i = 0; i < 3 && i < playerNotes.Count; i++)
				{
					stringBuilder.Append("* ").Append(playerNotes[i]).Append('\n');
				}
				return stringBuilder.ToString();
			}
			catch
			{
				return "Notes: \n";
			}
		}

		private static string? BuildDeathNoteLine(PlayerControllerB script)
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)script == (Object)null || !script.isPlayerDead)
				{
					return null;
				}
				Type type = AccessTools.TypeByName("Coroner.AdvancedDeathTracker");
				if (type != null)
				{
					MethodInfo methodInfo = AccessTools.Method(type, "GetCauseOfDeath", new Type[1] { typeof(PlayerControllerB) }, (Type[])null);
					if (methodInfo != null)
					{
						object obj = methodInfo.Invoke(null, new object[1] { script });
						MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
						foreach (MethodInfo methodInfo2 in methods)
						{
							if (methodInfo2.Name != "StringifyCauseOfDeath" || methodInfo2.GetParameters().Length != 1)
							{
								continue;
							}
							try
							{
								if (methodInfo2.Invoke(null, new object[1] { obj }) is string text && !string.IsNullOrWhiteSpace(text))
								{
									return text.Trim();
								}
							}
							catch
							{
							}
						}
					}
					MethodInfo methodInfo3 = AccessTools.Method(type, "StringifyCauseOfDeath", new Type[1] { typeof(CauseOfDeath) }, (Type[])null);
					if (methodInfo3 != null && methodInfo3.Invoke(null, new object[1] { script.causeOfDeath }) is string text2 && !string.IsNullOrWhiteSpace(text2))
					{
						return text2.Trim();
					}
				}
				return FriendlyCauseOfDeath(script.causeOfDeath);
			}
			catch
			{
				try
				{
					return FriendlyCauseOfDeath(script.causeOfDeath);
				}
				catch
				{
					return null;
				}
			}
		}

		private static string FriendlyCauseOfDeath(CauseOfDeath cause)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected I4, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			return (int)cause switch
			{
				0 => "Cause of death unknown", 
				1 => "Bludgeoned", 
				2 => "Fell to their death", 
				3 => "Killed by an explosion", 
				4 => "Strangled", 
				5 => "Suffocated", 
				6 => "Mauled", 
				7 => "Gunshot wounds", 
				8 => "Crushed", 
				9 => "Drowned", 
				10 => "Abandoned", 
				11 => "Electrocuted", 
				12 => "Kicked to death", 
				_ => Enum.GetName(typeof(CauseOfDeath), cause) ?? "Cause of death unknown", 
			};
		}

		internal static void FixGradeExcludingGhost(EndOfGameStatUIElements ui)
		{
			try
			{
				if ((Object)(object)ui?.gradeLetter == (Object)null)
				{
					return;
				}
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				if (allPlayerScripts == null)
				{
					return;
				}
				int num = 0;
				int num2 = 0;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if (ShouldShowInPerformanceReview(val))
					{
						if (val.isPlayerDead)
						{
							num++;
						}
						else if (val.isPlayerControlled)
						{
							num2++;
						}
					}
				}
				int num3 = num + num2;
				if (num3 <= 0 || num2 <= 0)
				{
					((TMP_Text)ui.gradeLetter).text = "F";
					ForceVisibleTmp(ui.gradeLetter);
					if ((Object)(object)ui.allPlayersDeadOverlay != (Object)null)
					{
						((Behaviour)ui.allPlayersDeadOverlay).enabled = true;
					}
					return;
				}
				int num4 = 0;
				float num5 = 0f;
				try
				{
					float num6 = (((Object)(object)RoundManager.Instance != (Object)null) ? RoundManager.Instance.totalScrapValueInLevel : 0f);
					float num7 = (((Object)(object)RoundManager.Instance != (Object)null) ? ((float)RoundManager.Instance.scrapCollectedInLevel) : 0f);
					if (num6 > 0.01f)
					{
						num5 = num7 / num6;
					}
				}
				catch
				{
					num5 = 0f;
				}
				if (num2 == num3)
				{
					num4++;
				}
				else if (num > 1)
				{
					num4--;
				}
				if (num5 >= 0.99f)
				{
					num4 += 2;
				}
				else if (num5 >= 0.6f)
				{
					num4++;
				}
				else if (num5 <= 0.25f)
				{
					num4--;
				}
				TextMeshProUGUI gradeLetter = ui.gradeLetter;
				string text = ((num4 <= -1) ? "D" : (num4 switch
				{
					0 => "C", 
					1 => "B", 
					2 => "A", 
					_ => "S", 
				}));
				((TMP_Text)gradeLetter).text = text;
				ForceVisibleTmp(ui.gradeLetter);
				if ((Object)(object)ui.allPlayersDeadOverlay != (Object)null)
				{
					((Behaviour)ui.allPlayersDeadOverlay).enabled = false;
				}
			}
			catch
			{
			}
		}

		private static void ForceVisibleTmp(TextMeshProUGUI? tmp)
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)tmp == (Object)null)
			{
				return;
			}
			try
			{
				if (!((Component)tmp).gameObject.activeSelf)
				{
					((Component)tmp).gameObject.SetActive(true);
				}
				((Behaviour)tmp).enabled = true;
				Color color = ((Graphic)tmp).color;
				if (color.a < 0.2f)
				{
					color.a = 1f;
					((Graphic)tmp).color = color;
				}
				((TMP_Text)tmp).ForceMeshUpdate(true, false);
			}
			catch
			{
			}
		}

		private static int SeatCount(EndOfGameStatUIElements ui)
		{
			int num = 0;
			if (ui.playerNamesText != null)
			{
				num = ui.playerNamesText.Length;
			}
			if (ui.playerStates != null)
			{
				num = Math.Max(num, ui.playerStates.Length);
			}
			if (ui.playerNotesText != null)
			{
				num = Math.Max(num, ui.playerNotesText.Length);
			}
			return num;
		}

		private static bool IsFilledSeat(string name, bool nameActive, bool stateOn, bool stateEnabled)
		{
			if (stateOn && stateEnabled)
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(name))
			{
				return true;
			}
			if (nameActive)
			{
				return true;
			}
			return false;
		}

		private static void ReadSeat(EndOfGameStatUIElements ui, int index, ref string name, ref bool nameActive, ref Color nameColor, ref bool stateOn, ref bool stateEnabled, ref Sprite? sprite, ref Color stateColor, ref string notes, ref bool notesActive, ref Color notesColor)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00ec: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			name = "";
			nameActive = false;
			nameColor = Color.white;
			stateOn = false;
			stateEnabled = false;
			sprite = null;
			stateColor = Color.white;
			notes = "";
			notesActive = false;
			notesColor = Color.white;
			if (ui.playerNamesText != null && index < ui.playerNamesText.Length && (Object)(object)ui.playerNamesText[index] != (Object)null)
			{
				TextMeshProUGUI val = ui.playerNamesText[index];
				name = ((TMP_Text)val).text ?? "";
				nameActive = ((Component)val).gameObject.activeSelf;
				nameColor = ((Graphic)val).color;
			}
			if (ui.playerStates != null && index < ui.playerStates.Length && (Object)(object)ui.playerStates[index] != (Object)null)
			{
				Image val2 = ui.playerStates[index];
				stateOn = ((Component)val2).gameObject.activeSelf;
				stateEnabled = ((Behaviour)val2).enabled;
				sprite = val2.sprite;
				stateColor = ((Graphic)val2).color;
			}
			if (ui.playerNotesText != null && index < ui.playerNotesText.Length && (Object)(object)ui.playerNotesText[index] != (Object)null)
			{
				TextMeshProUGUI val3 = ui.playerNotesText[index];
				notes = ((TMP_Text)val3).text ?? "";
				notesActive = ((Component)val3).gameObject.activeSelf;
				notesColor = ((Graphic)val3).color;
			}
		}

		private static void WriteSeat(EndOfGameStatUIElements ui, int index, string name, bool nameActive, Color nameColor, bool stateOn, bool stateEnabled, Sprite? sprite, Color stateColor, string notes, bool notesActive, Color notesColor)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (ui.playerNamesText != null && index < ui.playerNamesText.Length && (Object)(object)ui.playerNamesText[index] != (Object)null)
			{
				TextMeshProUGUI obj = ui.playerNamesText[index];
				((TMP_Text)obj).text = name;
				((Graphic)obj).color = nameColor;
				((Component)obj).gameObject.SetActive(nameActive);
			}
			if (ui.playerStates != null && index < ui.playerStates.Length && (Object)(object)ui.playerStates[index] != (Object)null)
			{
				Image obj2 = ui.playerStates[index];
				obj2.sprite = sprite;
				((Graphic)obj2).color = stateColor;
				((Behaviour)obj2).enabled = stateEnabled;
				((Component)obj2).gameObject.SetActive(stateOn);
			}
			if (ui.playerNotesText != null && index < ui.playerNotesText.Length && (Object)(object)ui.playerNotesText[index] != (Object)null)
			{
				TextMeshProUGUI val = ui.playerNotesText[index];
				((TMP_Text)val).text = notes;
				Color val2 = notesColor;
				if (val2.a < 0.2f)
				{
					((Color)(ref val2))..ctor(1f, 1f, 1f, 1f);
				}
				((Graphic)val).color = val2;
				((Component)val).gameObject.SetActive(notesActive);
				try
				{
					((TMP_Text)val).ForceMeshUpdate(true, false);
				}
				catch
				{
				}
			}
		}

		private static void ClearSeat(EndOfGameStatUIElements ui, int index)
		{
			if (ui.playerNamesText != null && ui.playerNamesText.Length > index && (Object)(object)ui.playerNamesText[index] != (Object)null)
			{
				((TMP_Text)ui.playerNamesText[index]).text = "";
				((Component)ui.playerNamesText[index]).gameObject.SetActive(false);
			}
			if (ui.playerStates != null && ui.playerStates.Length > index && (Object)(object)ui.playerStates[index] != (Object)null)
			{
				((Behaviour)ui.playerStates[index]).enabled = false;
				((Component)ui.playerStates[index]).gameObject.SetActive(false);
			}
			if (ui.playerNotesText != null && ui.playerNotesText.Length > index && (Object)(object)ui.playerNotesText[index] != (Object)null)
			{
				((TMP_Text)ui.playerNotesText[index]).text = "";
				((Component)ui.playerNotesText[index]).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "ApplyPenalty")]
	internal static class HideHostApplyPenaltyPatch
	{
		[HarmonyPrefix]
		private static void Prefix(ref int playersDead, ref int bodiesInsured)
		{
			if (!GhostSeat.WantHide())
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			PlayerControllerB val = ((instance?.allPlayerScripts != null && instance.allPlayerScripts.Length != 0) ? instance.allPlayerScripts[0] : null);
			if (!((Object)(object)val == (Object)null) && GhostSeat.IsGhost(val) && val.isPlayerDead)
			{
				if (playersDead > 0)
				{
					playersDead--;
				}
				if (bodiesInsured > playersDead)
				{
					bodiesInsured = playersDead;
				}
				Plugin.DebugLog($"ApplyPenalty adjusted for ghost: dead={playersDead}, insured={bodiesInsured}");
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "UpdateBoxesSpectateUI")]
	internal static class HideHostSpectateBoxesPatch
	{
		[HarmonyPostfix]
		private static void Postfix(HUDManager __instance)
		{
			if (!GhostSeat.WantHide() || __instance.spectatingPlayerBoxes == null || __instance.spectatingPlayerBoxes.Count == 0)
			{
				return;
			}
			try
			{
				List<Animator> list = new List<Animator>();
				foreach (KeyValuePair<Animator, PlayerControllerB> spectatingPlayerBox in __instance.spectatingPlayerBoxes)
				{
					if (GhostSeat.IsGhost(spectatingPlayerBox.Value))
					{
						list.Add(spectatingPlayerBox.Key);
					}
				}
				foreach (Animator item in list)
				{
					__instance.spectatingPlayerBoxes.Remove(item);
					if ((Object)(object)item != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)item).gameObject);
					}
					if (__instance.boxesAdded > 0)
					{
						__instance.boxesAdded--;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("HideHostSpectateBoxes: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SpectateNextPlayer")]
	internal static class SpectateSkipHostPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(PlayerControllerB __instance, bool getClosest)
		{
			if (!GhostSeat.WantHide())
			{
				return true;
			}
			try
			{
				PlayerControllerB val = GhostSeat.FindSpectateTarget(__instance, getClosest);
				if ((Object)(object)val != (Object)null)
				{
					GhostSeat.ApplySpectate(__instance, val);
					return false;
				}
				__instance.spectatedPlayerScript = null;
				EnterWipeSpectateIfNeeded(__instance);
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("SpectateSkipHost: " + ex.Message);
				__instance.spectatedPlayerScript = null;
				EnterWipeSpectateIfNeeded(__instance);
			}
			return false;
		}

		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			if (GhostSeat.WantHide() && GhostSeat.IsGhost(__instance.spectatedPlayerScript))
			{
				PlayerControllerB val = GhostSeat.FindSpectateTarget(__instance, getClosest: true);
				if ((Object)(object)val != (Object)null)
				{
					GhostSeat.ApplySpectate(__instance, val);
					return;
				}
				__instance.spectatedPlayerScript = null;
				EnterWipeSpectateIfNeeded(__instance);
			}
		}

		internal static void EnterWipeSpectateIfNeeded(PlayerControllerB self)
		{
			try
			{
				if ((Object)(object)self == (Object)null || !self.isPlayerDead || !((NetworkBehaviour)self).IsOwner)
				{
					return;
				}
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null || (!instance.allPlayersDead && !((Object)(object)GhostSeat.FindSpectateTarget(self, getClosest: true) == (Object)null)))
				{
					return;
				}
				try
				{
					instance.SetSpectateCameraToGameOverMode(true, self);
				}
				catch
				{
				}
				try
				{
					self.SetSpectatedPlayerEffects(true);
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("EnterWipeSpectate: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	internal static class SpectateKickGhostUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			if (GhostSeat.WantHide() && __instance.isPlayerDead && ((NetworkBehaviour)__instance).IsOwner && GhostSeat.IsGhost(__instance.spectatedPlayerScript))
			{
				PlayerControllerB val = GhostSeat.FindSpectateTarget(__instance, getClosest: true);
				if ((Object)(object)val != (Object)null)
				{
					GhostSeat.ApplySpectate(__instance, val);
					return;
				}
				__instance.spectatedPlayerScript = null;
				SpectateSkipHostPatch.EnterWipeSpectateIfNeeded(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SetSpectatedPlayerEffects")]
	internal static class SpectateEffectsRefuseGhostPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(PlayerControllerB __instance, bool allPlayersDead)
		{
			if (!GhostSeat.WantHide())
			{
				return true;
			}
			if (GhostSeat.IsGhost(__instance.spectatedPlayerScript))
			{
				PlayerControllerB val = GhostSeat.FindSpectateTarget(__instance, getClosest: true);
				if ((Object)(object)val != (Object)null)
				{
					__instance.spectatedPlayerScript = val;
					return true;
				}
				__instance.spectatedPlayerScript = null;
				return false;
			}
			if ((Object)(object)__instance.spectatedPlayerScript == (Object)null && !allPlayersDead)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ManualCameraRenderer))]
	internal static class RadarSkipHostPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void Awake_Postfix(ManualCameraRenderer __instance)
		{
			MapScreenGhostGuard.RetargetCameraLocal(__instance);
		}

		[HarmonyPatch("SwitchRadarTargetForward")]
		[HarmonyPrefix]
		private static bool SwitchForward_Prefix(ManualCameraRenderer __instance, bool callRPC)
		{
			if (!GhostSeat.WantHide())
			{
				return true;
			}
			try
			{
				if (__instance.radarTargets == null || __instance.radarTargets.Count == 0)
				{
					return true;
				}
				int num = MapScreenGhostGuard.FindNonGhostIndex(__instance, __instance.targetTransformIndex + 1);
				if (num < 0)
				{
					return false;
				}
				MapScreenGhostGuard.ApplyIndexLocal(__instance, num);
				if (callRPC)
				{
					try
					{
						__instance.SwitchRadarTargetServerRpc(num);
					}
					catch
					{
					}
				}
				return false;
			}
			catch
			{
			}
			return true;
		}

		[HarmonyPatch("SwitchRadarTargetAndSync")]
		[HarmonyPrefix]
		private static bool SwitchSync_Prefix(ManualCameraRenderer __instance, ref int switchToIndex)
		{
			if (!GhostSeat.WantHide())
			{
				return true;
			}
			if (MapScreenGhostGuard.IsValidRadarSwitchTarget(__instance, switchToIndex))
			{
				return true;
			}
			int num = MapScreenGhostGuard.FindNonGhostIndex(__instance, switchToIndex);
			if (num < 0)
			{
				return false;
			}
			switchToIndex = num;
			return true;
		}

		[HarmonyPatch("SwitchRadarTargetClientRpc")]
		[HarmonyPrefix]
		private static void SwitchClient_Prefix(ManualCameraRenderer __instance, ref int switchToIndex)
		{
			if (GhostSeat.WantHide() && !MapScreenGhostGuard.IsValidRadarSwitchTarget(__instance, switchToIndex))
			{
				int num = MapScreenGhostGuard.FindNonGhostIndex(__instance, switchToIndex);
				if (num >= 0)
				{
					switchToIndex = num;
				}
			}
		}

		[HarmonyPatch("SwitchRadarTargetClientRpc")]
		[HarmonyPostfix]
		private static void SwitchClient_Postfix(ManualCameraRenderer __instance)
		{
			if (GhostSeat.WantHide())
			{
				MapScreenGhostGuard.RetargetCameraLocal(__instance);
			}
		}

		[HarmonyPatch("SwitchScreenOn")]
		[HarmonyPrefix]
		private static bool SwitchScreenOn_Prefix(ManualCameraRenderer __instance)
		{
			if (!GhostSeat.WantHide())
			{
				return true;
			}
			try
			{
				if ((Object)(object)__instance.mesh == (Object)null || (Object)(object)__instance.onScreenMat == (Object)null || (Object)(object)__instance.offScreenMat == (Object)null)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("UpdateRadarTargetName")]
		[HarmonyPostfix]
		private static void UpdateName_Postfix(ManualCameraRenderer __instance)
		{
			if (GhostSeat.WantHide())
			{
				MapScreenGhostGuard.FixPlayerNameLabel(__instance);
			}
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void LateUpdate_Prefix(ManualCameraRenderer __instance)
		{
			if (!GhostSeat.WantHide())
			{
				return;
			}
			try
			{
				if (GhostSeat.IsGhost(__instance.targetedPlayer) || MapScreenGhostGuard.IsGhostRadarEntry(__instance, __instance.targetTransformIndex))
				{
					__instance.enableHeadMountedCam = false;
					__instance.headMountedCamTarget = null;
					MapScreenGhostGuard.RetargetCameraLocal(__instance);
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdate_Postfix(ManualCameraRenderer __instance)
		{
			if (GhostSeat.WantHide())
			{
				MapScreenGhostGuard.FixPlayerNameLabel(__instance);
			}
		}
	}
	internal static class MapScreenGhostGuard
	{
		internal static void RetargetLocal(StartOfRound sor, PlayerControllerB ghost)
		{
			try
			{
				ManualCameraRenderer mapScreen = sor.mapScreen;
				if (!((Object)(object)mapScreen == (Object)null) && ((Object)(object)mapScreen.targetedPlayer == (Object)(object)ghost || IsGhostRadarEntry(mapScreen, mapScreen.targetTransformIndex)))
				{
					RetargetCameraLocal(mapScreen);
				}
			}
			catch
			{
			}
		}

		internal static void RetargetCameraLocal(ManualCameraRenderer? cam)
		{
			if (!((Object)(object)cam == (Object)null) && cam.radarTargets != null && cam.radarTargets.Count != 0 && (!IsValidRadarSwitchTarget(cam, cam.targetTransformIndex) || GhostSeat.IsGhost(cam.targetedPlayer)))
			{
				int num = FindNonGhostIndex(cam, cam.targetTransformIndex);
				if (num >= 0)
				{
					ApplyIndexLocal(cam, num);
				}
			}
		}

		internal static void ApplyIndexLocal(ManualCameraRenderer cam, int idx)
		{
			try
			{
				if (cam.radarTargets == null || idx < 0 || idx >= cam.radarTargets.Count)
				{
					return;
				}
				TransformAndName val = cam.radarTargets[idx];
				if (!((Object)(object)val?.transform == (Object)null))
				{
					PlayerControllerB component = ((Component)val.transform).GetComponent<PlayerControllerB>();
					cam.targetTransformIndex = idx;
					cam.targetedPlayer = component;
					cam.enableHeadMountedCam = false;
					if (GhostSeat.IsGhost(component))
					{
						cam.headMountedCamTarget = null;
					}
					StartOfRound instance = StartOfRound.Instance;
					if ((Object)(object)instance?.mapScreenPlayerName != (Object)null && (Object)(object)instance.mapScreen != (Object)null && cam == instance.mapScreen)
					{
						string text = (((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.playerUsername)) ? component.playerUsername : (val.name ?? ""));
						((TMP_Text)instance.mapScreenPlayerName).text = text;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("ApplyIndexLocal: " + ex.Message);
			}
		}

		internal static bool IsJoinedCrew(PlayerControllerB? p)
		{
			if ((Object)(object)p == (Object)null || GhostSeat.IsGhost(p))
			{
				return false;
			}
			if (p.isPlayerControlled || p.isPlayerDead)
			{
				return true;
			}
			try
			{
				return p.playerSteamId != 0;
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsValidRadarSwitchTarget(ManualCameraRenderer cam, int index)
		{
			try
			{
				if (cam.radarTargets == null || index < 0 || index >= cam.radarTargets.Count)
				{
					return false;
				}
				if (IsGhostRadarEntry(cam, index))
				{
					return false;
				}
				TransformAndName val = cam.radarTargets[index];
				if ((Object)(object)val?.transform == (Object)null)
				{
					return false;
				}
				PlayerControllerB component = ((Component)val.transform).GetComponent<PlayerControllerB>();
				if ((Object)(object)component == (Object)null)
				{
					return true;
				}
				return IsJoinedCrew(component);
			}
			catch
			{
				return false;
			}
		}

		internal static int FindNonGhostIndex(ManualCameraRenderer cam, int from)
		{
			try
			{
				int num = cam.radarTargets?.Count ?? 0;
				if (num <= 0)
				{
					return -1;
				}
				for (int i = 0; i < num; i++)
				{
					int num2 = (from + i) % num;
					if (IsValidRadarSwitchTarget(cam, num2))
					{
						return num2;
					}
				}
			}
			catch
			{
			}
			return -1;
		}

		internal static bool IsGhostRadarEntry(ManualCameraRenderer cam, int index)
		{
			try
			{
				if (cam.radarTargets == null || index < 0 || index >= cam.radarTargets.Count)
				{
					return false;
				}
				Transform transform = cam.radarTargets[index].transform;
				if ((Object)(object)transform == (Object)null)
				{
					return false;
				}
				return GhostSeat.IsGhost(((Component)transform).GetComponent<PlayerControllerB>());
			}
			catch
			{
				return false;
			}
		}

		internal static void FixPlayerNameLabel(ManualCameraRenderer cam)
		{
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance?.mapScreenPlayerName == (Object)null || (Object)(object)cam == (Object)null || ((Object)(object)instance.mapScreen != (Object)null && cam != instance.mapScreen))
				{
					return;
				}
				int targetTransformIndex = cam.targetTransformIndex;
				PlayerControllerB val = cam.targetedPlayer;
				if ((Object)(object)val == (Object)null && cam.radarTargets != null && targetTransformIndex >= 0 && targetTransformIndex < cam.radarTargets.Count && (Object)(object)cam.radarTargets[targetTransformIndex]?.transform != (Object)null)
				{
					val = ((Component)cam.radarTargets[targetTransformIndex].transform).GetComponent<PlayerControllerB>();
				}
				if ((Object)(object)val == (Object)null || GhostSeat.IsGhost(val))
				{
					return;
				}
				string playerUsername = val.playerUsername;
				if (!string.IsNullOrEmpty(playerUsername))
				{
					if (cam.radarTargets != null && targetTransformIndex >= 0 && targetTransformIndex < cam.radarTargets.Count && cam.radarTargets[targetTransformIndex] != null && cam.radarTargets[targetTransformIndex].name != playerUsername)
					{
						cam.radarTargets[targetTransformIndex].name = playerUsername;
					}
					if (((TMP_Text)instance.mapScreenPlayerName).text != playerUsername)
					{
						((TMP_Text)instance.mapScreenPlayerName).text = playerUsername;
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class HostBodyHidePatches
	{
		private static int _hiddenGhostInstanceId;

		private static float _nextSoftCheckRealtime;

		private static bool WantHide()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		private static bool IsRemoteGhostHost(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (((NetworkBehaviour)player).IsOwner)
			{
				return false;
			}
			if (player.isHostPlayerObject)
			{
				return true;
			}
			return player.playerClientId == 0;
		}

		internal static void NeutralizeGhost(PlayerControllerB player)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: 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_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: 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_00d9: 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_00f7: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				player.syncFullRotation = Vector3.zero;
				player.syncFullCameraRotation = Vector3.zero;
				try
				{
					AccessTools.Field(typeof(PlayerControllerB), "targetYRot")?.SetValue(player, 0f);
				}
				catch
				{
				}
				if ((Object)(object)player.playerBodyAnimator != (Object)null)
				{
					((Behaviour)player.playerBodyAnimator).enabled = false;
				}
				Animator[] componentsInChildren = ((Component)player).GetComponentsInChildren<Animator>(true);
				foreach (Animator val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Behaviour)val).enabled = false;
					}
				}
				if ((Object)(object)player.localArmsRotationTarget != (Object)null)
				{
					player.localArmsRotationTarget.localRotation = Quaternion.identity;
				}
				if ((Object)(object)player.playerModelArmsMetarig != (Object)null)
				{
					player.playerModelArmsMetarig.localRotation = Quaternion.identity;
				}
				if ((Object)(object)player.localVisor != (Object)null)
				{
					player.localVisor.localRotation = Quaternion.identity;
				}
				if ((Object)(object)player.localVisorTargetPoint != (Object)null)
				{
					player.localVisorTargetPoint.localRotation = Quaternion.identity;
				}
				try
				{
					((Component)player).transform.localRotation = Quaternion.identity;
					((Component)player).transform.localScale = Vector3.one;
				}
				catch
				{
				}
				Transform[] componentsInChildren2 = ((Component)player).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren2)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					try
					{
						val2.localRotation = Quaternion.identity;
						Vector3 localScale = val2.localScale;
						if (localScale.x == 0f || localScale.y == 0f || localScale.z == 0f || float.IsNaN(localScale.x) || float.IsNaN(localScale.y) || float.IsNaN(localScale.z))
						{
							val2.localScale = Vector3.one;
						}
					}
					catch
					{
					}
				}
				if (!((Object)(object)player.thisPlayerBody != (Object)null) || !((Object)(object)player.thisPlayerBody != (Object)(object)((Component)player).transform))
				{
					return;
				}
				try
				{
					Vector3 localPosition = player.thisPlayerBody.localPosition;
					if (((Vector3)(ref localPosition)).sqrMagnitude > 4f)
					{
						player.thisPlayerBody.localPosition = Vector3.zero;
					}
					player.thisPlayerBody.localRotation = Quaternion.identity;
					player.thisPlayerBody.localScale = Vector3.one;
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("NeutralizeGhost: " + ex.Message);
			}
		}

		internal static void HideGhostVisuals(PlayerControllerB player, bool force = false)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)player).GetInstanceID();
			if (!force && _hiddenGhostInstanceId == instanceID)
			{
				return;
			}
			try
			{
				NeutralizeGhost(player);
				player.DisablePlayerModel(((Component)player).gameObject, false, true);
				Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.enabled = false;
					}
				}
				if ((Object)(object)player.usernameBillboard != (Object)null)
				{
					((Component)player.usernameBillboard).gameObject.SetActive(false);
				}
				if ((Object)(object)player.usernameCanvas != (Object)null)
				{
					((Component)player.usernameCanvas).gameObject.SetActive(false);
				}
				HideRadarBlip(player);
				Collider[] componentsInChildren2 = ((Component)player).GetComponentsInChildren<Collider>(true);
				foreach (Collider val2 in componentsInChildren2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = false;
					}
				}
				MuteGhostAudio(player);
				_hiddenGhostInstanceId = instanceID;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("HideGhostVisuals: " + ex.Message);
			}
		}

		internal static void HideRadarBlip(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)player.mapRadarDotAnimator != (Object)null)
				{
					try
					{
						player.mapRadarDotAnimator.SetBool("dead", true);
					}
					catch
					{
					}
					if (((Component)player.mapRadarDotAnimator).gameObject.activeSelf)
					{
						((Component)player.mapRadarDotAnimator).gameObject.SetActive(false);
					}
				}
				if ((Object)(object)player.mapRadarDirectionIndicator != (Object)null)
				{
					((Renderer)player.mapRadarDirectionIndicator).enabled = false;
				}
				Transform val = ((Component)player).transform.Find("RadarIcon") ?? ((Component)player).transform.Find("RadarDot");
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			catch
			{
			}
		}

		internal static void SoftRehideIfNeeded(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			HideRadarBlip(player);
			if (Time.realtimeSinceStartup < _nextSoftCheckRealtime)
			{
				return;
			}
			_nextSoftCheckRealtime = Time.realtimeSinceStartup + 2f;
			try
			{
				if ((Object)(object)player.thisPlayerModel != (Object)null && ((Renderer)player.thisPlayerModel).enabled)
				{
					HideGhostVisuals(player, force: true);
					return;
				}
				Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(false);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null && componentsInChildren[i].enabled)
					{
						HideGhostVisuals(player, force: true);
						break;
					}
				}
			}
			catch
			{
			}
		}

		internal static void ResetHideLatch()
		{
			_hiddenGhostInstanceId = 0;
			_nextSoftCheckRealtime = 0f;
		}

		private static void MuteGhostAudio(PlayerControllerB player)
		{
			try
			{
				AudioSource[] componentsInChildren = ((Component)player).GetComponentsInChildren<AudioSource>(true);
				foreach (AudioSource val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.Stop();
						val.mute = true;
						val.volume = 0f;
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch("ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void ConnectClientToPlayerObject_Postfix(PlayerControllerB __instance)
		{
			if (WantHide() && IsRemoteGhostHost(__instance))
			{
				HideGhostVisuals(__instance, force: true);
				Plugin.DebugLog("Hid remote ghost host on ConnectClientToPlayerObject.");
			}
		}

		[HarmonyPatch("SpawnPlayerAnimation")]
		[HarmonyPostfix]
		private static void SpawnPlayerAnimation_Postfix(PlayerControllerB __instance)
		{
			if (WantHide() && IsRemoteGhostHost(__instance))
			{
				HideGhostVisuals(__instance, force: true);
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Update_Prefix(PlayerControllerB __instance)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!WantHide() || !IsRemoteGhostHost(__instance))
			{
				return true;
			}
			__instance.isPlayerControlled = false;
			SoftRehideIfNeeded(__instance);
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (__instance.setPositionOfDeadPlayer && (Object)(object)instance?.notSpawnedPosition != (Object)null)
				{
					((Component)__instance).transform.localPosition = __instance.serverPlayerPosition;
				}
				else
				{
					((Component)__instance).transform.localPosition = __instance.serverPlayerPosition;
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool LateUpdate_Prefix(PlayerControllerB __instance)
		{
			if (!WantHide() || !IsRemoteGhostHost(__instance))
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch("KillPlayerClientRpc")]
		[HarmonyPrefix]
		private static bool KillPlayerClientRpc_Prefix(PlayerControllerB __instance, int playerId)
		{
			if (!WantHide() || playerId != 0)
			{
				return true;
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerObjects == null || playerId >= instance.allPlayerObjects.Length)
				{
					return true;
				}
				GameObject obj = instance.allPlayerObjects[playerId];
				PlayerControllerB val = ((obj != null) ? obj.GetComponent<PlayerControllerB>() : null);
				if ((Object)(object)val == (Object)null || !IsRemoteGhostHost(val))
				{
					return true;
				}
				if (!((NetworkBehaviour)__instance).IsServer && !((NetworkBehaviour)__instance).IsHost && instance.livingPlayers > 0)
				{
					instance.livingPlayers--;
				}
				LivingPlayersClient.Ensure("quiet-kill-client");
				val.isPlayerDead = true;
				val.isPlayerControlled = false;
				val.setPositionOfDeadPlayer = true;
				val.health = 0;
				val.bleedingHeavily = false;
				try
				{
					AudioSource slimeSlipAudio = val.slimeSlipAudio;
					if (slimeSlipAudio != null)
					{
						slimeSlipAudio.Stop();
					}
				}
				catch
				{
				}
				HideGhostVisuals(val, force: true);
				return false;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Quiet ghost KillPlayerClientRpc: " + ex.Message);
				return true;
			}
		}

		[HarmonyPatch("DisablePlayerModel")]
		[HarmonyPrefix]
		private static void DisablePlayerModel_Prefix(PlayerControllerB __instance, ref bool enable)
		{
			if (enable && WantHide() && IsRemoteGhostHost(__instance))
			{
				enable = false;
			}
		}

		[HarmonyPatch("BeginGrabObject")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool BeginGrabObject_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("GrabObjectClientRpc")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool GrabObjectClientRpc_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("DropAllHeldItems")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool DropAllHeldItems_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("DiscardHeldObject")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool DiscardHeldObject_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("UpdatePlayerRotationClientRpc")]
		[HarmonyPrefix]
		private static bool UpdatePlayerRotationClientRpc_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("UpdatePlayerRotationFullClientRpc")]
		[HarmonyPrefix]
		private static bool UpdatePlayerRotationFullClientRpc_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}

		[HarmonyPatch("UpdatePlayerRotationFullWithCameraClientRpc")]
		[HarmonyPrefix]
		private static bool UpdatePlayerRotationFullWithCameraClientRpc_Prefix(PlayerControllerB __instance)
		{
			if (WantHide())
			{
				return !IsRemoteGhostHost(__instance);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
	internal static class HostBodyHideOnJoin
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts != null && instance.allPlayerScripts.Length != 0)
				{
					PlayerControllerB val = instance.allPlayerScripts[0];
					if (!((Object)(object)val == (Object)null) && !((NetworkBehaviour)val).IsOwner)
					{
						HostBodyHidePatches.HideGhostVisuals(val, force: true);
						GhostSeatLateJoinEnforcer.EnforceNow(instance, "player-connected");
					}
				}
			}
			catch
			{
			}
		}
	}
	internal static class JoinBanGate
	{
		public static bool TryBlockJoin(Lobby lobby)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				try
				{
					((Lobby)(ref lobby)).Refresh();
				}
				catch
				{
				}
				if (!DedicatedLobby.TryGetLocalBanRemaining(lobby, out var remaining, out var permanent))
				{
					return false;
				}
				ShowBlocked(permanent ? "You are permanently banned from this server." : ("You were kicked from this server.\nYou can rejoin in " + DedicatedLobby.FormatBanCountdown(remaining) + "."));
				Plugin.Log.LogInfo((object)$"Join blocked (ban hint): permanent={permanent} rem={remaining}");
				return true;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("JoinBanGate: " + ex.Message);
				return false;
			}
		}

		public static void ShowBlocked(string body)
		{
			ShowJoinDenied(body);
		}

		public static void ShowJoinDenied(string body)
		{
			string text = (string.IsNullOrWhiteSpace(body) ? "Cannot join this dedicated server." : body.Trim());
			try
			{
				MenuManager val = Object.FindObjectOfType<MenuManager>();
				if ((Object)(object)val != (Object)null)
				{
					val.DisplayMenuNotification(text, "OK", true);
				}
			}
			catch
			{
			}
			VoteKickClientUi.ShowTip("Cannot join", TruncateOneLine(text), warning: true);
		}

		public static void ShowTipOnly(string title, string body)
		{
			VoteKickClientUi.ShowTip(title, TruncateOneLine(body));
		}

		private static string TruncateOneLine(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			string text = s.Replace('\n', ' ').Replace('\r', ' ');
			if (text.Length <= 140)
			{
				return text;
			}
			return text.Substring(0, 137) + "…";
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal static class JoinDedicatedMenuPatches
	{
		private static readonly Color DedicatedAccent = new Color(0.91f, 0.62f, 0.12f, 1f);

		private static bool _relabeled;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(MenuManager __instance)
		{
			_relabeled = false;
			RelabelJoinButtons(__instance);
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_Postfix(MenuManager __instance)
		{
			if (!_relabeled)
			{
				RelabelJoinButtons(__instance);
			}
		}

		[HarmonyPatch("ClickJoinButton")]
		[HarmonyPostfix]
		private static void ClickJoinButton_Postfix(MenuManager __instance)
		{
			RelabelJoinButtons(__instance);
			DedicatedLobbyListChrome.Apply();
		}

		private static void RelabelJoinButtons(MenuManager menu)
		{
			if (!Plugin.Config.ReplaceJoinWithDedicated.Value)
			{
				return;
			}
			try
			{
				if ((Object)(object)menu.startClientButton != (Object)null)
				{
					TextMeshProUGUI[] componentsInChildren = ((Component)menu.startClientButton).GetComponentsInChildren<TextMeshProUGUI>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						TryRewrite(componentsInChildren[i]);
					}
				}
				if ((Object)(object)menu.joinCrewButtonContainer != (Object)null)
				{
					TextMeshProUGUI[] componentsInChildren = menu.joinCrewButtonContainer.GetComponentsInChildren<TextMeshProUGUI>(true);
					foreach (TextMeshProUGUI val in componentsInChildren)
					{
						if (((TMP_Text)val).text != null && ((TMP_Text)val).text.IndexOf("Join a crew", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							TryRewrite(val);
						}
					}
				}
				_relabeled = true;
			}
			catch
			{
			}
		}

		private static void TryRewrite(TextMeshProUGUI tmp)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			string text = ((TMP_Text)tmp).text;
			if (string.IsNullOrEmpty(text) || text.IndexOf("Dedicated", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return;
			}
			if (text.Equals("JOIN A CREW", StringComparison.OrdinalIgnoreCase))
			{
				((TMP_Text)tmp).text = "JOIN DEDICATED";
			}
			else
			{
				if (text.IndexOf("Join a crew", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return;
				}
				((TMP_Text)tmp).text = text.Replace("Join a crew", "Join Dedicated").Replace("JOIN A CREW", "JOIN DEDICATED").Replace("join a crew", "Join Dedicated");
			}
			((Graphic)tmp).color = DedicatedAccent;
		}
	}
	internal static class DedicatedLobbyListChrome
	{
		public static void Apply()
		{
			try
			{
				SteamLobbyManager val = Object.FindObjectOfType<SteamLobbyManager>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((Object)(object)val.sortWithChallengeMoonsCheckbox != (Object)null)
				{
					Transform parent = ((Component)val.sortWithChallengeMoonsCheckbox).transform.parent;
					if (parent != null)
					{
						((Component)parent).gameObject.SetActive(false);
					}
				}
				if ((Object)(object)val.sortWithModdedClientsCheckbox != (Object)null)
				{
					Transform parent2 = ((Component)val.sortWithModdedClientsCheckbox).transform.parent;
					if (parent2 != null)
					{
						((Component)parent2).gameObject.SetActive(false);
					}
				}
				if ((Object)(object)val.sortWithModdedClientsWarning != (Object)null)
				{
					((Component)val.sortWithModdedClientsWarning).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("DedicatedLobbyListChrome: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobbyManager), "LoadServerList")]
	internal static class DedicatedListChromeOnLoadPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			if (Plugin.Config.DedicatedBrowserOnly.Value)
			{
				DedicatedLobbyListChrome.Apply();
			}
		}
	}
	[HarmonyPatch(typeof(HoverOverImageText), "OnPointerEnter")]
	internal static class HideModdedHostTipPatch
	{
		[HarmonyPrefix]
		private static bool Prefix()
		{
			if (!Plugin.Config.DedicatedBrowserOnly.Value)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class DedicatedLobbySlotSpacingPatch
	{
		private const float DedicatedSlotStepY = 72f;

		private const float VanillaSlotStepY = 42f;

		private static MethodBase TargetMethod()
		{
			return AccessTools.EnumeratorMoveNext((MethodBase)AccessTools.Method(typeof(SteamLobbyManager), "loadLobbyListAndFilter", (Type[])null, (Type[])null));
		}

		private static float SlotStepY()
		{
			if (!Plugin.Config.DedicatedBrowserOnly.Value)
			{
				return 42f;
			}
			return 72f;
		}

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			MethodInfo step = AccessTools.Method(typeof(DedicatedLobbySlotSpacingPatch), "SlotStepY", (Type[])null, (Type[])null);
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_R4 && instruction.operand is float num && Mathf.Approximately(num, 42f))
				{
					yield return new CodeInstruction(OpCodes.Call, (object)step);
				}
				else
				{
					yield return instruction;
				}
			}
		}
	}
	[HarmonyPatch(typeof(LobbySlot), "Update")]
	internal static class DedicatedLobbySlotPatches
	{
		private sealed class SlotExtras
		{
			public int AppliedLayoutVersion;

			public Button? ModsButton;

			public Button? JoinButton;

			public TextMeshProUGUI? JoinLabel;

			public string ModsCsv = "";

			public string ServerName = "";

			public string ProfileCode = "";
		}

		private const int LayoutVersion = 11;

		private const float BtnW = 68f;

		private const float BtnH = 22f;

		private const float BtnGap = 5f;

		private const float RightPad = 8f;

		private const float CountW = 56f;

		private const float CardH = 66f;

		internal const float SlotStepY = 72f;

		private static readonly Color Accent = new Color(0.91f, 0.62f, 0.12f, 1f);

		private static readonly Color BtnBg = new Color(0.14f, 0.12f, 0.1f, 0.98f);

		private static readonly Color BtnBgHover = new Color(0.28f, 0.2f, 0.1f, 1f);

		private static readonly Color BtnBgPressed = new Color(0.36f, 0.26f, 0.12f, 1f);

		private static readonly Color CardBg = new Color(0.12f, 0.08f, 0.07f, 0.92f);

		private static readonly Dictionary<int, SlotExtras> Extras = new Dictionary<int, SlotExtras>();

		internal static float CardHeight => 66f;

		private static float RightClusterReserve => 216f;

		internal static void ClearExtras()
		{
			Extras.Clear();
		}

		[HarmonyPostfix]
		private static void Postfix(LobbySlot __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: 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_017b: 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_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				Lobby thisLobby = __instance.thisLobby;
				if (!DedicatedLobby.IsDedicatedLobby(thisLobby))
				{
					return;
				}
				HideModIcons(__instance);
				int instanceID = ((Object)__instance).GetInstanceID();
				if (!Extras.TryGetValue(instanceID, out SlotExtras value) || value == null)
				{
					value = new SlotExtras();
					Extras[instanceID] = value;
				}
				EnsureLayout(__instance, value);
				PlaceActionCluster(__instance, value);
				UpdateJoinButtonLabel(value, DedicatedLobby.IsQueueableLobby(thisLobby));
				if ((Object)(object)__instance.LobbyName != (Object)null)
				{
					((Graphic)__instance.LobbyName).raycastTarget = false;
				}
				string text = SafeGet(thisLobby, "name");
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "Dedicated Server";
				}
				bool flag = DedicatedLobby.RequiresPassword(thisLobby);
				int num = DedicatedLobby.ReadModCount(thisLobby);
				string modsCsv = DedicatedLobby.ReadModList(thisLobby);
				string text2 = DedicatedLobby.ReadSessionTip(thisLobby);
				string profileCode = DedicatedLobby.ReadProfileCode(thisLobby);
				string text3 = DedicatedLobby.ReadMotd(thisLobby);
				string text4 = DedicatedLobby.FormatBrowserHostVersionBadge(thisLobby);
				value.ModsCsv = modsCsv;
				value.ServerName = text;
				value.ProfileCode = profileCode;
				if ((Object)(object)__instance.LobbyName != (Object)null)
				{
					((TMP_Text)__instance.LobbyName).fontSize = 14f;
					((TMP_Text)__instance.LobbyName).richText = true;
					((TMP_Text)__instance.LobbyName).enableWordWrapping = true;
					((TMP_Text)__instance.LobbyName).overflowMode = (TextOverflowModes)1;
					((TMP_Text)__instance.LobbyName).alignment = (TextAlignmentOptions)257;
					((TMP_Text)__instance.LobbyName).fontStyle = (FontStyles)1;
					((TMP_Text)__instance.LobbyName).lineSpacing = -18f;
					((Graphic)__instance.LobbyName).color = Accent;
					string text5 = text2;
					if (string.IsNullOrWhiteSpace(text5) && DedicatedLobby.IsQueueableLobby(thisLobby))
					{
						text5 = "on moon · join queue";
					}
					string text6 = DedicatedLobby.ReadData(thisLobby, "uexpPhase");
					if (text6.Equals("landing", StringComparison.OrdinalIgnoreCase) && (string.IsNullOrWhiteSpace(text5) || text5.IndexOf("orbit", StringComparison.OrdinalIgnoreCase) >= 0))
					{
						string text7 = DedicatedLobby.ReadData(thisLobby, "uexpMoon");
						text5 = (string.IsNullOrEmpty(text7) ? "landing…" : ("landing · " + text7));
					}
					string text8 = DedicatedLobby.ReadData(thisLobby, "uexpTime");
					if (!string.IsNullOrEmpty(text8) && !string.IsNullOrEmpty(text5) && text5.IndexOf(text8, StringComparison.OrdinalIgnoreCase) < 0 && text6.Equals("moon", StringComparison.OrdinalIgnoreCase))
					{
						text5 = text5 + " · " + text8;
					}
					List<string> list = new List<string>();
					if (DedicatedLobby.IsQueueableLobby(thisLobby))
					{
						int num2 = DedicatedLobby.ReadQueueCount(thisLobby);
						list.Add((num2 > 0) ? $"queue {num2}" : "queue open");
					}
					if (num > 0)
					{
						list.Add($"{num} mods");
					}
					else if (Plugin.Config.ShowModListOnSlots.Value)
					{
						list.Add("mods unknown");
					}
					if (list.Count > 0)
					{
						string text9 = string.Join(" · ", list);
						text5 = ((!string.IsNullOrEmpty(text5)) ? (text5 + " · " + text9) : text9);
					}
					string text10 = (flag ? "<color=#C84A3A>[Locked]</color>" : "<color=#6FBF4A>[Open]</color>") + "  " + Truncate(text, 40);
					if (!string.IsNullOrEmpty(text5) || !string.IsNullOrEmpty(text4))
					{
						text10 += "\n<size=76%>";
						if (!string.IsNullOrEmpty(text5))
						{
							text10 = text10 + "<color=#C8D0D8>" + Truncate(text5, 64) + "</color>";
						}
						if (!string.IsNullOrEmpty(text4))
						{
							if (!string.IsNullOrEmpty(text5))
							{
								text10 += " · ";
							}
							text10 += text4;
						}
						text10 += "</size>";
					}
					if (!string.IsNullOrEmpty(text3))
					{
						text10 = text10 + "\n<size=72%><color=#A8B0B8>" + Truncate(text3, 72) + "</color></size>";
					}
					if (((TMP_Text)__instance.LobbyName).text != text10)
					{
						((TMP_Text)__instance.LobbyName).text = text10;
					}
				}
				if ((Object)(object)__instance.playerCount != (Object)null)
				{
					((TMP_Text)__instance.playerCount).fontSize = 13f;
					((TMP_Text)__instance.playerCount).fontStyle = (FontStyles)1;
					((TMP_Text)__instance.playerCount).alignment = (TextAlignmentOptions)4100;
					((Graphic)__instance.playerCount).color = Accent;
					int num3 = DedicatedLobby.DisplayMemberCount(thisLobby);
					int num4 = DedicatedLobby.ReadHumanCapacity(thisLobby);
					string text11 = $"{num3}/{num4}";
					if (((TMP_Text)__instance.playerCount).text != text11)
					{
						((TMP_Text)__instance.playerCount).text = text11;
					}
				}
			}
			catch
			{
			}
		}

		private static void HideModIcons(LobbySlot slot)
		{
			try
			{
				if ((Object)(object)slot.modStateTrueIcon != (Object)null)
				{
					((Behaviour)slot.modStateTrueIcon).enabled = false;
					((Component)slot.modStateTrueIcon).gameObject.SetActive(false);
				}
				if ((Object)(object)slot.modStateUnknownIcon != (Object)null)
				{
					((Behaviour)slot.modStateUnknownIcon).enabled = false;
					((Component)slot.modStateUnknownIcon).gameObject.SetActive(false);
				}
			}
			catch
			{
			}
		}

		private static void EnsureLayout(LobbySlot slot, SlotExtras extras)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_0191: 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_01bb: 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_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			if (extras.AppliedLayoutVersion == 11)
			{
				return;
			}
			Transform transform = ((Component)slot).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float y = val.anchoredPosition.y;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(0.5f, 1f);
			val.offsetMin = new Vector2(8f, val.offsetMin.y);
			val.offsetMax = new Vector2(-8f, val.offsetMax.y);
			val.SetSizeWithCurrentAnchors((Axis)1, 66f);
			val.anchoredPosition = new Vector2(0f, y);
			Transform parent = ((Transform)val).parent;
			RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (val2 != null && (Object)(object)((Component)val2).GetComponent<LobbySlot>() == (Object)null && (Object)(object)((Component)val2).GetComponentInParent<SteamLobbyManager>() != (Object)null)
			{
				Transform parent2 = ((Transform)val2).parent;
				if ((Object)(object)parent2 != (Object)null)
				{
					SteamLobbyManager componentInParent = ((Component)parent2).GetComponentInParent<SteamLobbyManager>();
					if ((Object)(object)componentInParent != (Object)null && (Object)(object)parent2 == (Object)(object)componentInParent.levelListContainer)
					{
						val2.SetSizeWithCurrentAnchors((Axis)1, 66f);
					}
				}
			}
			EnsureCardWash(val);
			EnsureAccentBar(val);
			if ((Object)(object)slot.LobbyName != (Object)null)
			{
				((Graphic)slot.LobbyName).raycastTarget = false;
				RectTransform rectTransform = ((TMP_Text)slot.LobbyName).rectTransform;
				rectTransform.anchorMin = new Vector2(0f, 0f);
				rectTransform.anchorMax = new Vector2(1f, 1f);
				rectTransform.pivot = new Vector2(0f, 1f);
				rectTransform.offsetMin = new Vector2(12f, 4f);
				rectTransform.offsetMax = new Vector2(0f - RightClusterReserve, -3f);
			}
			if ((Object)(object)extras.ModsButton == (Object)null)
			{
				extras.ModsButton = CreateActionButton(slot, extras, "UEXP_ModsButton", "MODS", (UnityAction)delegate
				{
					DedicatedModsModal.Show(extras.ServerName, extras.ModsCsv, extras.ProfileCode);
				});
			}
			if ((Object)(object)extras.JoinButton == (Object)null)
			{
				LobbySlot captured = slot;
				extras.JoinButton = CreateActionButton(slot, extras, "UEXP_JoinButton", "JOIN", (UnityAction)delegate
				{
					try
					{
						captured.JoinButton();
					}
					catch (Exception ex)
					{
						Plugin.Log.LogWarning((object)("Join click: " + ex.Message));
					}
				});
				extras.JoinLabel = ((Component)extras.JoinButton).GetComponentInChildren<TextMeshProUGUI>(true);
				HideVanillaJoinButton(slot);
			}
			PlaceActionCluster(slot, extras);
			extras.AppliedLayoutVersion = 11;
		}

		private static void PlaceActionCluster(LobbySlot slot, SlotExtras extras)
		{
			float anchoredY = 22f;
			float anchoredX = -8f;
			float anchoredX2 = -81f;
			float anchoredX3 = -154f;
			HideVanillaJoinButton(slot);
			if ((Object)(object)slot.playerCount != (Object)null)
			{
				((Graphic)slot.playerCount).raycastTarget = false;
				RectTransform rectTransform = ((TMP_Text)slot.playerCount).rectTransform;
				if ((Object)(object)((Transform)rectTransform).parent != (Object)(object)((Component)slot).transform)
				{
					((Transform)rectTransform).SetParent(((Component)slot).transform, false);
				}
				PlaceRightCluster(rectTransform, anchoredX3, anchoredY, 56f, 22f);
			}
			if ((Object)(object)extras.ModsButton != (Object)null)
			{
				if ((Object)(object)((Component)extras.ModsButton).transform.parent != (Object)(object)((Component)slot).transform)
				{
					((Component)extras.ModsButton).transform.SetParent(((Component)slot).transform, false);
				}
				PlaceRightCluster(((Component)extras.ModsButton).GetComponent<RectTransform>(), anchoredX2, anchoredY, 68f, 22f);
			}
			if ((Object)(object)extras.JoinButton != (Object)null)
			{
				if ((Object)(object)((Component)extras.JoinButton).transform.parent != (Object)(object)((Component)slot).transform)
				{
					((Component)extras.JoinButton).transform.SetParent(((Component)slot).transform, false);
				}
				PlaceRightCluster(((Component)extras.JoinButton).GetComponent<RectTransform>(), anchoredX, anchoredY, 68f, 22f);
				((Component)extras.JoinButton).transform.SetAsLastSibling();
				((Selectable)extras.JoinButton).interactable = true;
				if (!((Component)extras.JoinButton).gameObject.activeSelf)
				{
					((Component)extras.JoinButton).gameObject.SetActive(true);
				}
			}
			if ((Object)(object)extras.ModsButton != (Object)null && (Object)(object)extras.JoinButton != (Object)null)
			{
				int siblingIndex = ((Component)extras.JoinButton).transform.GetSiblingIndex();
				if (siblingIndex > 0)
				{
					((Component)extras.ModsButton).transform.SetSiblingIndex(siblingIndex - 1);
				}
			}
		}

		private static void HideVanillaJoinButton(LobbySlot slot)
		{
			Button val = FindVanillaJoinButton(slot);
			if (!((Object)(object)val == (Object)null) && !(((Object)((Component)val).gameObject).name == "UEXP_JoinButton") && !(((Object)((Component)val).gameObject).name == "UEXP_ModsButton") && ((Component)val).gameObject.activeSelf)
			{
				((Component)val).gameObject.SetActive(false);
			}
		}

		private static void PlaceRightCluster(RectTransform rt, float anchoredX, float anchoredY, float w, float h)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(1f, 0f);
			rt.anchorMax = new Vector2(1f, 0f);
			rt.pivot = new Vector2(1f, 0f);
			rt.anchoredPosition = new Vector2(anchoredX, anchoredY);
			rt.sizeDelta = new Vector2(w, h);
			((Transform)rt).localScale = Vector3.one;
			((Transform)rt).localRotation = Quaternion.identity;
		}

		private static void EnsureCardWash(RectTransform root)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Transform)root).Find("UEXP_CardWash");
			if ((Object)(object)val != (Object)null)
			{
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).raycastTarget = false;
				}
				return;
			}
			GameObject val2 = new GameObject("UEXP_CardWash", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent((Transform)(object)root, false);
			val2.transform.SetAsFirstSibling();
			Image component2 = val2.GetComponent<Image>();
			((Graphic)component2).color = CardBg;
			((Graphic)component2).raycastTarget = false;
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
		}

		private static void EnsureAccentBar(RectTransform root)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Transform)root).Find("UEXP_Accent");
			if ((Object)(object)val != (Object)null)
			{
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).raycastTarget = false;
				}
				return;
			}
			GameObject val2 = new GameObject("UEXP_Accent", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent((Transform)(object)root, false);
			val2.transform.SetSiblingIndex(1);
			Image component2 = val2.GetComponent<Image>();
			((Graphic)component2).color = Accent;
			((Graphic)component2).raycastTarget = false;
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(0f, 1f);
			component3.pivot = new Vector2(0f, 0.5f);
			component3.sizeDelta = new Vector2(4f, 0f);
			component3.anchoredPosition = Vector2.zero;
		}

		private static void ApplyButtonStyle(Button btn, Image img)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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)
			((Graphic)img).color = Color.white;
			((Graphic)img).raycastTarget = true;
			((Selectable)btn).transition = (Transition)1;
			ColorBlock colors = ((Selectable)btn).colors;
			((ColorBlock)(ref colors)).normalColor = BtnBg;
			((ColorBlock)(ref colors)).highlightedColor = BtnBgHover;
			((ColorBlock)(ref colors)).pressedColor = BtnBgPressed;
			((ColorBlock)(ref colors)).selectedColor = BtnBgHover;
			((ColorBlock)(ref colors)).disabledColor = BtnBg;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)btn).colors = colors;
			((Selectable)btn).targetGraphic = (Graphic)(object)img;
			((Selectable)btn).interactable = true;
			((Behaviour)btn).enabled = true;
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)btn).navigation = navigation;
		}

		private static void UpdateJoinButtonLabel(SlotExtras extras, bool queueable)
		{
			if (!((Object)(object)extras.JoinLabel == (Object)null))
			{
				string text = (queueable ? "QUEUE" : "JOIN");
				if (((TMP_Text)extras.JoinLabel).text != text)
				{
					((TMP_Text)extras.JoinLabel).text = text;
				}
			}
		}

		private static Button? FindVanillaJoinButton(LobbySlot slot)
		{
			Button[] componentsInChildren = ((Component)slot).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string name = ((Object)((Component)val).gameObject).name;
				if (name == "UEXP_JoinButton" || name == "UEXP_ModsButton")
				{
					continue;
				}
				if (name.IndexOf("Join", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return val;
				}
				TextMeshProUGUI[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val2 in componentsInChildren2)
				{
					if (((TMP_Text)val2).text != null && (((TMP_Text)val2).text.IndexOf("Join", StringComparison.OrdinalIgnoreCase) >= 0 || ((TMP_Text)val2).text.IndexOf("Queue", StringComparison.OrdinalIgnoreCase) >= 0 || ((TMP_Text)val2).text.Equals("JOIN", StringComparison.OrdinalIgnoreCase) || ((TMP_Text)val2).text.Equals("QUEUE", StringComparison.OrdinalIgnoreCase)))
					{
						return val;
					}
				}
			}
			return null;
		}

		private static Button CreateActionButton(LobbySlot slot, SlotExtras extras, string objectName, string labelText, UnityAction onClick)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(objectName, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(((Component)slot).transform, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(68f, 22f);
			Image component = val.GetComponent<Image>();
			Button component2 = val.GetComponent<Button>();
			ApplyButtonStyle(component2, component);
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)slot.LobbyName != (Object)null && (Object)(object)((TMP_Text)slot.LobbyName).font != (Object)null)
			{
				((TMP_Text)val3).font = ((TMP_Text)slot.LobbyName).font;
			}
			((TMP_Text)val3).text = labelText;
			((TMP_Text)val3).fontSize = 13f;
			((TMP_Text)val3).fontStyle = (FontStyles)1;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			((Graphic)val3).color = Accent;
			((Graphic)val3).raycastTarget = false;
			RectTransform rectTransform = ((TMP_Text)val3).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((UnityEvent)component2.onClick).AddListener(onClick);
			return component2;
		}

		private static string SafeGet(Lobby lobby, string key)
		{
			try
			{
				return ((Lobby)(ref lobby)).GetData(key) ?? "";
			}
			catch
			{
				return "";
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	internal static class JoinOrbitQueuePrompt
	{
		private sealed class OrbitQueuePump : MonoBehaviour
		{
			private void Update()
			{
				Tick();
			}
		}

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

			public static UnityAction <>9__47_0;

			internal void <Build>b__47_0()
			{
				ForceClose();
			}
		}

		public const string MemberQueueKey = "uexpQ";

		public const string AdmitKey = "uexpAdmit";

		public const string QueueableKey = "uexpQueueable";

		public const string QueueCountKey = "uexpQueueN";

		public const string QueueDenyKey = "uexpQDeny";

		private const float LobbyRefreshInterval = 1.5f;

		private static GameObject? _root;

		private static TextMeshProUGUI? _title;

		private static TextMeshProUGUI? _tip;

		private static TextMeshProUGUI? _position;

		private static TextMeshProUGUI? _gameTime;

		private static TextMeshProUGUI? _status;

		private static TMP_FontAsset? _font;

		private static Lobby _lobby;

		private static SteamId _lobbyId;

		private static bool _softJoined;

		private static bool _joiningGame;

		private static bool _cancelled;

		private static long _queueStamp;

		private static int _softJoinGeneration;

		private static int _blockLobbyJoinUntilFrame = -1;

		private static bool _dataHooked;

		private static float _nextLobbyRefreshAt;

		private static readonly Color PanelBg = new Color(0.07f, 0.075f, 0.08f, 0.98f);

		private static readonly Color Accent = new Color(0.91f, 0.62f, 0.12f, 1f);

		private static readonly Color Text = new Color(0.95f, 0.93f, 0.86f, 1f);

		private static readonly Color Muted = new Color(0.72f, 0.74f, 0.7f, 1f);

		private static readonly Color BtnBg = new Color(0.16f, 0.14f, 0.09f, 1f);

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		public static bool IsJoiningGame => _joiningGame;

		public static bool ShouldBlockLobbyJoin
		{
			get
			{
				if (!IsOpen)
				{
					if (_blockLobbyJoinUntilFrame >= 0)
					{
						return Time.frameCount <= _blockLobbyJoinUntilFrame;
					}
					return false;
				}
				return true;
			}
		}

		public static void ClearJoiningFlag()
		{
			_joiningGame = false;
		}

		public static void Request(Lobby lobby, SteamId lobbyId)
		{
			//IL_0027: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!MenuOverlayLifecycle.MenuUiAllowed)
			{
				Plugin.Log.LogWarning((object)"Orbit queue blocked — menu UI not active.");
				return;
			}
			JoinPasswordPrompt.ForceClose();
			DedicatedModsModal.ForceClose();
			ForceClose(leaveLobby: false);
			_lobby = lobby;
			_lobbyId = lobbyId;
			_softJoined = false;
			_joiningGame = false;
			_cancelled = false;
			_queueStamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			int generation = ++_softJoinGeneration;
			MoreCompanyLobbyMatch.ApplyFromLobby(lobby, "OrbitQueue.Request");
			Build();
			if (!((Object)(object)_root == (Object)null))
			{
				string text = DedicatedLobby.ReadData(lobby, "name");
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "Dedicated Server";
				}
				if ((Object)(object)_title != (Object)null)
				{
					((TMP_Text)_title).text = text;
				}
				EnsureDataHook();
				_nextLobbyRefreshAt = 0f;
				try
				{
					((Lobby)(ref _lobby)).Refresh();
				}
				catch
				{
				}
				RefreshUi();
				SoftJoinAsync(generation);
				Plugin.DebugLog($"Orbit queue opened for lobby {lobbyId}.");
			}
		}

		public static void ForceClose(bool leaveLobby = true)
		{
			_blockLobbyJoinUntilFrame = Time.frameCount + 2;
			_cancelled = true;
			_softJoinGeneration++;
			ReleaseDataHook();
			_title = null;
			_tip = null;
			_position = null;
			_gameTime = null;
			_status = null;
			_font = null;
			if (leaveLobby && _softJoined && !_joiningGame)
			{
				try
				{
					ClearMemberQueueFlag();
					((Lobby)(ref _lobby)).Leave();
				}
				catch
				{
				}
			}
			_softJoined = false;
			if (!_joiningGame || leaveLobby)
			{
				_joiningGame = false;
			}
			if (leaveLobby)
			{
				if (!_joiningGame)
				{
					DedicatedLobby.ClearSessionDedicated("orbit-queue-cancel");
				}
				MoreCompanyLobbyMatch.ClearPending("orbit-queue-cancel");
			}
			if (!((Object)(object)_root != (Object)null))
			{
				return;
			}
			GameObject root = _root;
			_root = null;
			try
			{
				GraphicRaycaster[] componentsInChildren = root.GetComponentsInChildren<GraphicRaycaster>(true);
				foreach (GraphicRaycaster val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Behaviour)val).enabled = false;
					}
				}
				root.SetActive(false);
			}
			catch
			{
			}
			Object.Destroy((Object)(object)root);
		}

		internal static void Tick()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			if (!IsOpen || _cancelled || _joiningGame)
			{
				return;
			}
			try
			{
				Lobby? val = FindLiveLobby(_lobbyId);
				if (val.HasValue)
				{
					_lobby = val.Value;
				}
				if (Time.unscaledTime >= _nextLobbyRefreshAt)
				{
					_nextLobbyRefreshAt = Time.unscaledTime + 1.5f;
					try
					{
						((Lobby)(ref _lobby)).Refresh();
					}
					catch
					{
					}
				}
				RefreshUi();
				string text = DedicatedLobby.ReadData(_lobby, "uexpPhase");
				string text2 = DedicatedLobby.ReadData(_lobby, "uexpAdmit");
				string text3 = DedicatedLobby.ReadData(_lobby, "uexpQDeny");
				string localId = ((object)SteamClient.SteamId/*cast due to .constrained prefix*/).ToString();
				if (!string.IsNullOrEmpty(text3) && text3.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries).Any((string id) => id.Trim().Equals(localId, StringComparison.OrdinalIgnoreCase)))
				{
					string body = "You are kicked or banned from this server — removed from queue.";
					if (DedicatedLobby.TryGetLocalBanRemaining(_lobby, out var remaining, out var permanent))
					{
						body = (permanent ? "You are permanently banned from this server — removed from queue." : ("You were kicked — you can rejoin in " + DedicatedLobby.FormatBanCountdown(remaining) + ". Removed from queue."));
					}
					Plugin.Log.LogInfo((object)"Orbit queue: host denied join (kicked/banned) — leaving queue.");
					JoinBanGate.ShowBlocked(body);
					ClearMemberQueueFlag();
					ForceClose();
					return;
				}
				bool flag = text.Equals("orbit", StringComparison.OrdinalIgnoreCase) || !DedicatedLobby.IsQueueableLobby(_lobby);
				bool flag2 = !string.IsNullOrEmpty(text2) && text2.Equals(localId, StringComparison.OrdinalIgnoreCase);
				int num = DedicatedLobby.DisplayMemberCountExcludingQueue(_lobby);
				int num2 = DedicatedLobby.ReadHumanCapacity(_lobby);
				bool flag3 = num < num2;
				if (flag2 && flag3 && _softJoined)
				{
					BeginGameJoin();
				}
				else if (flag2 && !flag3)
				{
					SetStatus("Server full — waiting for a free seat…");
				}
				else if (flag && _softJoined && !flag2)
				{
					SetStatus($"In orbit — waiting your turn… · seats {num}/{num2}");
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Orbit queue tick: " + ex.Message);
			}
		}

		private static void BeginGameJoin()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (_joiningGame)
			{
				return;
			}
			_joiningGame = true;
			SetStatus("Joining…");
			Lobby lobby = _lobby;
			SteamId lobbyId = _lobbyId;
			long queueStamp = _queueStamp;
			try
			{
				ClearMemberQueueFlag();
				ForceClose(leaveLobby: false);
				LobbySlot.JoinLobbyAfterVerifying(lobby, lobbyId);
			}
			catch (Exception ex)
			{
				_joiningGame = false;
				Plugin.Log.LogWarning((object)("Orbit queue join failed: " + ex.Message));
				try
				{
					if (_softJoined)
					{
						((Lobby)(ref _lobby)).SetMemberData("uexpQ", queueStamp.ToString(CultureInfo.InvariantCulture));
					}
				}
				catch
				{
				}
				SetStatus("Join failed — stay in queue or Cancel and retry.");
			}
		}

		private static async void SoftJoinAsync(int generation)
		{
			try
			{
				SetStatus("Joining queue…");
				Lobby? val = await SteamMatchmaking.JoinLobbyAsync(_lobbyId);
				if (generation != _softJoinGeneration || _cancelled || (Object)(object)_root == (Object)null)
				{
					try
					{
						if (val.HasValue)
						{
							Lobby value = val.Value;
							((Lobby)(ref value)).Leave();
						}
						return;
					}
					catch
					{
						return;
					}
				}
				if (!val.HasValue)
				{
					SetStatus("Could not join queue.");
					return;
				}
				_lobby = val.Value;
				_softJoined = true;
				try
				{
					((Lobby)(ref _lobby)).SetMemberData("uexpQ", _queueStamp.ToString(CultureInfo.InvariantCulture));
				}
				catch (Exception ex)
				{
					Plugin.DebugLog("SetMemberData uexpQ failed: " + ex.Message);
				}
				SetStatus("In queue — waiting for orbit…");
				RefreshUi();
			}
			catch (Exception ex2)
			{
				if (generation == _softJoinGeneration)
				{
					SetStatus("Queue join failed: " + ex2.Message);
				}
				Plugin.Log.LogWarning((object)("Orbit queue soft-join: " + ex2.Message));
			}
		}

		private static void ClearMemberQueueFlag()
		{
			try
			{
				if (_softJoined)
				{
					((Lobby)(ref _lobby)).SetMemberData("uexpQ", "");
				}
			}
			catch
			{
			}
		}

		private static void EnsureDataHook()
		{
			if (_dataHooked)
			{
				return;
			}
			try
			{
				SteamMatchmaking.OnLobbyDataChanged += OnLobbyDataChanged;
				_dataHooked = true;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Orbit queue OnLobbyDataChanged hook failed: " + ex.Message);
			}
		}

		private static void ReleaseDataHook()
		{
			if (_dataHooked)
			{
				try
				{
					SteamMatchmaking.OnLobbyDataChanged -= OnLobbyDataChanged;
				}
				catch
				{
				}
				_dataHooked = false;
			}
		}

		private static void OnLobbyDataChanged(Lobby lobby)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (IsOpen && !_cancelled && SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == SteamId.op_Implicit(_lobbyId))
				{
					_lobby = lobby;
					RefreshUi();
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Orbit queue data changed: " + ex.Message);
			}
		}

		private static Lobby? FindLiveLobby(SteamId id)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if ((Object)(object)instance != (Object)null && instance.currentLobby.HasValue)
				{
					Lobby value = instance.currentLobby.Value;
					if (SteamId.op_Implicit(((Lobby)(ref value)).Id) == SteamId.op_Implicit(id))
					{
						return instance.currentLobby.Value;
					}
				}
			}
			catch
			{
			}
			if (_softJoined && SteamId.op_Implicit(((Lobby)(ref _lobby)).Id) == SteamId.op_Implicit(id))
			{
				return _lobby;
			}
			try
			{
				return new Lobby(id);
			}
			catch
			{
				return null;
			}
		}

		private static void RefreshUi()
		{
			//IL_0000: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			string text = DedicatedLobby.ReadSessionTip(_lobby);
			if ((Object)(object)_tip != (Object)null)
			{
				((TMP_Text)_tip).text = (string.IsNullOrWhiteSpace(text) ? "Waiting for the ship to leave the moon…" : text);
			}
			DedicatedLobby.ReadLocalQueuePosition(_lobby, _queueStamp, out var position, out var total);
			if (int.TryParse(DedicatedLobby.ReadData(_lobby, "uexpQueueN"), out var result) && result > total)
			{
				total = result;
			}
			if ((Object)(object)_position != (Object)null)
			{
				if (position <= 0)
				{
					((TMP_Text)_position).text = ((total > 0) ? $"Queue: — / {total}" : "Queue: joining…");
				}
				else
				{
					((TMP_Text)_position).text = $"Queue position: {position} of {total}";
				}
			}
			string text2 = DedicatedLobby.ReadData(_lobby, "uexpTime");
			string text3 = DedicatedLobby.ReadData(_lobby, "uexpPhase");
			if ((Object)(object)_gameTime != (Object)null)
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					((TMP_Text)_gameTime).text = "Moon time: " + text2;
				}
				else if (text3.Equals("landing", StringComparison.OrdinalIgnoreCase))
				{
					((TMP_Text)_gameTime).text = "Moon time: landing…";
				}
				else if (text3.Equals("orbit", StringComparison.OrdinalIgnoreCase))
				{
					((TMP_Text)_gameTime).text = "Moon time: — (in orbit)";
				}
				else
				{
					string text4 = DedicatedLobby.ReadData(_lobby, "uexpDay");
					string text5 = DedicatedLobby.ReadData(_lobby, "uexpQuota");
					if (!string.IsNullOrEmpty(text4) || !string.IsNullOrEmpty(text5))
					{
						List<string> list = new List<string>(2);
						if (!string.IsNullOrEmpty(text4))
						{
							list.Add(text4);
						}
						if (!string.IsNullOrEmpty(text5))
						{
							list.Add("quota " + text5);
						}
						((TMP_Text)_gameTime).text = string.Join(" · ", list);
					}
					else
					{
						((TMP_Text)_gameTime).text = "Moon time: —";
					}
				}
			}
			int num = DedicatedLobby.DisplayMemberCountExcludingQueue(_lobby);
			int num2 = DedicatedLobby.ReadHumanCapacity(_lobby);
			if ((Object)(object)_status != (Object)null && !_joiningGame && _softJoined)
			{
				if (text3.Equals("landing", StringComparison.OrdinalIgnoreCase))
				{
					((TMP_Text)_status).text = $"Landing · seats {num}/{num2} · waiting for orbit…";
				}
				else if (text3.Equals("moon", StringComparison.OrdinalIgnoreCase) || DedicatedLobby.IsQueueableLobby(_lobby))
				{
					((TMP_Text)_status).text = $"On moon · seats {num}/{num2} · waiting for orbit…";
				}
			}
		}

		private static void SetStatus(string msg)
		{
			if ((Object)(object)_status != (Object)null)
			{
				((TMP_Text)_status).text = msg ?? "";
			}
		}

		private static void Build()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_014c: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Expected O, but got Unknown
			_font = FindMenuFont();
			_root = ((Component)MenuOverlayLifecycle.CreateOverlayCanvas("UEXP_OrbitQueue", 6050)).gameObject;
			if ((Object)(object)_root.GetComponent<OrbitQueuePump>() == (Object)null)
			{
				_root.AddComponent<OrbitQueuePump>();
			}
			Stretch(((Graphic)CreateImage(_root.transform, "Dim", new Color(0.01f, 0.01f, 0.015f, 0.82f))).rectTransform);
			Image obj = CreateImage(_root.transform, "Panel", PanelBg);
			RectTransform rectTransform = ((Graphic)obj).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(640f, 360f);
			RectTransform rectTransform2 = ((Graphic)CreateImage(((Component)obj).transform, "Accent", Accent)).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(0f, 1f);
			rectTransform2.pivot = new Vector2(0f, 0.5f);
			rectTransform2.sizeDelta = new Vector2(6f, 0f);
			SetRect(((TMP_Text)CreateTmp(((Component)obj).transform, "Header", "JOIN QUEUE", 24f, Accent, (FontStyles)1)).rectTransform, 28f, -22f, 400f, 32f);
			_title = CreateTmp(((Component)obj).transform, "Title", "", 20f, Text, (FontStyles)1);
			SetRect(((TMP_Text)_title).rectTransform, 28f, -60f, 580f, 30f);
			_tip = CreateTmp(((Component)obj).transform, "Tip", "", 16f, Muted, (FontStyles)0);
			SetRect(((TMP_Text)_tip).rectTransform, 28f, -100f, 580f, 48f);
			((TMP_Text)_tip).enableWordWrapping = true;
			_position = CreateTmp(((Component)obj).transform, "Position", "", 18f, Text, (FontStyles)1);
			SetRect(((TMP_Text)_position).rectTransform, 28f, -160f, 580f, 28f);
			_gameTime = CreateTmp(((Component)obj).transform, "GameTime", "Moon time: —", 16f, Accent, (FontStyles)0);
			SetRect(((TMP_Text)_gameTime).rectTransform, 28f, -192f, 580f, 26f);
			_status = CreateTmp(((Component)obj).transform, "Status", "", 15f, Muted, (FontStyles)0);
			SetRect(((TMP_Text)_status).rectTransform, 28f, -224f, 580f, 40f);
			((TMP_Text)_status).enableWordWrapping = true;
			Button obj2 = CreateButton(((Component)obj).transform, "Cancel", "CANCEL");
			SetRect(((Component)obj2).GetComponent<RectTransform>(), 28f, -290f, 160f, 44f);
			ButtonClickedEvent onClick = obj2.onClick;
			object obj3 = <>c.<>9__47_0;
			if (obj3 == null)
			{
				UnityAction val = delegate
				{
					ForceClose();
				};
				<>c.<>9__47_0 = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
		}

		private static TMP_FontAsset? FindMenuFont()
		{
			try
			{
				TextMeshProUGUI val = Object.FindObjectOfType<TextMeshProUGUI>();
				if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
				{
					return ((TMP_Text)val).font;
				}
			}
			catch
			{
			}
			return TMP_Settings.defaultFontAsset;
		}

		private static Image CreateImage(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			return component;
		}

		private static TextMeshProUGUI CreateTmp(Transform parent, string name, string text, float size, Color color, FontStyles style)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val2).font = _font;
			}
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = size;
			((Graphic)val2).color = color;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).raycastTarget = false;
			return val2;
		}

		private static Button CreateButton(Transform parent, string name, string label)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0050: 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)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = BtnBg;
			Button component = val.GetComponent<Button>();
			TextMeshProUGUI obj = CreateTmp(val.transform, "Label", label, 16f, Accent, (FontStyles)1);
			Stretch(((TMP_Text)obj).rectTransform);
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			return component;
		}

		private static void Stretch(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		private static void SetRect(RectTransform rt, float x, float y, float w, float h)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 1f);
			rt.anchoredPosition = new Vector2(x, y);
			rt.sizeDelta = new Vector2(w, h);
		}
	}
	[HarmonyPatch(typeof(LobbySlot), "JoinButton")]
	internal static class JoinPasswordGatePatch
	{
		private static int _handledJoinFrame = -1;

		[HarmonyPrefix]
		private static bool Prefix(LobbySlot __instance)
		{
			//IL_0092: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Time.frameCount == _handledJoinFrame)
				{
					return false;
				}
				_handledJoinFrame = Time.frameCount;
				if (JoinPasswordPrompt.ShouldBlockLobbyJoin || JoinOrbitQueuePrompt.ShouldBlockLobbyJoin)
				{
					return false;
				}
				Lobby lobby = __instance.thisLobby;
				if (!DedicatedLobby.IsDedicatedLobby(lobby))
				{
					return true;
				}
				if (!MenuOverlayLifecycle.MenuUiAllowed)
				{
					return true;
				}
				if (JoinBanGate.TryBlockJoin(lobby))
				{
					return false;
				}
				try
				{
					((Lobby)(ref lobby)).Refresh();
				}
				catch
				{
				}
				if (DedicatedLobby.TryGetClientVersionMismatch(lobby, out string message))
				{
					JoinBanGate.ShowJoinDenied(message);
					Plugin.Log.LogInfo((object)message.Replace('\n', ' '));
					return false;
				}
				if (RejoinClientFixes.ShouldBlockRapidRejoin(out string message2))
				{
					JoinBanGate.ShowTipOnly("Wait", message2);
					Plugin.Log.LogInfo((object)message2.Replace('\n', ' '));
					return false;
				}
				SteamId lobbyId = __instance.lobbyId;
				bool num = DedicatedLobby.RequiresPassword(lobby);
				bool flag = DedicatedLobby.IsQueueableLobby(lobby);
				if (num)
				{
					string expectedHash = DedicatedLobby.ExpectedPasswordHash(lobby);
					JoinPasswordPrompt.Request(lobby, lobbyId, expectedHash, delegate
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0021: 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_000e: 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)
						try
						{
							if (DedicatedLobby.IsQueueableLobby(lobby))
							{
								JoinOrbitQueuePrompt.Request(lobby, lobbyId);
							}
							else
							{
								LobbySlot.JoinLobbyAfterVerifying(lobby, lobbyId);
							}
						}
						catch (Exception ex2)
						{
							Plugin.Log.LogWarning((object)("Password join failed: " + ex2.Message));
						}
					});
					return false;
				}
				if (flag)
				{
					JoinOrbitQueuePrompt.Request(lobby, lobbyId);
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("JoinPasswordGate: " + ex.Message);
				return true;
			}
		}
	}
	internal static class JoinPasswordPrompt
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<char> <0>__OnTextInput;

			public static UnityAction <1>__Cancel;

			public static UnityAction <2>__TrySubmit;
		}

		private static GameObject? _root;

		private static TextMeshProUGUI? _title;

		private static TextMeshProUGUI? _subtitle;

		private static TextMeshProUGUI? _error;

		private static TextMeshProUGUI? _fieldDisplay;

		private static string _input = "";

		private static string _expectedHash = "";

		private static Action? _onSuccess;

		private static bool _listening;

		private static bool _kbHooked;

		private static int _blockLobbyJoinUntilFrame = -1;

		private static int _ignoreEnterUntilFrame = -1;

		private static readonly Color PanelBg = new Color(0.07f, 0.075f, 0.08f, 0.98f);

		private static readonly Color Accent = new Color(0.91f, 0.62f, 0.12f, 1f);

		private static readonly Color Text = new Color(0.95f, 0.93f, 0.86f, 1f);

		private static readonly Color Muted = new Color(0.62f, 0.64f, 0.6f, 1f);

		private static readonly Color FieldBg = new Color(0.04f, 0.04f, 0.045f, 1f);

		private static readonly Color BtnBg = new Color(0.16f, 0.14f, 0.09f, 1f);

		private static readonly Color Err = new Color(0.95f, 0.4f, 0.32f, 1f);

		private static Keyboard? _hookedKb;

		public static bool IsOpen
		{
			get
			{
				if (_listening)
				{
					return (Object)(object)_root != (Object)null;
				}
				return false;
			}
		}

		public static bool ShouldBlockLobbyJoin
		{
			get
			{
				if (!IsOpen)
				{
					return Time.frameCount <= _blockLobbyJoinUntilFrame;
				}
				return true;
			}
		}

		public unsafe static void Request(Lobby lobby, SteamId lobbyId, string expectedHash, Action onSuccess)
		{
			if (!MenuOverlayLifecycle.MenuUiAllowed)
			{
				Plugin.Log.LogWarning((object)"Password prompt blocked — menu UI not active.");
				return;
			}
			_expectedHash = expectedHash ?? "";
			_onSuccess = onSuccess;
			string text;
			try
			{
				text = ((Lobby)(ref lobby)).GetData("name") ?? ((object)(*(SteamId*)(&lobbyId))/*cast due to .constrained prefix*/).ToString();
			}
			catch
			{
				text = "Dedicated";
			}
			if (IsOpen)
			{
				if ((Object)(object)_subtitle != (Object)null)
				{
					((TMP_Text)_subtitle).text = text;
				}
				Plugin.DebugLog("Password prompt already open; updated callback only.");
			}
			else
			{
				Plugin.Log.LogInfo((object)("Password required for lobby \"" + text + "\"."));
				Show(text);
			}
		}

		public static void ForceClose()
		{
			_onSuccess = null;
			DestroyUi();
		}

		public static void Tick()
		{
			if (!_listening || (Object)(object)_root == (Object)null || !_root.activeSelf)
			{
				return;
			}
			Keyboard current = Keyboard.current;
			if (current != null)
			{
				if (Time.frameCount > _ignoreEnterUntilFrame && (((ButtonControl)current.enterKey).wasPressedThisFrame || ((ButtonControl)current.numpadEnterKey).wasPressedThisFrame))
				{
					TrySubmit();
				}
				else if (((ButtonControl)current.escapeKey).wasPressedThisFrame)
				{
					Cancel();
				}
				else if (((ButtonControl)current.backspaceKey).wasPressedThisFrame && _input.Length > 0)
				{
					_input = _input.Substring(0, _input.Length - 1);
					RefreshFieldDisplay();
				}
			}
		}

		private static void OnTextInput(char c)
		{
			if (_listening && !((Object)(object)_root == (Object)null) && _root.activeSelf && !char.IsControl(c) && _input.Length < 64)
			{
				_input += c;
				RefreshFieldDisplay();
			}
		}

		private static void HookKeyboard(bool on)
		{
			if (on)
			{
				Keyboard current = Keyboard.current;
				if (current == null)
				{
					return;
				}
				if (_kbHooked && _hookedKb != null && _hookedKb != current)
				{
					try
					{
						_hookedKb.onTextInput -= OnTextInput;
					}
					catch
					{
					}
					_kbHooked = false;
					_hookedKb = null;
				}
				if (!_kbHooked)
				{
					current.onTextInput += OnTextInput;
					_hookedKb = current;
					_kbHooked = true;
				}
				return;
			}
			if (_hookedKb != null)
			{
				try
				{
					_hookedKb.onTextInput -= OnTextInput;
				}
				catch
				{
				}
			}
			try
			{
				Keyboard current2 = Keyboard.current;
				if (current2 != null)
				{
					current2.onTextInput -= OnTextInput;
				}
			}
			catch
			{
			}
			_hookedKb = null;
			_kbHooked = false;
		}

		private static void ClearUiSelection()
		{
			try
			{
				if ((Object)(object)EventSystem.current != (Object)null)
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
			}
			catch
			{
			}
		}

		private static void Show(string lobbyTitle)
		{
			DedicatedModsModal.ForceClose();
			JoinOrbitQueuePrompt.ForceClose();
			DestroyUi();
			Build();
			if (!((Object)(object)_root == (Object)null) && !((Object)(object)_title == (Object)null))
			{
				_input = "";
				((TMP_Text)_title).text = "PASSWORD REQUIRED";
				if ((Object)(object)_subtitle != (Object)null)
				{
					((TMP_Text)_subtitle).text = lobbyTitle;
				}
				if ((Object)(object)_error != (Object)null)
				{
					((TMP_Text)_error).text = "";
				}
				RefreshFieldDisplay();
				_root.SetActive(true);
				_listening = true;
				_ignoreEnterUntilFrame = Time.frameCount + 2;
				ClearUiSelection();
				HookKeyboard(on: true);
				Plugin.DebugLog("Password prompt shown.");
			}
		}

		private static void RefreshFieldDisplay()
		{
			if (!((Object)(object)_fieldDisplay == (Object)null))
			{
				((TMP_Text)_fieldDisplay).text = ((_input.Length == 0) ? "<color=#7A7E78>type password…</color>" : new string('•', _input.Length));
			}
		}

		private static void TrySubmit()
		{
			if (!_listening)
			{
				return;
			}
			string a = Sha256Hex(_input ?? "");
			if (string.IsNullOrEmpty(_expectedHash) || !string.Equals(a, _expectedHash, StringComparison.OrdinalIgnoreCase))
			{
				if ((Object)(object)_error != (Object)null)
				{
					((TMP_Text)_error).text = "Wrong password.";
				}
				_input = "";
				RefreshFieldDisplay();
				ClearUiSelection();
				Plugin.DebugLog("Password rejected.");
				return;
			}
			Action onSuccess = _onSuccess;
			_onSuccess = null;
			_blockLobbyJoinUntilFrame = Time.frameCount + 5;
			DestroyUi();
			ClearUiSelection();
			Plugin.Log.LogInfo((object)"Password accepted — joining lobby.");
			try
			{
				onSuccess?.Invoke();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Password join invoke failed: " + ex.Message));
			}
		}

		private static void Cancel()
		{
			_onSuccess = null;
			DestroyUi();
			ClearUiSelection();
			DedicatedLobby.ClearSessionDedicated("password-cancel");
			MoreCompanyLobbyMatch.ClearPending("password-cancel");
		}

		private static void DestroyUi()
		{
			_listening = false;
			HookKeyboard(on: false);
			_input = "";
			_title = null;
			_subtitle = null;
			_error = null;
			_fieldDisplay = null;
			if (!((Object)(object)_root != (Object)null))
			{
				return;
			}
			GameObject root = _root;
			_root = null;
			try
			{
				GraphicRaycaster[] componentsInChildren = root.GetComponentsInChildren<GraphicRaycaster>(true);
				foreach (GraphicRaycaster val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						((Behaviour)val).enabled = false;
					}
				}
				root.SetActive(false);
			}
			catch
			{
			}
			Object.Destroy((Object)(object)root);
		}

		private static void Build()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Expected O, but got Unknown
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Expected O, but got Unknown
			TMP_FontAsset font = FindMenuFont();
			_root = ((Component)MenuOverlayLifecycle.CreateOverlayCanvas("UEXP_PasswordPrompt", 6000)).gameObject;
			_root.AddComponent<PasswordPromptHost>();
			Image obj = CreateImage(_root.transform, "Dim", new Color(0.01f, 0.01f, 0.015f, 0.82f));
			StretchFull(((Graphic)obj).rectTransform);
			((Graphic)obj).raycastTarget = true;
			Button obj2 = ((Component)obj).gameObject.AddComponent<Button>();
			((Selectable)obj2).transition = (Transition)0;
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)obj2).navigation = navigation;
			ButtonClickedEvent onClick = obj2.onClick;
			object obj3 = <>O.<1>__Cancel;
			if (obj3 == null)
			{
				UnityAction val = Cancel;
				<>O.<1>__Cancel = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			Image val2 = CreateImage(_root.transform, "Panel", PanelBg);
			((Graphic)val2).raycastTarget = true;
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.sizeDelta = new Vector2(620f, 280f);
			Image obj4 = CreateImage(((Component)val2).transform, "Accent", Accent);
			((Graphic)obj4).raycastTarget = false;
			RectTransform rectTransform2 = ((Graphic)obj4).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(0f, 1f);
			rectTransform2.pivot = new Vector2(0f, 0.5f);
			rectTransform2.sizeDelta = new Vector2(6f, 0f);
			_title = CreateTmp(((Component)val2).transform, "Title", "PASSWORD REQUIRED", 26f, Accent, font, (FontStyles)1);
			SetRect(((TMP_Text)_title).rectTransform, 28f, -24f, 560f, 36f);
			_subtitle = CreateTmp(((Component)val2).transform, "Subtitle", "", 18f, Text, font, (FontStyles)0);
			SetRect(((TMP_Text)_subtitle).rectTransform, 28f, -64f, 560f, 28f);
			SetRect(((TMP_Text)CreateTmp(((Component)val2).transform, "Hint", "Type password, then JOIN (Enter).", 14f, Muted, font, (FontStyles)0)).rectTransform, 28f, -96f, 560f, 22f);
			GameObject val3 = new GameObject("Field", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(((Component)val2).transform, false);
			Image component = val3.GetComponent<Image>();
			((Graphic)component).color = FieldBg;
			((Graphic)component).raycastTarget = true;
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = new Vector2(0f, -130f);
			component2.sizeDelta = new Vector2(-56f, 48f);
			_fieldDisplay = CreateTmp(val3.transform, "Display", "", 22f, Text, font, (FontStyles)0);
			StretchFull(((TMP_Text)_fieldDisplay).rectTransform);
			((TMP_Text)_fieldDisplay).margin = new Vector4(14f, 4f, 14f, 4f);
			((TMP_Text)_fieldDisplay).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)_fieldDisplay).richText = true;
			_error = CreateTmp(((Component)val2).transform, "Error", "", 15f, Err, font, (FontStyles)1);
			SetRect(((TMP_Text)_error).rectTransform, 28f, -190f, 560f, 24f);
			Button obj5 = CreateButton(((Component)val2).transform, "Join", "JOIN", font);
			SetRect(((Component)obj5).GetComponent<RectTransform>(), 28f, -224f, 140f, 40f);
			ButtonClickedEvent onClick2 = obj5.onClick;
			object obj6 = <>O.<2>__TrySubmit;
			if (obj6 == null)
			{
				UnityAction val4 = TrySubmit;
				<>O.<2>__TrySubmit = val4;
				obj6 = (object)val4;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj6);
			Button obj7 = CreateButton(((Component)val2).transform, "Cancel", "CANCEL", font);
			SetRect(((Component)obj7).GetComponent<RectTransform>(), 184f, -224f, 140f, 40f);
			ButtonClickedEvent onClick3 = obj7.onClick;
			object obj8 = <>O.<1>__Cancel;
			if (obj8 == null)
			{
				UnityAction val5 = Cancel;
				<>O.<1>__Cancel = val5;
				obj8 = (object)val5;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj8);
		}

		private static TMP_FontAsset? FindMenuFont()
		{
			try
			{
				TextMeshProUGUI val = Object.FindObjectOfType<TextMeshProUGUI>();
				if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
				{
					return ((TMP_Text)val).font;
				}
			}
			catch
			{
			}
			return TMP_Settings.defaultFontAsset;
		}

		private static Image CreateImage(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = color;
			return component;
		}

		private static TextMeshProUGUI CreateTmp(Transform parent, string name, string text, float size, Color color, TMP_FontAsset? font, FontStyles style)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val2).font = font;
			}
			((TMP_Text)val2).text = text;
			((TMP_Text)val2).fontSize = size;
			((Graphic)val2).color = color;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).raycastTarget = false;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			return val2;
		}

		private static Button CreateButton(Transform parent, string name, string label, TMP_FontAsset? font)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = BtnBg;
			Button component = val.GetComponent<Button>();
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component).navigation = navigation;
			ColorBlock colors = ((Selectable)component).colors;
			((ColorBlock)(ref colors)).normalColor = BtnBg;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.28f, 0.22f, 0.1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.35f, 0.28f, 0.12f, 1f);
			((Selectable)component).colors = colors;
			TextMeshProUGUI obj = CreateTmp(val.transform, "Label", label, 16f, Accent, font, (FontStyles)1);
			StretchFull(((TMP_Text)obj).rectTransform);
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			return component;
		}

		private static void StretchFull(RectTransform rt)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = Vector2.zero;
			rt.offsetMax = Vector2.zero;
		}

		private static void SetRect(RectTransform rt, float x, float y, float w, float h)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 1f);
			rt.anchoredPosition = new Vector2(x, y);
			rt.sizeDelta = new Vector2(w, h);
		}

		private static string Sha256Hex(string value)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(value));
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class PasswordPromptHost : MonoBehaviour
	{
		private void Update()
		{
			JoinPasswordPrompt.Tick();
		}
	}
	[HarmonyPatch(typeof(StartMatchLever))]
	internal static class StartMatchLeverPatches
	{
		private static bool WantClientLever()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(StartMatchLever __instance)
		{
			if (WantClientLever() && !((NetworkBehaviour)__instance).IsServer && !((Object)(object)__instance.triggerScript == (Object)null))
			{
				__instance.triggerScript.interactable = true;
				bool flag = (Object)(object)GameNetworkManager.Instance != (Object)null && GameNetworkManager.Instance.gameHasStarted;
				__instance.triggerScript.hoverTip = (flag ? "Land ship : [LMB]" : "Start game : [LMB]");
				Plugin.DebugLog("Client lever unlocked (dedicated lobby).");
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static void Update_Prefix(StartMatchLever __instance)
		{
			if (WantClientLever() && !((NetworkBehaviour)__instance).IsServer && !((Object)(object)__instance.triggerScript == (Object)null) && !__instance.leverHasBeenPulled)
			{
				StartOfRound val = __instance.playersManager ?? StartOfRound.Instance;
				if ((!((Object)(object)val != (Object)null) || (!val.shipIsLeaving && !val.shipLeftAutomatically)) && !__instance.triggerScript.interactable)
				{
					__instance.triggerScript.interactable = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
	internal static class SetShipReadyToLandLeverPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (DedicatedLobby.IsCurrentLobbyDedicated())
			{
				StartMatchLever val = Object.FindObjectOfType<StartMatchLever>();
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.triggerScript == (Object)null) && !((NetworkBehaviour)val).IsServer)
				{
					val.triggerScript.interactable = true;
					val.triggerScript.hoverTip = "Land ship : [LMB]";
				}
			}
		}
	}
	[HarmonyPatch(typeof(QuickMenuManager))]
	internal static class QuickMenuCrewListPatches
	{
		private static Vector2[]? _baseAnchoredPositions;

		private static float _slotStepY = -42f;

		private static bool WantHideHostSeat()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		[HarmonyPatch("AddUserToPlayerList")]
		[HarmonyPrefix]
		private static bool AddUserToPlayerList_Prefix(int playerObjectId)
		{
			if (playerObjectId != 0)
			{
				return true;
			}
			if (!WantHideHostSeat())
			{
				return true;
			}
			Plugin.DebugLog("Crew list: skipped adding host seat 0.");
			return false;
		}

		[HarmonyPatch("AddUserToPlayerList")]
		[HarmonyPostfix]
		private static void AddUserToPlayerList_Postfix(QuickMenuManager __instance, string playerName, int playerObjectId)
		{
			if (!WantHideHostSeat())
			{
				return;
			}
			try
			{
				if (playerObjectId > 0 && __instance.playerListSlots != null && playerObjectId < __instance.playerListSlots.Length)
				{
					PlayerListSlot val = __instance.playerListSlots[playerObjectId];
					if ((Object)(object)val?.usernameHeader != (Object)null)
					{
						((TMP_Text)val.usernameHeader).text = DisplaySafeName(playerName, playerObjectId, val.usernameHeader);
						RoleNameColors.ApplyHeaderColor(val.usernameHeader, playerObjectId);
					}
				}
			}
			catch
			{
			}
			CompactCrewListVisual(__instance);
			RepairCrewListNames(__instance);
		}

		[HarmonyPatch("OpenQuickMenu")]
		[HarmonyPostfix]
		private static void OpenQuickMenu_Postfix(QuickMenuManager __instance)
		{
			if (WantHideHostSeat())
			{
				try
				{
					__instance.RemoveUserFromPlayerList(0);
				}
				catch
				{
				}
				CompactCrewListVisual(__instance);
				RepairCrewListNames(__instance);
			}
		}

		[HarmonyPatch("RemoveUserFromPlayerList")]
		[HarmonyPostfix]
		private static void RemoveUserFromPlayerList_Postfix(QuickMenuManager __instance)
		{
			if (WantHideHostSeat())
			{
				CompactCrewListVisual(__instance);
				RepairCrewListNames(__instance);
			}
		}

		internal static void RepairCrewListNames(QuickMenuManager menu)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (menu?.playerListSlots == null)
			{
				return;
			}
			PlayerControllerB[] array = StartOfRound.Instance?.allPlayerScripts;
			for (int i = 1; i < menu.playerListSlots.Length; i++)
			{
				PlayerListSlot val = menu.playerListSlots[i];
				if (val == null || !val.isConnected || (Object)(object)val.usernameHeader == (Object)null)
				{
					continue;
				}
				string text = ((TMP_Text)val.usernameHeader).text ?? "";
				if (array != null && i < array.Length && (Object)(object)array[i] != (Object)null)
				{
					string playerUsername = array[i].playerUsername;
					if (!string.IsNullOrWhiteSpace(playerUsername))
					{
						text = playerUsername;
					}
				}
				if (val.playerSteamId != 0L && (string.IsNullOrWhiteSpace(text) || LooksLikeTofu(text, val.usernameHeader)))
				{
					try
					{
						Friend val2 = new Friend(SteamId.op_Implicit(val.playerSteamId));
						string name = ((Friend)(ref val2)).Name;
						if (!string.IsNullOrWhiteSpace(name))
						{
							text = name;
						}
					}
					catch
					{
					}
				}
				((TMP_Text)val.usernameHeader).text = DisplaySafeName(text, i, val.usernameHeader);
				RoleNameColors.ApplyHeaderColor(val.usernameHeader, i);
			}
		}

		private static bool LooksLikeTofu(string text, TextMeshProUGUI header)
		{
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			TMP_FontAsset font = ((TMP_Text)header).font;
			if ((Object)(object)font == (Object)null)
			{
				return false;
			}
			foreach (char c in text)
			{
				if (!char.IsWhiteSpace(c) && !FontHasChar(font, c))
				{
					return true;
				}
			}
			return false;
		}

		private static bool FontHasChar(TMP_FontAsset font, char c)
		{
			try
			{
				return font.HasCharacter(c, true, false);
			}
			catch
			{
				try
				{
					return font.HasCharacters(c.ToString());
				}
				catch
				{
					return c <= '\u007f';
				}
			}
		}

		private static string DisplaySafeName(string? name, int objectId, TextMeshProUGUI? header)
		{
			string text = (name ?? "").Trim();
			if (text.Length == 0)
			{
				return $"Player {objectId}";
			}
			ulong steamId = 0uL;
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts != null && objectId >= 0 && objectId < instance.allPlayerScripts.Length && (Object)(object)instance.allPlayerScripts[objectId] != (Object)null)
				{
					steamId = RoleNameColors.EffectiveSteamId(instance.allPlayerScripts[objectId]);
				}
			}
			catch
			{
			}
			bool flag = RoleNameColors.IsDeveloperRole(steamId);
			if (flag)
			{
				text = RoleNameColors.StripDevPrefix(text);
			}
			TMP_FontAsset val = (((Object)(object)header != (Object)null) ? ((TMP_Text)header).font : null);
			bool flag2 = false;
			if ((Object)(object)val != (Object)null)
			{
				string text2 = text;
				foreach (char c in text2)
				{
					if (!char.IsWhiteSpace(c) && !FontHasChar(val, c))
					{
						flag2 = true;
						break;
					}
				}
			}
			string text3;
			if (!flag2)
			{
				text3 = ((text.Length > 24) ? text.Substring(0, 24) : text);
			}
			else
			{
				StringBuilder stringBuilder = new StringBuilder(text.Length);
				string text2 = text;
				foreach (char c2 in text2)
				{
					if (c2 <= '\u007f' && (char.IsLetterOrDigit(c2) || c2 == '_' || c2 == '.' || c2 == '-' || c2 == ' '))
					{
						stringBuilder.Append(c2);
					}
				}
				string text4 = stringBuilder.ToString().Trim();
				text3 = ((text4.Length < 1) ? $"Player {objectId}" : ((text4.Length > 24) ? text4.Substring(0, 24) : text4));
			}
			if (!flag)
			{
				return text3;
			}
			return RoleNameColors.WithDevPrefix(text3);
		}

		internal static void CompactCrewListVisual(QuickMenuManager menu)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if (menu?.playerListSlots == null || menu.playerListSlots.Length == 0)
			{
				return;
			}
			try
			{
				PlayerListSlot[] playerListSlots = menu.playerListSlots;
				CacheBaseLayout(playerListSlots);
				PlayerListSlot val = playerListSlots[0];
				if (val != null)
				{
					val.isConnected = false;
					if ((Object)(object)val.slotContainer != (Object)null)
					{
						val.slotContainer.SetActive(false);
					}
				}
				List<PlayerListSlot> list = new List<PlayerListSlot>();
				for (int i = 1; i < playerListSlots.Length; i++)
				{
					PlayerListSlot val2 = playerListSlots[i];
					if (val2 == null)
					{
						continue;
					}
					if (!val2.isConnected)
					{
						if ((Object)(object)val2.slotContainer != (Object)null)
						{
							val2.slotContainer.SetActive(false);
						}
					}
					else
					{
						list.Add(val2);
					}
				}
				if (_baseAnchoredPositions == null || _baseAnchoredPositions.Length == 0)
				{
					return;
				}
				Vector2 val3 = _baseAnchoredPositions[0];
				for (int j = 0; j < list.Count; j++)
				{
					PlayerListSlot val4 = list[j];
					if (!((Object)(object)val4.slotContainer == (Object)null))
					{
						val4.slotContainer.SetActive(true);
						Transform transform = val4.slotContainer.transform;
						RectTransform val5 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
						if (!((Object)(object)val5 == (Object)null))
						{
							val5.anchoredPosition = new Vector2(val3.x, val3.y + _slotStepY * (float)j);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("CompactCrewListVisual: " + ex.Message);
			}
		}

		private static void CacheBaseLayout(PlayerListSlot[] slots)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (_baseAnchoredPositions != null && _baseAnchoredPositions.Length == slots.Length)
			{
				return;
			}
			_baseAnchoredPositions = (Vector2[]?)(object)new Vector2[slots.Length];
			for (int i = 0; i < slots.Length; i++)
			{
				PlayerListSlot val = slots[i];
				if (!((Object)(object)val?.slotContainer == (Object)null))
				{
					Transform transform = val.slotContainer.transform;
					RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					if (val2 != null)
					{
						_baseAnchoredPositions[i] = val2.anchoredPosition;
					}
				}
			}
			if (slots.Length <= 1 || !((Object)(object)slots[0]?.slotContainer != (Object)null) || !((Object)(object)slots[1]?.slotContainer != (Object)null))
			{
				return;
			}
			Transform transform2 = slots[0].slotContainer.transform;
			RectTransform val3 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if (val3 == null)
			{
				return;
			}
			Transform transform3 = slots[1].slotContainer.transform;
			RectTransform val4 = (RectTransform)(object)((transform3 is RectTransform) ? transform3 : null);
			if (val4 != null)
			{
				float num = val4.anchoredPosition.y - val3.anchoredPosition.y;
				if (Mathf.Abs(num) > 1f)
				{
					_slotStepY = num;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
	internal static class CrewListHostHideOnJoin
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				QuickMenuManager val = Object.FindObjectOfType<QuickMenuManager>();
				if (!((Object)(object)val == (Object)null))
				{
					val.RemoveUserFromPlayerList(0);
					QuickMenuCrewListPatches.CompactCrewListVisual(val);
					QuickMenuCrewListPatches.RepairCrewListNames(val);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")]
	internal static class CrewListNameSyncPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				QuickMenuManager val = Object.FindObjectOfType<QuickMenuManager>();
				if (!((Object)(object)val == (Object)null))
				{
					QuickMenuCrewListPatches.RepairCrewListNames(val);
				}
			}
			catch
			{
			}
		}
	}
	internal static class LivingPlayersClient
	{
		public static void Ensure(string reason)
		{
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if (instance?.allPlayerScripts == null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				if (i != 0)
				{
					PlayerControllerB val = instance.allPlayerScripts[i];
					if (!((Object)(object)val == (Object)null) && !val.isPlayerDead && val.isPlayerControlled)
					{
						num++;
					}
				}
			}
			if (instance.livingPlayers != num)
			{
				Plugin.DebugLog($"client livingPlayers {instance.livingPlayers}->{num} ({reason}).");
				instance.livingPlayers = num;
			}
		}
	}
	[HarmonyPatch]
	internal static class LocalOwnerSpawnMeshGuard
	{
		[HarmonyPatch(typeof(PlayerControllerB), "SpawnPlayerAnimation")]
		[HarmonyPostfix]
		private static void Spawn_Postfix(PlayerControllerB __instance)
		{
			if (!ShouldGuard(__instance))
			{
				return;
			}
			Apply(__instance, "SpawnPlayerAnimation");
			try
			{
				((MonoBehaviour)__instance).StartCoroutine(DelayedReassert(__instance));
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DisablePlayerModel")]
		[HarmonyPostfix]
		private static void DisablePlayerModel_Postfix(PlayerControllerB __instance, bool enable)
		{
			if (enable && ShouldGuard(__instance))
			{
				Apply(__instance, "DisablePlayerModel");
			}
		}

		private static bool ShouldGuard(PlayerControllerB? player)
		{
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return false;
			}
			if ((Object)(object)player == (Object)null || !((NetworkBehaviour)player).IsOwner || player.isPlayerDead)
			{
				return false;
			}
			if (GhostSeat.IsGhost(player) && !((NetworkBehaviour)player).IsOwner)
			{
				return false;
			}
			return true;
		}

		private static IEnumerator DelayedReassert(PlayerControllerB player)
		{
			yield return (object)new WaitForSeconds(2f);
			Apply(player, "delayed");
		}

		internal static void Apply(PlayerControllerB? player, string reason)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			if ((Object)(object)player == (Object)null || !((NetworkBehaviour)player).IsOwner || player.isPlayerDead || (Object)(object)player.gameplayCamera == (Object)null || !((Behaviour)player.gameplayCamera).enabled)
			{
				return;
			}
			try
			{
				if ((Object)(object)player.thisPlayerModel != (Object)null && (int)((Renderer)player.thisPlayerModel).shadowCastingMode != 3)
				{
					((Renderer)player.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)3;
					Plugin.DebugLog("FP body re-asserted ShadowsOnly (" + reason + ").");
				}
				if ((Object)(object)player.thisPlayerModelLOD1 != (Object)null && ((Renderer)player.thisPlayerModelLOD1).enabled)
				{
					((Renderer)player.thisPlayerModelLOD1).shadowCastingMode = (ShadowCastingMode)3;
				}
				if ((Object)(object)player.thisPlayerModelLOD2 != (Object)null && ((Renderer)player.thisPlayerModelLOD2).enabled)
				{
					((Renderer)player.thisPlayerModelLOD2).shadowCastingMode = (ShadowCastingMode)3;
				}
				if ((Object)(object)player.thisPlayerModelArms != (Object)null)
				{
					((Renderer)player.thisPlayerModelArms).enabled = true;
					((Renderer)player.thisPlayerModelArms).shadowCastingMode = (ShadowCastingMode)1;
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("LocalOwnerSpawnMeshGuard(" + reason + "): " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager), "Awake")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "me.swipez.melonloader.morecompany" })]
	internal static class MenuLogoOverridePatch
	{
		private const string LooseFileName = "uexp-dedicated-company-logo.png";

		private const float HeaderScaleMul = 0.68f;

		private const float LoadingLogoScaleMul = 0.52f;

		private const float LoadingLogoYNudge = 48f;

		private static Sprite? _logoSprite;

		private static bool _loadAttempted;

		private static Vector3? _headerBaseScale;

		private static Vector3? _loadingLogoBaseScale;

		private static Vector3? _loadingLogoBasePos;

		[HarmonyPostfix]
		private static void Postfix(MenuManager __instance)
		{
			if (!Plugin.IsEnabled || (Object)(object)__instance == (Object)null || __instance.isInitScene)
			{
				return;
			}
			ApplyLogo(__instance, "Awake");
			try
			{
				((MonoBehaviour)__instance).StartCoroutine(ReapplyNextFrames(__instance));
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Menu logo coroutine failed: " + ex.Message);
			}
		}

		private static IEnumerator ReapplyNextFrames(MenuManager menu)
		{
			yield return null;
			yield return null;
			if ((Object)(object)menu != (Object)null)
			{
				ApplyLogo(menu, "delayed");
			}
		}

		private static void ApplyLogo(MenuManager menu, string reason)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			Sprite logoSprite = GetLogoSprite();
			if ((Object)(object)logoSprite == (Object)null)
			{
				return;
			}
			try
			{
				Transform parent = ((Component)menu).transform.parent;
				if ((Object)(object)parent == (Object)null)
				{
					return;
				}
				Transform val = parent.Find("MenuContainer/MainButtons/HeaderImage");
				if ((Object)(object)val != (Object)null)
				{
					FitImage(val, logoSprite, 0.68f, 0f, isHeader: true);
				}
				Transform val2 = parent.Find("MenuContainer/LoadingScreen");
				if ((Object)(object)val2 != (Object)null)
				{
					try
					{
						if (val2.localScale.y > 1.01f)
						{
							val2.localScale = new Vector3(1f, 1f, 1f);
						}
					}
					catch
					{
					}
					Transform val3 = val2.Find("Image");
					if ((Object)(object)val3 != (Object)null)
					{
						FitImage(val3, logoSprite, 0.52f, 48f, isHeader: false);
					}
				}
				Plugin.DebugLog("Menu logo applied (" + reason + ").");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Menu logo apply failed (" + reason + "): " + ex.Message));
			}
		}

		private static void FitImage(Transform target, Sprite sprite, float scaleMul, float yNudge, bool isHeader)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)target).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				component.sprite = sprite;
				component.preserveAspect = true;
			}
			Vector3 valueOrDefault;
			if (isHeader)
			{
				valueOrDefault = _headerBaseScale.GetValueOrDefault();
				if (!_headerBaseScale.HasValue)
				{
					valueOrDefault = target.localScale;
					_headerBaseScale = valueOrDefault;
				}
				target.localScale = _headerBaseScale.Value * scaleMul;
				return;
			}
			valueOrDefault = _loadingLogoBaseScale.GetValueOrDefault();
			if (!_loadingLogoBaseScale.HasValue)
			{
				valueOrDefault = target.localScale;
				_loadingLogoBaseScale = valueOrDefault;
			}
			valueOrDefault = _loadingLogoBasePos.GetValueOrDefault();
			if (!_loadingLogoBasePos.HasValue)
			{
				valueOrDefault = target.localPosition;
				_loadingLogoBasePos = valueOrDefault;
			}
			target.localScale = _loadingLogoBaseScale.Value * scaleMul;
			Vector3 value = _loadingLogoBasePos.Value;
			value.y += yNudge;
			target.localPosition = value;
		}

		private static Sprite? GetLogoSprite()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_logoSprite != (Object)null)
			{
				return _logoSprite;
			}
			if (_loadAttempted)
			{
				return null;
			}
			_loadAttempted = true;
			try
			{
				byte[] array = ReadLogoBytes();
				if (array == null || array.Length == 0)
				{
					Plugin.Log.LogWarning((object)"UEXP menu logo PNG not found (embedded or beside DLL).");
					return null;
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array, true))
				{
					Plugin.Log.LogWarning((object)"UEXP menu logo LoadImage failed.");
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Texture)val).filterMode = (FilterMode)1;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				_logoSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				Plugin.Log.LogInfo((object)$"UEXP menu logo loaded ({((Texture)val).width}x{((Texture)val).height}).");
				return _logoSprite;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("UEXP menu logo load failed: " + ex.Message));
				return null;
			}
		}

		private static byte[]? ReadLogoBytes()
		{
			Assembly assembly = typeof(MenuLogoOverridePatch).Assembly;
			try
			{
				string text = null;
				string[] manifestResourceNames = assembly.GetManifestResourceNames();
				foreach (string text2 in manifestResourceNames)
				{
					if (text2.EndsWith("uexp-dedicated-company-logo.png", StringComparison.OrdinalIgnoreCase))
					{
						text = text2;
						break;
					}
				}
				if (text != null)
				{
					using Stream stream = assembly.GetManifestResourceStream(text);
					if (stream != null)
					{
						using (MemoryStream memoryStream = new MemoryStream())
						{
							stream.CopyTo(memoryStream);
							return memoryStream.ToArray();
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				string directoryName = Path.GetDirectoryName(assembly.Location);
				if (!string.IsNullOrEmpty(directoryName))
				{
					string path = Path.Combine(directoryName, "uexp-dedicated-company-logo.png");
					if (File.Exists(path))
					{
						return File.ReadAllBytes(path);
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
	internal static class MenuOverlayLifecycle
	{
		public static bool MenuUiAllowed { get; private set; } = true;

		public static void AllowMenuUi()
		{
			MenuUiAllowed = true;
		}

		public static void DisableForGameplay(string reason)
		{
			MenuUiAllowed = false;
			JoinPasswordPrompt.ForceClose();
			DedicatedModsModal.ForceClose();
			JoinOrbitQueuePrompt.ForceClose(!JoinOrbitQueuePrompt.IsJoiningGame && reason.IndexOf("JoinLobbyAfterVerifying", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("SetLoadingScreen", StringComparison.OrdinalIgnoreCase) < 0);
			JoinOrbitQueuePrompt.ClearJoiningFlag();
			DedicatedLobbySoftRefresh.Stop();
			Plugin.DebugLog("Menu overlays disabled (" + reason + ").");
		}

		public static Canvas CreateOverlayCanvas(string name, int sortingOrder)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0041: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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)
			GameObject val = new GameObject(name, new Type[4]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).IsValid())
			{
				SceneManager.MoveGameObjectToScene(val, activeScene);
			}
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Transform)component).localScale = Vector3.one;
			Canvas component2 = val.GetComponent<Canvas>();
			component2.renderMode = (RenderMode)0;
			component2.sortingOrder = sortingOrder;
			component2.overrideSorting = true;
			CanvasScaler component3 = val.GetComponent<CanvasScaler>();
			component3.uiScaleMode = (ScaleMode)1;
			component3.referenceResolution = new Vector2(1920f, 1080f);
			component3.matchWidthOrHeight = 0.5f;
			return component2;
		}
	}
	[HarmonyPatch(typeof(MenuManager), "Start")]
	internal static class MenuOverlayOnMenuStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			MenuOverlayLifecycle.AllowMenuUi();
		}
	}
	[HarmonyPatch(typeof(MenuManager), "ClickJoinButton")]
	internal static class MenuOverlayOnJoinListPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			MenuOverlayLifecycle.AllowMenuUi();
		}
	}
	[HarmonyPatch(typeof(MenuManager), "SetLoadingScreen")]
	internal static class MenuOverlayOnLoadingPatch
	{
		[HarmonyPrefix]
		private static void Prefix(bool isLoading)
		{
			if (isLoading)
			{
				MenuOverlayLifecycle.DisableForGameplay("SetLoadingScreen");
			}
			else
			{
				MenuOverlayLifecycle.AllowMenuUi();
			}
		}
	}
	[HarmonyPatch(typeof(LobbySlot), "JoinLobbyAfterVerifying")]
	internal static class MenuOverlayOnLobbyJoinPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			MenuOverlayLifecycle.DisableForGameplay("JoinLobbyAfterVerifying");
		}
	}
	internal static class MoreCompanyLobbyMatch
	{
		public const string MoreCompanyGuid = "me.swipez.melonloader.morecompany";

		private static int _pendingTotal;

		private static bool _loggedNoMoreCompany;

		internal static int PendingTotal => _pendingTotal;

		public static void ApplyFromLobby(Lobby lobby, string reason)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsEnabled || !DedicatedLobby.IsDedicatedLobby(lobby))
			{
				return;
			}
			if (reason.IndexOf("OnLobbyEntered", StringComparison.OrdinalIgnoreCase) >= 0 || reason.IndexOf("JoinLobbyAfterVerifying", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				DedicatedLobby.MarkSessionDedicated(reason);
			}
			int num = DedicatedLobby.ReadHumanCapacity(lobby);
			if (num >= 1)
			{
				int num2 = (_pendingTotal = ResolveTotalSlots(lobby, num));
				if (!TrySetPlayerCount(num2, out string detail))
				{
					LogMcMissingOrFail(reason, detail);
				}
				else
				{
					Plugin.Log.LogInfo((object)($"MoreCompany Player Count set to {num2} for dedicated join " + $"(host uexpMax={num}). QueueSlots are Steam-only. ({reason}) detail={detail}"));
				}
			}
		}

		public static void OnSteamLobbyEntered(Lobby lobby)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsEnabled)
			{
				return;
			}
			try
			{
				if (DedicatedLobby.IsDedicatedLobby(lobby))
				{
					DedicatedLobby.MarkSessionDedicated("Steam.OnLobbyEntered");
					RoleNameColors.TryPullFromLobby();
					ApplyFromLobby(lobby, "Steam.OnLobbyEntered");
					Plugin.TryPatchMoreCompanyGuardsRetry("OnLobbyEntered");
				}
				else
				{
					DedicatedLobby.ClearSessionDedicated("non-dedicated lobby enter");
					ReapplyPending("Steam.OnLobbyEntered");
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("OnSteamLobbyEntered: " + ex.Message);
			}
		}

		public static void ReapplyPending(string reason)
		{
			if (Plugin.IsEnabled && _pendingTotal >= 4)
			{
				if (!TrySetPlayerCount(_pendingTotal, out string detail))
				{
					LogMcMissingOrFail(reason, detail);
				}
				else if (!detail.StartsWith("already", StringComparison.Ordinal))
				{
					Plugin.Log.LogWarning((object)($"MoreCompany MaxMembers stomp blocked: forced back to {_pendingTotal} before {reason} ({detail}). " + "Steam MaxMembers/QueueSlots must not drive crew size."));
				}
			}
		}

		public static void ClearPending(string reason)
		{
			if (_pendingTotal != 0)
			{
				Plugin.DebugLog($"MoreCompany pending clear ({reason}) was {_pendingTotal}");
				_pendingTotal = 0;
			}
		}

		private static void LogMcMissingOrFail(string reason, string detail)
		{
			if (detail.IndexOf("not loaded", StringComparison.OrdinalIgnoreCase) >= 0 || detail.IndexOf("missing", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				if (!_loggedNoMoreCompany)
				{
					_loggedNoMoreCompany = true;
					Plugin.DebugLog("MoreCompany unavailable (" + reason + "): " + detail);
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)("MoreCompany match failed (" + reason + "): " + detail));
			}
		}

		private static int ResolveTotalSlots(Lobby lobby, int humans)
		{
			try
			{
				string data = ((Lobby)(ref lobby)).GetData("uexpTotal");
				if (!string.IsNullOrEmpty(data) && int.TryParse(data, out var result) && result >= 4)
				{
					return Mathf.Clamp(result, 4, 50);
				}
			}
			catch
			{
			}
			return Mathf.Clamp(humans + 1, 4, 50);
		}

		public static bool TrySetPlayerCount(int totalSlots, out string detail)
		{
			detail = "";
			if (!Chainloader.PluginInfos.ContainsKey("me.swipez.melonloader.morecompany"))
			{
				detail = "MoreCompany not loaded";
				return false;
			}
			try
			{
				Type type = FindMainClass();
				if (type == null)
				{
					detail = "MoreCompany.MainClass missing";
					return false;
				}
				int num = ReadStaticInt(type, "minPlayerCount", 4);
				int num2 = ReadStaticInt(type, "maxPlayerCount", 50);
				int num3 = Mathf.Clamp(totalSlots, num, num2);
				FieldInfo field = type.GetField("newPlayerCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null || field.FieldType != typeof(int))
				{
					detail = "newPlayerCount missing";
					return false;
				}
				int num4 = (int)field.GetValue(null);
				if (num4 == num3)
				{
					detail = $"already {num3}";
					return true;
				}
				field.SetValue(null, num3);
				if (type.GetField("playerCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is ConfigEntry<int> val)
				{
					val.Value = num3;
					try
					{
						object? obj = type.GetField("StaticConfig", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null);
						ConfigFile val2 = (ConfigFile)((obj is ConfigFile) ? obj : null);
						if (val2 != null)
						{
							val2.Save();
						}
					}
					catch
					{
					}
				}
				try
				{
					GameObject val3 = GameObject.Find("MC_CrewCount");
					TMP_InputField val4 = (((Object)(object)val3 != (Object)null) ? val3.GetComponentInChildren<TMP_InputField>(true) : null);
					if ((Object)(object)val4 != (Object)null)
					{
						val4.text = num3.ToString();
					}
				}
				catch
				{
				}
				detail = $"{num4} → {num3}";
				return true;
			}
			catch (Exception ex)
			{
				detail = ex.Message;
				return false;
			}
		}

		private static Type? FindMainClass()
		{
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (pluginInfo.Key.Equals("me.swipez.melonloader.morecompany", StringComparison.OrdinalIgnoreCase))
				{
					Type type = (((object)pluginInfo.Value.Instance)?.GetType().Assembly)?.GetType("MoreCompany.MainClass");
					if (type != null)
					{
						return type;
					}
				}
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type type2 = assembly.GetType("MoreCompany.MainClass");
					if (type2 != null)
					{
						return type2;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static int ReadStaticInt(Type type, string name, int fallback)
		{
			FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(int))
			{
				return (int)field.GetValue(null);
			}
			return fallback;
		}
	}
	[HarmonyPatch(typeof(LobbySlot), "JoinButton")]
	internal static class MoreCompanyMatchOnJoinButtonPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(LobbySlot __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MoreCompanyLobbyMatch.ApplyFromLobby(__instance.thisLobby, "JoinButton");
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(LobbySlot), "JoinLobbyAfterVerifying")]
	internal static class MoreCompanyMatchOnJoinPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(Lobby lobby)
		{
			//IL_0000: 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)
			MoreCompanyLobbyMatch.ApplyFromLobby(lobby, "JoinLobbyAfterVerifying");
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			try
			{
				if (DedicatedLobby.TryGetClientVersionMismatch(lobby, out string message))
				{
					JoinBanGate.ShowJoinDenied(message);
					Plugin.Log.LogInfo((object)message.Replace('\n', ' '));
					return false;
				}
			}
			catch
			{
			}
			return true;
		}
	}
	internal static class MoreCompanyCrewCountUiGuardPatch
	{
		public static bool Prefix(TMP_InputField inputField, string s)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			int pendingTotal = MoreCompanyLobbyMatch.PendingTotal;
			if (pendingTotal < 4)
			{
				return true;
			}
			if (int.TryParse(s, out var result) && result == pendingTotal)
			{
				return true;
			}
			if ((Object)(object)inputField != (Object)null)
			{
				inputField.text = pendingTotal.ToString();
			}
			MoreCompanyLobbyMatch.ReapplyPending("MC_CrewCount.UpdateTextBox");
			return false;
		}
	}
	internal static class MoreCompanyResizeGuardPatch
	{
		public static void Prefix()
		{
			MoreCompanyLobbyMatch.ReapplyPending("ResizePlayerCache");
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "SetConnectionDataBeforeConnecting")]
	internal static class MoreCompanyMatchBeforeConnectPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix()
		{
			MoreCompanyLobbyMatch.ReapplyPending("SetConnectionData");
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Awake")]
	internal static class MoreCompanyMatchOnShipAwakePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix()
		{
			MoreCompanyLobbyMatch.ReapplyPending("StartOfRound.Awake");
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class MoreCompanyMatchClearOnDisconnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			MoreCompanyLobbyMatch.ClearPending("Disconnect");
			DedicatedLobby.ClearSessionDedicated("Disconnect");
			RoleNameColors.Clear("Disconnect");
		}
	}
	internal static class MotdJoinTip
	{
		private static bool _shownThisSession;

		private static string _lastBody = "";

		private static float _shownAt;

		private static bool _coroutineRunning;

		public static void ResetSession()
		{
			_shownThisSession = false;
			_lastBody = "";
			_shownAt = 0f;
			_coroutineRunning = false;
		}

		public static bool ShouldSuppressDuplicate(string body)
		{
			string text = (body ?? "").Trim();
			if (!_shownThisSession || string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (!string.Equals(_lastBody, text, StringComparison.Ordinal))
			{
				return false;
			}
			return Time.realtimeSinceStartup < _shownAt + 60f;
		}

		public static void MarkShown(string body)
		{
			string text = (body ?? "").Trim();
			if (!string.IsNullOrEmpty(text))
			{
				_shownThisSession = true;
				_lastBody = text;
				_shownAt = Time.realtimeSinceStartup;
			}
		}

		public static void ShowIfNeeded(string body)
		{
			string text = (body ?? "").Trim();
			if (!string.IsNullOrEmpty(text) && !ShouldSuppressDuplicate(text))
			{
				MarkShown(text);
				VoteKickClientUi.ShowTip("Admin", Truncate(text, 120));
				Plugin.Log.LogInfo((object)"MOTD tip shown (join).");
			}
		}

		public static void TryStartFromLobby(string reason)
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated() && !_shownThisSession && !_coroutineRunning && !((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(ShowFromLobbyCoroutine(reason));
			}
		}

		internal static IEnumerator ShowFromLobbyCoroutine(string reason = "spawn")
		{
			if (_coroutineRunning)
			{
				yield break;
			}
			_coroutineRunning = true;
			try
			{
				float[] delays = new float[6] { 1.5f, 3f, 5f, 8f, 12f, 18f };
				for (int i = 0; i < delays.Length; i++)
				{
					yield return (object)new WaitForSecondsRealtime(delays[i]);
					if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated() || _shownThisSession)
					{
						yield break;
					}
					string text = "";
					try
					{
						GameNetworkManager instance = GameNetworkManager.Instance;
						if (instance != null && instance.currentLobby.HasValue && instance.currentLobby.HasValue)
						{
							text = DedicatedLobby.ReadMotd(instance.currentLobby.Value);
						}
					}
					catch
					{
						continue;
					}
					if (!string.IsNullOrWhiteSpace(text))
					{
						ShowIfNeeded(text.Trim());
						Plugin.DebugLog($"MOTD lobby backup shown ({reason}, attempt {i + 1}).");
						yield break;
					}
				}
				Plugin.DebugLog("MOTD lobby backup empty after retries (" + reason + ").");
			}
			finally
			{
				_coroutineRunning = false;
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SpawnPlayerAnimation")]
	internal static class MotdJoinTipSpawnPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && ((NetworkBehaviour)__instance).IsOwner)
			{
				MotdJoinTip.TryStartFromLobby("SpawnPlayerAnimation");
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
	internal static class MotdJoinTipConnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix(PlayerControllerB __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && ((NetworkBehaviour)__instance).IsOwner)
			{
				MotdJoinTip.TryStartFromLobby("ConnectClientToPlayerObject");
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class MotdJoinTipDisconnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			MotdJoinTip.ResetSession();
		}
	}
	internal static class NegativeScaleSanitizer
	{
		private static float _nextPassRealtime;

		private static float _sessionStartRealtime = -1f;

		internal static void Tick()
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated())
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (_sessionStartRealtime < 0f)
				{
					_sessionStartRealtime = realtimeSinceStartup;
				}
				float num = ((realtimeSinceStartup - _sessionStartRealtime < 20f) ? 0.5f : 5f);
				if (!(realtimeSinceStartup < _nextPassRealtime))
				{
					_nextPassRealtime = realtimeSinceStartup + num;
					RunPass("tick");
				}
			}
		}

		internal static void OnSessionCleared()
		{
			_sessionStartRealtime = -1f;
			_nextPassRealtime = 0f;
		}

		internal static void RunPass(string reason)
		{
			int num = 0;
			try
			{
				GameObject obj = GameObject.Find("Environment/HangarShip");
				object obj2 = ((obj != null) ? obj.transform : null);
				if (obj2 == null)
				{
					GameObject obj3 = GameObject.Find("HangarShip");
					obj2 = ((obj3 != null) ? obj3.transform : null);
				}
				Transform val = (Transform)obj2;
				if ((Object)(object)val != (Object)null)
				{
					num += SanitizeKnownBadOnly(val);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("NegativeScaleSanitizer(" + reason + "): " + ex.Message);
				return;
			}
			if (num > 0)
			{
				Plugin.DebugLog($"NegativeScaleSanitizer: fixed {num} known-bad transform(s) ({reason}).");
			}
		}

		internal static bool IsIntentionalMirrorScale(Transform t)
		{
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (name.IndexOf("HangarDoor", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.IndexOf("AnimatedShipDoor", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.IndexOf("Shelf", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.IndexOf("Cabinet", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.IndexOf("Locker", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.IndexOf("Door", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				if (name.Equals("HangarShip", StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				val = val.parent;
			}
			return false;
		}

		private static bool IsKnownBadNegScale(Transform t)
		{
			if ((Object)(object)t == (Object)null || IsIntentionalMirrorScale(t))
			{
				return false;
			}
			string name = ((Object)t).name;
			if (name.IndexOf("EnginePart", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (name.IndexOf("BloodParticle", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (name.IndexOf("BloodStab", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			return false;
		}

		internal static bool OnlyIntentionalNegScalesOnShip()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject obj = GameObject.Find("Environment/HangarShip");
				object obj2 = ((obj != null) ? obj.transform : null);
				if (obj2 == null)
				{
					GameObject obj3 = GameObject.Find("HangarShip");
					obj2 = ((obj3 != null) ? obj3.transform : null);
				}
				Transform val = (Transform)obj2;
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					Vector3 localScale = val2.localScale;
					if (!(localScale.x >= 0f) || !(localScale.y >= 0f) || !(localScale.z >= 0f))
					{
						if (IsKnownBadNegScale(val2))
						{
							return false;
						}
						if (!IsIntentionalMirrorScale(val2))
						{
							return false;
						}
					}
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static int SanitizeKnownBadOnly(Transform root)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !IsKnownBadNegScale(val))
				{
					continue;
				}
				try
				{
					Vector3 localScale = val.localScale;
					if (!(localScale.x >= 0f) || !(localScale.y >= 0f) || !(localScale.z >= 0f))
					{
						val.localScale = new Vector3(Mathf.Abs(localScale.x), Mathf.Abs(localScale.y), Mathf.Abs(localScale.z));
						Vector3 localScale2 = val.localScale;
						if (localScale2.x < 0.0001f || localScale2.y < 0.0001f || localScale2.z < 0.0001f)
						{
							val.localScale = Vector3.one;
						}
						num++;
					}
				}
				catch
				{
				}
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
	internal static class NegativeScaleSanitizerOnJoinPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated())
			{
				NegativeScaleSanitizer.RunPass("player-connected");
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Start")]
	internal static class NegativeScaleSanitizerStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated())
			{
				NegativeScaleSanitizer.RunPass("start");
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "Update")]
	internal static class NegativeScaleSanitizerUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			NegativeScaleSanitizer.Tick();
		}
	}
	internal static class OpenBodyCamsGhostGuard
	{
		private static bool _patched;

		internal static void TryPatch(Harmony harmony)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			if (_patched)
			{
				return;
			}
			try
			{
				Type type = AccessTools.TypeByName("OpenBodyCams.BodyCamComponent");
				if (!(type == null))
				{
					MethodInfo methodInfo = AccessTools.Method(type, "SetTargetToPlayer", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(OpenBodyCamsGhostGuard), "SetTargetToPlayer_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					MethodInfo methodInfo2 = AccessTools.Method(type, "SetTargetToTransform", (Type[])null, (Type[])null);
					if (methodInfo2 != null)
					{
						harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(OpenBodyCamsGhostGuard), "SetTargetToTransform_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					_patched = methodInfo != null || methodInfo2 != null;
					if (_patched)
					{
						Plugin.Log.LogInfo((object)"OpenBodyCams ghost-target guard patched.");
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("OpenBodyCams guard failed: " + ex.Message));
			}
		}

		private static bool SetTargetToPlayer_Prefix(ref PlayerControllerB player)
		{
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return true;
			}
			if (!GhostSeat.IsGhost(player))
			{
				return true;
			}
			PlayerControllerB val = GhostSeat.FindSpectateTarget(player, getClosest: false);
			if ((Object)(object)val != (Object)null)
			{
				player = val;
				return true;
			}
			return false;
		}

		private static bool SetTargetToTransform_Prefix(Transform transform)
		{
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated() || (Object)(object)transform == (Object)null)
			{
				return true;
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				PlayerControllerB val = ((instance?.allPlayerScripts != null && instance.allPlayerScripts.Length != 0) ? instance.allPlayerScripts[0] : null);
				if ((Object)(object)val != (Object)null && ((Object)(object)transform == (Object)(object)((Component)val).transform || transform.IsChildOf(((Component)val).transform)))
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}
	}
	internal static class PlanetIntroHudCleanup
	{
		private static float _nextForceAt;

		private static float _nextTravelStripAt;

		private static bool _clearedThisLanding;

		internal static void ClearPlanetIntroTexts(string reason)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				ClearTmp(instance.planetInfoHeaderText);
				ClearTmp(instance.planetInfoSummaryText);
				ClearTmp(instance.planetRiskLevelText);
				try
				{
					Animator planetIntroAnimator = instance.planetIntroAnimator;
					if ((Object)(object)planetIntroAnimator != (Object)null && ((Behaviour)planetIntroAnimator).isActiveAndEnabled)
					{
						planetIntroAnimator.ResetTrigger("introAnimation");
						if ((Object)(object)planetIntroAnimator.runtimeAnimatorController != (Object)null)
						{
							planetIntroAnimator.Play(0, 0, 1f);
						}
					}
				}
				catch
				{
				}
				Plugin.DebugLog("PlanetIntro cleared (" + reason + ")");
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("PlanetIntro clear failed: " + ex.Message);
			}
		}

		internal static void EnsureMapRadarMode(string reason)
		{
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				if ((Object)(object)instance.screenLevelDescription != (Object)null)
				{
					((Behaviour)instance.screenLevelDescription).enabled = false;
				}
				try
				{
					if ((Object)(object)instance.screenLevelVideoReel != (Object)null)
					{
						((Behaviour)instance.screenLevelVideoReel).enabled = false;
						((Component)instance.screenLevelVideoReel).gameObject.SetActive(false);
					}
				}
				catch
				{
				}
				if ((Object)(object)instance.mapScreenPlayerName != (Object)null)
				{
					((Behaviour)instance.mapScreenPlayerName).enabled = true;
				}
				if ((Object)(object)instance.mapScreenPlayerNameBG != (Object)null)
				{
					((Behaviour)instance.mapScreenPlayerNameBG).enabled = true;
				}
				try
				{
					if ((Object)(object)instance.mapScreen != (Object)null)
					{
						instance.mapScreen.overrideCameraForOtherUse = false;
						if ((Object)(object)instance.mapScreen.compassRose != (Object)null)
						{
							((Behaviour)instance.mapScreen.compassRose).enabled = true;
						}
					}
				}
				catch
				{
				}
				Plugin.DebugLog("Map radar mode forced (" + reason + ")");
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("Map radar force failed: " + ex.Message);
			}
		}

		internal static void AfterLanded(string reason)
		{
			if (DedicatedLobby.IsCurrentLobbyDedicated())
			{
				ClearPlanetIntroTexts(reason);
				EnsureMapRadarMode(reason);
				_clearedThisLanding = true;
			}
		}

		internal static void TickWhileOnMoon()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			TickWhileTravelling();
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null || instance.inShipPhase || !instance.shipHasLanded)
			{
				if ((Object)(object)instance != (Object)null && instance.inShipPhase)
				{
					_clearedThisLanding = false;
				}
				return;
			}
			if (!_clearedThisLanding)
			{
				AfterLanded("tick-first-land");
			}
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			if ((Object)(object)val != (Object)null && val.isPlayerDead && !(Time.unscaledTime < _nextForceAt))
			{
				_nextForceAt = Time.unscaledTime + 1.5f;
				if (PlanetIntroLooksStuck())
				{
					ClearPlanetIntroTexts("spectate-stuck");
				}
				if ((Object)(object)instance.screenLevelDescription != (Object)null && ((Behaviour)instance.screenLevelDescription).enabled)
				{
					EnsureMapRadarMode("spectate-map-text");
				}
			}
		}

		internal static void TickWhileTravelling()
		{
			if (!GhostSeat.WantHide())
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null || (!instance.travellingToNewLevel && !instance.beganLoadingNewLevel) || Time.unscaledTime < _nextTravelStripAt)
			{
				return;
			}
			_nextTravelStripAt = Time.unscaledTime + 0.5f;
			try
			{
				HUDManager instance2 = HUDManager.Instance;
				if (instance2?.statsUIElements != null)
				{
					HideHostEndGameStatsPatch.CompactStatsUi(instance2.statsUIElements);
				}
			}
			catch
			{
			}
			try
			{
				QuickMenuManager obj2 = Object.FindObjectOfType<QuickMenuManager>();
				if (obj2 != null)
				{
					obj2.RemoveUserFromPlayerList(0);
				}
			}
			catch
			{
			}
		}

		private static bool PlanetIntroLooksStuck()
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				return TmpVisibleWithText(instance.planetInfoHeaderText) || TmpVisibleWithText(instance.planetInfoSummaryText) || TmpVisibleWithText(instance.planetRiskLevelText);
			}
			catch
			{
				return false;
			}
		}

		private static bool TmpVisibleWithText(TextMeshProUGUI? t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return false;
			}
			if (!((Behaviour)t).isActiveAndEnabled)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(((TMP_Text)t).text))
			{
				return false;
			}
			try
			{
				if ((Object)(object)t.canvasRenderer != (Object)null && t.canvasRenderer.GetAlpha() < 0.05f)
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}

		private static void ClearTmp(TextMeshProUGUI? t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return;
			}
			((TMP_Text)t).text = "";
			((Behaviour)t).enabled = false;
			try
			{
				if ((Object)(object)t.canvasRenderer != (Object)null)
				{
					t.canvasRenderer.SetAlpha(0f);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnShipLandedMiscEvents")]
	internal static class PlanetIntroOnLandedPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			PlanetIntroHudCleanup.AfterLanded("OnShipLandedMiscEvents");
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "SwitchMapMonitorPurpose")]
	internal static class PlanetIntroMapPurposePatch
	{
		[HarmonyPostfix]
		private static void Postfix(bool displayInfo)
		{
			if (DedicatedLobby.IsCurrentLobbyDedicated() && !displayInfo)
			{
				PlanetIntroHudCleanup.EnsureMapRadarMode("SwitchMapMonitorPurpose(false)");
				StartOfRound instance = StartOfRound.Instance;
				if ((Object)(object)instance != (Object)null && instance.shipHasLanded && !instance.inShipPhase)
				{
					PlanetIntroHudCleanup.ClearPlanetIntroTexts("SwitchMapMonitorPurpose-landed");
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SetSpectatedPlayerEffects")]
	internal static class PlanetIntroOnSpectatePatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if (!((Object)(object)instance == (Object)null) && !instance.inShipPhase)
			{
				if (instance.shipHasLanded)
				{
					PlanetIntroHudCleanup.AfterLanded("SetSpectatedPlayerEffects");
				}
				else
				{
					PlanetIntroHudCleanup.ClearPlanetIntroTexts("SetSpectatedPlayerEffects-preland");
				}
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "Update")]
	internal static class PlanetIntroHudUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			PlanetIntroHudCleanup.TickWhileOnMoon();
		}
	}
	[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
	internal static class HideHostEndGameStatsDelayedPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(HUDManager __instance)
		{
			if (!GhostSeat.WantHide() || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				((MonoBehaviour)__instance).StartCoroutine(RecompactNextFrames(__instance));
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("EndGame recompact schedule: " + ex.Message);
			}
		}

		private static IEnumerator RecompactNextFrames(HUDManager hud)
		{
			yield return null;
			TryCompact(hud);
			yield return null;
			TryCompact(hud);
			yield return (object)new WaitForSeconds(0.35f);
			TryCompact(hud);
			yield return (object)new WaitForSeconds(0.75f);
			TryCompact(hud);
			yield return (object)new WaitForSeconds(1.25f);
			TryCompact(hud);
		}

		private static void TryCompact(HUDManager hud)
		{
			try
			{
				if (hud?.statsUIElements != null)
				{
					HideHostEndGameStatsPatch.CompactStatsUi(hud.statsUIElements);
					HideHostEndGameStatsPatch.FixGradeExcludingGhost(hud.statsUIElements);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("EndGame recompact: " + ex.Message);
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "StartGame")]
	internal static class TravelHideGhostRosterPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!GhostSeat.WantHide())
			{
				return;
			}
			try
			{
				QuickMenuManager obj = Object.FindObjectOfType<QuickMenuManager>();
				if (obj != null)
				{
					obj.RemoveUserFromPlayerList(0);
				}
			}
			catch
			{
			}
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance?.statsUIElements != null)
				{
					HideHostEndGameStatsPatch.CompactStatsUi(instance.statsUIElements);
				}
			}
			catch
			{
			}
			try
			{
				StartOfRound instance2 = StartOfRound.Instance;
				if ((Object)(object)instance2?.mapScreen != (Object)null)
				{
					MapScreenGhostGuard.RetargetCameraLocal(instance2.mapScreen);
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ArriveAtLevel")]
	internal static class ArriveAtLevelHideGhostRosterPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (!GhostSeat.WantHide())
			{
				return;
			}
			try
			{
				QuickMenuManager obj = Object.FindObjectOfType<QuickMenuManager>();
				if (obj != null)
				{
					obj.RemoveUserFromPlayerList(0);
				}
			}
			catch
			{
			}
			try
			{
				HUDManager instance = HUDManager.Instance;
				if (instance?.statsUIElements != null)
				{
					HideHostEndGameStatsPatch.CompactStatsUi(instance.statsUIElements);
				}
			}
			catch
			{
			}
			try
			{
				StartOfRound instance2 = StartOfRound.Instance;
				if ((Object)(object)instance2?.mapScreen != (Object)null)
				{
					MapScreenGhostGuard.RetargetCameraLocal(instance2.mapScreen);
				}
			}
			catch
			{
			}
		}
	}
	internal static class QuatSpamProbe
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static LogCallback <0>__OnLog;
		}

		private static bool _hooked;

		private static bool _armed;

		private static float _nextDumpRealtime;

		private static float _nextGetLogRealtime;

		private static int _hitCount;

		private static int _dumpsLogged;

		private static int _getLogsLogged;

		private const int MaxDumpsPerSession = 2;

		private const int MaxGetLogsPerSession = 4;

		private const float DumpCooldownSeconds = 45f;

		internal static void EnsureHooked()
		{
			//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_0042: Expected O, but got Unknown
			if (Plugin.Config == null || !Plugin.Config.EnableQuatSpamProbe.Value || _hooked)
			{
				return;
			}
			_hooked = true;
			try
			{
				object obj = <>O.<0>__OnLog;
				if (obj == null)
				{
					LogCallback val = OnLog;
					<>O.<0>__OnLog = val;
					obj = (object)val;
				}
				Application.logMessageReceived += (LogCallback)obj;
				Plugin.Log.LogInfo((object)"QuatSpamProbe: hooked Application.logMessageReceived.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("QuatSpamProbe hook failed: " + ex.Message));
			}
		}

		internal static void ClearSession()
		{
			_hitCount = 0;
			_dumpsLogged = 0;
			_getLogsLogged = 0;
			_armed = false;
			QuatSpamProbeArmed.Value = false;
			_nextDumpRealtime = 0f;
			_nextGetLogRealtime = 0f;
			NegativeScaleSanitizer.OnSessionCleared();
		}

		internal static void Arm(string reason)
		{
			if (Plugin.Config != null && Plugin.Config.EnableQuatSpamProbe.Value && !_armed)
			{
				_armed = true;
				QuatSpamProbeArmed.Value = true;
				Plugin.Log.LogWarning((object)("QuatSpamProbe: armed (" + reason + ") — Transform.get_rotation watch active."));
			}
		}

		private static void OnLog(string condition, string stackTrace, LogType type)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			if (Plugin.Config == null || !Plugin.Config.EnableQuatSpamProbe.Value || ((int)type != 0 && (int)type != 4) || string.IsNullOrEmpty(condition) || condition.IndexOf("Rotation quaternions must be unit length", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return;
			}
			_hitCount++;
			if (NegativeScaleSanitizer.OnlyIntentionalNegScalesOnShip())
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_dumpsLogged >= 2 || realtimeSinceStartup < _nextDumpRealtime)
			{
				return;
			}
			_nextDumpRealtime = realtimeSinceStartup + 45f;
			_dumpsLogged++;
			try
			{
				StringBuilder stringBuilder = new StringBuilder(3072);
				stringBuilder.Append("[QuatSpamProbe] hit #").Append(_hitCount).Append(" dump ")
					.Append(_dumpsLogged)
					.Append('/')
					.Append(2)
					.Append(" dedicated=")
					.Append(DedicatedLobby.IsCurrentLobbyDedicated())
					.AppendLine();
				if (!string.IsNullOrEmpty(stackTrace))
				{
					stringBuilder.AppendLine("--- Unity stack ---");
					stringBuilder.AppendLine(stackTrace.TrimEnd());
				}
				else
				{
					stringBuilder.AppendLine("--- Unity stack: empty (often native; see Transform.get_rotation watch) ---");
				}
				AppendMapState(stringBuilder);
				AppendPlayerDump(stringBuilder);
				AppendNegativeScales(stringBuilder);
				Plugin.Log.LogWarning((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("QuatSpamProbe dump failed: " + ex.Message));
			}
			if (_dumpsLogged < 2)
			{
				return;
			}
			try
			{
				object obj = <>O.<0>__OnLog;
				if (obj == null)
				{
					LogCallback val = OnLog;
					<>O.<0>__OnLog = val;
					obj = (object)val;
				}
				Application.logMessageReceived -= (LogCallback)obj;
				_hooked = false;
			}
			catch
			{
			}
			ClearSession();
			Plugin.Log.LogWarning((object)"QuatSpamProbe: unhooked after dump budget.");
		}

		private static void AppendNegativeScales(StringBuilder sb)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject obj = GameObject.Find("Environment/HangarShip");
				object obj2 = ((obj != null) ? obj.transform : null);
				if (obj2 == null)
				{
					GameObject obj3 = GameObject.Find("HangarShip");
					obj2 = ((obj3 != null) ? obj3.transform : null);
				}
				Transform val = (Transform)obj2;
				if ((Object)(object)val == (Object)null)
				{
					sb.AppendLine("negScale: no HangarShip");
					return;
				}
				int num = 0;
				Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (num >= 12)
					{
						break;
					}
					Transform val2 = componentsInChildren[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						Vector3 localScale = val2.localScale;
						if (!(localScale.x >= 0f) || !(localScale.y >= 0f) || !(localScale.z >= 0f))
						{
							num++;
							sb.Append("negScale ").Append(PathOf(val2)).Append(" localScale=")
								.Append(((Vector3)(ref localScale)).ToString("F3"))
								.AppendLine();
						}
					}
				}
				if (num == 0)
				{
					sb.AppendLine("negScale: none under HangarShip");
				}
			}
			catch (Exception ex)
			{
				sb.Append("negScale dump error: ").AppendLine(ex.Message);
			}
		}

		internal static void OnBadGetRotation(Transform t)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!_armed || (Object)(object)t == (Object)null)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_getLogsLogged >= 4 || realtimeSinceStartup < _nextGetLogRealtime)
			{
				return;
			}
			_nextGetLogRealtime = realtimeSinceStartup + 45f;
			_getLogsLogged++;
			try
			{
				float num = Mag2(t.localRotation);
				StringBuilder stringBuilder = new StringBuilder(1024);
				stringBuilder.Append("[QuatSpamProbe] get_rotation on BAD bone dump ").Append(_getLogsLogged).Append('/')
					.Append(4)
					.Append(" mag2=")
					.Append(num.ToString("F4"))
					.Append(" path=")
					.Append(PathOf(t))
					.AppendLine();
				stringBuilder.AppendLine("--- managed stack ---");
				stringBuilder.AppendLine(new StackTrace(2, fNeedFileInfo: true).ToString());
				AppendMapState(stringBuilder);
				Plugin.Log.LogWarning((object)stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("QuatSpamProbe get_rotation log failed: " + ex.Message));
			}
		}

		private static void AppendMapState(StringBuilder sb)
		{
			try
			{
				ManualCameraRenderer val = StartOfRound.Instance?.mapScreen;
				if ((Object)(object)val == (Object)null)
				{
					sb.AppendLine("mapScreen: null");
					return;
				}
				PlayerControllerB targetedPlayer = val.targetedPlayer;
				sb.Append("mapScreen targetIndex=").Append(val.targetTransformIndex).Append(" enableHeadCam=")
					.Append(val.enableHeadMountedCam)
					.Append(" headTarget=")
					.Append(((Object)(object)val.headMountedCamTarget != (Object)null) ? PathOf(val.headMountedCamTarget) : "null")
					.Append(" targetedPlayer=");
				if ((Object)(object)targetedPlayer == (Object)null)
				{
					sb.AppendLine("null");
				}
				else
				{
					sb.Append(((Object)((Component)targetedPlayer).gameObject).name).Append(" clientId=").Append(targetedPlayer.playerClientId)
						.Append(" hostObj=")
						.Append(targetedPlayer.isHostPlayerObject)
						.Append(" owned=")
						.Append(((NetworkBehaviour)targetedPlayer).IsOwner)
						.Append(" controlled=")
						.Append(targetedPlayer.isPlayerControlled)
						.Append(" dead=")
						.Append(targetedPlayer.isPlayerDead)
						.AppendLine();
				}
				if ((Object)(object)val.headMountedCamTarget != (Object)null)
				{
					AppendTransformHealth(sb, "  headCamTarget", val.headMountedCamTarget);
				}
			}
			catch (Exception ex)
			{
				sb.Append("mapScreen dump error: ").AppendLine(ex.Message);
			}
		}

		private static void AppendPlayerDump(StringBuilder sb)
		{
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts == null)
				{
					sb.AppendLine("allPlayerScripts: null");
					return;
				}
				for (int i = 0; i < Math.Min(instance.allPlayerScripts.Length, 8); i++)
				{
					PlayerControllerB val = instance.allPlayerScripts[i];
					if (!((Object)(object)val == (Object)null) && (i == 0 || ((NetworkBehaviour)val).IsOwner || val.isPlayerControlled || val.isHostPlayerObject))
					{
						sb.Append("player[").Append(i).Append("] ")
							.Append(((Object)((Component)val).gameObject).name)
							.Append(" steam=")
							.Append(val.playerSteamId)
							.Append(" controlled=")
							.Append(val.isPlayerControlled)
							.Append(" dead=")
							.Append(val.isPlayerDead)
							.Append(" owner=")
							.Append(((NetworkBehaviour)val).IsOwner)
							.AppendLine();
						string firstBadPath;
						int value = CountBadQuats(((Component)val).transform, out firstBadPath);
						sb.Append("  badLocalQuats=").Append(value);
						if (firstBadPath != null)
						{
							sb.Append(" first=").Append(firstBadPath);
						}
						sb.AppendLine();
						AppendNamed(sb, "  localArmsRotationTarget", val.localArmsRotationTarget);
						AppendNamed(sb, "  playerModelArmsMetarig", val.playerModelArmsMetarig);
						AppendNamed(sb, "  localVisor", val.localVisor);
						AppendNamed(sb, "  playerGlobalHead", val.playerGlobalHead);
						AppendNamed(sb, "  thisPlayerBody", val.thisPlayerBody);
						AppendNamed(sb, "  gameplayCamera", ((Object)(object)val.gameplayCamera != (Object)null) ? ((Component)val.gameplayCamera).transform : null);
					}
				}
			}
			catch (Exception ex)
			{
				sb.Append("player dump error: ").AppendLine(ex.Message);
			}
		}

		private static void AppendNamed(StringBuilder sb, string label, Transform? t)
		{
			if (!((Object)(object)t == (Object)null))
			{
				AppendTransformHealth(sb, label, t);
			}
		}

		private static void AppendTransformHealth(StringBuilder sb, string label, Transform t)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float mag = Mag2(t.localRotation);
				bool num = IsBadMag2(mag);
				sb.Append(label).Append(" path=").Append(PathOf(t))
					.Append(" localMag2=")
					.Append(mag.ToString("F4"));
				if (num)
				{
					sb.Append(" BAD");
				}
				sb.AppendLine();
			}
			catch (Exception ex)
			{
				sb.Append(label).Append(" ERROR reading localRotation: ").AppendLine(ex.Message);
			}
		}

		private static int CountBadQuats(Transform root, out string? firstBadPath)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			firstBadPath = null;
			int num = 0;
			try
			{
				Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
				foreach (Transform val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						float mag = Mag2(val.localRotation);
						if (IsBadMag2(mag))
						{
							num++;
							if (firstBadPath == null)
							{
								firstBadPath = PathOf(val) + " mag2=" + mag.ToString("F4");
							}
						}
					}
					catch
					{
						num++;
						if (firstBadPath == null)
						{
							firstBadPath = PathOf(val) + " (read threw)";
						}
					}
				}
			}
			catch
			{
			}
			return num;
		}

		internal static float Mag2(Quaternion q)
		{
			//IL_0000: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
		}

		internal static bool IsBadMag2(float mag2)
		{
			if (!float.IsNaN(mag2) && !float.IsInfinity(mag2) && !(mag2 < 0.95f))
			{
				return mag2 > 1.05f;
			}
			return true;
		}

		private static string PathOf(Transform t)
		{
			try
			{
				StringBuilder stringBuilder = new StringBuilder(((Object)t).name.Length * 4);
				Transform val = t;
				int num = 0;
				while ((Object)(object)val != (Object)null && num++ < 24)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Insert(0, '/');
					}
					stringBuilder.Insert(0, ((Object)val).name);
					val = val.parent;
				}
				return stringBuilder.ToString();
			}
			catch
			{
				return ((Object)(object)t != (Object)null) ? ((Object)t).name : "?";
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Start")]
	internal static class QuatSpamProbeStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			QuatSpamProbe.EnsureHooked();
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class QuatSpamProbeDisconnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			QuatSpamProbe.ClearSession();
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class QuatSpamProbeGetRotationPatch
	{
		private static bool Prepare()
		{
			return Plugin.Config.EnableQuatSpamProbe.Value;
		}

		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static void Prefix(Transform __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!QuatSpamProbeArmed.Value || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				if (QuatSpamProbe.IsBadMag2(QuatSpamProbe.Mag2(__instance.localRotation)))
				{
					QuatSpamProbe.OnBadGetRotation(__instance);
				}
			}
			catch
			{
			}
		}
	}
	internal static class QuatSpamProbeArmed
	{
		internal static bool Value;
	}
	[HarmonyPatch(typeof(ManualCameraRenderer), "LateUpdate")]
	internal static class MapScreenQuatSafeLateUpdatePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(801)]
		private static void Prefix(ManualCameraRenderer __instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				if (GhostSeat.IsGhost(__instance.targetedPlayer) || MapScreenGhostGuard.IsGhostRadarEntry(__instance, __instance.targetTransformIndex))
				{
					__instance.enableHeadMountedCam = false;
					__instance.headMountedCamTarget = null;
					return;
				}
				Transform headMountedCamTarget = __instance.headMountedCamTarget;
				if (!((Object)(object)headMountedCamTarget == (Object)null))
				{
					float num = QuatSpamProbe.Mag2(headMountedCamTarget.localRotation);
					if (QuatSpamProbe.IsBadMag2(num))
					{
						__instance.enableHeadMountedCam = false;
						__instance.headMountedCamTarget = null;
						Plugin.DebugLog($"MapScreenQuatSafe: disabled head cam (bad bone mag2={num:F4}).");
					}
				}
			}
			catch
			{
				try
				{
					__instance.enableHeadMountedCam = false;
					__instance.headMountedCamTarget = null;
				}
				catch
				{
				}
			}
		}
	}
	internal static class QuatUnityLogFilter
	{
		private static bool _patched;

		internal static void TryPatch(Harmony harmony)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (_patched)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(AccessTools.TypeByName("BepInEx.Logging.UnityLogSource"), "OnUnityLogMessageReceived", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.Log.LogInfo((object)"QuatUnityLogFilter: OnUnityLogMessageReceived not found.");
					return;
				}
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(QuatUnityLogFilter), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_patched = true;
				Plugin.Log.LogInfo((object)"QuatUnityLogFilter: patched UnityLogSource.OnUnityLogMessageReceived.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("QuatUnityLogFilter: " + ex.Message));
			}
		}

		private static bool Prefix(string message)
		{
			if (string.IsNullOrEmpty(message))
			{
				return true;
			}
			if (message.IndexOf("Rotation quaternions must be unit length", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			return true;
		}
	}
	internal static class RejoinClientFixes
	{
		internal static string LastDenialReason = "";

		private static float _rejoinBlockedUntil;

		private const float RejoinCooldownSeconds = 1.25f;

		public static void NoteDisconnected()
		{
			_rejoinBlockedUntil = Time.realtimeSinceStartup + 1.25f;
		}

		public static bool ShouldBlockRapidRejoin(out string message)
		{
			message = "";
			try
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if ((Object)(object)singleton != (Object)null && singleton.ShutdownInProgress)
				{
					message = "Still disconnecting from the last session.\nWait a moment, then join again.";
					return true;
				}
			}
			catch
			{
			}
			float num = _rejoinBlockedUntil - Time.realtimeSinceStartup;
			if (num <= 0f)
			{
				return false;
			}
			message = $"Please wait {num:0.0}s before rejoining.\n" + "Instant reconnect after quit often fails before the host finishes cleaning up.";
			return true;
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "OnLocalClientConnectionDisapproved")]
	internal static class ConnectionDisapprovedReasonFixPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Prefix(GameNetworkManager __instance)
		{
			if (!Plugin.IsEnabled)
			{
				return;
			}
			try
			{
				RejoinClientFixes.NoteDisconnected();
				string text = "";
				try
				{
					if ((Object)(object)NetworkManager.Singleton != (Object)null)
					{
						text = NetworkManager.Singleton.DisconnectReason ?? "";
					}
				}
				catch
				{
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					text = __instance.disconnectionReasonMessage ?? "";
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "Connection was not approved (host refused). Wait a couple seconds and join again.";
				}
				__instance.disconnectionReasonMessage = text;
				RejoinClientFixes.LastDenialReason = text;
				Plugin.Log.LogInfo((object)("Join denied: " + text));
				if (LooksLikeHardHandshakeDeny(text))
				{
					JoinBanGate.ShowJoinDenied(text);
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("ConnectionDisapprovedReasonFix: " + ex.Message);
			}
		}

		private static bool LooksLikeHardHandshakeDeny(string reason)
		{
			if (string.IsNullOrWhiteSpace(reason))
			{
				return false;
			}
			if (reason.IndexOf("Active Development", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("join instructions", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("uexp.org", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("outdated", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("older UEXP Dedicated host", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("host administrator", StringComparison.OrdinalIgnoreCase) < 0 && reason.IndexOf("Update the client", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return reason.IndexOf("missing version handshake", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MenuManager), "SetLoadingScreen")]
	internal static class SetLoadingScreenShowDenialReasonPatch
	{
		[HarmonyPrefix]
		private static void Prefix(bool isLoading, ref string overrideMessage)
		{
			if (!Plugin.IsEnabled || isLoading || !string.IsNullOrEmpty(overrideMessage) || string.IsNullOrWhiteSpace(RejoinClientFixes.LastDenialReason))
			{
				return;
			}
			overrideMessage = RejoinClientFixes.LastDenialReason;
			try
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if ((Object)(object)instance != (Object)null && string.IsNullOrWhiteSpace(instance.disconnectionReasonMessage))
				{
					instance.disconnectionReasonMessage = RejoinClientFixes.LastDenialReason;
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		private static void Postfix(bool isLoading)
		{
			if (!isLoading)
			{
				RejoinClientFixes.LastDenialReason = "";
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class DisconnectLeaveSteamLobbyPatch
	{
		[HarmonyPostfix]
		private static void Postfix(GameNetworkManager __instance)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsEnabled)
			{
				return;
			}
			RejoinClientFixes.NoteDisconnected();
			try
			{
				if (__instance.currentLobby.HasValue)
				{
					try
					{
						Lobby value = __instance.currentLobby.Value;
						((Lobby)(ref value)).Leave();
					}
					catch
					{
					}
					__instance.currentLobby = null;
				}
				try
				{
					__instance.LeaveCurrentSteamLobby();
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				Plugin.DebugLog("DisconnectLeaveSteamLobby: " + ex.Message);
			}
		}
	}
	internal static class RoleNameColors
	{
		public const string ChatPrefix = "[UEXP]roles:";

		public const string LobbyKey = "uexpRoles";

		public static readonly Color AdminColor = new Color(0.55f, 0f, 0f, 1f);

		public static readonly Color ModColor = new Color(0.1f, 0.72f, 0.22f, 1f);

		public const string AdminHex = "#8B0000";

		public const string ModHex = "#12B838";

		public const string DevTag = "[DEV]";

		private static readonly Dictionary<ulong, char> Roles = new Dictionary<ulong, char>();

		public static string WithDevPrefix(string? name)
		{
			string text = (name ?? "").Trim();
			if (text.Length == 0)
			{
				return "[DEV]";
			}
			if (text.StartsWith("[DEV]", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return "[DEV] " + text;
		}

		public static string StripDevPrefix(string? name)
		{
			string text = (name ?? "").Trim();
			if (text.StartsWith("[DEV]", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("[DEV]".Length).TrimStart();
			}
			return text;
		}

		public static void Clear(string reason = "")
		{
			Roles.Clear();
			Plugin.DebugLog("Role colors cleared" + (string.IsNullOrEmpty(reason) ? "" : (" (" + reason + ")")));
		}

		public static bool TryHandleRolesChat(string? chatMessage)
		{
			if (string.IsNullOrEmpty(chatMessage))
			{
				return false;
			}
			if (!chatMessage.StartsWith("[UEXP]roles:", StringComparison.Ordinal))
			{
				return false;
			}
			ApplyPayload(chatMessage.Substring("[UEXP]roles:".Length));
			return true;
		}

		public static void TryPullFromLobby()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				GameNetworkManager instance = GameNetworkManager.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.currentLobby.HasValue)
				{
					Lobby value = instance.currentLobby.Value;
					string text = ((Lobby)(ref value)).GetData("uexpRoles") ?? "";
					if (!string.IsNullOrEmpty(text))
					{
						ApplyPayload(text);
					}
				}
			}
			catch
			{
			}
		}

		public static void ApplyPayload(string payload)
		{
			Roles.Clear();
			foreach (ulong item in DeveloperRoster.Snapshot())
			{
				Roles[item] = 'd';
			}
			if (!string.IsNullOrWhiteSpace(payload))
			{
				string[] array = payload.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					int num = text.IndexOf('=');
					if (num > 0 && ulong.TryParse(text.Substring(0, num).Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result != 0L)
					{
						string text2 = text.Substring(num + 1).Trim().ToLowerInvariant();
						if (text2.StartsWith("d") || DeveloperRoster.IsDeveloper(result))
						{
							Roles[result] = 'd';
						}
						else if (text2.StartsWith("a"))
						{
							Roles[result] = 'a';
						}
						else if (text2.StartsWith("m"))
						{
							Roles[result] = 'm';
						}
					}
				}
			}
			Plugin.DebugLog($"Role colors applied ({Roles.Count}).");
			ApplyBillboards();
			ApplyCrewListColors();
		}

		public static bool IsDeveloperRole(ulong steamId)
		{
			if (!DeveloperRoster.IsDeveloper(steamId))
			{
				if (steamId != 0L && Roles.TryGetValue(steamId, out var value))
				{
					return value == 'd';
				}
				return false;
			}
			return true;
		}

		public static ulong EffectiveSteamId(PlayerControllerB? p)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null)
			{
				return 0uL;
			}
			if (p.playerSteamId != 0L)
			{
				return p.playerSteamId;
			}
			if (((NetworkBehaviour)p).IsOwner)
			{
				try
				{
					return SteamId.op_Implicit(SteamClient.SteamId);
				}
				catch
				{
				}
			}
			return 0uL;
		}

		public static string? HexForSteam(ulong steamId)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (steamId == 0L)
			{
				return null;
			}
			if (IsDeveloperRole(steamId))
			{
				return ColorUtility.ToHtmlStringRGB(RainbowColor());
			}
			if (!Roles.TryGetValue(steamId, out var value))
			{
				return null;
			}
			if (value != 'a')
			{
				return "#12B838";
			}
			return "#8B0000";
		}

		public static Color? ColorForSteam(ulong steamId)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (steamId == 0L)
			{
				return null;
			}
			if (IsDeveloperRole(steamId))
			{
				return RainbowColor();
			}
			if (!Roles.TryGetValue(steamId, out var value))
			{
				return null;
			}
			return (value == 'a') ? AdminColor : ModColor;
		}

		public static Color RainbowColor(float speed = 0.45f)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			float num = Time.unscaledTime * speed % 1f;
			if (num < 0f)
			{
				num += 1f;
			}
			return Color.HSVToRGB(num, 0.85f, 1f);
		}

		public static string RainbowRichName(string name, float speed = 0.45f)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(name))
			{
				return name;
			}
			StringBuilder stringBuilder = new StringBuilder(name.Length * 18);
			float num = Time.unscaledTime * speed % 1f;
			if (num < 0f)
			{
				num += 1f;
			}
			for (int i = 0; i < name.Length; i++)
			{
				Color val = Color.HSVToRGB((num + (float)i * 0.08f) % 1f, 0.85f, 1f);
				stringBuilder.Append("<color=#").Append(ColorUtility.ToHtmlStringRGB(val)).Append('>')
					.Append(name[i])
					.Append("</color>");
			}
			return stringBuilder.ToString();
		}

		public static void ApplyHeaderColor(TextMeshProUGUI? header, int objectId)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)header == (Object)null)
			{
				return;
			}
			ulong num = 0uL;
			string text = null;
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts != null && objectId >= 0 && objectId < instance.allPlayerScripts.Length && (Object)(object)instance.allPlayerScripts[objectId] != (Object)null)
				{
					num = instance.allPlayerScripts[objectId].playerSteamId;
					text = instance.allPlayerScripts[objectId].playerUsername;
					if (num == 0L)
					{
						num = EffectiveSteamId(instance.allPlayerScripts[objectId]);
					}
				}
			}
			catch
			{
			}
			((Graphic)header).color = (Color)(((??)ColorForSteam(num)) ?? Color.white);
			if (IsDeveloperRole(num))
			{
				string text2 = WithDevPrefix((!string.IsNullOrWhiteSpace(text)) ? text : StripDevPrefix(((TMP_Text)header).text));
				if (!string.Equals(((TMP_Text)header).text, text2, StringComparison.Ordinal))
				{
					((TMP_Text)header).text = text2;
				}
			}
		}

		public static ulong SteamFromPlayerId(int playerWhoSent, string? nameOfUserWhoTyped)
		{
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts == null)
				{
					return 0uL;
				}
				if (playerWhoSent >= 0 && playerWhoSent < instance.allPlayerScripts.Length)
				{
					PlayerControllerB val = instance.allPlayerScripts[playerWhoSent];
					if ((Object)(object)val != (Object)null && val.playerSteamId != 0L)
					{
						return val.playerSteamId;
					}
				}
				if (!string.IsNullOrEmpty(nameOfUserWhoTyped))
				{
					string b = StripDevPrefix(nameOfUserWhoTyped);
					PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
					foreach (PlayerControllerB val2 in allPlayerScripts)
					{
						if (!((Object)(object)val2 == (Object)null) && (string.Equals(val2.playerUsername, nameOfUserWhoTyped, StringComparison.OrdinalIgnoreCase) || string.Equals(val2.playerUsername, b, StringComparison.OrdinalIgnoreCase) || string.Equals(WithDevPrefix(val2.playerUsername), nameOfUserWhoTyped, StringComparison.OrdinalIgnoreCase)))
						{
							return val2.playerSteamId;
						}
					}
				}
			}
			catch
			{
			}
			return 0uL;
		}

		public static void ApplyBillboards()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				StartOfRound instance = StartOfRound.Instance;
				if (instance?.allPlayerScripts == null)
				{
					return;
				}
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if ((Object)(object)val?.usernameBillboardText == (Object)null)
					{
						continue;
					}
					ulong steamId = EffectiveSteamId(val);
					Color? val2 = ColorForSteam(steamId);
					((Graphic)val.usernameBillboardText).color = (Color)(((??)val2) ?? Color.white);
					if (IsDeveloperRole(steamId))
					{
						string text = WithDevPrefix(val.playerUsername);
						if (!string.Equals(((TMP_Text)val.usernameBillboardText).text, text, StringComparison.Ordinal))
						{
							((TMP_Text)val.usernameBillboardText).text = text;
						}
					}
				}
			}
			catch
			{
			}
		}

		public static void ApplyCrewListColors()
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return;
			}
			try
			{
				QuickMenuManager val = Object.FindObjectOfType<QuickMenuManager>();
				if (val?.playerListSlots == null)
				{
					return;
				}
				for (int i = 0; i < val.playerListSlots.Length; i++)
				{
					PlayerListSlot val2 = val.playerListSlots[i];
					if (!((Object)(object)val2?.usernameHeader == (Object)null) && val2.isConnected)
					{
						ApplyHeaderColor(val2.usernameHeader, i);
					}
				}
			}
			catch
			{
			}
		}

		public static void RecolorChatHistoryLast(string nameOfUserWhoTyped, string hexOrRainbowMarker, bool rainbow)
		{
			try
			{
				HUDManager instance = HUDManager.Instance;
				if ((Object)(object)instance == (Object)null || !(AccessTools.Field(typeof(HUDManager), "ChatMessageHistory")?.GetValue(instance) is List<string> { Count: not 0 } list))
				{
					return;
				}
				int index = list.Count - 1;
				string text = list[index];
				string name = (rainbow ? WithDevPrefix(nameOfUserWhoTyped) : nameOfUserWhoTyped);
				string text2 = "<color=#FF0000>" + nameOfUserWhoTyped + "</color>";
				string newValue = (rainbow ? RainbowRichName(name) : ("<color=" + hexOrRainbowMarker + ">" + nameOfUserWhoTyped + "</color>"));
				if (!text.Contains(text2))
				{
					string text3 = "<color=#FF0000>" + WithDevPrefix(nameOfUserWhoTyped) + "</color>";
					if (!rainbow || !text.Contains(text3))
					{
						return;
					}
					list[index] = text.Replace(text3, RainbowRichName(WithDevPrefix(nameOfUserWhoTyped)));
				}
				else
				{
					list[index] = text.Replace(text2, newValue);
				}
				if (!((Object)(object)instance.chatText == (Object)null))
				{
					StringBuilder stringBuilder = new StringBuilder();
					for (int i = 0; i < list.Count; i++)
					{
						stringBuilder.Append('\n').Append(list[i]);
					}
					((TMP_Text)instance.chatText).text = stringBuilder.ToString();
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class RoleSyncChatHideAndColorPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool PrefixHideRoles(string chatMessage, string nameOfUserWhoTyped)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(nameOfUserWhoTyped))
			{
				return true;
			}
			if (RoleNameColors.TryHandleRolesChat(chatMessage))
			{
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		private static void PostfixColor(string chatMessage, string nameOfUserWhoTyped, int playerWhoSent)
		{
			if (!Plugin.IsEnabled || !DedicatedLobby.IsCurrentLobbyDedicated() || string.IsNullOrEmpty(nameOfUserWhoTyped))
			{
				return;
			}
			ulong steamId = RoleNameColors.SteamFromPlayerId(playerWhoSent, nameOfUserWhoTyped);
			if (RoleNameColors.IsDeveloperRole(steamId))
			{
				RoleNameColors.RecolorChatHistoryLast(nameOfUserWhoTyped, "", rainbow: true);
				return;
			}
			string text = RoleNameColors.HexForSteam(steamId);
			if (text != null)
			{
				RoleNameColors.RecolorChatHistoryLast(nameOfUserWhoTyped, text, rainbow: false);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	internal static class RoleBillboardColorPatch
	{
		private static float _nextSlow;

		private static float _nextRainbow;

		[HarmonyPostfix]
		private static void Postfix()
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated())
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (realtimeSinceStartup >= _nextRainbow)
				{
					_nextRainbow = realtimeSinceStartup + 0.05f;
					RoleNameColors.ApplyBillboards();
				}
				if (realtimeSinceStartup >= _nextSlow)
				{
					_nextSlow = realtimeSinceStartup + 1.5f;
					RoleNameColors.ApplyCrewListColors();
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
	internal static class RoleColorsClearOnDisconnectPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			RoleNameColors.Clear("Disconnect");
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
	internal static class RoleColorsEnsureDevelopersOnJoinPatch
	{
		[HarmonyPostfix]
		private static void Postfix()
		{
			if (Plugin.IsEnabled && DedicatedLobby.IsCurrentLobbyDedicated())
			{
				RoleNameColors.ApplyPayload("");
				RoleNameColors.TryPullFromLobby();
			}
		}
	}
	internal static class ShipLeaveEarlyVotes
	{
		public static bool Want()
		{
			return DedicatedLobby.IsCurrentLobbyDedicated();
		}

		public static int VotesNeeded()
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 0;
			}
			if (!Want())
			{
				return Mathf.Max(0, instance.connectedPlayersAmount + 1 - instance.livingPlayers);
			}
			int num = Mathf.Max(0, instance.connectedPlayersAmount);
			int num2 = 0;
			if (instance.allPlayerScripts != null)
			{
				for (int i = 0; i < instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val = instance.allPlayerScripts[i];
					if (!((Object)(object)val == (Object)null) && !val.isPlayerDead && val.isPlayerControlled && i != 0 && !val.isHostPlayerObject && val.playerClientId != 0L)
					{
						num2++;
					}
				}
			}
			return Mathf.Max(0, num - num2);
		}

		public static void ApplyVotesText(HUDManager hud, int votes)
		{
			if (!((Object)(object)hud?.holdButtonToEndGameEarlyVotesText == (Object)null))
			{
				((TMP_Text)hud.holdButtonToEndGameEarlyVotesText).text = $"({votes}/{VotesNeeded()} Votes)";
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager), "SetShipLeaveEarlyVotesText")]
	internal static class ShipLeaveEarlyVotesTextPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(HUDManager __instance, int votes)
		{
			if (!ShipLeaveEarlyVotes.Want())
			{
				return true;
			}
			ShipLeaveEarlyVotes.ApplyVotesText(__instance, votes);
			return false;
		}
	}
	[HarmonyPatch(typeof(HUDManager), "Update")]
	internal static class ShipLeaveEarlyVotesHudUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(HUDManager __instance)
		{
			try
			{
				if (!ShipLeaveEarlyVotes.Want() || (Object)(object)__instance.holdButtonToEndGameEarlyVotesText == (Object)null)
				{
					return;
				}
				string text = ((TMP_Text)__instance.holdButtonToEndGameEarlyVotesText).text;
				if (string.IsNullOrEmpty(text) || text.IndexOf("Votes", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return;
				}
				TimeOfDay instance = TimeOfDay.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					string text2 = $"({instance.votesForShipToLeaveEarly}/{ShipLeaveEarlyVotes.VotesNeeded()} Votes)";
					if (text != text2)
					{
						((TMP_Text)__instance.holdButtonToEndGameEarlyVotesText).text = text2;
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(StartMatchLever), "StartGame")]
	internal static class StartMatchLeverStartGamePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(StartMatchLever __instance)
		{
			if (!DedicatedLobby.IsCurrentLobbyDedicated())
			{
				return true;
			}
			if (((NetworkBehaviour)__instance).IsServer)
			{
				return true;
			}
			StartOfRound playersManager = __instance.playersManager;
			if ((Object)(object)playersManager == (Object)null)
			{
				return true;
			}
			if (playersManager.travellingToNewLevel || !playersManager.inShipPhase || playersManager.beganLoadingNewLevel)
			{
				return true;
			}
			int num = playersManager.connectedPlayersAmount + 1;
			int num2 = ((playersManager.fullyLoadedPlayers != null) ? playersManager.fullyLoadedPlayers.Count : 0);
			Plugin.DebugLog($"Dedicated StartGame: client forcing StartGameServerRpc (local loaded {num2}/{num}).");
			try
			{
				playersManager.StartGameServerRpc();
				if ((Object)(object)__instance.triggerScript != (Object)null)
				{
					bool flag = (Object)(object)GameNetworkManager.Instance != (Object)null && GameNetworkManager.Instance.gameHasStarted;
					__instance.triggerScript.hoverTip = (flag ? "Land ship : [LMB]" : "Start game : [LMB]");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Dedicated StartGameServerRpc failed: " + ex.Message));
				return true;
			}
			return false;
		}
	}
	internal static class VoteKickClientUi
	{
		public static void ShowTip(string title, string body, bool warning = false)
		{
			try
			{
				if (!((Object)(object)HUDManager.Instance == (Object)null))
				{
					HUDManager.Instance.DisplayTip(title, body, warning, false, "UEXP_VoteKick");
				}
			}
			catch
			{
			}
		}

		public static bool LooksLikeVoteKickBan(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.IndexOf("Vote-kicked", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("vote-kicked", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("Banned permanently", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("You can rejoin in", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("You were kicked", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		public static bool LooksLikeVoteKickChat(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.StartsWith("[ADMIN]@", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (!text.StartsWith("[VK]", StringComparison.OrdinalIgnoreCase) && !text.StartsWith("[VOTE]", StringComparison.OrdinalIgnoreCase) && !text.StartsWith("[ADMIN]", StringComparison.OrdinalIgnoreCase))
			{
				return text.IndexOf("VOTE KICK", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		public static bool TryHandleAdminWhisper(string? chatMessage)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(chatMessage))
			{
				return false;
			}
			if (TryHandleDevDump(chatMessage) || TryHandleDevTip(chatMessage))
			{
				return true;
			}
			if (!chatMessage.StartsWith("[ADMIN]@", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text = chatMessage.Substring("[ADMIN]@".Length);
			int num = text.IndexOf('|');
			if (num <= 0)
			{
				return true;
			}
			string s = text.Substring(0, num).Trim();
			string text2 = text.Substring(num + 1).Trim();
			if (!ulong.TryParse(s, out var result) || result == 0L)
			{
				return true;
			}
			try
			{
				ulong num2 = LocalSteamId();
				if (num2 != 0L && num2 == result && !string.IsNullOrEmpty(text2))
				{
					bool flag = false;
					try
					{
						GameNetworkManager instance = GameNetworkManager.Instance;
						if (instance != null && instance.currentLobby.HasValue && GameNetworkManager.Instance.currentLobby.HasValue)
						{
							string text3 = DedicatedLobby.ReadMotd(GameNetworkManager.Instance.currentLobby.Value).Trim();
							flag = text3.Length > 0 && string.Equals(text3, text2.Trim(), StringComparison.Ordinal);
						}
					}
					catch
					{
					}
					if (flag && MotdJoinTip.ShouldSuppressDuplicate(text2))
					{
						return true;
					}
					if (flag)
					{
						MotdJoinTip.MarkShown(text2);
					}
					ShowTip("Admin", Truncate(text2, 120));
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool TryHandleDevTip(string chatMessage)
		{
			if (!chatMessage.StartsWith("[DEVTIP]@", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text = chatMessage.Substring("[DEVTIP]@".Length);
			int num = text.IndexOf('|');
			if (num <= 0)
			{
				return true;
			}
			if (!ulong.TryParse(text.Substring(0, num).Trim(), out var result) || result == 0L)
			{
				return true;
			}
			string text2 = text.Substring(num + 1).Trim();
			try
			{
				if (LocalSteamId() == result && !string.IsNullOrEmpty(text2))
				{
					ShowTip("DEV", Truncate(text2, 120));
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool TryHandleDevDump(string chatMessage)
		{
			if (!chatMessage.StartsWith("[DEVDUMP]@", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text = chatMessage.Substring("[DEVDUMP]@".Length);
			int num = text.IndexOf('|');
			if (num <= 0)
			{
				return true;
			}
			if (!ulong.TryParse(text.Substring(0, num).Trim(), out var result) || result == 0L)
			{
				return true;
			}
			string text2 = text.Substring(num + 1);
			int num2 = text2.IndexOf('|');
			string text3 = ((num2 >= 0) ? text2.Substring(num2 + 1) : text2);
			string text4 = ((num2 >= 0) ? text2.Substring(0, num2) : "?");
			try
			{
				if (LocalSteamId() == result)
				{
					Plugin.Log.LogInfo((object)("[DEVDUMP " + text4 + "] " + text3));
				}
			}
			catch
			{
			}
			return true;
		}

		private static ulong LocalSteamId()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)GameNetworkManager.Instance?.localPlayerController != (Object)null)
				{
					return GameNetworkManager.Instance.localPlayerController.playerSteamId;
				}
			}
			catch
			{
			}
			try
			{
				return SteamId.op_Implicit(SteamClient.SteamId);
			}
			catch
			{
				return 0uL;
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class AdminWhisperHidePatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(string chatMessage, string nameOfUserWhoTyped)
		{
			if (!Plugin.IsEnabled)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(nameOfUserWhoTyped))
			{
				return true;
			}
			if (VoteKickClientUi.TryHandleAdminWhisper(chatMessage))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
	internal static class VoteKickChatTipPatch
	{
		[HarmonyPostfix]
		private static void Postfix(string chatMessage, string nameOfUserWhoTyped)
		{
			if (Plugin.IsEnabled && string.IsNullOrEmpty(nameOfUserWhoTyped) && VoteKickClientUi.LooksLikeVoteKickChat(chatMessage))
			{
				string text = chatMessage ?? "";
				if (text.StartsWith("[VK]", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(4).Trim();
				}
				else if (text.StartsWith("[VOTE]", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(6).Trim();
				}
				else if (text.StartsWith("[ADMIN]", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(7).Trim();
				}
				string title = ((chatMessage ?? "").StartsWith("[ADMIN]", StringComparison.OrdinalIgnoreCase) ? "Admin" : ((!(chatMessage ?? "").StartsWith("[VOTE]", StringComparison.OrdinalIgnoreCase)) ? "Vote Kick" : "Vote"));
				VoteKickClientUi.ShowTip(title, Truncate(text, 120), warning: true);
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(MenuManager), "DisplayMenuNotification")]
	internal static class VoteKickJoinDenyPatch
	{
		[HarmonyPrefix]
		private static void Prefix(ref string notificationText)
		{
			if (Plugin.IsEnabled && VoteKickClientUi.LooksLikeVoteKickBan(notificationText))
			{
				string text = notificationText ?? "";
				if (text.IndexOf("Vote-kicked", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("Banned", StringComparison.OrdinalIgnoreCase) < 0)
				{
					notificationText = "Vote-kicked — " + text;
				}
			}
		}

		[HarmonyPostfix]
		private static void Postfix(string notificationText)
		{
			if (Plugin.IsEnabled && VoteKickClientUi.LooksLikeVoteKickBan(notificationText))
			{
				VoteKickClientUi.ShowTip("Vote Kick Ban", Truncate(notificationText, 140), warning: true);
				Plugin.Log.LogInfo((object)("Join denied (vote-kick): " + notificationText));
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager), "OnLocalClientConnectionDisapproved")]
	internal static class VoteKickConnectionDisapprovedPatch
	{
		[HarmonyPostfix]
		private static void Postfix(GameNetworkManager __instance)
		{
			if (!Plugin.IsEnabled)
			{
				return;
			}
			try
			{
				string text = __instance.disconnectionReasonMessage ?? "";
				if (string.IsNullOrEmpty(text) && (Object)(object)NetworkManager.Singleton != (Object)null)
				{
					text = NetworkManager.Singleton.DisconnectReason ?? "";
				}
				if (VoteKickClientUi.LooksLikeVoteKickBan(text))
				{
					VoteKickClientUi.ShowTip("Vote Kick Ban", Truncate(text, 140), warning: true);
				}
			}
			catch
			{
			}
		}

		private static string Truncate(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			return s.Substring(0, max - 1) + "…";
		}
	}
	[HarmonyPatch(typeof(HUDManager), "UpdateWeightCounter")]
	internal static class WeightKgDisplayPatch
	{
		private const float LbToKg = 0.45359236f;

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(HUDManager __instance)
		{
			if (!Plugin.IsEnabled)
			{
				return;
			}
			TextMeshProUGUI weightCounter = __instance.weightCounter;
			if ((Object)(object)weightCounter == (Object)null)
			{
				return;
			}
			try
			{
				PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
				if (!((Object)(object)val == (Object)null))
				{
					float num = Mathf.Round(Mathf.Clamp(val.carryWeight - 1f, 0f, 100f) * 105f) * 0.45359236f;
					((TMP_Text)weightCounter).text = ((num < 10f) ? $"{num:0.#} kg" : $"{Mathf.RoundToInt(num)} kg");
				}
			}
			catch
			{
			}
		}
	}
}
namespace Entiffo.UEXPDedicatedClient.Config
{
	public class ModConfig
	{
		public ConfigEntry<bool> Enabled { get; private set; }

		public ConfigEntry<bool> DebugLogging { get; private set; }

		public ConfigEntry<bool> ReplaceJoinWithDedicated { get; private set; }

		public ConfigEntry<bool> DedicatedBrowserOnly { get; private set; }

		public ConfigEntry<bool> ShowModListOnSlots { get; private set; }

		public ConfigEntry<string> PinnedOfficialNames { get; private set; }

		public ConfigEntry<string> PinnedOfficialProfileCodes { get; private set; }

		public ConfigEntry<bool> AutoSelectOnlineMode { get; private set; }

		public ConfigEntry<bool> EnableQuatSpamProbe { get; private set; }

		public ModConfig(ConfigFile cfg)
		{
			//IL_0012: 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_002d: Expected O, but got Unknown
			//IL_002d: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0059: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0085: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00b1: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00e1: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0111: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_013d: Expected O, but got Unknown
			//IL_014e: 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_0169: Expected O, but got Unknown
			//IL_0169: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			//IL_0195: Expected O, but got Unknown
			Enabled = cfg.Bind<bool>(new ConfigDefinition("General", "Enabled"), true, new ConfigDescription("Master toggle. When false, UEXP_Dedicated_Client does nothing — vanilla join/menus for normal games. Restart required after changing.", (AcceptableValueBase)null, Array.Empty<object>()));
			ReplaceJoinWithDedicated = cfg.Bind<bool>(new ConfigDefinition("Browser", "ReplaceJoinWithDedicated"), true, new ConfigDescription("Rename main-menu \"Join a crew\" to \"Join Dedicated\".", (AcceptableValueBase)null, Array.Empty<object>()));
			DedicatedBrowserOnly = cfg.Bind<bool>(new ConfigDefinition("Browser", "DedicatedBrowserOnly"), true, new ConfigDescription("Vanilla server list only shows lobbies marked uexpDedicated=1.", (AcceptableValueBase)null, Array.Empty<object>()));
			ShowModListOnSlots = cfg.Bind<bool>(new ConfigDefinition("Browser", "ShowModListOnSlots"), true, new ConfigDescription("Show host-published mod list under each dedicated lobby name.", (AcceptableValueBase)null, Array.Empty<object>()));
			PinnedOfficialNames = cfg.Bind<string>(new ConfigDefinition("Browser", "PinnedOfficialNames"), "UEXP Official 24/7", new ConfigDescription("Lobby names (semicolon-separated) always sorted to the top of Join Dedicated when online.", (AcceptableValueBase)null, Array.Empty<object>()));
			PinnedOfficialProfileCodes = cfg.Bind<string>(new ConfigDefinition("Browser", "PinnedOfficialProfileCodes"), "019f9417-e940-6130-828c-b8957c2e5cab", new ConfigDescription("r2modman profile codes (semicolon/comma-separated) that also pin a lobby to the top.", (AcceptableValueBase)null, Array.Empty<object>()));
			AutoSelectOnlineMode = cfg.Bind<bool>(new ConfigDefinition("Launch", "AutoSelectOnlineMode"), true, new ConfigDescription("Skip LAN / Online launch picker and always continue in Steam online mode.", (AcceptableValueBase)null, Array.Empty<object>()));
			DebugLogging = cfg.Bind<bool>(new ConfigDefinition("General", "DebugLogging"), false, new ConfigDescription("Extra logs (local only).", (AcceptableValueBase)null, Array.Empty<object>()));
			EnableQuatSpamProbe = cfg.Bind<bool>(new ConfigDefinition("General", "EnableQuatSpamProbe"), false, new ConfigDescription("Opt-in diagnostics for Unity 'Rotation quaternions must be unit length' spam. Off by default — leave off for normal play.", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}