using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BabyStepsMenuLib;
using BabyStepsMultiplayerClient;
using BabyStepsMultiplayerClient.Audio;
using BabyStepsMultiplayerClient.Components;
using BabyStepsMultiplayerClient.Config;
using BabyStepsMultiplayerClient.Extensions;
using BabyStepsMultiplayerClient.Localization;
using BabyStepsMultiplayerClient.Networking;
using BabyStepsMultiplayerClient.Networking.Steam;
using BabyStepsMultiplayerClient.Player;
using BabyStepsMultiplayerClient.UI;
using BabyStepsMultiplayerClient.UI.Elements;
using BabyStepsNetworking.Client;
using BabyStepsNetworking.Host;
using BabyStepsNetworking.Packets;
using BabyStepsNetworking.ServerBrowser;
using BabyStepsNetworking.Shared;
using BabyStepsNetworking.Transport;
using BabyStepsNetworking.Transport.LiteNetLib;
using BabyStepsNetworking.Transport.LocalLoopback;
using BabyStepsNetworking.Transport.Steam;
using Concentus.Enums;
using Concentus.Structs;
using HarmonyLib;
using Il2Cpp;
using Il2CppBabySteps.Core.Audio;
using Il2CppCinemachine;
using Il2CppFMOD;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppNWH.DWP2.WaterObjects;
using Il2CppRewired;
using Il2CppSteamworks;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using Tomlet;
using Tomlet.Models;
using Unity.LiveCapture.ARKitFaceCapture;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "BabyStepsMultiplayerClient", "1.3.2", "Caleb Orchard", "https://github.com/caleborchard/Baby-Steps-Multiplayer-Mod-Client")]
[assembly: MelonGame("DefaultCompany", "BabySteps")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Caleb Orchard")]
[assembly: AssemblyConfiguration("Retail - Debug")]
[assembly: AssemblyDescription("A MelonLoader mod for Baby Steps that adds multiplayer to the game.")]
[assembly: AssemblyFileVersion("1.3.2")]
[assembly: AssemblyInformationalVersion("1.3.2+c32baaf3066f84489719f6b43cbaf0715cdaa69b")]
[assembly: AssemblyProduct("BabyStepsMultiplayerClient")]
[assembly: AssemblyTitle("BabyStepsMultiplayerClient")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/caleborchard/Baby-Steps-Multiplayer-Mod-Client")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BabyStepsMultiplayerClient
{
	public class Core : MelonMod
	{
		public const string SERVER_VERSION = "108";

		public static string CLIENT_VERSION;

		public const string cloneText = "(Clone)";

		public static Instance logger;

		public static UIManager uiManager;

		public static NetworkManager networkManager;

		public static InGameHost inGameHost;

		public static Action OnConnectionStateChanged;

		private static ulong _pendingInviteConnect = 0uL;

		private static string _pendingInviteKey = string.Empty;

		private static float _continueBtnFirstSeenAt = -1f;

		private static float _lastContinueClickAt = -10f;

		private static ulong _pendingJoinLobbyCall = 0uL;

		private static ulong _pendingJoinLobbyId = 0uL;

		public override void OnLateInitializeMelon()
		{
			CLIENT_VERSION = ((MelonBase)this).Info.Version;
			logger = ((MelonBase)this).LoggerInstance;
			try
			{
				((MelonBase)this).HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
				((MelonBase)this).HarmonyInstance.PatchAll(typeof(MenuInjectionLibrary).Assembly);
			}
			catch (Exception value)
			{
				logger.Error($"Harmony patching failed: {value}");
			}
			ManagedEnumerator.Register();
			try
			{
				SteamClient.Init(0u, false);
				logger.Msg("[Steam] Facepunch initialized for invite callbacks");
			}
			catch (Exception ex) when (ex.Message.Contains("already initialized") || ex.Message.Contains("SteamAPI_SteamInput") || ex.Message.Contains("entry point") || ex.Message.Contains("SteamInput"))
			{
				logger.Msg("[Steam] Facepunch init note: " + ex.Message);
			}
			catch (Exception ex2)
			{
				logger.Warning("[Steam] Facepunch init failed: " + ex2.Message);
			}
			uiManager = new UIManager();
			networkManager = new NetworkManager();
			MultiplayerMenu.Initialize();
			NativeSteamAPI.RegisterLobbyJoinRequestedCallback(delegate(ulong lobbyId)
			{
				logger.Msg($"[Steam] Lobby invite accepted — lobbyId={lobbyId}, calling JoinLobby to fetch host ID…");
				if (_pendingJoinLobbyCall != 0)
				{
					logger.Warning($"[Steam] Overwriting a pending JoinLobby call ({_pendingJoinLobbyCall}) for lobby {_pendingJoinLobbyId}");
				}
				_pendingJoinLobbyCall = NativeSteamAPI.JoinLobby(lobbyId);
				_pendingJoinLobbyId = lobbyId;
				logger.Msg($"[Steam] JoinLobby handle={_pendingJoinLobbyCall} (will poll for result in OnUpdate)");
			});
			NativeSteamAPI.RegisterJoinRequestedCallback(delegate(string connectStr)
			{
				logger.Msg("[Steam] GameRichPresenceJoinRequested fired — connectStr='" + connectStr + "'");
				if (ulong.TryParse(connectStr.Trim(), out var result3) && result3 != 0)
				{
					logger.Msg($"[Steam] Game invite accepted — queuing connect to {result3}");
					_pendingInviteConnect = result3;
				}
				else
				{
					logger.Warning("[Steam] GameRichPresenceJoinRequested: could not parse '" + connectStr + "' as SteamID64");
				}
			});
			try
			{
				SteamFriends.OnGameLobbyJoinRequested += delegate(Lobby lobby, SteamId friend)
				{
					//IL_0003: 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)
					ulong num = SteamId.op_Implicit(((Lobby)(ref lobby)).Id);
					logger.Msg($"[Steam] Facepunch GameLobbyJoinRequested lid={num} friend={friend.Value}");
					if (_pendingJoinLobbyCall != 0)
					{
						logger.Warning($"[Steam] Overwriting pending JoinLobby {_pendingJoinLobbyCall}");
					}
					_pendingJoinLobbyCall = NativeSteamAPI.JoinLobby(num);
					_pendingJoinLobbyId = num;
					logger.Msg($"[Steam] JoinLobby handle={_pendingJoinLobbyCall}");
				};
				logger.Msg("[Steam] Facepunch OnGameLobbyJoinRequested hooked");
			}
			catch (Exception ex3)
			{
				logger.Msg("[Steam] Facepunch GameLobbyJoinRequested hook: " + ex3.Message);
			}
			try
			{
				SteamFriends.OnGameRichPresenceJoinRequested += delegate(Friend friend, string connectStr)
				{
					//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)
					logger.Msg($"[Steam] Facepunch GameRichPresenceJoinRequested connectStr='{connectStr}' friend={friend.Id.Value}");
					if (ulong.TryParse(connectStr.Trim(), out var result2) && result2 != 0)
					{
						_pendingInviteConnect = result2;
					}
					else
					{
						logger.Warning("[Steam] Facepunch GameRichPresenceJoinRequested: could not parse '" + connectStr + "'");
					}
				};
				logger.Msg("[Steam] Facepunch OnGameRichPresenceJoinRequested hooked");
			}
			catch (Exception ex4)
			{
				logger.Msg("[Steam] Facepunch GameRichPresenceJoinRequested hook: " + ex4.Message);
			}
			try
			{
				string text = NativeSteamAPI.GetLaunchCommandLine().Trim();
				if (!string.IsNullOrEmpty(text) && ulong.TryParse(text, out var result) && result != 0)
				{
					logger.Msg($"[Steam] Launched from game invite, will connect to {result}");
					_pendingInviteConnect = result;
				}
			}
			catch
			{
			}
			logger.Msg("Initialized!");
			VersionCheck.CheckForUpdate();
		}

		public override void OnGUI()
		{
			if (uiManager != null)
			{
				uiManager.Draw();
			}
		}

		public override void OnUpdate()
		{
			if (uiManager == null || networkManager == null)
			{
				return;
			}
			uiManager.Update();
			networkManager.Update();
			inGameHost?.Tick(Time.deltaTime * 1000f);
			MultiplayerMenu.Update();
			if (LocalPlayer.Instance != null)
			{
				LocalPlayer.Instance.Update();
			}
			InGameHost obj = inGameHost;
			if (obj == null || !obj.IsRunning)
			{
				try
				{
					NativeSteamAPI.RunCallbacks();
				}
				catch
				{
				}
				try
				{
					SteamClient.RunCallbacks();
				}
				catch
				{
				}
			}
			if (_pendingJoinLobbyCall != 0)
			{
				bool flag;
				bool failed;
				try
				{
					flag = NativeSteamAPI.IsAPICallCompleted(_pendingJoinLobbyCall, out failed);
				}
				catch (Exception ex)
				{
					logger.Warning("[Steam] IsAPICallCompleted threw: " + ex.Message);
					flag = false;
					failed = false;
				}
				if (flag)
				{
					ulong pendingJoinLobbyCall = _pendingJoinLobbyCall;
					ulong pendingJoinLobbyId = _pendingJoinLobbyId;
					_pendingJoinLobbyCall = 0uL;
					_pendingJoinLobbyId = 0uL;
					logger.Msg($"[Steam] JoinLobby call={pendingJoinLobbyCall} lobby={pendingJoinLobbyId} completed, failed={failed}");
					if (!failed)
					{
						string lobbyData = NativeSteamAPI.GetLobbyData(pendingJoinLobbyId, "bbs_host");
						string lobbyData2 = NativeSteamAPI.GetLobbyData(pendingJoinLobbyId, "bbs_invite_key");
						ulong lobbyOwner = NativeSteamAPI.GetLobbyOwner(pendingJoinLobbyId);
						logger.Msg($"[Steam] Invite lobby {pendingJoinLobbyId}: bbs_host='{lobbyData}' GetLobbyOwner={lobbyOwner} hasInviteKey={!string.IsNullOrEmpty(lobbyData2)}");
						ulong result = 0uL;
						if (!string.IsNullOrEmpty(lobbyData) && lobbyData != "0")
						{
							ulong.TryParse(lobbyData, out result);
						}
						if (result == 0)
						{
							result = lobbyOwner;
						}
						if (result != 0)
						{
							logger.Msg($"[Steam] Resolved invite host SteamID: {result}, queuing connect…");
							_pendingInviteConnect = result;
							_pendingInviteKey = lobbyData2;
						}
						else
						{
							logger.Warning($"[Steam] Could not resolve host SteamID from invite lobby {pendingJoinLobbyId} — bbs_host='{lobbyData}' owner={lobbyOwner}");
						}
					}
					else
					{
						logger.Warning($"[Steam] JoinLobby failed for lobby {pendingJoinLobbyId}");
					}
					try
					{
						NativeSteamAPI.LeaveLobby(pendingJoinLobbyId);
					}
					catch
					{
					}
				}
			}
			if (_pendingInviteConnect != 0L && !networkManager.IsConnected)
			{
				if (!HasLoadedGame())
				{
					Menu me = Menu.me;
					Button val = ((me != null) ? me.ContinueGameButton : null);
					if ((Object)(object)val != (Object)null)
					{
						float realtimeSinceStartup = Time.realtimeSinceStartup;
						if (_continueBtnFirstSeenAt < 0f)
						{
							_continueBtnFirstSeenAt = realtimeSinceStartup;
							logger.Msg("[Invite] ContinueGameButton found — waiting for menu to settle before clicking");
						}
						float num = realtimeSinceStartup - _continueBtnFirstSeenAt;
						float num2 = realtimeSinceStartup - _lastContinueClickAt;
						if (num >= 3f && num2 >= 5f)
						{
							_lastContinueClickAt = realtimeSinceStartup;
							logger.Msg($"[Invite] Clicking ContinueGameButton (interactable={((Selectable)val).interactable}, sinceAppear={num:F1}s, sinceClick={num2:F1}s)");
							((UnityEvent)val.onClick).Invoke();
						}
					}
					else
					{
						_continueBtnFirstSeenAt = -1f;
						float realtimeSinceStartup2 = Time.realtimeSinceStartup;
						if (realtimeSinceStartup2 - _lastContinueClickAt >= 5f)
						{
							_lastContinueClickAt = realtimeSinceStartup2;
							logger.Msg($"[Invite] Waiting for main menu (Menu.me={(((Object)(object)Menu.me != (Object)null) ? "exists" : "null")}, HasLoadedGame={HasLoadedGame()})");
						}
					}
				}
				else
				{
					_continueBtnFirstSeenAt = -1f;
					_lastContinueClickAt = -10f;
					ulong pendingInviteConnect = _pendingInviteConnect;
					string pendingInviteKey = _pendingInviteKey;
					_pendingInviteConnect = 0uL;
					_pendingInviteKey = string.Empty;
					logger.Msg($"[Steam] Auto-connecting to invite host {pendingInviteConnect} (inviteKey={!string.IsNullOrEmpty(pendingInviteKey)})");
					networkManager.ConnectSteam(pendingInviteConnect.ToString(), pendingInviteKey);
				}
			}
			else if (_pendingInviteConnect == 0)
			{
				_continueBtnFirstSeenAt = -1f;
				_lastContinueClickAt = -10f;
			}
			SteamP2PTest.Poll();
			if (MelonDebug.IsEnabled())
			{
				if (Input.GetKeyDown((KeyCode)284))
				{
					networkManager.Connect(ModSettings.connection.Address.Value, ModSettings.connection.Port.Value, ModSettings.connection.Password.Value);
				}
				if (Input.GetKeyDown((KeyCode)285))
				{
					networkManager.Disconnect();
				}
			}
		}

		public override void OnLateUpdate()
		{
			if (networkManager != null)
			{
				if (LocalPlayer.Instance != null)
				{
					LocalPlayer.Instance.LateUpdate();
				}
				networkManager.LateUpdate();
			}
		}

		public override void OnApplicationQuit()
		{
			InGameHost obj = inGameHost;
			if (obj != null && obj.IsRunning)
			{
				inGameHost.Stop();
			}
			networkManager?.Disconnect();
		}

		public static bool HasLoadedGame()
		{
			if ((Object)(object)Menu.me == (Object)null)
			{
				return false;
			}
			return Menu.me.gameInProgress;
		}

		public static void DebugMsg(string msg)
		{
			logger.Msg(msg);
		}

		public static bool RegisterComponent<T>(params Type[] interfaces) where T : class
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			try
			{
				RegisterTypeOptions val = new RegisterTypeOptions();
				val.set_LogSuccess(true);
				val.set_Interfaces(Il2CppInterfaceCollection.op_Implicit(interfaces));
				ClassInjector.RegisterTypeInIl2Cpp<T>(val);
			}
			catch (Exception value)
			{
				logger.Error($"Exception while attempting to Register {typeof(T).Name}: {value}");
				return false;
			}
			return true;
		}
	}
	public static class ModSettings
	{
		public static readonly ConnectionConfig connection = new ConnectionConfig();

		public static readonly PlayerConfig player = new PlayerConfig();

		public static readonly AudioConfig audio = new AudioConfig();

		public static void Load()
		{
			connection.Load();
			player.Load();
			audio.Load();
		}

		public static void Save()
		{
			connection.Save();
			player.Save();
			audio.Save();
		}
	}
}
namespace BabyStepsMultiplayerClient.UI
{
	internal static class InputBindingHelper
	{
		private static readonly bool CaptureLoggingEnabled = true;

		private const string RewiredActionPrefix = "RWACTION:";

		private const string RewiredButtonPrefix = "RWBTN:";

		private const string RewiredAxisPrefix = "RWAXIS:";

		private const float AxisThreshold = 0.5f;

		private const int MaxRawRewiredButtonId = 1023;

		private static readonly Dictionary<string, bool> _previousState = new Dictionary<string, bool>();

		private static readonly int[] _inputActionIds = BuildInputActionIdList();

		private static readonly KeyCode[] _joystickButtonKeyCodes = BuildJoystickButtonKeyCodes();

		public static bool IsInputHeldForCapture()
		{
			if (Input.anyKey)
			{
				return true;
			}
			for (int i = 0; i < _joystickButtonKeyCodes.Length; i++)
			{
				if (Input.GetKey(_joystickButtonKeyCodes[i]))
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryCapturePressedBinding(out string binding, out string displayName)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_009b: 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)
			for (int i = 0; i < _joystickButtonKeyCodes.Length; i++)
			{
				KeyCode val = _joystickButtonKeyCodes[i];
				if (Input.GetKeyDown(val))
				{
					binding = ((object)(KeyCode)(ref val)).ToString();
					displayName = ((object)(KeyCode)(ref val)).ToString();
					LogCapture("joystick-keycode", binding, displayName);
					return true;
				}
			}
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				KeyCode val2 = value;
				if ((int)val2 == 0 || IsJoystickKeyCode(val2) || !Input.GetKeyDown(val2))
				{
					continue;
				}
				binding = ((object)(KeyCode)(ref val2)).ToString();
				displayName = ((object)(KeyCode)(ref val2)).ToString();
				LogCapture("keyboard", binding, displayName);
				return true;
			}
			Menu me = Menu.me;
			Player val3 = ((me != null) ? me.rwPlayer : null);
			if (val3 != null)
			{
				for (int j = 0; j < _inputActionIds.Length; j++)
				{
					int num = _inputActionIds[j];
					if (val3.GetButtonDown(num))
					{
						if (!TryGetInputActionName(num, out var actionName))
						{
							actionName = "Action_" + num;
						}
						if (!IsAxisLikeAction(num, actionName))
						{
							binding = "RWACTION:" + actionName;
							displayName = FormatActionDisplayName(actionName);
							LogCapture("rewired-action", binding, displayName);
							return true;
						}
					}
				}
				if (TryCaptureAxisDown(out binding, out displayName))
				{
					return true;
				}
				for (int k = 0; k <= 1023; k++)
				{
					if (val3.GetButtonDown(k))
					{
						binding = "RWBTN:" + k;
						displayName = GetRewiredButtonDisplayName(k);
						LogCapture("rewired-raw-button", binding, displayName);
						return true;
					}
				}
			}
			binding = null;
			displayName = null;
			return false;
		}

		public static bool IsPressed(string binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return Input.GetKey(keyCode);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				Menu me = Menu.me;
				int result;
				if (me == null)
				{
					result = 0;
				}
				else
				{
					Player rwPlayer = me.rwPlayer;
					result = (((rwPlayer != null) ? new bool?(rwPlayer.GetButton(actionId)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result != 0;
			}
			if (TryParseRewiredAction(binding, out var actionName) && TryGetInputActionId(actionName, out var actionId2))
			{
				Menu me2 = Menu.me;
				int result2;
				if (me2 == null)
				{
					result2 = 0;
				}
				else
				{
					Player rwPlayer2 = me2.rwPlayer;
					result2 = (((rwPlayer2 != null) ? new bool?(rwPlayer2.GetButton(actionId2)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result2 != 0;
			}
			if (TryParseRewiredAxis(binding, out var axisId, out var direction))
			{
				Menu me3 = Menu.me;
				Player val = ((me3 != null) ? me3.rwPlayer : null);
				if (val == null)
				{
					return false;
				}
				float axis = val.GetAxis(axisId);
				return (direction > 0) ? (axis > 0.5f) : (axis < -0.5f);
			}
			return false;
		}

		public static bool IsDown(string binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return Input.GetKeyDown(keyCode);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				Menu me = Menu.me;
				int result;
				if (me == null)
				{
					result = 0;
				}
				else
				{
					Player rwPlayer = me.rwPlayer;
					result = (((rwPlayer != null) ? new bool?(rwPlayer.GetButtonDown(actionId)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result != 0;
			}
			if (TryParseRewiredAction(binding, out var actionName) && TryGetInputActionId(actionName, out var actionId2))
			{
				Menu me2 = Menu.me;
				int result2;
				if (me2 == null)
				{
					result2 = 0;
				}
				else
				{
					Player rwPlayer2 = me2.rwPlayer;
					result2 = (((rwPlayer2 != null) ? new bool?(rwPlayer2.GetButtonDown(actionId2)) : null).GetValueOrDefault() ? 1 : 0);
				}
				return (byte)result2 != 0;
			}
			if (TryParseRewiredAxis(binding, out var _, out var _))
			{
				bool flag = IsPressed(binding);
				_previousState.TryGetValue(binding, out var value);
				_previousState[binding] = flag;
				return flag && !value;
			}
			return false;
		}

		public static bool IsControllerBinding(string binding)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(binding))
			{
				return false;
			}
			if (TryParseKeyCode(binding, out var keyCode))
			{
				return IsJoystickKeyCode(keyCode);
			}
			if (binding.StartsWith("RWACTION:", StringComparison.Ordinal) || binding.StartsWith("RWBTN:", StringComparison.Ordinal) || binding.StartsWith("RWAXIS:", StringComparison.Ordinal))
			{
				return true;
			}
			return false;
		}

		public static string GetDisplayName(string binding)
		{
			if (TryParseRewiredAction(binding, out var actionName))
			{
				return FormatActionDisplayName(actionName);
			}
			if (TryParseRewiredButton(binding, out var actionId))
			{
				return GetRewiredButtonDisplayName(actionId);
			}
			if (TryParseRewiredAxis(binding, out var axisId, out var direction))
			{
				switch (axisId)
				{
				case 13:
					return (direction > 0) ? "AXIS Up" : "AXIS Down";
				case 12:
					return (direction > 0) ? "AXIS Right" : "AXIS Left";
				}
			}
			return binding;
		}

		private static bool TryParseKeyCode(string binding, out KeyCode keyCode)
		{
			if (string.IsNullOrWhiteSpace(binding))
			{
				keyCode = (KeyCode)0;
				return false;
			}
			if (!Enum.TryParse<KeyCode>(binding, ignoreCase: true, out keyCode))
			{
				return false;
			}
			return (int)keyCode != 0;
		}

		private static bool TryParseRewiredButton(string binding, out int actionId)
		{
			actionId = -1;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWBTN:", StringComparison.Ordinal))
			{
				return false;
			}
			return int.TryParse(binding.Substring("RWBTN:".Length), out actionId);
		}

		private static bool TryParseRewiredAction(string binding, out string actionName)
		{
			actionName = null;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWACTION:", StringComparison.Ordinal))
			{
				return false;
			}
			actionName = binding.Substring("RWACTION:".Length);
			return !string.IsNullOrWhiteSpace(actionName);
		}

		private static bool TryParseRewiredAxis(string binding, out int axisId, out int direction)
		{
			axisId = -1;
			direction = 0;
			if (string.IsNullOrWhiteSpace(binding) || !binding.StartsWith("RWAXIS:", StringComparison.Ordinal))
			{
				return false;
			}
			string text = binding.Substring("RWAXIS:".Length);
			string[] array = text.Split(':');
			if (array.Length != 2)
			{
				return false;
			}
			if (!int.TryParse(array[0], out axisId))
			{
				return false;
			}
			if (array[1] == "+")
			{
				direction = 1;
				return true;
			}
			if (array[1] == "-")
			{
				direction = -1;
				return true;
			}
			return false;
		}

		private static bool TryCaptureAxisDown(out string binding, out string displayName)
		{
			Menu me = Menu.me;
			Player val = ((me != null) ? me.rwPlayer : null);
			if (val == null)
			{
				binding = null;
				displayName = null;
				return false;
			}
			float axis = val.GetAxis(12);
			float axisPrev = val.GetAxisPrev(12);
			float axis2 = val.GetAxis(13);
			float axisPrev2 = val.GetAxisPrev(13);
			if (axis2 > 0.5f && axisPrev2 <= 0.5f)
			{
				binding = "RWAXIS:" + 13 + ":+";
				displayName = "AXIS Up";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis2 < -0.5f && axisPrev2 >= -0.5f)
			{
				binding = "RWAXIS:" + 13 + ":-";
				displayName = "AXIS Down";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis > 0.5f && axisPrev <= 0.5f)
			{
				binding = "RWAXIS:" + 12 + ":+";
				displayName = "AXIS Right";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			if (axis < -0.5f && axisPrev >= -0.5f)
			{
				binding = "RWAXIS:" + 12 + ":-";
				displayName = "AXIS Left";
				LogCapture("rewired-axis", binding, displayName);
				return true;
			}
			binding = null;
			displayName = null;
			return false;
		}

		private static string GetRewiredButtonDisplayName(int actionId)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.IsDefined(typeof(InputActions), actionId))
			{
				InputActions val = (InputActions)actionId;
				return ((object)(InputActions)(ref val)).ToString();
			}
			return "Controller Button " + actionId;
		}

		private static int[] BuildInputActionIdList()
		{
			Array values = Enum.GetValues(typeof(InputActions));
			List<int> list = new List<int>(values.Length);
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < values.Length; i++)
			{
				int item = (int)values.GetValue(i);
				if (hashSet.Add(item))
				{
					list.Add(item);
				}
			}
			list.Sort();
			return list.ToArray();
		}

		private static bool TryGetInputActionName(int actionId, out string actionName)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			actionName = null;
			if (!Enum.IsDefined(typeof(InputActions), actionId))
			{
				return false;
			}
			InputActions val = (InputActions)actionId;
			actionName = ((object)(InputActions)(ref val)).ToString();
			return !string.IsNullOrWhiteSpace(actionName);
		}

		private static bool TryGetInputActionId(string actionName, out int actionId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			actionId = -1;
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return false;
			}
			if (!Enum.TryParse<InputActions>(actionName, ignoreCase: true, out InputActions result))
			{
				return false;
			}
			actionId = (int)result;
			return true;
		}

		private static bool IsAxisLikeAction(int actionId, string actionName)
		{
			if (actionId == 12 || actionId == 13)
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return false;
			}
			return actionName.IndexOf("Horizontal", StringComparison.OrdinalIgnoreCase) >= 0 || actionName.IndexOf("Vertical", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static KeyCode[] BuildJoystickButtonKeyCodes()
		{
			//IL_0029: 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)
			List<KeyCode> list = new List<KeyCode>();
			for (int i = 0; i <= 19; i++)
			{
				if (Enum.TryParse<KeyCode>("JoystickButton" + i, out KeyCode result))
				{
					list.Add(result);
				}
			}
			for (int j = 1; j <= 8; j++)
			{
				for (int k = 0; k <= 19; k++)
				{
					if (Enum.TryParse<KeyCode>("Joystick" + j + "Button" + k, out KeyCode result2))
					{
						list.Add(result2);
					}
				}
			}
			return list.ToArray();
		}

		private static bool IsJoystickKeyCode(KeyCode keyCode)
		{
			string text = ((object)(KeyCode)(ref keyCode)).ToString();
			return text.IndexOf("Joystick", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static string FormatActionDisplayName(string actionName)
		{
			if (string.IsNullOrWhiteSpace(actionName))
			{
				return actionName;
			}
			if (actionName.StartsWith("UI", StringComparison.OrdinalIgnoreCase))
			{
				return "DPAD " + actionName.Substring(2);
			}
			return actionName;
		}

		private static void LogCapture(string source, string binding, string displayName)
		{
			if (CaptureLoggingEnabled)
			{
				Core.DebugMsg($"[BindCapture] source={source} binding={binding} display={displayName}");
			}
		}
	}
	public static class MultiplayerMenu
	{
		private enum KeybindCaptureTarget
		{
			None,
			PushToTalk,
			TabMenu,
			ChatMenu
		}

		private static InjectedMenu _menu;

		private static Toggle _collisionToggle;

		private static Toggle _cutsceneToggle;

		private static Toggle _nametagToggle;

		private static Button _pttKeyBtn;

		private static Button _tabMenuKeyBtn;

		private static Button _chatMenuKeyBtn;

		private static Button _audioDeviceBtn;

		private static float _lastAudioDeviceLabelRefresh = -10f;

		private static Image _colorPreviewImage;

		private static KeybindCaptureTarget _keybindCaptureTarget;

		private static bool _waitingForRelease;

		private static BaseInputModule _cachedInputModule;

		private static bool _playerMovementSuppressedForCapture;

		private static bool _playerMovementWasEnabledBeforeCapture;

		private static Button _connectTabBtn;

		private static Button _hostLanTabBtn;

		private static Button _hostSteamTabBtn;

		private static string _lastKnownLanguage;

		private static TMP_Text _lobbyBrowserLabel;

		private static TMP_Text _audioDeviceStaticLabel;

		private static TMP_Text _gainLabel;

		private static Button _tabBtn0;

		private static Button _tabBtn1;

		private static Button _tabBtn2;

		private static Button _tabBtn3;

		private static Button _tabBtn4;

		private static Toggle _microphoneToggle;

		private static Toggle _deafenToggle;

		private static Toggle _pttToggle;

		private static Button _updateAppearanceBtn;

		private static TMP_Text _serverIpLabel;

		private static TMP_Text _serverPortLabel;

		private static TMP_Text _passwordOptLabel;

		private static InputFieldInfo _serverIpInputInfo;

		private static InputFieldInfo _serverPortInputInfo;

		private static InputFieldInfo _lanPasswordInputInfo;

		private static InputFieldInfo _hostingPasswordInputInfo;

		private static TMP_Text _pwEnterTmp;

		private static TMP_Text _pwBackTmp;

		private const int PublicMainPort = 7777;

		private const int PublicMainStatusPort = 7778;

		private const string PublicMainName = "Public Main";

		private static SteamLobbyBrowser _lobbyBrowser;

		private static readonly List<ServerInfo> _foundLobbies = new List<ServerInfo>();

		private static readonly List<ServerInfo> _displayLobbies = new List<ServerInfo>();

		private static readonly List<Button> _lobbyButtons = new List<Button>();

		private static Button _refreshBtn;

		private const int PageSize = 5;

		private static int _lobbyPage = 0;

		private static Button _prevPageBtn;

		private static TMP_Text _pageLabel;

		private static Button _nextPageBtn;

		private static (int PlayerCount, int MaxPlayers, bool IsLocked)? _publicMainStatus;

		private static Task<(int PlayerCount, int MaxPlayers, bool IsLocked)?>? _publicMainQueryTask;

		private static ServerInfo _connectedServerInfo;

		private static int _lastDisplayedPlayerCount = -1;

		private static bool _buttonsWereReady = false;

		private static ServerInfo _pendingLockedLobby;

		private static string _pendingJoinPassword = string.Empty;

		private static GameObject _pwCanvas;

		private static TMP_Text _pwTitle;

		private static Button _pwInputBtn;

		private static InputFieldInfo _pwInputInfo;

		private static float _pwEnterDebounce = -10f;

		private static Sprite _lockSprite;

		private static readonly GameObject[] _lobbyLockIcons = (GameObject[])(object)new GameObject[5];

		private static Button _pwEnterBtn;

		private static Button _pwBackBtn;

		private static float _lastAutoLobbyRefresh = -30f;

		private static string _steamJoinId = string.Empty;

		private static Button _hostingPasswordBtn;

		private static bool _steamJoinInProgress = false;

		private static ulong _ownLobbyId;

		private static float _lastHostSteamClickTime = -10f;

		private static float _lastConnectClickTime = -10f;

		private static float _lastLobbyClickTime = -10f;

		public static bool IsCapturingKeybind => _keybindCaptureTarget != KeybindCaptureTarget.None;

		private static string PublicMainAddress
		{
			get
			{
				string text = ModSettings.connection.PublicMainIpOverride?.Value;
				return (!string.IsNullOrEmpty(text)) ? text : "bbsmm.mooo.com";
			}
		}

		public static void Initialize()
		{
			if (_menu == null)
			{
				MenuInjectionLibrary.Logger = Core.logger;
				MenuInjectionLibrary.IsCapturingKeybindProvider = () => IsCapturingKeybind;
				MenuInjectionLibrary.IsOverlayBlockingMenuProvider = () => (Object)(object)_pwCanvas != (Object)null && _pwCanvas.activeSelf;
				MenuInjectionLibrary.OnChatKeyboardCancelled += delegate
				{
					Core.uiManager.showChatTab = false;
				};
				ModSettings.Load();
				_lobbyBrowser = new SteamLobbyBrowser();
				((SteamLobbyBrowserSource)_lobbyBrowser).ServersFound += OnLobbiesFound;
				ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
				_lastKnownLanguage = LanguageManager.CurrentLanguage;
				_menu = MenuInjectionLibrary.CreateMenu("Multiplayer").AddTab(currentLanguage.TabLobby, (Action<TabBuilder>)ConfigureServersTab).AddTab(currentLanguage.TabPlayer, (Action<TabBuilder>)ConfigurePlayerTab)
					.AddTab(currentLanguage.TabGeneral, (Action<TabBuilder>)ConfigureGeneralTab)
					.AddTab(currentLanguage.TabAudio, (Action<TabBuilder>)ConfigureAudioTab)
					.AddTab(currentLanguage.TabLAN, (Action<TabBuilder>)ConfigureConnectionTab)
					.AddFixedButton(currentLanguage.ButtonBack, (UnityAction)null)
					.WithMargin(136f, 125f)
					.Build();
				Core.OnConnectionStateChanged = (Action)Delegate.Combine(Core.OnConnectionStateChanged, new Action(RefreshConnectionState));
				Core.OnConnectionStateChanged = (Action)Delegate.Combine(Core.OnConnectionStateChanged, new Action(RefreshHostState));
				Core.OnConnectionStateChanged = (Action)Delegate.Combine(Core.OnConnectionStateChanged, new Action(RefreshHostSteamState));
				_publicMainQueryTask = DedicatedServerQuery.QueryAsync(PublicMainAddress, 7778);
				SteamLobbyBrowser lobbyBrowser = _lobbyBrowser;
				if (lobbyBrowser != null)
				{
					((SteamLobbyBrowserSource)lobbyBrowser).Refresh();
				}
				RebuildLobbyUI();
			}
		}

		public static void Update()
		{
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			string currentLanguage = LanguageManager.CurrentLanguage;
			if (currentLanguage != _lastKnownLanguage)
			{
				_lastKnownLanguage = currentLanguage;
				RefreshLocalizableText();
			}
			_lobbyBrowser?.Poll();
			if (!_buttonsWereReady && _lobbyButtons.Count > 0)
			{
				_buttonsWereReady = true;
				InjectedMenu menu = _menu;
				_tabBtn0 = ((menu != null) ? menu.GetTab(0) : null);
				InjectedMenu menu2 = _menu;
				_tabBtn1 = ((menu2 != null) ? menu2.GetTab(1) : null);
				InjectedMenu menu3 = _menu;
				_tabBtn2 = ((menu3 != null) ? menu3.GetTab(2) : null);
				InjectedMenu menu4 = _menu;
				_tabBtn3 = ((menu4 != null) ? menu4.GetTab(3) : null);
				InjectedMenu menu5 = _menu;
				_tabBtn4 = ((menu5 != null) ? menu5.GetTab(4) : null);
				RefreshLocalizableText();
				RepositionPaginationRow();
				InjectedMenu menu6 = _menu;
				Button val = ((menu6 != null) ? menu6.GetFixedButton(0) : null);
				if ((Object)(object)val != (Object)null)
				{
					RectTransform component = ((Component)val).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						component.anchoredPosition = new Vector2(component.anchoredPosition.x, component.anchoredPosition.y - 135f);
					}
				}
				RebuildLobbyUI();
				if (_publicMainQueryTask == null || _publicMainQueryTask.IsCompleted)
				{
					_publicMainQueryTask = DedicatedServerQuery.QueryAsync(PublicMainAddress, 7778);
				}
			}
			if (_publicMainQueryTask != null && _publicMainQueryTask.IsCompleted)
			{
				_publicMainStatus = _publicMainQueryTask.Result;
				_publicMainQueryTask = null;
				RebuildLobbyUI();
			}
			if (Core.networkManager.IsConnected && _connectedServerInfo != null)
			{
				int num = Core.networkManager.players.Values.Count((RemotePlayer p) => p.firstAppearanceApplication) + 1;
				if (num != _lastDisplayedPlayerCount)
				{
					_lastDisplayedPlayerCount = num;
					RebuildLobbyUI();
				}
			}
			else if (!Core.networkManager.IsConnected && _connectedServerInfo != null)
			{
				_connectedServerInfo = null;
				_lastDisplayedPlayerCount = -1;
				RebuildLobbyUI();
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!Core.networkManager.IsConnected)
			{
				InGameHost inGameHost = Core.inGameHost;
				if ((inGameHost == null || !inGameHost.IsRunning) && realtimeSinceStartup - _lastAutoLobbyRefresh >= 30f)
				{
					_lastAutoLobbyRefresh = realtimeSinceStartup;
					SteamLobbyBrowser lobbyBrowser = _lobbyBrowser;
					if (lobbyBrowser != null)
					{
						((SteamLobbyBrowserSource)lobbyBrowser).Refresh();
					}
					if (_publicMainQueryTask == null || _publicMainQueryTask.IsCompleted)
					{
						_publicMainQueryTask = DedicatedServerQuery.QueryAsync(PublicMainAddress, 7778);
					}
				}
			}
			if ((Object)(object)_audioDeviceBtn != (Object)null)
			{
				float realtimeSinceStartup2 = Time.realtimeSinceStartup;
				if (realtimeSinceStartup2 - _lastAudioDeviceLabelRefresh >= 3f)
				{
					_lastAudioDeviceLabelRefresh = realtimeSinceStartup2;
					SetBtnText(_audioDeviceBtn, GetAudioDeviceLabel());
				}
			}
			if (_keybindCaptureTarget == KeybindCaptureTarget.None)
			{
				return;
			}
			UpdateGameplayInputSuppressionForCapture();
			string binding;
			string displayName;
			if (_waitingForRelease)
			{
				if (!InputBindingHelper.IsInputHeldForCapture())
				{
					_waitingForRelease = false;
				}
			}
			else if (InputBindingHelper.TryCapturePressedBinding(out binding, out displayName))
			{
				ApplyCapturedKeybind(binding, displayName);
			}
		}

		private static void ConfigurePlayerTab(TabBuilder tab)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			Color value = ModSettings.player.SuitColor.Value;
			_updateAppearanceBtn = tab.AddButton(currentLanguage.UpdateNameAndAppearance, UnityAction.op_Implicit((Action)OnUpdateAppearanceClicked));
			tab.AddInputField(currentLanguage.Nickname, UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				ModSettings.player.Nickname.Value = v;
			}), ModSettings.player.Nickname.Value);
			Slider val2 = null;
			Slider val3 = null;
			Slider val4 = null;
			val2 = tab.AddSlider("R:", 0f, 1f, value.r, UnityAction<float>.op_Implicit((Action<float>)delegate(float val)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				Color value4 = ModSettings.player.SuitColor.Value;
				value4.r = val;
				ModSettings.player.SuitColor.Value = value4;
				RefreshColorPreview();
			}), false);
			val3 = tab.AddSlider("G:", 0f, 1f, value.g, UnityAction<float>.op_Implicit((Action<float>)delegate(float val)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				Color value3 = ModSettings.player.SuitColor.Value;
				value3.g = val;
				ModSettings.player.SuitColor.Value = value3;
				RefreshColorPreview();
			}), false);
			val4 = tab.AddSlider("B:", 0f, 1f, value.b, UnityAction<float>.op_Implicit((Action<float>)delegate(float val)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				Color value2 = ModSettings.player.SuitColor.Value;
				value2.b = val;
				ModSettings.player.SuitColor.Value = value2;
				RefreshColorPreview();
			}), false);
			_colorPreviewImage = tab.AddImage(value, 40f);
		}

		private static void ConfigureConnectionTab(TabBuilder tab)
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			_serverIpLabel = tab.AddLabel(currentLanguage.ServerIP);
			tab.AddInputField(currentLanguage.ServerIP, UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				ModSettings.connection.Address.Value = v;
			}), ModSettings.connection.Address.Value);
			_serverIpInputInfo = MenuInjectionLibrary.LastCreatedInputFieldInfo;
			_serverPortLabel = tab.AddLabel(currentLanguage.ServerPort);
			tab.AddInputField(currentLanguage.ServerPort, UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				if (int.TryParse(v, out var result))
				{
					ModSettings.connection.Port.Value = result;
				}
			}), ModSettings.connection.Port.Value.ToString());
			_serverPortInputInfo = MenuInjectionLibrary.LastCreatedInputFieldInfo;
			_passwordOptLabel = tab.AddLabel(currentLanguage.PasswordOptional);
			tab.AddInputField(currentLanguage.PasswordOptional, UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				ModSettings.connection.Password.Value = v;
			}), ModSettings.connection.Password.Value);
			_lanPasswordInputInfo = MenuInjectionLibrary.LastCreatedInputFieldInfo;
			_connectTabBtn = tab.AddButton(GetConnectLabel(), UnityAction.op_Implicit((Action)OnConnectClicked));
			_hostLanTabBtn = tab.AddButton(GetHostLabel(), UnityAction.op_Implicit((Action)OnHostClicked));
		}

		private static void ConfigureGeneralTab(TabBuilder tab)
		{
			_collisionToggle = tab.AddToggle(GetCollisionToggleLabel(), ModSettings.player.Collisions.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnCollisionToggled));
			_cutsceneToggle = tab.AddToggle(GetCutsceneToggleLabel(), ModSettings.player.CutscenePlayerVisibility.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnCutsceneToggled));
			_nametagToggle = tab.AddToggle(GetNametagToggleLabel(), ModSettings.player.ShowNametags.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnNametagToggled));
			_tabMenuKeyBtn = tab.AddButton(GetTabMenuKeyLabel(), UnityAction.op_Implicit((Action)OnTabMenuKeyClicked));
			_chatMenuKeyBtn = tab.AddButton(GetChatMenuKeyLabel(), UnityAction.op_Implicit((Action)OnChatMenuKeyClicked));
		}

		private static void ConfigureAudioTab(TabBuilder tab)
		{
			_microphoneToggle = tab.AddToggle(GetMicrophoneToggleLabel(), ModSettings.audio.MicrophoneEnabled.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnMicrophoneToggled));
			_deafenToggle = tab.AddToggle(GetDeafenToggleLabel(), ModSettings.audio.Deafened.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnDeafenToggled));
			_pttToggle = tab.AddToggle(GetPushToTalkToggleLabel(), ModSettings.audio.PushToTalk.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnPushToTalkToggled));
			_pttKeyBtn = tab.AddButton(GetPttKeyLabel(), UnityAction.op_Implicit((Action)OnPttKeyClicked));
			((Selectable)_pttKeyBtn).interactable = ModSettings.audio.PushToTalk.Value;
			Slider val2 = null;
			_gainLabel = tab.AddLabel(GetGainLabel());
			val2 = tab.AddSlider("", 0f, 3f, ModSettings.audio.MicrophoneGain.Value, UnityAction<float>.op_Implicit((Action<float>)delegate(float val)
			{
				ModSettings.audio.MicrophoneGain.Value = val;
				LocalPlayer.Instance?.mic.SetGain(val);
				if ((Object)(object)_gainLabel != (Object)null)
				{
					_gainLabel.text = GetGainLabel();
					_gainLabel.ForceMeshUpdate(false, false);
				}
			}), false);
			_audioDeviceStaticLabel = tab.AddLabel(LanguageManager.GetCurrentLanguage().AudioDevice);
			_audioDeviceBtn = tab.AddButton(GetAudioDeviceLabel(), UnityAction.op_Implicit((Action)OnAudioDeviceCycled));
		}

		private static void ConfigureServersTab(TabBuilder tab)
		{
			//IL_0002: 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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01d2: Unknown result type (might be due to invalid IL or missing references)
			tab.AddImage(Color.clear, 10f);
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			_hostSteamTabBtn = tab.AddButton(GetHostSteamLabel(), UnityAction.op_Implicit((Action)OnHostSteamClicked));
			_hostingPasswordBtn = tab.AddInputField(currentLanguage.LobbyPassword, UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				ModSettings.connection.HostPassword.Value = v;
			}), ModSettings.connection.HostPassword.Value);
			_hostingPasswordInputInfo = MenuInjectionLibrary.LastCreatedInputFieldInfo;
			tab.AddImage(Color.clear, 24f);
			_lobbyBrowserLabel = tab.AddLabel(currentLanguage.LobbyBrowser);
			_refreshBtn = tab.AddButton(currentLanguage.Refresh, UnityAction.op_Implicit((Action)OnRefreshLobbies));
			_prevPageBtn = tab.AddButton("<", UnityAction.op_Implicit((Action)OnPrevPage));
			_pageLabel = tab.AddLabel("1/1");
			_nextPageBtn = tab.AddButton(">", UnityAction.op_Implicit((Action)OnNextPage));
			for (int i = 0; i < 5; i++)
			{
				int captured = i;
				Button val = tab.AddButton("---", UnityAction.op_Implicit((Action)delegate
				{
					OnLobbyButtonClicked(captured);
				}));
				((Selectable)val).interactable = false;
				ColorBlock colors = ((Selectable)val).colors;
				((ColorBlock)(ref colors)).disabledColor = new Color(((ColorBlock)(ref colors)).disabledColor.r, ((ColorBlock)(ref colors)).disabledColor.g, ((ColorBlock)(ref colors)).disabledColor.b, 0.8f);
				((Selectable)val).colors = colors;
				_lobbyButtons.Add(val);
			}
			BuildPasswordPopup();
		}

		private static void OnConnectClicked()
		{
			if (Core.networkManager.IsConnected)
			{
				Core.networkManager.Disconnect();
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup - _lastConnectClickTime < 0.5f))
			{
				_lastConnectClickTime = realtimeSinceStartup;
				ModSettings.Save();
				Core.networkManager.Connect(ModSettings.connection.Address.Value, ModSettings.connection.Port.Value, ModSettings.connection.Password.Value);
			}
		}

		private static void OnHostSteamClicked()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - _lastHostSteamClickTime < 0.5f)
			{
				return;
			}
			_lastHostSteamClickTime = realtimeSinceStartup;
			bool flag = Core.inGameHost?.IsRunning ?? false;
			if (!flag && Core.networkManager.IsConnected)
			{
				Core.networkManager.Disconnect();
				return;
			}
			if (flag)
			{
				Core.inGameHost?.Stop();
				Core.inGameHost = null;
				_ownLobbyId = 0uL;
				Core.networkManager.Disconnect();
				Core.uiManager.notificationsUI.AddMessage(LanguageManager.GetCurrentLanguage().StoppedHosting);
				RefreshHostSteamState();
				OnRefreshLobbies();
				return;
			}
			ModSettings.Save();
			string value = ModSettings.connection.HostPassword.Value;
			InGameHost inGameHost = new InGameHost();
			inGameHost.PlayerJoined += delegate(string name)
			{
				Core.uiManager.notificationsUI.AddMessage(string.Format(LanguageManager.GetCurrentLanguage().PlayerJoinedSession, name));
			};
			inGameHost.PlayerLeft += delegate(string name)
			{
				Core.uiManager.notificationsUI.AddMessage(string.Format(LanguageManager.GetCurrentLanguage().PlayerLeftSession, name));
			};
			LocalLoopbackClientTransport loopback = inGameHost.StartSteam(value);
			inGameHost.LobbyCreated += delegate(string lobbyIdStr)
			{
				ulong.TryParse(lobbyIdStr, out _ownLobbyId);
				RefreshHostSteamState();
				Core.networkManager.ConnectLoopback(loopback);
				OnRefreshLobbies();
			};
			Core.inGameHost = inGameHost;
			Core.uiManager.notificationsUI.AddMessage(LanguageManager.GetCurrentLanguage().CreatingLobby);
		}

		private static void OnHostClicked()
		{
			InGameHost inGameHost = Core.inGameHost;
			if (inGameHost != null && inGameHost.IsRunning)
			{
				Core.inGameHost?.Stop();
				Core.inGameHost = null;
				Core.networkManager.Disconnect();
				Core.uiManager.notificationsUI.AddMessage(LanguageManager.GetCurrentLanguage().StoppedHosting);
				RefreshHostState();
				return;
			}
			ModSettings.Save();
			int value = ModSettings.connection.Port.Value;
			string value2 = ModSettings.connection.Password.Value;
			InGameHost inGameHost2 = new InGameHost();
			inGameHost2.Log += delegate(string msg)
			{
				Core.logger.Msg("[Host] " + msg);
			};
			inGameHost2.PlayerJoined += delegate(string name)
			{
				Core.uiManager.notificationsUI.AddMessage(string.Format(LanguageManager.GetCurrentLanguage().PlayerJoinedSession, name));
			};
			inGameHost2.PlayerLeft += delegate(string name)
			{
				Core.uiManager.notificationsUI.AddMessage(string.Format(LanguageManager.GetCurrentLanguage().PlayerLeftSession, name));
			};
			inGameHost2.Start(value, value2);
			Core.inGameHost = inGameHost2;
			Core.networkManager.Connect("127.0.0.1", value, value2);
			Core.uiManager.notificationsUI.AddMessage(string.Format(LanguageManager.GetCurrentLanguage().HostingOnPort, value));
		}

		private static void OnJoinBySteamId()
		{
			if (_steamJoinInProgress)
			{
				return;
			}
			if (string.IsNullOrWhiteSpace(_steamJoinId))
			{
				Core.uiManager.notificationsUI.AddMessage("Enter the host's SteamID64 first.");
				return;
			}
			if (Core.networkManager.IsConnected)
			{
				Core.uiManager.notificationsUI.AddMessage("Disconnect first.");
				return;
			}
			_steamJoinInProgress = true;
			try
			{
				ModSettings.Save();
				Core.networkManager.ConnectSteam(_steamJoinId.Trim(), ModSettings.connection.Password.Value);
			}
			finally
			{
				_steamJoinInProgress = false;
			}
		}

		private static void OnP2PTestListenToggle()
		{
			if (SteamP2PTest.IsListening)
			{
				SteamP2PTest.StopListening();
			}
			else
			{
				SteamP2PTest.StartListening();
			}
		}

		private static void OnP2PTestPing()
		{
			if (!ulong.TryParse(_steamJoinId?.Trim(), out var result) || result == 0)
			{
				Core.uiManager.notificationsUI.AddMessage("Enter host SteamID64 in the field above first.");
			}
			else
			{
				SteamP2PTest.SendPing(result);
			}
		}

		private static void OnPrevPage()
		{
			int num = Mathf.Max(1, Mathf.CeilToInt((float)_displayLobbies.Count / 5f));
			_lobbyPage = (_lobbyPage - 1 + num) % num;
			RebuildLobbyUI();
		}

		private static void OnNextPage()
		{
			int num = Mathf.Max(1, Mathf.CeilToInt((float)_displayLobbies.Count / 5f));
			_lobbyPage = (_lobbyPage + 1) % num;
			RebuildLobbyUI();
		}

		private static void RepositionPaginationRow()
		{
			//IL_0095: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: 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_01ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_prevPageBtn == (Object)null || (Object)(object)_pageLabel == (Object)null || (Object)(object)_nextPageBtn == (Object)null)
			{
				return;
			}
			RectTransform component = ((Component)_prevPageBtn).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)_pageLabel).GetComponent<RectTransform>();
			RectTransform component3 = ((Component)_nextPageBtn).GetComponent<RectTransform>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null)
			{
				return;
			}
			Transform parent = ((Transform)component).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			float num;
			if ((Object)(object)val != (Object)null)
			{
				Rect rect = val.rect;
				if (((Rect)(ref rect)).width > 10f)
				{
					rect = val.rect;
					num = ((Rect)(ref rect)).width;
					goto IL_00c1;
				}
			}
			num = 800f;
			goto IL_00c1;
			IL_00c1:
			float num2 = num;
			float rowY = component.anchoredPosition.y;
			float num3 = num2 - 180f;
			Place(component, 0f, 90f);
			Place(component2, 90f, num3);
			Place(component3, 90f + num3, 90f);
			TMP_Text componentInChildren = ((Component)_prevPageBtn).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontStyle = (FontStyles)1;
				componentInChildren.ForceMeshUpdate(false, false);
			}
			TMP_Text componentInChildren2 = ((Component)_nextPageBtn).GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.fontStyle = (FontStyles)1;
				componentInChildren2.ForceMeshUpdate(false, false);
			}
			_pageLabel.alignment = (TextAlignmentOptions)514;
			_pageLabel.fontSize = 20f;
			_pageLabel.ForceMeshUpdate(false, false);
			foreach (Button lobbyButton in _lobbyButtons)
			{
				RectTransform component4 = ((Component)lobbyButton).GetComponent<RectTransform>();
				if ((Object)(object)component4 != (Object)null)
				{
					component4.anchoredPosition += new Vector2(0f, 124f);
				}
			}
			void Place(RectTransform rt, float x, float w)
			{
				//IL_000c: 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_0038: 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_005d: 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.sizeDelta = new Vector2(w, 52f);
				rt.anchoredPosition = new Vector2(x, rowY);
			}
		}

		private static void OnRefreshLobbies()
		{
			SetBtnText(_refreshBtn, LanguageManager.GetCurrentLanguage().Refreshing);
			foreach (Button lobbyButton in _lobbyButtons)
			{
				SetBtnText(lobbyButton, "---");
				((Selectable)lobbyButton).interactable = false;
			}
			_lastAutoLobbyRefresh = Time.realtimeSinceStartup;
			_publicMainQueryTask = DedicatedServerQuery.QueryAsync(PublicMainAddress, 7778);
			SteamLobbyBrowser lobbyBrowser = _lobbyBrowser;
			if (lobbyBrowser != null)
			{
				((SteamLobbyBrowserSource)lobbyBrowser).Refresh();
			}
		}

		private static void RebuildLobbyUI()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_00be: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: 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_01dd: Expected O, but got Unknown
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			_displayLobbies.Clear();
			InGameHost inGameHost = Core.inGameHost;
			if (inGameHost != null && inGameHost.IsRunning && _ownLobbyId != 0)
			{
				string personaName = NativeSteamAPI.GetPersonaName();
				bool flag = !string.IsNullOrEmpty(ModSettings.connection.HostPassword.Value);
				string name = (flag ? "\ud83d\udd12 " : "") + (string.IsNullOrEmpty(personaName) ? $"{NativeSteamAPI.GetLocalSteamId()}  (this session)" : (personaName + "'s Session  (this session)"));
				_displayLobbies.Add(new ServerInfo
				{
					Name = name,
					IsPasswordProtected = flag,
					Address = NativeSteamAPI.GetLocalSteamId().ToString(),
					SessionId = _ownLobbyId.ToString(),
					PlayerCount = Math.Max(1, Core.inGameHost.PlayerCount),
					MaxPlayers = 16,
					Type = (ServerType)1
				});
			}
			bool flag2 = _publicMainStatus?.IsLocked ?? false;
			_displayLobbies.Add(new ServerInfo
			{
				Name = (flag2 ? "\ud83d\udd12 " : "") + "Public Main",
				Address = PublicMainAddress,
				Port = 7777,
				PlayerCount = (_publicMainStatus?.PlayerCount ?? (-1)),
				MaxPlayers = (_publicMainStatus?.MaxPlayers ?? 16),
				IsPasswordProtected = flag2,
				Type = (ServerType)0
			});
			InGameHost inGameHost2 = Core.inGameHost;
			string ownAddress = ((inGameHost2 != null && inGameHost2.IsRunning && _ownLobbyId != 0L) ? NativeSteamAPI.GetLocalSteamId().ToString() : null);
			List<ServerInfo> collection = (from s in _foundLobbies
				where (int)s.Type != 1 || s.Address != ownAddress
				orderby s.PlayerCount descending
				select s).ToList();
			_displayLobbies.AddRange(collection);
			int num = Mathf.Max(1, Mathf.CeilToInt((float)_displayLobbies.Count / 5f));
			_lobbyPage = Mathf.Clamp(_lobbyPage, 0, num - 1);
			int num2 = _lobbyPage * 5;
			if ((Object)(object)_pageLabel != (Object)null)
			{
				_pageLabel.text = $"{_lobbyPage + 1}/{num}";
				_pageLabel.ForceMeshUpdate(false, false);
			}
			bool interactable = !Core.networkManager.IsConnected;
			int num3 = (Core.networkManager.IsConnected ? (Core.networkManager.players.Values.Count((RemotePlayer p) => p.firstAppearanceApplication) + 1) : (-2));
			for (int i = 0; i < _lobbyButtons.Count; i++)
			{
				int num4 = num2 + i;
				if (num4 < _displayLobbies.Count)
				{
					ServerInfo val = _displayLobbies[num4];
					int num5 = ((_connectedServerInfo != null && _connectedServerInfo.Address == val.Address && ((int)_connectedServerInfo.Type != 0 || _connectedServerInfo.Port == val.Port) && num3 >= 0) ? num3 : val.PlayerCount);
					string value = val.Name.Replace("\ud83d\udd12 ", string.Empty);
					string value2 = ((num5 < 0) ? "?" : num5.ToString());
					SetBtnText(_lobbyButtons[i], $"{value}  ({value2}/{val.MaxPlayers})");
					((Selectable)_lobbyButtons[i]).interactable = interactable;
					SetLobbyLockIcon(i, val.IsPasswordProtected);
				}
				else
				{
					SetBtnText(_lobbyButtons[i], "---");
					((Selectable)_lobbyButtons[i]).interactable = false;
					SetLobbyLockIcon(i, show: false);
				}
			}
		}

		private static void JoinServer(ServerInfo info, string password)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			_connectedServerInfo = info;
			_lastDisplayedPlayerCount = -1;
			ModSettings.Save();
			string arg = info.Name.Replace("\ud83d\udd12 ", string.Empty);
			string message = string.Format(LanguageManager.GetCurrentLanguage().JoiningServer, arg);
			if ((int)info.Type == 0)
			{
				Core.networkManager.Connect(info.Address, info.Port, password);
				Core.uiManager.notificationsUI.AddMessage(message);
			}
			else
			{
				Core.networkManager.ConnectSteam(info.Address, password);
				Core.uiManager.notificationsUI.AddMessage(message);
			}
		}

		private static void OnLobbyButtonClicked(int slot)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - _lastLobbyClickTime < 0.5f)
			{
				return;
			}
			_lastLobbyClickTime = realtimeSinceStartup;
			int num = _lobbyPage * 5 + slot;
			if (num < _displayLobbies.Count)
			{
				ServerInfo val = _displayLobbies[num];
				if (val.IsPasswordProtected)
				{
					ShowPasswordPrompt(val);
				}
				else
				{
					JoinServer(val, string.Empty);
				}
			}
		}

		private static void ShowPasswordPrompt(ServerInfo lobby)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			_pendingLockedLobby = lobby;
			_pendingJoinPassword = string.Empty;
			if ((Object)(object)_pwTitle != (Object)null)
			{
				string arg = lobby.Name.Replace("\ud83d\udd12 ", string.Empty).Trim();
				_pwTitle.text = string.Format(LanguageManager.GetCurrentLanguage().PasswordForSession, arg);
				_pwTitle.ForceMeshUpdate(false, false);
			}
			if (_pwInputInfo != null)
			{
				_pwInputInfo.Value = string.Empty;
				if ((Object)(object)_pwInputInfo.DisplayText != (Object)null)
				{
					_pwInputInfo.DisplayText.text = _pwInputInfo.Placeholder;
					((Graphic)_pwInputInfo.DisplayText).color = _pwInputInfo.PlaceholderColor;
					_pwInputInfo.DisplayText.ForceMeshUpdate(false, false);
				}
			}
			GameObject pwCanvas = _pwCanvas;
			if (pwCanvas != null)
			{
				pwCanvas.SetActive(true);
			}
			MenuInjectionLibrary.ShowPopupDim(new Color(0f, 0f, 0f, 0.78f));
			MenuInjectionLibrary.OverlayNavigableItems = ((IEnumerable<GameObject>)(object)new GameObject[3]
			{
				((Object)(object)_pwInputBtn != (Object)null) ? ((Component)_pwInputBtn).gameObject : null,
				((Object)(object)_pwEnterBtn != (Object)null) ? ((Component)_pwEnterBtn).gameObject : null,
				((Object)(object)_pwBackBtn != (Object)null) ? ((Component)_pwBackBtn).gameObject : null
			}).Where((GameObject g) => (Object)(object)g != (Object)null).ToArray();
			EventSystem current = EventSystem.current;
			if (current != null)
			{
				current.SetSelectedGameObject(((Object)(object)_pwEnterBtn != (Object)null) ? ((Component)_pwEnterBtn).gameObject : null);
			}
		}

		private static void BuildPasswordPopup()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Expected O, but got Unknown
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Expected O, but got Unknown
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_pwCanvas != (Object)null)
			{
				return;
			}
			_pwCanvas = new GameObject("BBSPasswordPopup");
			Object.DontDestroyOnLoad((Object)(object)_pwCanvas);
			Canvas val = _pwCanvas.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 9999;
			_pwCanvas.AddComponent<CanvasScaler>();
			_pwCanvas.AddComponent<GraphicRaycaster>();
			GameObject val2 = new GameObject("Panel");
			val2.transform.SetParent(_pwCanvas.transform, false);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.12f, 0.12f, 0.12f, 0.97f);
			RectTransform component = val2.GetComponent<RectTransform>();
			SetRTCenter(component, new Vector2(400f, 260f), Vector2.zero);
			Button hostSteamTabBtn = _hostSteamTabBtn;
			object obj;
			if (hostSteamTabBtn == null)
			{
				obj = null;
			}
			else
			{
				TMP_Text componentInChildren = ((Component)hostSteamTabBtn).GetComponentInChildren<TMP_Text>(true);
				obj = ((componentInChildren != null) ? ((Component)componentInChildren).gameObject : null);
			}
			GameObject val3 = (GameObject)obj;
			if ((Object)(object)val3 != (Object)null)
			{
				GameObject val4 = Object.Instantiate<GameObject>(val3, val2.transform);
				val4.SetActive(true);
				_pwTitle = val4.GetComponent<TMP_Text>();
				if ((Object)(object)_pwTitle != (Object)null)
				{
					_pwTitle.text = "Enter password:";
					_pwTitle.alignment = (TextAlignmentOptions)514;
					_pwTitle.enableAutoSizing = false;
					_pwTitle.fontSize = 24f;
					_pwTitle.ForceMeshUpdate(false, false);
				}
				SetRTCenter(val4.GetComponent<RectTransform>(), new Vector2(360f, 70f), new Vector2(0f, 90f));
			}
			_pwInputBtn = MenuInjectionLibrary.AddInputField("type password...", UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				_pendingJoinPassword = v;
			}), string.Empty, component);
			_pwInputInfo = MenuInjectionLibrary.LastCreatedInputFieldInfo;
			if ((Object)(object)_pwInputBtn != (Object)null)
			{
				SetRTCenter(((Component)_pwInputBtn).GetComponent<RectTransform>(), new Vector2(340f, 52f), new Vector2(0f, 15f));
			}
			if ((Object)(object)_refreshBtn != (Object)null)
			{
				GameObject val5 = Object.Instantiate<GameObject>(((Component)_refreshBtn).gameObject, val2.transform);
				val5.SetActive(true);
				_pwEnterBtn = val5.GetComponent<Button>();
				if ((Object)(object)_pwEnterBtn != (Object)null)
				{
					((Selectable)_pwEnterBtn).interactable = true;
					_pwEnterBtn.onClick = new ButtonClickedEvent();
					((UnityEvent)_pwEnterBtn.onClick).AddListener(UnityAction.op_Implicit((Action)OnPopupEnterClicked));
				}
				_pwEnterTmp = val5.GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)_pwEnterTmp != (Object)null)
				{
					_pwEnterTmp.text = "Enter";
					_pwEnterTmp.ForceMeshUpdate(false, false);
				}
				SetRTCenter(val5.GetComponent<RectTransform>(), new Vector2(140f, 52f), new Vector2(-85f, -72f));
				GameObject val6 = Object.Instantiate<GameObject>(((Component)_refreshBtn).gameObject, val2.transform);
				val6.SetActive(true);
				_pwBackBtn = val6.GetComponent<Button>();
				if ((Object)(object)_pwBackBtn != (Object)null)
				{
					((Selectable)_pwBackBtn).interactable = true;
					_pwBackBtn.onClick = new ButtonClickedEvent();
					((UnityEvent)_pwBackBtn.onClick).AddListener(UnityAction.op_Implicit((Action)HidePasswordPopup));
				}
				_pwBackTmp = val6.GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)_pwBackTmp != (Object)null)
				{
					_pwBackTmp.text = "Back";
					_pwBackTmp.ForceMeshUpdate(false, false);
				}
				SetRTCenter(val6.GetComponent<RectTransform>(), new Vector2(140f, 52f), new Vector2(85f, -72f));
				if ((Object)(object)_pwEnterBtn != (Object)null && (Object)(object)_pwBackBtn != (Object)null)
				{
					SetExplicitNav(_pwEnterBtn, _pwBackBtn, _pwBackBtn);
					SetExplicitNav(_pwBackBtn, _pwEnterBtn, _pwEnterBtn);
				}
			}
			_pwCanvas.SetActive(false);
		}

		private static void SetExplicitNav(Button btn, Button left, Button right)
		{
			Navigation navigation = ((Selectable)btn).navigation;
			navigation.mode = (Mode)4;
			navigation.selectOnLeft = (Selectable)(object)left;
			navigation.selectOnRight = (Selectable)(object)right;
			navigation.selectOnUp = null;
			navigation.selectOnDown = null;
			((Selectable)btn).navigation = navigation;
		}

		private static void SetRTFill(RectTransform rt)
		{
			//IL_0002: 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_001a: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.sizeDelta = Vector2.zero;
			rt.anchoredPosition = Vector2.zero;
		}

		private static void SetRTCenter(RectTransform rt, Vector2 size, Vector2 pos)
		{
			//IL_0015: 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_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_0025: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			rt.pivot = val;
			Vector2 anchorMin = (rt.anchorMax = val);
			rt.anchorMin = anchorMin;
			rt.sizeDelta = size;
			rt.anchoredPosition = pos;
		}

		private static void HidePasswordPopup()
		{
			_pendingLockedLobby = null;
			_pendingJoinPassword = string.Empty;
			MenuInjectionLibrary.ForceCloseMouseTyping();
			MenuInjectionLibrary.OverlayNavigableItems = null;
			MenuInjectionLibrary.HidePopupDim();
			GameObject pwCanvas = _pwCanvas;
			if (pwCanvas != null)
			{
				pwCanvas.SetActive(false);
			}
			EventSystem current = EventSystem.current;
			if (current != null)
			{
				current.SetSelectedGameObject((GameObject)null);
			}
		}

		private static void HidePasswordPrompt()
		{
			HidePasswordPopup();
		}

		private static void OnPopupEnterClicked()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup - _pwEnterDebounce < 0.5f))
			{
				_pwEnterDebounce = realtimeSinceStartup;
				if (_pendingLockedLobby != null)
				{
					string pendingJoinPassword = _pendingJoinPassword;
					ServerInfo pendingLockedLobby = _pendingLockedLobby;
					HidePasswordPopup();
					JoinServer(pendingLockedLobby, pendingJoinPassword);
				}
			}
		}

		private static Sprite GetLockSprite()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0076: 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_009b: 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)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lockSprite != (Object)null)
			{
				return _lockSprite;
			}
			Texture2D val = new Texture2D(24, 24, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)0;
			Color32[] px = (Color32[])(object)new Color32[576];
			Color32 c2 = default(Color32);
			((Color32)(ref c2))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
			for (int i = 0; i < px.Length; i++)
			{
				px[i] = val2;
			}
			Rect(2, 1, 21, 10, c2);
			Rect(5, 8, 8, 19, c2);
			Rect(15, 8, 18, 19, c2);
			Rect(5, 17, 18, 20, c2);
			Rect(9, 10, 14, 17, val2);
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(px));
			val.Apply();
			_lockSprite = Sprite.Create(val, new Rect(0f, 0f, 24f, 24f), new Vector2(0.5f, 0.5f), 24f);
			return _lockSprite;
			void Rect(int x0, int y0, int x1, int y1, Color32 c)
			{
				//IL_002f: 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)
				for (int j = y0; j <= y1; j++)
				{
					for (int k = x0; k <= x1; k++)
					{
						if (k >= 0 && k < 24 && j >= 0 && j < 24)
						{
							px[j * 24 + k] = c;
						}
					}
				}
			}
		}

		private static void SetLobbyLockIcon(int slot, bool show)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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_0143: 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)
			if (slot < 0 || slot >= _lobbyButtons.Count)
			{
				return;
			}
			Button val = _lobbyButtons[slot];
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)_lobbyLockIcons[slot] == (Object)null)
				{
					GameObject val2 = new GameObject("LockIcon");
					val2.transform.SetParent(((Component)val).transform, false);
					Image val3 = val2.AddComponent<Image>();
					val3.sprite = GetLockSprite();
					val3.preserveAspect = true;
					RectTransform component = val2.GetComponent<RectTransform>();
					component.anchorMin = new Vector2(0f, 0.72f);
					component.anchorMax = new Vector2(0f, 0.72f);
					component.pivot = new Vector2(0f, 0.5f);
					component.anchoredPosition = new Vector2(4f, 0f);
					component.sizeDelta = new Vector2(20f, 20f);
					_lobbyLockIcons[slot] = val2;
				}
				_lobbyLockIcons[slot].SetActive(show);
				TMP_Text componentInChildren = ((Component)val).GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					Vector4 margin = componentInChildren.margin;
					margin.x = (show ? 30f : 0f);
					componentInChildren.margin = margin;
				}
			}
		}

		private static void OnLobbiesFound(IReadOnlyList<ServerInfo> servers)
		{
			_foundLobbies.Clear();
			_foundLobbies.AddRange(servers);
			SetBtnText(_refreshBtn, LanguageManager.GetCurrentLanguage().Refresh);
			if (!Core.networkManager.IsConnected && !(Core.inGameHost?.IsRunning ?? false))
			{
				string text = NativeSteamAPI.GetLocalSteamId().ToString();
				string key = "bbs_invite_" + text;
				foreach (ServerInfo server in servers)
				{
					if (string.IsNullOrEmpty(server.SessionId) || !ulong.TryParse(server.SessionId, out var result) || result == 0 || NativeSteamAPI.GetLobbyData(result, key) != "1")
					{
						continue;
					}
					Core.logger.Msg($"[Steam] Invite detected in lobby {result} — joining {server.Name}");
					Core.uiManager.notificationsUI.AddMessage("Auto-joining " + server.Name.Replace("\ud83d\udd12 ", "") + "…");
					Core.networkManager.ConnectSteam(server.Address, string.Empty);
					break;
				}
			}
			RebuildLobbyUI();
		}

		private static void OnMicrophoneToggled(bool enabled)
		{
			ModSettings.audio.MicrophoneEnabled.Value = enabled;
			LocalPlayer.Instance?.SetMicrophoneEnabled(enabled);
		}

		private static void OnDeafenToggled(bool enabled)
		{
			ModSettings.audio.Deafened.Value = enabled;
		}

		private static void OnPushToTalkToggled(bool enabled)
		{
			ModSettings.audio.PushToTalk.Value = enabled;
			LocalPlayer.Instance?.SetPushToTalkEnabled(enabled);
			if ((Object)(object)_pttKeyBtn != (Object)null)
			{
				((Selectable)_pttKeyBtn).interactable = enabled;
			}
		}

		private static void OnAudioDeviceCycled()
		{
			string[] availableDevicesStatic = BBSMicrophoneCapture.GetAvailableDevicesStatic();
			if (availableDevicesStatic != null && availableDevicesStatic.Length != 0)
			{
				int num = (ModSettings.audio.SelectedMicrophoneIndex.Value + 1) % availableDevicesStatic.Length;
				ModSettings.audio.SelectedMicrophoneIndex.Value = num;
				LocalPlayer.Instance?.SetMicrophoneDevice(num);
				ModSettings.Save();
				SetBtnText(_audioDeviceBtn, GetAudioDeviceLabel());
			}
		}

		private static void OnPttKeyClicked()
		{
			BeginCapture(KeybindCaptureTarget.PushToTalk);
			SetBtnText(_pttKeyBtn, LanguageManager.GetCurrentLanguage().PressAnyKey);
		}

		private static void OnTabMenuKeyClicked()
		{
			BeginCapture(KeybindCaptureTarget.TabMenu);
			SetBtnText(_tabMenuKeyBtn, LanguageManager.GetCurrentLanguage().PressAnyKey);
		}

		private static void OnChatMenuKeyClicked()
		{
			BeginCapture(KeybindCaptureTarget.ChatMenu);
			SetBtnText(_chatMenuKeyBtn, LanguageManager.GetCurrentLanguage().PressAnyKey);
		}

		private static void OnCollisionToggled(bool enabled)
		{
			if (!Core.networkManager.IsConnected)
			{
				if ((Object)(object)_collisionToggle != (Object)null && _collisionToggle.isOn != ModSettings.player.Collisions.Value)
				{
					_collisionToggle.isOn = ModSettings.player.Collisions.Value;
				}
			}
			else
			{
				if (ModSettings.player.Collisions.Value == enabled)
				{
					return;
				}
				ModSettings.player.Collisions.Value = enabled;
				Core.networkManager.SendCollisionToggle(enabled);
				foreach (KeyValuePair<byte, RemotePlayer> player in Core.networkManager.players)
				{
					if (ModSettings.player.Collisions.Value && player.Value.netCollisionsEnabled)
					{
						player.Value.EnableCollision();
					}
					else
					{
						player.Value.DisableCollision();
					}
				}
			}
		}

		private static void OnCutsceneToggled(bool enabled)
		{
			if (!Core.networkManager.IsConnected)
			{
				if ((Object)(object)_cutsceneToggle != (Object)null && _cutsceneToggle.isOn != ModSettings.player.CutscenePlayerVisibility.Value)
				{
					_cutsceneToggle.isOn = ModSettings.player.CutscenePlayerVisibility.Value;
				}
			}
			else
			{
				ModSettings.player.CutscenePlayerVisibility.Value = enabled;
			}
		}

		private static void OnNametagToggled(bool enabled)
		{
			if (!Core.networkManager.IsConnected)
			{
				if ((Object)(object)_nametagToggle != (Object)null && _nametagToggle.isOn != ModSettings.player.ShowNametags.Value)
				{
					_nametagToggle.isOn = ModSettings.player.ShowNametags.Value;
				}
			}
			else
			{
				ModSettings.player.ShowNametags.Value = enabled;
			}
		}

		private static void OnUpdateAppearanceClicked()
		{
			if (Core.networkManager.IsConnected)
			{
				ModSettings.Save();
				Core.networkManager.SendPlayerInformation();
				LocalPlayer.Instance?.ApplySuitColor();
				Core.uiManager.notificationsUI.AddMessage(LanguageManager.GetCurrentLanguage().AppearanceUpdated);
			}
		}

		private static void RefreshConnectionState()
		{
			SetBtnText(_connectTabBtn, GetConnectLabel());
			RefreshHostSteamState();
		}

		private static void RefreshHostState()
		{
			SetBtnText(_hostLanTabBtn, GetHostLabel());
			if ((Object)(object)_hostLanTabBtn != (Object)null)
			{
				((Selectable)_hostLanTabBtn).interactable = !Core.networkManager.IsConnected || (Core.inGameHost?.IsRunning ?? false);
			}
		}

		private static void RefreshHostSteamState()
		{
			SetBtnText(_hostSteamTabBtn, GetHostSteamLabel());
			RebuildLobbyUI();
		}

		private static void RefreshColorPreview()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_colorPreviewImage != (Object)null)
			{
				((Graphic)_colorPreviewImage).color = ModSettings.player.SuitColor.Value;
			}
		}

		private static string GetConnectLabel()
		{
			NetworkManager networkManager = Core.networkManager;
			return (networkManager != null && networkManager.IsConnected) ? LanguageManager.GetCurrentLanguage().Disconnect : LanguageManager.GetCurrentLanguage().Connect;
		}

		private static string GetHostLabel()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			InGameHost inGameHost = Core.inGameHost;
			return (inGameHost != null && inGameHost.IsRunning) ? currentLanguage.StopHosting : currentLanguage.HostLAN;
		}

		private static string GetHostSteamLabel()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			InGameHost inGameHost = Core.inGameHost;
			if (inGameHost != null && inGameHost.IsRunning)
			{
				return currentLanguage.StopHosting;
			}
			NetworkManager networkManager = Core.networkManager;
			if (networkManager != null && networkManager.IsConnected)
			{
				return currentLanguage.Disconnect;
			}
			return currentLanguage.HostLobby;
		}

		private static string GetMicrophoneToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().EnableMicrophone, LanguageManager.GetCurrentLanguage().DisableMicrophone);
		}

		private static string GetDeafenToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().Deafen, LanguageManager.GetCurrentLanguage().Undeafen);
		}

		private static string GetPushToTalkToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().EnablePushToTalk, LanguageManager.GetCurrentLanguage().DisablePushToTalk);
		}

		private static string GetCollisionToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().EnableCollisions, LanguageManager.GetCurrentLanguage().DisableCollisions);
		}

		private static string GetCutsceneToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().EnablePlayerCutsceneVisibility, LanguageManager.GetCurrentLanguage().DisablePlayerCutsceneVisibility);
		}

		private static string GetNametagToggleLabel()
		{
			return GetNeutralToggleLabel(LanguageManager.GetCurrentLanguage().EnableNametags, LanguageManager.GetCurrentLanguage().DisableNametags);
		}

		private static string GetPttKeyLabel()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			return currentLanguage.PushToTalkKey + " " + InputBindingHelper.GetDisplayName(ModSettings.audio.PushToTalkKey.Value);
		}

		private static string GetTabMenuKeyLabel()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			return currentLanguage.PlayerListKeyLabel + " " + InputBindingHelper.GetDisplayName(ModSettings.player.TabMenuKey.Value);
		}

		private static string GetChatMenuKeyLabel()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			return currentLanguage.ChatMenuKeyLabel + " " + InputBindingHelper.GetDisplayName(ModSettings.player.ChatMenuKey.Value);
		}

		private static string GetGainLabel()
		{
			return $"{LanguageManager.GetCurrentLanguage().MicrophoneGain} {ModSettings.audio.MicrophoneGain.Value:F2}x";
		}

		private static string GetAudioDeviceLabel()
		{
			string[] availableDevicesStatic = BBSMicrophoneCapture.GetAvailableDevicesStatic();
			if (availableDevicesStatic == null || availableDevicesStatic.Length == 0)
			{
				return LanguageManager.GetCurrentLanguage().NoDevicesFound;
			}
			int num = Mathf.Clamp(ModSettings.audio.SelectedMicrophoneIndex.Value, 0, availableDevicesStatic.Length - 1);
			return availableDevicesStatic[num];
		}

		private static string GetNeutralToggleLabel(string enabledText, string disabledText)
		{
			if (string.IsNullOrEmpty(enabledText))
			{
				return disabledText ?? string.Empty;
			}
			if (string.IsNullOrEmpty(disabledText))
			{
				return enabledText;
			}
			if (disabledText.EndsWith(enabledText, StringComparison.OrdinalIgnoreCase))
			{
				return enabledText;
			}
			if (enabledText.EndsWith(disabledText, StringComparison.OrdinalIgnoreCase))
			{
				return disabledText;
			}
			string[] array = enabledText.Split(' ');
			string[] array2 = disabledText.Split(' ');
			int num = array.Length - 1;
			int num2 = array2.Length - 1;
			int num3 = 0;
			while (num >= 0 && num2 >= 0 && string.Equals(array[num], array2[num2], StringComparison.OrdinalIgnoreCase))
			{
				num3++;
				num--;
				num2--;
			}
			if (num3 > 0)
			{
				int startIndex = array.Length - num3;
				string text = string.Join(" ", array, startIndex, num3).Trim();
				if (!string.IsNullOrEmpty(text))
				{
					return text;
				}
			}
			return enabledText;
		}

		private static void RefreshLocalizableText()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			InjectedMenu menu = _menu;
			if (menu != null)
			{
				menu.SetMainButtonLabel(currentLanguage.MultiplayerTitle);
			}
			InjectedMenu menu2 = _menu;
			if (menu2 != null)
			{
				menu2.SetTabName(0, currentLanguage.TabLobby);
			}
			InjectedMenu menu3 = _menu;
			if (menu3 != null)
			{
				menu3.SetTabName(1, currentLanguage.TabPlayer);
			}
			InjectedMenu menu4 = _menu;
			if (menu4 != null)
			{
				menu4.SetTabName(2, currentLanguage.TabGeneral);
			}
			InjectedMenu menu5 = _menu;
			if (menu5 != null)
			{
				menu5.SetTabName(3, currentLanguage.TabAudio);
			}
			InjectedMenu menu6 = _menu;
			if (menu6 != null)
			{
				menu6.SetTabName(4, currentLanguage.TabLAN);
			}
			SetBtnText(_tabBtn0, currentLanguage.TabLobby);
			SetBtnText(_tabBtn1, currentLanguage.TabPlayer);
			SetBtnText(_tabBtn2, currentLanguage.TabGeneral);
			SetBtnText(_tabBtn3, currentLanguage.TabAudio);
			SetBtnText(_tabBtn4, currentLanguage.TabLAN);
			InjectedMenu menu7 = _menu;
			SetBtnText((menu7 != null) ? menu7.GetFixedButton(0) : null, currentLanguage.ButtonBack);
			SetBtnText(_connectTabBtn, GetConnectLabel());
			SetBtnText(_hostLanTabBtn, GetHostLabel());
			SetBtnText(_hostSteamTabBtn, GetHostSteamLabel());
			SetBtnText(_refreshBtn, currentLanguage.Refresh);
			RefreshInputFieldPlaceholder(_hostingPasswordInputInfo, currentLanguage.LobbyPassword);
			TMP_FontAsset currentToggleFont = MenuInjectionLibrary.GetCurrentToggleFont();
			SetToggleText(_collisionToggle, GetCollisionToggleLabel(), currentToggleFont);
			SetToggleText(_cutsceneToggle, GetCutsceneToggleLabel(), currentToggleFont);
			SetToggleText(_nametagToggle, GetNametagToggleLabel(), currentToggleFont);
			SetBtnText(_tabMenuKeyBtn, GetTabMenuKeyLabel());
			SetBtnText(_chatMenuKeyBtn, GetChatMenuKeyLabel());
			SetToggleText(_microphoneToggle, GetMicrophoneToggleLabel(), currentToggleFont);
			SetToggleText(_deafenToggle, GetDeafenToggleLabel(), currentToggleFont);
			SetToggleText(_pttToggle, GetPushToTalkToggleLabel(), currentToggleFont);
			SetBtnText(_pttKeyBtn, GetPttKeyLabel());
			SetBtnText(_audioDeviceBtn, GetAudioDeviceLabel());
			if ((Object)(object)_audioDeviceStaticLabel != (Object)null)
			{
				_audioDeviceStaticLabel.text = currentLanguage.AudioDevice;
				_audioDeviceStaticLabel.ForceMeshUpdate(false, false);
			}
			if ((Object)(object)_gainLabel != (Object)null)
			{
				_gainLabel.text = GetGainLabel();
				_gainLabel.ForceMeshUpdate(false, false);
			}
			if ((Object)(object)_lobbyBrowserLabel != (Object)null)
			{
				_lobbyBrowserLabel.text = currentLanguage.LobbyBrowser;
				_lobbyBrowserLabel.ForceMeshUpdate(false, false);
			}
			SetBtnText(_updateAppearanceBtn, currentLanguage.UpdateNameAndAppearance);
			SetLabelText(_serverIpLabel, currentLanguage.ServerIP);
			SetLabelText(_serverPortLabel, currentLanguage.ServerPort);
			SetLabelText(_passwordOptLabel, currentLanguage.PasswordOptional);
			RefreshInputFieldPlaceholder(_serverIpInputInfo, currentLanguage.ServerIP);
			RefreshInputFieldPlaceholder(_serverPortInputInfo, currentLanguage.ServerPort);
			RefreshInputFieldPlaceholder(_lanPasswordInputInfo, currentLanguage.PasswordOptional);
			if ((Object)(object)_pwEnterTmp != (Object)null)
			{
				_pwEnterTmp.text = currentLanguage.Enter;
				_pwEnterTmp.ForceMeshUpdate(false, false);
			}
			if ((Object)(object)_pwBackTmp != (Object)null)
			{
				_pwBackTmp.text = currentLanguage.ButtonBack;
				_pwBackTmp.ForceMeshUpdate(false, false);
			}
		}

		private static void SetLabelText(TMP_Text label, string text)
		{
			if (!((Object)(object)label == (Object)null))
			{
				label.text = text;
				label.ForceMeshUpdate(false, false);
			}
		}

		private static void RefreshInputFieldPlaceholder(InputFieldInfo info, string placeholder)
		{
			if (info != null)
			{
				info.Placeholder = placeholder;
				if (string.IsNullOrEmpty(info.Value) && (Object)(object)info.DisplayText != (Object)null)
				{
					info.DisplayText.text = placeholder;
					info.DisplayText.ForceMeshUpdate(false, false);
				}
			}
		}

		private static void SetBtnText(Button btn, string text)
		{
			if (!((Object)(object)btn == (Object)null))
			{
				TMP_Text componentInChildren = ((Component)btn).GetComponentInChildren<TMP_Text>(true);
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					componentInChildren.text = text;
					componentInChildren.ForceMeshUpdate(false, false);
				}
			}
		}

		private static void SetToggleText(Toggle toggle, string text, TMP_FontAsset font = null)
		{
			if ((Object)(object)toggle == (Object)null)
			{
				return;
			}
			TMP_Text componentInChildren = ((Component)toggle).GetComponentInChildren<TMP_Text>(true);
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				componentInChildren.text = text;
				if ((Object)(object)font != (Object)null)
				{
					componentInChildren.font = font;
				}
				componentInChildren.ForceMeshUpdate(false, false);
			}
		}

		private static void ApplyCapturedKeybind(string binding, string displayName)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			KeyCode val = (KeyCode)27;
			if (string.Equals(binding, ((object)(KeyCode)(ref val)).ToString(), StringComparison.OrdinalIgnoreCase))
			{
				CancelCapture();
				return;
			}
			switch (_keybindCaptureTarget)
			{
			case KeybindCaptureTarget.PushToTalk:
				ModSettings.audio.PushToTalkKey.Value = binding;
				SetBtnText(_pttKeyBtn, "Bind Key: " + displayName);
				break;
			case KeybindCaptureTarget.TabMenu:
				ModSettings.player.TabMenuKey.Value = binding;
				SetBtnText(_tabMenuKeyBtn, GetTabMenuKeyLabel());
				break;
			case KeybindCaptureTarget.ChatMenu:
				ModSettings.player.ChatMenuKey.Value = binding;
				SetBtnText(_chatMenuKeyBtn, GetChatMenuKeyLabel());
				break;
			}
			_keybindCaptureTarget = KeybindCaptureTarget.None;
			ModSettings.Save();
			EndCapture();
		}

		private static void BeginCapture(KeybindCaptureTarget target)
		{
			if (_keybindCaptureTarget != 0)
			{
				return;
			}
			_keybindCaptureTarget = target;
			_waitingForRelease = true;
			UpdateGameplayInputSuppressionForCapture();
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				_cachedInputModule = EventSystem.current.currentInputModule;
				if ((Object)(object)_cachedInputModule != (Object)null)
				{
					((Behaviour)_cachedInputModule).enabled = false;
				}
			}
		}

		private static void CancelCapture()
		{
			switch (_keybindCaptureTarget)
			{
			case KeybindCaptureTarget.PushToTalk:
				SetBtnText(_pttKeyBtn, GetPttKeyLabel());
				break;
			case KeybindCaptureTarget.TabMenu:
				SetBtnText(_tabMenuKeyBtn, GetTabMenuKeyLabel());
				break;
			case KeybindCaptureTarget.ChatMenu:
				SetBtnText(_chatMenuKeyBtn, GetChatMenuKeyLabel());
				break;
			}
			EndCapture();
		}

		private static void UpdateGameplayInputSuppressionForCapture()
		{
			PlayerMovement val = LocalPlayer.Instance?.playerMovement;
			if ((Object)(object)val == (Object)null)
			{
				_playerMovementSuppressedForCapture = false;
			}
			else if (IsCapturingKeybind)
			{
				if (!_playerMovementSuppressedForCapture)
				{
					_playerMovementWasEnabledBeforeCapture = ((Behaviour)val).enabled;
					if (_playerMovementWasEnabledBeforeCapture)
					{
						((Behaviour)val).enabled = false;
					}
					_playerMovementSuppressedForCapture = true;
				}
			}
			else if (_playerMovementSuppressedForCapture)
			{
				((Behaviour)val).enabled = _playerMovementWasEnabledBeforeCapture;
				_playerMovementSuppressedForCapture = false;
			}
		}

		private static void EndCapture()
		{
			if ((Object)(object)_cachedInputModule != (Object)null)
			{
				((Behaviour)_cachedInputModule).enabled = true;
			}
			_keybindCaptureTarget = KeybindCaptureTarget.None;
			_waitingForRelease = false;
			UpdateGameplayInputSuppressionForCapture();
		}
	}
	public class RuntimeFoldout
	{
		private bool isExpanded;

		private string label;

		public RuntimeFoldout(string label, bool defaultState = false)
		{
			this.label = label;
			isExpanded = defaultState;
		}

		public bool Draw(Action contents)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_009a: 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_00ab: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(new GUIContent(label), StyleManager.Styles.Button);
			if (GUI.Button(rect, "", StyleManager.Styles.Button))
			{
				isExpanded = !isExpanded;
			}
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x + 10f, ((Rect)(ref rect)).y, 20f, ((Rect)(ref rect)).height);
			GUI.Label(val, isExpanded ? "▼" : "▶", StyleManager.Styles.RuntimeFoldoutButton);
			GUIStyle val2 = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)4,
				fontStyle = StyleManager.Styles.Button.fontStyle,
				fontSize = StyleManager.Styles.Button.fontSize
			};
			val2.normal.textColor = StyleManager.Styles.Button.normal.textColor;
			GUIStyle val3 = val2;
			GUI.Label(rect, label, val3);
			if (isExpanded && contents != null)
			{
				GUILayout.BeginVertical(StyleManager.Styles.Box, (Il2CppReferenceArray<GUILayoutOption>)null);
				contents();
				GUILayout.EndVertical();
			}
			return isExpanded;
		}

		public void SetLabel(string newLabel)
		{
			label = newLabel;
		}

		public void SetExpanded(bool expanded)
		{
			isExpanded = expanded;
		}
	}
	public class RuntimeWindow
	{
		private const float REFERENCE_HEIGHT = 1080f;

		public float ScrollbarWidth = 16f;

		public bool IsOpen;

		public bool IsDraggable = true;

		public bool ShouldDrawBox = true;

		public bool ShouldDrawScrollBar = true;

		public bool ShouldDrawContentBacker = true;

		public bool ShouldAutoResizeHeight;

		public float MinResizeHeight = 10f;

		public float MaxResizeHeight;

		public string Label;

		private float _contentHeight;

		private Rect _windowRect = default(Rect);

		private Vector2 _scrollPos;

		private Rect _windowHeaderRect = default(Rect);

		private Rect _windowContentRect = default(Rect);

		private Rect _windowScrollViewRect = default(Rect);

		private Rect _windowScrollRect = default(Rect);

		private Rect _scrollBarRect = default(Rect);

		private bool _hasClicked;

		private bool _isDragging;

		private Vector2 _dragOffset = default(Vector2);

		private Vector2 _posCache = default(Vector2);

		private Vector2 _sizeCache = default(Vector2);

		private float ScaleFactor => (float)Screen.height / 1080f;

		public Vector2 Position
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _posCache;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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)
				_posCache.x = value.x;
				_posCache.y = value.y;
				((Rect)(ref _windowRect)).position = _posCache;
			}
		}

		public Vector2 Size
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _sizeCache;
			}
			set
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: 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)
				_sizeCache.x = value.x;
				_sizeCache.y = value.y;
				((Rect)(ref _windowRect)).size = _sizeCache;
			}
		}

		public RuntimeWindow(string label, int id, Vector2 defaultPos = default(Vector2), Vector2 defaultSize = default(Vector2), bool defaultState = false)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_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_00bf: Unknown result type (might be due to invalid IL or missing references)
			Label = label;
			Position = defaultPos;
			Size = defaultSize;
			_contentHeight = defaultSize.y;
			IsOpen = defaultState;
		}

		public bool Draw()
		{
			//IL_0210: 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_0014: 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_0021: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0121: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Invalid comparison between Unknown and I4
			//IL_0154: 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_0193: 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)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen)
			{
				Matrix4x4 matrix = GUI.matrix;
				float scaleFactor = ScaleFactor;
				GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(scaleFactor, scaleFactor, 1f));
				try
				{
					RecalculateBounds();
					if (Label == null)
					{
						Label = string.Empty;
					}
					if (ShouldDrawBox)
					{
						GUI.Box(_windowRect, Label, StyleManager.Styles.Box);
					}
					GUI.BeginGroup(_windowContentRect);
					if (ShouldDrawScrollBar && _contentHeight > ((Rect)(ref _windowContentRect)).height)
					{
						_scrollPos.y = GUI.VerticalScrollbar(_scrollBarRect, _scrollPos.y, ((Rect)(ref _scrollBarRect)).height, 0f, _contentHeight, StyleManager.Styles.VerticalScrollBar);
					}
					else
					{
						_scrollPos.y = 0f;
					}
					if (ShouldDrawContentBacker)
					{
						GUI.BeginGroup(_windowScrollRect, StyleManager.Styles.Box);
					}
					else
					{
						GUI.BeginGroup(_windowScrollRect);
					}
					GUILayout.BeginArea(_windowScrollViewRect);
					DrawContent();
					if ((int)Event.current.type == 7)
					{
						Rect lastRect = GUILayoutUtility.GetLastRect();
						_contentHeight = ((Rect)(ref lastRect)).y + ((Rect)(ref lastRect)).height;
					}
					GUILayout.EndArea();
					GUI.EndGroup();
					GUI.EndGroup();
					if (ShouldAutoResizeHeight)
					{
						Vector2 size = Size;
						float num = ((Rect)(ref _windowHeaderRect)).height + ((Rect)(ref _windowScrollRect)).height + 10f;
						if (MaxResizeHeight > 0f && num > MaxResizeHeight)
						{
							num = MaxResizeHeight;
						}
						if (num < MinResizeHeight)
						{
							num = MinResizeHeight;
						}
						size.y = num;
						Size = size;
					}
				}
				finally
				{
					GUI.matrix = matrix;
				}
			}
			HandleDrag();
			return IsOpen;
		}

		internal virtual void DrawContent()
		{
		}

		private void RecalculateBounds()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//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_0015: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			Vector2 position = Position;
			Vector2 size = Size;
			((Rect)(ref _windowHeaderRect)).x = position.x;
			((Rect)(ref _windowHeaderRect)).y = position.y;
			((Rect)(ref _windowHeaderRect)).width = size.x + 8f;
			((Rect)(ref _windowHeaderRect)).height = 30f;
			((Rect)(ref _windowContentRect)).x = ((Rect)(ref _windowHeaderRect)).x + 10f;
			((Rect)(ref _windowContentRect)).y = ((Rect)(ref _windowHeaderRect)).y + ((Rect)(ref _windowHeaderRect)).height;
			((Rect)(ref _windowContentRect)).width = ((Rect)(ref _windowHeaderRect)).width - 28f;
			((Rect)(ref _windowContentRect)).height = size.y - (((Rect)(ref _windowHeaderRect)).height + 10f);
			if (ShouldDrawScrollBar && _contentHeight > ((Rect)(ref _windowContentRect)).height)
			{
				ref Rect windowContentRect = ref _windowContentRect;
				((Rect)(ref windowContentRect)).width = ((Rect)(ref windowContentRect)).width + 5f;
			}
			((Rect)(ref _windowScrollViewRect)).width = ((Rect)(ref _windowContentRect)).width;
			((Rect)(ref _windowScrollViewRect)).height = _contentHeight;
			if (ShouldDrawScrollBar && _contentHeight > ((Rect)(ref _windowContentRect)).height)
			{
				ref Rect windowScrollViewRect = ref _windowScrollViewRect;
				((Rect)(ref windowScrollViewRect)).width = ((Rect)(ref windowScrollViewRect)).width - (ScrollbarWidth + 5f);
			}
			((Rect)(ref _windowScrollRect)).x = ((Rect)(ref _windowScrollViewRect)).x;
			((Rect)(ref _windowScrollRect)).y = 0f - _scrollPos.y;
			((Rect)(ref _windowScrollRect)).width = ((Rect)(ref _windowScrollViewRect)).width;
			((Rect)(ref _windowScrollRect)).height = _contentHeight;
			((Rect)(ref _scrollBarRect)).x = ((Rect)(ref _windowScrollViewRect)).width + 5f;
			((Rect)(ref _scrollBarRect)).width = ScrollbarWidth;
			((Rect)(ref _scrollBarRect)).height = ((Rect)(ref _windowContentRect)).height;
		}

		private void HandleDrag()
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0056: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!IsOpen || !IsDraggable)
			{
				_isDragging = false;
				return;
			}
			float scaleFactor = ScaleFactor;
			Vector2 val = Vector2.op_Implicit(Input.mousePosition);
			Vector2 val2 = new Vector2(val.x, (float)Screen.height - val.y) / scaleFactor;
			if (_hasClicked)
			{
				if (Input.GetMouseButtonUp(0))
				{
					_hasClicked = false;
					_isDragging = false;
				}
			}
			else if (Input.GetMouseButtonDown(0))
			{
				_hasClicked = true;
				if (((Rect)(ref _windowHeaderRect)).Contains(val2))
				{
					_isDragging = true;
					_dragOffset.x = val2.x - Position.x;
					_dragOffset.y = val2.y - Position.y;
				}
			}
			if (_isDragging)
			{
				Vector2 position = Position;
				position.x = val2.x - _dragOffset.x;
				position.y = val2.y - _dragOffset.y;
				Position = position;
			}
		}
	}
	internal static class StyleManager
	{
		internal static class Fonts
		{
			internal static Font Arial { get; private set; }

			internal static void Prepare()
			{
				if ((Object)(object)Arial == (Object)null)
				{
					Arial = Resources.GetBuiltinResource<Font>("Arial.ttf");
				}
			}
		}

		internal static class Styles
		{
			internal static GUIStyle Label { get; private set; }

			internal static GUIStyle MiddleCenterLabel { get; private set; }

			internal static GUIStyle TextField { get; private set; }

			internal static GUIStyle MiddleLeftTextField { get; private set; }

			internal static GUIStyle Box { get; private set; }

			internal static GUIStyle Button { get; private set; }

			internal static GUIStyle ButtonLeftCenteredText { get; private set; }

			internal static GUIStyle VerticalScrollBar { get; private set; }

			internal static GUIStyle HorizontalSlider { get; private set; }

			internal static GUIStyle HorizontalSliderThumb { get; private set; }

			internal static GUIStyle RuntimeFoldoutButton { get; private set; }

			internal static void Prepare()
			{
				//IL_0017: 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_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)
				//IL_002e: 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)
				//IL_003f: Expected O, but got Unknown
				//IL_0045: Expected O, but got Unknown
				//IL_0057: 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_0069: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Expected O, but got Unknown
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Expected O, but got Unknown
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Expected O, but got Unknown
				//IL_0113: 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_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Expected O, but got Unknown
				//IL_014e: 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_015f: 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_017c: Expected O, but got Unknown
				//IL_0195: 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_01ab: Expected O, but got Unknown
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Expected O, but got Unknown
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Expected O, but got Unknown
				//IL_0219: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				//IL_022b: Expected O, but got Unknown
				if (Label == null)
				{
					Label = new GUIStyle(GUI.skin.label)
					{
						font = Fonts.Arial,
						normal = new GUIStyleState
						{
							textColor = Color.white
						}
					};
				}
				if (MiddleCenterLabel == null)
				{
					MiddleCenterLabel = new GUIStyle(Label)
					{
						alignment = (TextAnchor)4
					};
				}
				if (Box == null)
				{
					Box = new GUIStyle(GUI.skin.box)
					{
						font = Fonts.Arial
					};
				}
				if (Button == null)
				{
					Button = new GUIStyle(GUI.skin.button)
					{
						font = Fonts.Arial
					};
				}
				if (ButtonLeftCenteredText == null)
				{
					ButtonLeftCenteredText = new GUIStyle(GUI.skin.button)
					{
						font = Fonts.Arial,
						alignment = (TextAnchor)3
					};
				}
				if (HorizontalSlider == null)
				{
					HorizontalSlider = new GUIStyle(GUI.skin.horizontalSlider)
					{
						font = Fonts.Arial,
						fixedHeight = 20f
					};
				}
				if (HorizontalSliderThumb == null)
				{
					HorizontalSliderThumb = new GUIStyle(GUI.skin.horizontalSliderThumb)
					{
						font = Fonts.Arial,
						fixedHeight = 20f,
						fixedWidth = 20f
					};
				}
				if (VerticalScrollBar == null)
				{
					VerticalScrollBar = new GUIStyle(GUI.skin.verticalScrollbar)
					{
						font = Fonts.Arial
					};
				}
				if (TextField == null)
				{
					TextField = new GUIStyle(GUI.skin.textField)
					{
						font = Fonts.Arial
					};
				}
				if (MiddleLeftTextField == null)
				{
					MiddleLeftTextField = new GUIStyle(TextField)
					{
						alignment = (TextAnchor)3
					};
				}
				if (RuntimeFoldoutButton == null)
				{
					RuntimeFoldoutButton = new GUIStyle(GUI.skin.label)
					{
						alignment = (TextAnchor)3
					};
				}
			}
		}
	}
	public class UIManager
	{
		public bool showChatTab;

		private string chatMenuBinding;

		private string tabMenuBinding;

		private bool playerMovementSuppressedForChat;

		private bool playerMovementWasEnabledBeforeChat;

		public bool ChatMenuUsesControllerBinding { get; private set; }

		public PlayersTabUI playersTabUI { get; private set; }

		public NotificationUI notificationsUI { get; private set; }

		public ChatTabUI chatTabUI { get; private set; }

		public UIManager()
		{
			//IL_0003: 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)
			KeyCode val = (KeyCode)116;
			chatMenuBinding = ((object)(KeyCode)(ref val)).ToString();
			val = (KeyCode)9;
			tabMenuBinding = ((object)(KeyCode)(ref val)).ToString();
			base..ctor();
			StyleManager.Fonts.Prepare();
			notificationsUI = new NotificationUI();
			playersTabUI = new PlayersTabUI();
			chatTabUI = new ChatTabUI();
		}

		public void Draw()
		{
			StyleManager.Styles.Prepare();
			notificationsUI.DrawUI();
			playersTabUI.Draw();
			if (showChatTab)
			{
				chatTabUI.DrawUI();
			}
			else
			{
				notificationsUI.ShowChatHistory = false;
			}
		}

		public void Update()
		{
			RefreshConfiguredKeys();
			if (!Core.networkManager.IsConnected)
			{
				playersTabUI.IsOpen = false;
				showChatTab = false;
			}
			else
			{
				if (!showChatTab && InputBindingHelper.IsDown(chatMenuBinding))
				{
					showChatTab = true;
					ChatMenuUsesControllerBinding = InputBindingHelper.IsControllerBinding(chatMenuBinding);
				}
				playersTabUI.IsOpen = !showChatTab && InputBindingHelper.IsPressed(tabMenuBinding);
			}
			if (!showChatTab)
			{
				ChatMenuUsesControllerBinding = false;
			}
			UpdateGameplayInputSuppression();
		}

		private void UpdateGameplayInputSuppression()
		{
			PlayerMovement val = LocalPlayer.Instance?.playerMovement;
			if ((Object)(object)val == (Object)null)
			{
				playerMovementSuppressedForChat = false;
			}
			else if (showChatTab)
			{
				if (!playerMovementSuppressedForChat)
				{
					playerMovementWasEnabledBeforeChat = ((Behaviour)val).enabled;
					if (playerMovementWasEnabledBeforeChat)
					{
						((Behaviour)val).enabled = false;
					}
					playerMovementSuppressedForChat = true;
				}
			}
			else if (playerMovementSuppressedForChat)
			{
				((Behaviour)val).enabled = playerMovementWasEnabledBeforeChat;
				playerMovementSuppressedForChat = false;
			}
		}

		private void RefreshConfiguredKeys()
		{
			//IL_002b: 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)
			string? text;
			KeyCode val;
			if (!string.IsNullOrWhiteSpace(ModSettings.player.ChatMenuKey.Value))
			{
				text = ModSettings.player.ChatMenuKey.Value;
			}
			else
			{
				val = (KeyCode)116;
				text = ((object)(KeyCode)(ref val)).ToString();
			}
			chatMenuBinding = text;
			string? text2;
			if (!string.IsNullOrWhiteSpace(ModSettings.player.TabMenuKey.Value))
			{
				text2 = ModSettings.player.TabMenuKey.Value;
			}
			else
			{
				val = (KeyCode)9;
				text2 = ((object)(KeyCode)(ref val)).ToString();
			}
			tabMenuBinding = text2;
		}

		public void ApplyCollisionToggle(RemotePlayer player, bool collisionsEnabled)
		{
			if (collisionsEnabled)
			{
				player.netCollisionsEnabled = true;
				notificationsUI.AddMessage(player.displayName + " has enabled collisions");
				if (ModSettings.player.Collisions.Value)
				{
					player.EnableCollision();
				}
				else
				{
					player.DisableCollision();
				}
			}
			else
			{
				player.netCollisionsEnabled = false;
				notificationsUI.AddMessage(player.displayName + " has disabled collisions");
				player.DisableCollision();
			}
		}
	}
}
namespace BabyStepsMultiplayerClient.UI.Elements
{
	public class ChatTabUI
	{
		private string message = "";

		private Rect textFieldRect;

		private GUIStyle textFieldStyle;

		private Texture2D backgroundTexture;

		public float FakeCursorHeightMultiplier { get; set; } = 0.7f;


		public void DrawUI()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (textFieldStyle == null)
			{
				textFieldStyle = new GUIStyle(StyleManager.Styles.MiddleLeftTextField);
			}
			textFieldStyle.fontSize = Mathf.RoundToInt((float)Screen.height * 0.02f);
			textFieldStyle.wordWrap = false;
			if ((Object)(object)backgroundTexture == (Object)null)
			{
				backgroundTexture = new Texture2D(1, 1);
				backgroundTexture.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.7f));
				backgroundTexture.Apply();
			}
			Core.uiManager.notificationsUI.ShowChatHistory = true;
			bool controllerKeyboardActive = TrySyncControllerKeyboard();
			HandleChatInput(controllerKeyboardActive);
			float num = (float)Screen.width * 0.4f;
			float num2 = (float)Screen.height * 0.05f;
			float num3 = ((float)Screen.width - num) / 2f;
			float num4 = (float)Screen.height - num2 - 20f;
			textFieldRect = new Rect(num3, num4, num, num2);
			float num5 = num4 - 20f;
			float num6 = (float)Screen.height - num5;
			GUI.DrawTexture(new Rect(0f, num5, (float)Screen.width, num6), (Texture)(object)backgroundTexture);
			float num7 = ((Rect)(ref textFieldRect)).width - (float)textFieldStyle.padding.horizontal;
			float num8 = Mathf.Max(1f, (float)textFieldStyle.fontSize * 0.08f);
			string visibleTail = GetVisibleTail(message, Mathf.Max(4f, num7 - num8 - 2f));
			GUI.TextField(textFieldRect, visibleTail, 150, textFieldStyle);
			DrawFakeCursor(visibleTail, num8);
			if ((int)Event.current.type == 7)
			{
				GUI.FocusControl(string.Empty);
			}
		}

		private bool TrySyncControllerKeyboard()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0065: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			InjectedMenu keyboardMenu = MenuInjectionLibrary.GetKeyboardMenu();
			if (keyboardMenu == null || !Core.uiManager.ChatMenuUsesControllerBinding)
			{
				return false;
			}
			if (!keyboardMenu.IsKeyboardOpen)
			{
				InputFieldInfo val = new InputFieldInfo
				{
					Value = message,
					DisplayText = null,
					OnChanged = UnityAction<string>.op_Implicit((Action<string>)delegate(string value)
					{
						message = value;
					}),
					Placeholder = string.Empty,
					Viewport = null,
					ActiveColor = Color.white,
					PlaceholderColor = new Color(1f, 1f, 1f, 0.45f),
					OwnerButton = null,
					CursorImage = null
				};
				keyboardMenu.OpenKeyboardForChat(val, (Action)delegate
				{
					SendCurrentMessage();
					Core.uiManager.showChatTab = false;
				});
			}
			return keyboardMenu.IsKeyboardOpen;
		}

		private void HandleChatInput(bool controllerKeyboardActive)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			Event current = Event.current;
			if ((int)current.type != 4)
			{
				return;
			}
			if (current.control && (int)current.keyCode == 97)
			{
				current.Use();
			}
			else if ((int)current.keyCode == 13 || (int)current.keyCode == 271)
			{
				SendCurrentMessage();
				InjectedMenu keyboardMenu = MenuInjectionLibrary.GetKeyboardMenu();
				if (keyboardMenu != null)
				{
					keyboardMenu.CloseKeyboardOverlay();
				}
				Core.uiManager.showChatTab = false;
				current.Use();
			}
			else if ((int)current.keyCode == 27)
			{
				InjectedMenu keyboardMenu2 = MenuInjectionLibrary.GetKeyboardMenu();
				if (keyboardMenu2 != null)
				{
					keyboardMenu2.CloseKeyboardOverlay();
				}
				Core.uiManager.showChatTab = false;
				current.Use();
			}
			else if ((int)current.keyCode == 8)
			{
				if (!controllerKeyboardActive && message.Length > 0)
				{
					message = message.Substring(0, message.Length - 1);
				}
				current.Use();
			}
			else if (!controllerKeyboardActive && !char.IsControl(current.character) && message.Length < 150)
			{
				message += current.character;
				current.Use();
			}
		}

		private string GetVisibleTail(string fullText, float maxWidth)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(fullText))
			{
				return string.Empty;
			}
			int startIndex = fullText.Length - 1;
			int num = fullText.Length - 1;
			while (num >= 0)
			{
				string text = fullText.Substring(num);
				float x = textFieldStyle.CalcSize(new GUIContent(text)).x;
				if (x <= maxWidth)
				{
					startIndex = num;
					num--;
					continue;
				}
				break;
			}
			return fullText.Substring(startIndex);
		}

		private void DrawFakeCursor(string visibleMessage, float cursorWidth)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)Event.current.type == 7 && !(Mathf.Repeat(Time.unscaledTime, 1f) >= 0.5f))
			{
				float num = ((Rect)(ref textFieldRect)).height - (float)textFieldStyle.padding.vertical;
				float num2 = Mathf.Clamp(num * FakeCursorHeightMultiplier, 4f, num);
				float num3 = ((Rect)(ref textFieldRect)).x + (float)textFieldStyle.padding.left;
				float num4 = ((Rect)(ref textFieldRect)).xMax - (float)textFieldStyle.padding.right;
				float num5 = ((Rect)(ref textFieldRect)).y + (float)textFieldStyle.padding.top;
				float x = textFieldStyle.CalcSize(new GUIContent(visibleMessage)).x;
				float num6 = Mathf.Min(num3 + x - 5f, num4 - cursorWidth);
				float num7 = num5 + (num - num2) * 0.5f;
				Color color = GUI.color;
				GUI.color = Color.white;
				GUI.DrawTexture(new Rect(num6, num7, cursorWidth, num2), (Texture)(object)Texture2D.whiteTexture);
				GUI.color = color;
			}
		}

		public void SendCurrentMessage()
		{
			if (!string.IsNullOrWhiteSpace(message))
			{
				Core.networkManager.SendChatMessage(message);
				ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
				Core.uiManager.notificationsUI.AddMessage(currentLanguage.You + ": " + message);
				message = "";
			}
		}
	}
	public class NotificationUI
	{
		private class Message
		{
			public string Text;

			public float TimeAdded;

			public Color Color;

			public float HoldDuration;
		}

		private const float REFERENCE_HEIGHT = 1080f;

		private const float BACKDROP_ALPHA = 0.5f;

		private const float fadeDuration = 1f;

		private readonly List<Message> messages = new List<Message>();

		private readonly List<Message> messagesToRemove = new List<Message>();

		private readonly List<Message> chatHistory = new List<Message>();

		private GUIStyle backdropStyle;

		public bool ShowChatHistory { get; set; }

		private static float GetTime()
		{
			return Time.unscaledTime;
		}

		public void AddMessage(string message, float? holdDuration = null, Color? color = null)
		{
			//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)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Core.logger.Msg(message);
			float holdDuration2 = holdDuration ?? Mathf.Clamp(3.5f + (float)(message?.Length ?? 0) * 0.075f, 4f, 16f);
			Message item = new Message
			{
				Text = message,
				HoldDuration = holdDuration2,
				Color = (Color)(((??)color) ?? Color.white),
				TimeAdded = 0f
			};
			messages.Add(item);
			chatHistory.Add(item);
		}

		public void DrawUI()
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Expected O, but got Unknown
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Screen.height / 1080f;
			float num2 = Mathf.Max(num, 1f);
			int fontSize = Mathf.RoundToInt(16f * num2);
			GUIStyle val = new GUIStyle(StyleManager.Styles.Label)
			{
				fontSize = fontSize,
				wordWrap = true
			};
			if (backdropStyle == null)
			{
				backdropStyle = new GUIStyle(GUI.skin.box);
				backdropStyle.normal.background = Texture2D.whiteTexture;
			}
			try
			{
				float time = GetTime();
				float num3 = 10f * num2;
				float num4 = 10f * num2;
				float num5 = (float)Screen.width - num4 * 2f;
				for (int num6 = messages.Count - 1; num6 >= 0; num6--)
				{
					Message message = messages[num6];
					if (message.TimeAdded <= 0f)
					{
						message.TimeAdded = time;
					}
					float age = time - message.TimeAdded;
					if (FadeMessage(message.HoldDuration, age, out var alpha))
					{
						messagesToRemove.Add(message);
					}
					else
					{
						float num7 = val.CalcHeight(new GUIContent(message.Text), num5);
						float x = val.CalcSize(new GUIContent(message.Text)).x;
						float num8 = 4f * num2;
						GUI.color = new Color(0.2f, 0.2f, 0.2f, 0.5f * alpha);
						GUI.Box(new Rect(num4 - num8, num3 - num8, x + num8 * 2f, num7 + num8 * 2f), "", backdropStyle);
						GUI.color = new Color(message.Color.r, message.Color.g, message.Color.b, alpha);
						GUI.Label(new Rect(num4, num3, num5, num7), message.Text, val);
						num3 += num7 + num8 + 4f * num2;
					}
				}
				if (ShowChatHistory && chatHistory.Count > 0)
				{
					num3 += 20f * num2;
					float num9 = (float)Screen.height - num3 - 50f;
					float num10 = 0f;
					for (int num11 = chatHistory.Count - 1; num11 >= 0; num11--)
					{
						float num12 = val.CalcHeight(new GUIContent(chatHistory[num11].Text), num5);
						float x2 = val.CalcSize(new GUIContent(chatHistory[num11].Text)).x;
						float num13 = 4f * num2;
						float num14 = num12 + num13 + 4f * num2;
						if (num10 + num14 > num9)
						{
							break;
						}
						GUI.color = new Color(0.2f, 0.2f, 0.2f, 0.5f);
						GUI.Box(new Rect(num4 - num13, num3 - num13, x2 + num13 * 2f, num12 + num13 * 2f), "", backdropStyle);
						GUI.color = Color.white;
						GUI.Label(new Rect(num4, num3, num5, num12), chatHistory[num11].Text, val);
						num3 += num14;
						num10 += num14;
					}
				}
			}
			finally
			{
				GUI.color = Color.white;
			}
			if (messagesToRemove.Count > 0)
			{
				messages.RemoveAll(messagesToRemove.Contains);
				messagesToRemove.Clear();
			}
		}

		private static bool FadeMessage(float HoldDuration, float age, out float alpha)
		{
			if (age < HoldDuration)
			{
				alpha = 1f;
			}
			else
			{
				float num = age - HoldDuration;
				alpha = Mathf.Clamp01(1f - num / 1f);
				if (alpha <= 0f)
				{
					return true;
				}
			}
			return false;
		}
	}
	public class PlayersTabUI : RuntimeWindow
	{
		private static Vector2 defaultSize = new Vector2(300f, 10f);

		public PlayersTabUI()
			: base(LanguageManager.GetCurrentLanguage().ConnectedPlayers, 2, new Vector2((float)Screen.width / 2f - defaultSize.x / 2f, 20f), defaultSize)
		{
			//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)
			IsDraggable = false;
			ShouldDrawScrollBar = false;
			ShouldAutoResizeHeight = true;
			MinResizeHeight = defaultSize.y;
			MaxResizeHeight = Screen.height - 20;
		}

		internal override void DrawContent()
		{
			//IL_0015: 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_002c: 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_0051: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			float num = (float)Screen.height / 1080f;
			Vector2 position = base.Position;
			position.x = (float)Screen.width / num / 2f - base.Size.x / 2f;
			base.Position = position;
			MaxResizeHeight = (float)Screen.height - position.y - 20f;
			int value = 0;
			if (LocalPlayer.Instance != null && (Object)(object)LocalPlayer.Instance.headBone != (Object)null)
			{
				value = (int)(LocalPlayer.Instance.headBone.position.y - 120f);
			}
			Label = $"{currentLanguage.ConnectedPlayers} [Y:{value}]";
			GUILayout.Space(1f);
			if (Core.networkManager.players.Count == 0)
			{
				GUILayout.Label(currentLanguage.NoPlayersConnected, StyleManager.Styles.MiddleCenterLabel, (Il2CppReferenceArray<GUILayoutOption>)null);
			}
			else
			{
				foreach (KeyValuePair<byte, RemotePlayer> player in Core.networkManager.players)
				{
					RemotePlayer value2 = player.Value;
					if (value2 != null && value2.firstAppearanceApplication)
					{
						int value3 = 0;
						if ((Object)(object)value2.rootBone != (Object)null)
						{
							value3 = (int)value2.rootBone.position.y - 120;
						}
						GUILayout.Label($"[Y:{value3}] {value2.displayName}", StyleManager.Styles.MiddleCenterLabel, (Il2CppReferenceArray<GUILayoutOption>)null);
					}
				}
			}
			GUILayout.Space(2f);
		}
	}
	public class ServerConnectUI : RuntimeWindow
	{
		private enum KeybindCaptureTarget
		{
			None,
			PushToTalk,
			TabMenu,
			ChatMenu
		}

		private RuntimeFoldout serverInfoFoldout;

		private RuntimeFoldout audioSettingsFoldout;

		private RuntimeFoldout microphoneDevicesFoldout;

		private RuntimeFoldout generalSettingsFoldout;

		private RuntimeFoldout playerCustomizationFoldout;

		private RuntimeFoldout languageSettingsFoldout;

		private string[] availableDevices = new string[0];

		private KeybindCaptureTarget keybindCaptureTarget = KeybindCaptureTarget.None;

		private float currentPeak = 0f;

		private float peakDecayRate = 0.95f;

		public ServerConnectUI()
			: base("Server Join Panel v" + Core.CLIENT_VERSION, 0, new Vector2(30f, 30f), new Vector2(250f, 400f))
		{
			//IL_0044: 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)
			ShouldDrawContentBacker = false;
			UpdateFoldoutLabels();
		}

		private void UpdateFoldoutLabels()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			serverInfoFoldout = new RuntimeFoldout(currentLanguage.ServerInformation);
			audioSettingsFoldout = new RuntimeFoldout(currentLanguage.AudioSettings);
			microphoneDevicesFoldout = new RuntimeFoldout(currentLanguage.MicrophoneDevices);
			generalSettingsFoldout = new RuntimeFoldout(currentLanguage.GeneralSettings);
			playerCustomizationFoldout = new RuntimeFoldout(currentLanguage.PlayerCustomization, defaultState: true);
			languageSettingsFoldout = new RuntimeFoldout(currentLanguage.Language);
		}

		internal override void DrawContent()
		{
			//IL_0035: 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_003d: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			if (keybindCaptureTarget != 0)
			{
				foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
				{
					if (Input.GetKeyDown(value) && (int)value != 0 && (int)value != 323)
					{
						ApplyCapturedKey(value);
						break;
					}
				}
			}
			bool isConnected = Core.networkManager.IsConnected;
			string text = (isConnected ? currentLanguage.Disconnect : currentLanguage.Connect);
			if (GUILayout.Button(text, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				if (isConnected)
				{
					Core.networkManager.Disconnect();
				}
				else
				{
					Core.logger.Msg($"{ModSettings.player.Nickname.Value}, {ModSettings.connection.Address.Value}:{ModSettings.connection.Port.Value}");
					SaveConfig();
					Core.networkManager.Connect(ModSettings.connection.Address.Value, ModSettings.connection.Port.Value, ModSettings.connection.Password.Value);
				}
			}
			GUILayout.Space(5f);
			languageSettingsFoldout.Draw(HandleLanguageSettings);
			GUILayout.Space(10f);
			serverInfoFoldout.Draw(HandleServerInfo);
			GUILayout.Space(10f);
			audioSettingsFoldout.Draw(HandleAudioSettings);
			GUILayout.Space(10f);
			generalSettingsFoldout.Draw(HandleGeneralSettings);
			GUILayout.Space(10f);
			playerCustomizationFoldout.Draw(HandlePlayerCustomization);
		}

		private void HandleLanguageSettings()
		{
			string[] availableLanguages = LanguageManager.GetAvailableLanguages();
			string[] array = new string[availableLanguages.Length];
			for (int i = 0; i < availableLanguages.Length; i++)
			{
				array[i] = LanguageNativeNames.GetNativeName(availableLanguages[i]);
			}
			int num = Array.IndexOf(availableLanguages, LanguageManager.CurrentLanguage);
			if (num < 0)
			{
				num = 0;
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (GUILayout.Button(array[j], StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
				{
					LanguageManager.SetLanguage(availableLanguages[j]);
					UpdateFoldoutLabels();
				}
			}
		}

		private void HandleServerInfo()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			GUILayout.Label(currentLanguage.ServerIP, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			ModSettings.connection.Address.Value = GUILayout.TextField(ModSettings.connection.Address.Value, 32, StyleManager.Styles.TextField, Array.Empty<GUILayoutOption>());
			GUILayout.Label(currentLanguage.ServerPort, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			string s = GUILayout.TextField(ModSettings.connection.Port.Value.ToString(), 5, StyleManager.Styles.TextField, Array.Empty<GUILayoutOption>());
			if (int.TryParse(s, out var result))
			{
				ModSettings.connection.Port.Value = result;
			}
			GUILayout.Label(currentLanguage.PasswordOptional, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			ModSettings.connection.Password.Value = GUILayout.PasswordField(ModSettings.connection.Password.Value, '*', 32, StyleManager.Styles.TextField, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
		}

		private void HandleAudioSettings()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			GUI.enabled = LocalPlayer.Instance != null;
			string text = (ModSettings.audio.MicrophoneEnabled.Value ? currentLanguage.DisableMicrophone : currentLanguage.EnableMicrophone);
			if (GUILayout.Button(text, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.audio.MicrophoneEnabled.Value = !ModSettings.audio.MicrophoneEnabled.Value;
				LocalPlayer.Instance?.SetMicrophoneEnabled(ModSettings.audio.MicrophoneEnabled.Value);
			}
			GUILayout.Space(5f);
			if (GUILayout.Button(ModSettings.audio.Deafened.Value ? currentLanguage.Undeafen : currentLanguage.Deafen, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.audio.Deafened.Value = !ModSettings.audio.Deafened.Value;
			}
			GUILayout.Space(5f);
			if (GUILayout.Button(ModSettings.audio.PushToTalk.Value ? currentLanguage.DisablePushToTalk : currentLanguage.EnablePushToTalk, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.audio.PushToTalk.Value = !ModSettings.audio.PushToTalk.Value;
				LocalPlayer.Instance?.SetPushToTalkEnabled(ModSettings.audio.PushToTalk.Value);
			}
			GUILayout.Space(5f);
			GUI.enabled = LocalPlayer.Instance != null && ModSettings.audio.PushToTalk.Value;
			GUILayout.BeginHorizontal((Il2CppReferenceArray<GUILayoutOption>)null);
			GUILayout.Label(currentLanguage.PushToTalkKey, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			string keybindButtonText = GetKeybindButtonText(ModSettings.audio.PushToTalkKey.Value, KeybindCaptureTarget.PushToTalk, currentLanguage.PressAnyKey);
			if (GUILayout.Button(keybindButtonText, StyleManager.Styles.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				keybindCaptureTarget = KeybindCaptureTarget.PushToTalk;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(5f);
			GUI.enabled = LocalPlayer.Instance != null;
			GUILayout.Label($"{currentLanguage.MicrophoneGain} {ModSettings.audio.MicrophoneGain.Value:F2}x", StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			float num = GUILayout.HorizontalSlider(ModSettings.audio.MicrophoneGain.Value, 0f, 3f, StyleManager.Styles.HorizontalSlider, StyleManager.Styles.HorizontalSliderThumb, Array.Empty<GUILayoutOption>());
			if (num != ModSettings.audio.MicrophoneGain.Value)
			{
				ModSettings.audio.MicrophoneGain.Value = num;
				LocalPlayer.Instance?.mic.SetGain(num);
			}
			GUILayout.Space(5f);
			DrawPeakMeter();
			GUILayout.Space(5f);
			microphoneDevicesFoldout.Draw(HandleMicrophoneDevices);
			GUI.enabled = true;
		}

		private void DrawPeakMeter()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_01cc: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: 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_0163: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			if (LocalPlayer.Instance != null && LocalPlayer.Instance.mic != null && LocalPlayer.Instance.mic.IsRecording())
			{
				UpdatePeakLevel();
			}
			else
			{
				currentPeak = 0f;
			}
			GUILayout.BeginHorizontal((Il2CppReferenceArray<GUILayoutOption>)null);
			GUILayout.Label(LanguageManager.GetCurrentLanguage().Level, StyleManager.Styles.Label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(45f) });
			Rect rect = GUILayoutUtility.GetRect(180f, 20f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.color = new Color(0.2f, 0.2f, 0.2f, 1f);
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
			float num = 20f * Mathf.Log10(Mathf.Max(currentPeak, 0.0001f));
			float num2 = Mathf.Clamp01((num + 60f) / 60f);
			if (num2 > 0.01f)
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width * num2, ((Rect)(ref rect)).height);
				Color color;
				if (num2 < 0.666f)
				{
					color = Color.green;
				}
				else if (num2 < 0.85f)
				{
					float num3 = (num2 - 0.666f) / 0.18400002f;
					color = Color.Lerp(Color.green, Color.yellow, num3);
				}
				else
				{
					float num4 = (num2 - 0.85f) / 0.14999998f;
					color = Color.Lerp(Color.yellow, Color.red, num4);
				}
				GUI.color = color;
				GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = Color.white;
			}
			DrawTickMark(rect, 0.666f);
			DrawTickMark(rect, 0.85f);
			GUILayout.EndHorizontal();
			string text = ((num > -60f) ? $"{num:F1} dB" : "-inf dB");
			GUILayout.Label(text, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
		}

		private void DrawTickMark(Rect meterRect, float position)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Rect)(ref meterRect)).x + ((Rect)(ref meterRect)).width * position;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num - 1f, ((Rect)(ref meterRect)).y, 2f, ((Rect)(ref meterRect)).height);
			GUI.color = new Color(0.5f, 0.5f, 0.5f, 0.8f);
			GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
		}

		private void UpdatePeakLevel()
		{
			currentPeak *= peakDecayRate;
			BBSMicrophoneCapture bBSMicrophoneCapture = LocalPlayer.Instance?.mic;
			if (bBSMicrophoneCapture != null && bBSMicrophoneCapture.IsRecording())
			{
				float lastFramePeak = bBSMicrophoneCapture.GetLastFramePeak();
				if (lastFramePeak > currentPeak)
				{
					currentPeak = lastFramePeak;
				}
			}
		}

		private void HandleMicrophoneDevices()
		{
			if (LocalPlayer.Instance == null || LocalPlayer.Instance.mic == null)
			{
				return;
			}
			if (availableDevices.Length < 1)
			{
				availableDevices = LocalPlayer.Instance.mic.GetAvailableDevices();
			}
			if (availableDevices.Length != 0)
			{
				ModSettings.audio.SelectedMicrophoneIndex.Value = Mathf.Clamp(ModSettings.audio.SelectedMicrophoneIndex.Value, 0, availableDevices.Length - 1);
				int num = GUILayout.SelectionGrid(ModSettings.audio.SelectedMicrophoneIndex.Value, Il2CppStringArray.op_Implicit(availableDevices), 1, StyleManager.Styles.ButtonLeftCenteredText, Array.Empty<GUILayoutOption>());
				if (num != ModSettings.audio.SelectedMicrophoneIndex.Value)
				{
					ModSettings.audio.SelectedMicrophoneIndex.Value = num;
					LocalPlayer.Instance.SetMicrophoneDevice(ModSettings.audio.SelectedMicrophoneIndex.Value);
				}
			}
		}

		private void HandleGeneralSettings()
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			GUILayout.BeginHorizontal((Il2CppReferenceArray<GUILayoutOption>)null);
			GUILayout.Label(currentLanguage.PlayerListKeyLabel, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			string keybindButtonText = GetKeybindButtonText(ModSettings.player.TabMenuKey.Value, KeybindCaptureTarget.TabMenu, currentLanguage.PressAnyKey);
			if (GUILayout.Button(keybindButtonText, StyleManager.Styles.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				keybindCaptureTarget = KeybindCaptureTarget.TabMenu;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal((Il2CppReferenceArray<GUILayoutOption>)null);
			GUILayout.Label(currentLanguage.ChatMenuKeyLabel, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			string keybindButtonText2 = GetKeybindButtonText(ModSettings.player.ChatMenuKey.Value, KeybindCaptureTarget.ChatMenu, currentLanguage.PressAnyKey);
			if (GUILayout.Button(keybindButtonText2, StyleManager.Styles.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				keybindCaptureTarget = KeybindCaptureTarget.ChatMenu;
			}
			GUILayout.EndHorizontal();
			GUILayout.Space(5f);
			GUI.enabled = Core.networkManager.IsConnected;
			if (GUILayout.Button(ModSettings.player.Collisions.Value ? currentLanguage.DisableCollisions : currentLanguage.EnableCollisions, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.player.Collisions.Value = !ModSettings.player.Collisions.Value;
				Core.networkManager.SendCollisionToggle(ModSettings.player.Collisions.Value);
				foreach (KeyValuePair<byte, RemotePlayer> player in Core.networkManager.players)
				{
					if (ModSettings.player.Collisions.Value && player.Value.netCollisionsEnabled)
					{
						player.Value.EnableCollision();
					}
					else
					{
						player.Value.DisableCollision();
					}
				}
			}
			GUILayout.Space(5f);
			GUI.enabled = true;
			GUI.enabled = Core.networkManager.IsConnected;
			if (GUILayout.Button(ModSettings.player.CutscenePlayerVisibility.Value ? currentLanguage.DisablePlayerCutsceneVisibility : currentLanguage.EnablePlayerCutsceneVisibility, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.player.CutscenePlayerVisibility.Value = !ModSettings.player.CutscenePlayerVisibility.Value;
			}
			GUILayout.Space(5f);
			GUI.enabled = true;
			GUI.enabled = Core.networkManager.IsConnected;
			if (GUILayout.Button(ModSettings.player.ShowNametags.Value ? currentLanguage.DisableNametags : currentLanguage.EnableNametags, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.player.ShowNametags.Value = !ModSettings.player.ShowNametags.Value;
			}
			GUILayout.Space(5f);
			GUI.enabled = true;
		}

		private void HandlePlayerCustomization()
		{
			//IL_00f8: 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_00fe: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: 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_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			GUI.enabled = Core.networkManager.IsConnected;
			if (GUILayout.Button(currentLanguage.UpdateNameAndAppearance, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()) && Core.networkManager.IsConnected)
			{
				SaveConfig();
				Core.networkManager.SendPlayerInformation();
				if (LocalPlayer.Instance != null)
				{
					LocalPlayer.Instance.ApplySuitColor();
				}
				Core.uiManager.notificationsUI.AddMessage(currentLanguage.AppearanceUpdated);
			}
			GUILayout.Space(5f);
			GUI.enabled = true;
			GUILayout.Label(currentLanguage.Nickname, StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			ModSettings.player.Nickname.Value = FilterKeyboardCharacters(GUILayout.TextField(ModSettings.player.Nickname.Value, 20, StyleManager.Styles.TextField, Array.Empty<GUILayoutOption>()));
			Color value = ModSettings.player.SuitColor.Value;
			if (value.a != 1f)
			{
				value.a = 1f;
			}
			GUILayout.Space(5f);
			GUILayout.BeginHorizontal((Il2CppReferenceArray<GUILayoutOption>)null);
			GUILayout.Label(currentLanguage.SuitTint, StyleManager.Styles.Label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			GUI.color = value;
			GUILayout.Label("████████", StyleManager.Styles.MiddleCenterLabel, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			GUI.color = Color.white;
			GUILayout.EndHorizontal();
			GUILayout.Space(2f);
			GUILayout.Label($"{currentLanguage.Red} {(int)(value.r * 255f)}", StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			value.r = GUILayout.HorizontalSlider(value.r, 0f, 1f, StyleManager.Styles.HorizontalSlider, StyleManager.Styles.HorizontalSliderThumb, Array.Empty<GUILayoutOption>());
			GUILayout.Label($"{currentLanguage.Green} {(int)(value.g * 255f)}", StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			value.g = GUILayout.HorizontalSlider(value.g, 0f, 1f, StyleManager.Styles.HorizontalSlider, StyleManager.Styles.HorizontalSliderThumb, Array.Empty<GUILayoutOption>());
			GUILayout.Label($"{currentLanguage.Blue} {(int)(value.b * 255f)}", StyleManager.Styles.Label, (Il2CppReferenceArray<GUILayoutOption>)null);
			value.b = GUILayout.HorizontalSlider(value.b, 0f, 1f, StyleManager.Styles.HorizontalSlider, StyleManager.Styles.HorizontalSliderThumb, Array.Empty<GUILayoutOption>());
			GUILayout.Space(5f);
			ModSettings.player.SuitColor.Value = value;
			GUI.enabled = Core.networkManager.IsConnected;
			if (GUILayout.Button(ModSettings.player.ShowNametags.Value ? currentLanguage.DisableNametags : currentLanguage.EnableNametags, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				ModSettings.player.ShowNametags.Value = !ModSettings.player.ShowNametags.Value;
			}
			GUILayout.Space(5f);
			GUI.enabled = true;
		}

		public void SaveConfig()
		{
			ModSettings.Save();
		}

		public void LoadConfig()
		{
			ModSettings.Load();
		}

		private string FilterKeyboardCharacters(string input)
		{
			return Regex.Replace(input, "[^\\p{L}\\p{N}!@#\\$%\\^&\\*\\(\\)_\\+\\-=\\[\\]{};:'\",<.>/?\\\\|`~ ]", "");
		}

		private void ApplyCapturedKey(KeyCode keyCode)
		{
			switch (keybindCaptureTarget)
			{
			case KeybindCaptureTarget.PushToTalk:
				ModSettings.audio.PushToTalkKey.Value = ((object)(KeyCode)(ref keyCode)).ToString();
				if (LocalPlayer.Instance != null)
				{
					LocalPlayer.Instance.SetPushToTalkBinding(((object)(KeyCode)(ref keyCode)).ToString());
				}
				break;
			case KeybindCaptureTarget.TabMenu:
				ModSettings.player.TabMenuKey.Value = ((object)(KeyCode)(ref keyCode)).ToString();
				break;
			case KeybindCaptureTarget.ChatMenu:
				ModSettings.player.ChatMenuKey.Value = ((object)(KeyCode)(ref keyCode)).ToString();
				break;
			}
			keybindCaptureTarget = KeybindCaptureTarget.None;
			ModSettings.Save();
		}

		private string GetKeybindButtonText(string configuredKey, KeybindCaptureTarget target, string prompt)
		{
			return (keybindCaptureTarget == target) ? prompt : configuredKey;
		}
	}
}
namespace BabyStepsMultiplayerClient.Player
{
	public class BasePlayer
	{
		public GameObject baseObject;

		public Transform baseMesh;

		public SkinnedMeshRenderer skinnedMeshRenderer;

		public GameObject jiminyRibbon;

		public MeshRenderer nateGlasses;

		public Transform particleHouse;

		public Transform particleCrushers;

		public ParticleParty particleParty;

		public Material hairMaterial;

		public Material suitMaterial;

		public Color baseColor = Color.white;

		public Color playerColor = Color.white;

		public List<Transform> boneChildren;

		public List<Transform> puppetBones;

		public Transform puppetMaster;

		public Transform headBone;

		public Transform rootBone;

		public Transform spineBone;

		public (Transform, Transform) handBones;

		public (Transform, Transform) footBones;

		public (Transform, Transform) eyeLids;

		public (Transform, Transform) eyeBalls;

		public (SkinnedMeshRenderer, SkinnedMeshRenderer) eyeBallRenderers;

		public Dictionary<string, Transform> boneMudMeshes;

		public Material[] meshMaterials;

		public Transform jawMaster;

		public Transform mchJawMaster;

		private const float CLOSED_JAW_X = 36.65f;

		private const float OPEN_JAW_X = 5f;

		private const float OPEN_LIP_X = 15f;

		public FaceActor faceActor;

		private int idxJawOpen = -1;

		private int idxMouthClose = -1;

		public virtual void Initialize()
		{
			if ((Object)(object)baseObject == (Object)null)
			{
				return;
			}
			if ((Object)(object)puppetMaster == (Object)null)
			{
				puppetMaster = baseObject.transform.FindChild("PuppetMaster");
			}
			if ((Object)(object)baseMesh == (Object)null)
			{
				baseMesh = baseObject.transform.Find("IKTargets/HipTarget/NathanAnimIK_October2022");
			}
			if (!((Object)(object)baseMesh != (Object)null))
			{
				return;
			}
			if ((Object)(object)skinnedMeshRenderer == (Object)null)
			{
				skinnedMeshRenderer = ((Component)baseMesh.Find("Nathan.001")).GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)particleHouse == (Object)null)
			{
				particleHouse = baseObject.transform.Find("ParticleHouse");
			}
			if ((Object)(object)particleHouse != (Object)null)
			{
				if ((Object)(object)particleCrushers == (Object)null)
				{
					particleCrushers = particleHouse.Find("Crushers");
				}
				if ((Object)(object)particleParty == (Object)null)
				{
					particleParty = ((Component)particleHouse).GetComponent<ParticleParty>();
				}
			}
			if ((Object)(object)eyeLids.Item1 == (Object)null)
			{
				eyeLids.Item1 = ((Component)baseMesh).transform.FindChild("Nathan_EyeLOuter");
			}
			if ((Object)(object)eyeLids.Item2 == (Object)null)
			{
				eyeLids.Item2 = ((Component)baseMesh).transform.FindChild("Nathan_EyeROuter");
			}
			if ((Object)(object)eyeBalls.Item1 == (Object)null)
			{
				eyeBalls.Item1 = ((Component)baseMesh).transform.FindChild("Nathan_EyeLInner");
			}
			if ((Object)(object)eyeBalls.Item1 != (Object)null)
			{
				eyeBallRenderers.Item1 = ((Component)eyeBalls.Item1).GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)eyeBalls.Item2 == (Object)null)
			{
				eyeBalls.Item2 = ((Component)baseMesh).transform.FindChild("Nathan_EyeRInner");
			}
			if ((Object)(object)eyeBalls.Item2 != (Object)null)
			{
				eyeBallRenderers.Item2 = ((Component)eyeBalls.Item2).GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)jiminyRibbon == (Object)null)
			{
				Transform val = baseMesh.FindChildByKeyword("JiminysCricketsRibbon");
				if ((Object)(object)val != (Object)null)
				{
					jiminyRibbon = ((Component)val).gameObject;
				}
			}
			if ((Object)(object)faceActor == (Object)null)
			{
				faceActor = baseObject.GetComponentInChildren<FaceActor>(true);
			}
		}

		protected void InitializeJawMasters()
		{
			if (!((Object)(object)headBone == (Object)null))
			{
				Transform val = headBone.Find("ORG-face");
				if ((Object)(object)val != (Object)null)
				{
					jawMaster = val.Find("jaw_master");
					mchJawMaster = val.Find("MCH-jaw_master");
				}
			}
		}

		public void SetMouthOpen(float openAmount)
		{
			//IL_005f: 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)
			if (!((Object)(object)jawMaster == (Object)null) && !((Object)(object)mchJawMaster == (Object)null))
			{
				openAmount = Mathf.Clamp01(openAmount);
				float num = Mathf.Lerp(36.65f, 5f, openAmount);
				float num2 = Mathf.Lerp(36.65f, 15f, openAmount);
				jawMaster.localEulerAngles = new Vector3(num, 180f, 180f);
				mchJawMaster.localEulerAngles = new Vector3(num2, 180f, 180f);
			}
		}

		public void CloseMouth()
		{
			SetMouthOpen(0f);
		}

		public virtual void Dispose()
		{
		}

		public virtual void Update()
		{
		}

		public virtual void LateUpdate()
		{
		}

		protected static Color GetRainbowColor(float time)
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Repeat(time * 0.2f, 1f);
			return Color.HSVToRGB(num, 1f, 1f);
		}

		public Texture2D CloneSuitTexture()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)suitMaterial == (Object)null)
			{
				return null;
			}
			Texture texture = suitMaterial.GetTexture("_AlbedoMap");
			Texture2D val = new Texture2D(texture.width, texture.height, (TextureFormat)5, false);
			RenderTexture val2 = new RenderTexture(texture.width, texture.height, 0);
			RenderTexture active = RenderTexture.active;
			Graphics.Blit(texture, val2);
			RenderTexture.active = val2;
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), 0, 0);
			val.Apply();
			RenderTexture.active = active;
			val2.Release();
			return val;
		}

		public void SetHairHat(float hatMax, Vector4 hatUp)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			SetHairValues(hairMaterial, hatMax, hatUp);
		}

		public static void SetHairValues(Material mat, float hatMax, Vector4 hatUp)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)mat == (Object)null))
			{
				mat.SetFloat("_HatMax", hatMax);
				mat.SetVector("_HatUp", hatUp);
				((Object)mat).MarkDirty();
			}
		}

		public Color GetSuitColor()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return playerColor;
		}

		public virtual void SetSuitColor(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			playerColor = color;
			if ((Object)(object)suitMaterial != (Object)null && suitMaterial.color != playerColor)
			{
				suitMaterial.color = playerColor;
			}
		}

		public void ResetSuitColor()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)suitMaterial == (Object)null))
			{
				suitMaterial.color = baseColor;
			}
		}

		public void FadeByDistance(float distance)
		{
			if (!((Object)(object)baseObject == (Object)null))
			{
				float num = 1.3f;
				float num2 = 0.7f;
				float opacity = Mathf.Clamp01((distance - num2) / (num - num2));
				SetOpacity(opacity);
			}
		}

		public virtual void SetOpacity(float opacity)
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)skinnedMeshRenderer != (Object)null)
			{
				Il2CppReferenceArray<Material> materials = ((Renderer)skinnedMeshRenderer).materials;
				for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)materials).Count; i++)
				{
					Material val = ((Il2CppArrayBase<Material>)(object)materials)[i];
					if (val.HasProperty("_DitherAlpha"))
					{
						val.SetFloat("_DitherAlpha", opacity);
					}
					else if (val.HasProperty("_Cutoff"))
					{
						val.SetFloat("_Cutoff", Mathf.Lerp(1.05f, 0.12f, opacity * opacity));
					}
				}
			}
			if ((Object)(object)nateGlasses != (Object)null)
			{
				Il2CppReferenceArray<Material> materials2 = ((Renderer)nateGlasses).materials;
				if (((Il2CppArrayBase<Material>)(object)materials2).Length > 1 && (Object)(object)((Il2CppArrayBase<Material>)(object)materials2)[1] != (Object)null && ((Il2CppArrayBase<Material>)(object)materials2)[1].HasProperty("_DitherAlpha"))
				{
					((Il2CppArrayBase<Material>)(object)materials2)[1].SetFloat("_DitherAlpha", opacity);
				}
			}
			if ((Object)(object)eyeBallRenderers.Item1 != (Object)null && (Object)(object)((Renderer)eyeBallRenderers.Item1).material != (Object)null)
			{
				Color color = ((Renderer)eyeBallRenderers.Item1).material.GetColor("_Color");
				color.a = opacity;
				((Renderer)eyeBallRenderers.Item1).material.SetColor("_Color", color);
			}
			if ((Object)(object)eyeBallRenderers.Item2 != (Object)null && (Object)(object)((Renderer)eyeBallRenderers.Item2).material != (Object)null)
			{
				Color color2 = ((Renderer)eyeBallRenderers.Item2).material.GetColor("_Color");
				color2.a = opacity;
				((Renderer)eyeBallRenderers.Item2).material.SetColor("_Color", color2);
			}
		}

		private static Transform[] ExtractValidBones(Transform[] meshBones, Transform meshRoot)
		{
			Transform[] array = (Transform[])(object)new Transform[meshBones.Length];
			HashSet<Transform> hashSet = new HashSet<Transform>(meshBones);
			Queue<Transform> queue = new Queue<Transform>();
			Transform item = meshRoot.Find("root/root.x");
			queue.Enqueue(item);
			int num = 0;
			while (queue.Count > 0 && num < array.Length)
			{
				Transform val = queue.Dequeue();
				if (!IsBoneNameValid(((Object)val).name))
				{
					continue;
				}
				if (hashSet.Contains(val))
				{
					array[num++] = val;
				}
				if (!(((Object)val).name != "ORG-face") && !((Object)val).name.Contains("hand") && !((Object)val).name.Contains("foot"))
				{
					continue;
				}
				for (int i = 0; i < val.childCount; i++)
				{
					Transform child = val.GetChild(i);
					if (hashSet.Contains(child))
					{
						queue.Enqueue(child);
					}
				}
			}
			if (num < array.Length)
			{
				Array.Resize(ref array, num);
			}
			return array;
		}

		private static bool IsBoneNameValid(string name)
		{
			if (name == null)
			{
				return false;
			}
			string text = name.ToLowerInvariant();
			string[] array = new string[10] { "belly", "butt", "twist", "boob", "backfat", "index", "middle", "pinky", "thumb", "ring" };
			string[] array2 = array;
			foreach (string value in array2)
			{
				if (text.Contains(value))
				{
					return false;
				}
			}
			return !string.Equals(name, "JiminysCricketsRibbon");
		}

		public void ResetBonesToBind()
		{
			//IL_007f: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: 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_00a2: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c3: 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_0121: 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)
			if ((Object)(object)skinnedMeshRenderer == (Object)null || (Object)(object)LocalPlayer.Instance.skinnedMeshRenderer == (Object)null)
			{
				return;
			}
			Transform[] array = Il2CppArrayBase<Transform>.op_Implicit((Il2CppArrayBase<Transform>)(object)skinnedMeshRenderer.bones);
			Matrix4x4[] array2 = Il2CppArrayBase<Matrix4x4>.op_Implicit((Il2CppArrayBase<Matrix4x4>)(object)LocalPlayer.Instance.skinnedMeshRenderer.sharedMesh.bindposes);
			Transform val = skinnedMeshRenderer.rootBone;
			for (int i = 0; i < array.Length; i++)
			{
				Transform val2 = array[i];
				Matrix4x4 inverse = ((Matrix4x4)(ref array2[i])).inverse;
				Vector3 localPosition;
				Quaternion localRotation;
				if ((Object)(object)val2.parent == (Object)null)
				{
					localPosition = Vector4.op_Implicit(((Matrix4x4)(ref inverse)).GetColumn(3));
					localRotation = Quaternion.LookRotation(Vector4.op_Implicit(((Matrix4x4)(ref inverse)).GetColumn(2)), Vector4.op_Implicit(((Matrix4x4)(ref inverse)).GetColumn(1)));
				}
				else
				{
					Matrix4x4 val3 = val2.parent.worldToLocalMatrix * val.localToWorldMatrix * inverse;
					localPosition = Vector4.op_Implicit(((Matrix4x4)(ref val3)).GetColumn(3));
					localRotation = Quaternion.LookRotation(Vector4.op_Implicit(((Matrix4x4)(ref val3)).GetColumn(2)), Vector4.op_Implicit(((Matrix4x4)(ref val3)).GetColumn(1)));
				}
				val2.localPosition = localPosition;
				val2.localRotation = localRotation;
			}
		}

		public void SetupBonesAndMaterials()
		{
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)skinnedMeshRenderer != (Object)null)
			{
				if (meshMaterials == null)
				{
					meshMaterials = Il2CppArrayBase<Material>.op_Implicit((Il2CppArrayBase<Material>)(object)((Renderer)skinnedMeshRenderer).sharedMaterials);
				}
				if (boneMudMeshes == null)
				{
					boneMudMeshes = new Dictionary<string, Transform>();
				}
				boneChildren = ExtractValidBones(Il2CppArrayBase<Transform>.op_Implicit((Il2CppArrayBase<Transform>)(object)skinnedMeshRenderer.bones), baseMesh).ToList();
				if (boneChildren != null)
				{
					if ((Object)(object)puppetMaster != (Object)null)
					{
						if (puppetBones == null)
						{
							puppetBones = puppetMaster.FindMatchingChildren(boneChildren);
						}
						if (puppetBones != null)
						{
							foreach (Transform puppetBone in puppetBones)
							{
								if ((Object)(object)puppetBone == (Object)null)
								{
									continue;
								}
								string name = ((Object)puppetBone).name;
								if (!boneMudMeshes.ContainsKey(name))
								{
									Transform val = puppetBone.FindChildByKeyword("mudMesh");
									if ((Object)(object)val != (Object)null)
									{
										boneMudMeshes[name] = val;
									}
								}
							}
						}
					}
					foreach (Transform boneChild in boneChildren)
					{
						if ((Object)(object)boneChild == (Object)null)
						{
							continue;
						}
						switch (((Object)boneChild).name)
						{
						case "head.x":
							if ((Object)(object)headBone == (Object)null)
							{
								headBone = boneChild;
							}
							break;
						case "root.x":
							if ((Object)(object)rootBone == (Object)null)
							{
								rootBone = boneChild;
							}
							break;
						case "spine_02.x":
							if ((Object)(object)spineBone == (Object)null)
							{
								spineBone = boneChild;
							}
							break;
						case "hand.r":
							if ((Object)(object)handBones.Item1 == (Object)null)
							{
								handBones.Item1 = boneChild;
							}
							break;
						case "hand.l":
							if ((Object)(object)handBones.Item2 == (Object)null)
							{
								handBones.Item2 = boneChild;
							}
							break;
						case "foot.l":
							if ((Object)(object)footBones.Item1 == (Object)null)
							{
								footBones.Item1 = boneChild;
							}
							break;
						case "foot.r":
							if ((Object)(object)footBones.Item2 == (Object)null)
							{
								footBones.Item2 = boneChild;
							}
							break;
						}
					}
				}
			}
			if (meshMaterials != null)
			{
				if ((Object)(object)hairMaterial == (Object)null)
				{
					hairMaterial = ((IEnumerable<Material>)meshMaterials).FirstOrDefault((Func<Material, bool>)((Material m) => ((Object)m).name.Contains("Hair2_lux")));
				}
				if ((Object)(object)suitMaterial == (Object)null)
				{
					suitMaterial = ((IEnumerable<Material>)meshMaterials).FirstOrDefault((Func<Material, bool>)((Material m) => ((Object)m).name.Contains("NewSuit_Oct22")));
				}
				if ((Object)(object)suitMaterial != (Object)null)
				{
					baseColor = suitMaterial.color;
					playerColor = baseColor;
				}
			}
			if ((Object)(object)headBone != (Object)null && (Object)(object)nateGlasses == (Object)null)
			{
				Transform val2 = headBone.FindChild("Nathan_Glasses");
				if ((Object)(object)val2 != (Object)null)
				{
					nateGlasses = ((Component)val2).GetComponent<MeshRenderer>();
				}
			}
			InitializeJawMasters();
		}
	}
	public class LineOfSightManager
	{
		private float coneAngle = 60f;

		private float coneDistance = 50f;

		private Transform playerHeadBone;

		private bool debugVisualization = false;

		public LineOfSightManager(Transform headBone)
		{
			playerHeadBone = headBone;
		}

		public bool IsInLineOfSight(Vector3 targetPosition)
		{
			//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_0024: 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)
			//IL_0030: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0065: 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 ((Object)(object)playerHeadBone == (Object)null)
			{
				return false;
			}
			Vector3 forward = playerHeadBone.forward;
			Vector3 val = targetPosition - playerHeadBone.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = Vector3.Distance(playerHeadBone.position, targetPosition);
			if (num > coneDistance)
			{
				return false;
			}
			float num2 = Vector3.Angle(forward, normalized);
			return num2 <= coneAngle;
		}

		public bool HasClearLineOfSight(Vector3 targetPosition)
		{
			//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_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_002b: 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)
			//IL_0034: 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)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerHeadBone == (Object)null)
			{
				return false;
			}
			Vector3 position = playerHeadBone.position;
			Vector3 val = targetPosition - position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = Vector3.Distance(position, targetPosition);
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(position, normalized, ref val2, num))
			{
				return ((RaycastHit)(ref val2)).distance >= num * 0.95f;
			}
			return true;
		}

		public bool CanSee(Vector3 targetPosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return IsInLineOfSight(targetPosition) && HasClearLineOfSight(targetPosition);
		}

		public void SetConeAngle(float angle)
		{
			coneAngle = Mathf.Clamp(angle, 0f, 180f);
		}

		public void SetConeDistance(float distance)
		{
			coneDistance = Mathf.Max(0f, distance);
		}

		public float GetConeAngle()
		{
			return coneAngle;
		}

		public float GetConeDistance()
		{
			return coneDistance;
		}

		public bool IsDebugVisualizationEnabled()
		{
			return debugVisualization;
		}
	}
	public class LocalPlayer : BasePlayer
	{
		public static LocalPlayer Instance;

		public PlayerMovement playerMovement;

		public GameObject cinemachineBrainObj;

		public CinemachineBrain cinemachineBrain;

		public Material pmSuitMaterial;

		public bool lastJiminyState;

		public Grabable lastLeftHandItem;

		public Grabable lastRightHandItem;

		public Hat lastHat;

		private bool _sentInitialState = false;

		private bool rainbowSuitActive = false;

		private float lastBoneSendTime = 0f;

		private const float boneSendInterval = 0.033f;

		private const int bytesPerBone = 29;

		private const int bonesPerPacket = 35;

		public BBSMicrophoneCapture mic;

		private bool micEnabled = false;

		private int micDevice = 0;

		public byte[] latestAudioFrame = null;

		private float _currentJawTarget = 0f;

		private bool _isSpeaking = false;

		private CameraCallback _onPreCullDelegate;

		private bool pushToTalkEnabled = false;

		private string pushToTalkBinding;

		private LineOfSightManager lineOfSightManager;

		private float lastGazableUpdateTime;

		private const float gazableUpdateInterval = 0.1f;

		public override void Initialize()
		{
			Core.DebugMsg("Starting LocalPlayer Initialize function");
			baseObject = GameObject.Find("Dudest");
			if ((Object)(object)baseObject == (Object)null)
			{
				Core.DebugMsg("Failed to find Dudest gO!");
			}
			playerMovement = baseObject.GetComponent<PlayerMovement>();
			if ((Object)(object)playerMovement == (Object)null)
			{
				Core.DebugMsg("Failed to find PlayerMovement component!");
			}
			else
			{
				pmSuitMaterial = playerMovement.suitMat;
			}
			cinemachineBrainObj = GameObject.Find("BigManagerPrefab/Camera");
			if ((Object)(object)cinemachineBrainObj == (Object)null)
			{
				Core.DebugMsg("Failed to find cinemachineBrainObj!");
			}
			else
			{
				cinemachineBrain = cinemachineBrainObj.GetComponent<CinemachineBrain>();
			}
			if ((Object)(object)cinemachineBrain == (Object)null)
			{
				Core.DebugMsg("Failed to find CinemachineBrain Component!");
			}
			base.Initialize();
			SetupBonesAndMaterials();
			ApplySuitColor();
			latestAudioFrame = new byte[0];
			mic = new BBSMicrophoneCapture();
			mic.Initialize(micDevice);
			if (micEnabled)
			{
				mic.StartRecording();
			}
			SetPushToTalkEnabled(ModSettings.audio.PushToTalk.Value);
			SetPushToTalkBinding(ModSettings.audio.PushToTalkKey.Value);
			_onPreCullDelegate = CameraCallback.op_Implicit((Action<Camera>)OnCameraPreCull);
			Camera.onPreCull += _onPreCullDelegate;
			if ((Object)(object)headBone != (Object)null)
			{
				lineOfSightManager = new LineOfSightManager(headBone);
			}
			Core.DebugMsg("LocalPlayer Initialized");
		}

		public override void Dispose()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Delegate)(object)_onPreCullDelegate != (Delegate)null)
			{
				Camera.onPreCull -= _onPreCullDelegate;
				_onPreCullDelegate = null;
			}
			SetSuitColor(Color.white);
			ResetSuitColor();
			if (mic != null)
			{
				mic.Dispose();
			}
			mic = null;
			lineOfSightManager = null;
		}

		private void OnCameraPreCull(Camera cam)
		{
			if (_isSpeaking)
			{
				SetMouthOpen(_currentJawTarget);
			}
		}

		private void UpdateMicrophone()
		{
			if (mic == null || !micEnabled)
			{
				return;
			}
			if (Core.networkManager == null || !Core.networkManager.IsConnected)
			{
				if (mic.IsRecording())
				{
					mic.StopRecording();
				}
			}
			else if (!mic.IsRecording())
			{
				mic.StartRecording();
			}
		}

		public void SetMicrophoneEnabled(bool state)
		{
			micEnabled = state;
			if (state)
			{
				if (!mic.IsInitialized())
				{
					mic.Initialize(micDevice);
					mic.StartRecording();
				}
				else
				{
					mic.StartRecording();
				}
			}
			else if (mic.IsInitialized())
			{
				mic.StopRecording();
			}
		}

		public bool IsMicrophoneEnabled()
		{
			return micEnabled;
		}

		public void SetPushToTalkEnabled(bool state)
		{
			pushToTalkEnabled = state;
		}

		public bool IsPushToTalkEnabled()
		{
			return pushToTalkEnabled;
		}

		public void SetPushToTalkBinding(string binding)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			string? text;
			if (!string.IsNullOrWhiteSpace(binding))
			{
				text = binding;
			}
			else
			{
				KeyCode val = (KeyCode)118;
				text = ((object)(KeyCode)(ref val)).ToString();
			}
			pushToTalkBinding = text;
		}

		public string GetPushToTalkBinding()
		{
			return pushToTalkBinding;
		}

		public void SetMicrophoneDevice(int deviceIndex)
		{
			micDevice = deviceIndex;
			if (mic != null && mic.IsInitialized())
			{
				bool flag = mic.IsRecording();
				mic.Dispose();
				mic = new BBSMicrophoneCapture();
				mic.Initialize(micDevice);
				if (flag)
				{
					mic.StartRecording();
				}
			}
		}

		public int GetMicrophoneDevice()
		{
			return micDevice;
		}

		public GameObject GetCameraObject()
		{
			if ((Object)(object)cinemachineBrain == (Object)null)
			{
				return null;
			}
			ICinemachineCamera activeVirtualCamera = cinemachineBrain.ActiveVirtualCamera;
			if (activeVirtualCamera == null)
			{
				return null;
			}
			GameObject virtualCameraGameObject = activeVirtualCamera.VirtualCameraGameObject;
			if ((Object)(object)virtualCameraGameObject == (Object)null)
			{
				return null;
			}
			return virtualCameraGameObject;
		}

		public void ApplySuitColor()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			Color value = ModSettings.player.SuitColor.Value;
			if (value.a != 1f)
			{
				value.a = 1f;
			}
			SetSuitColor(value);
		}

		public override void SetSuitColor(Color color)
		{
			//IL_0002: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			base.SetSuitColor(color);
			if ((Object)(object)pmSuitMaterial != (Object)null && pmSuitMaterial.color != playerColor)
			{
				pmSuitMaterial.color = playerColor;
			}
		}

		public void CleanCompletely()
		{
			if (!((Object)(object)playerMovement == (Object)null))
			{
				playerMovement.CleanPlayerCompletely();
			}
		}

		public override void Update()
		{
			UpdateMicrophone();
			if (!Core.networkManager.IsConnected || !Core.networkManager.HasReceivedUUID || (Object)(object)playerMovement == (Object)null)
			{
				return;
			}
			if (!_sentInitialState)
			{
				Hat currentHat = playerMovement.currentHat;
				if ((Object)(object)currentHat != (Object)null)
				{
					Core.networkManager.SendDonHat(currentHat);
				}
				lastHat = currentHat;
				Grabable val = ((Il2CppArrayBase<Grabable>)(object)playerMovement.handItems)[0];
				Grabable val2 = (lastLeftHandItem = ((Il2CppArrayBase<Grabable>)(object)playerMovement.handItems)[1]);
				lastRightHandItem = val;
				if ((Object)(object)val != (Object)null)
				{
					Core.networkManager.SendHoldGrabable(val, 0);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					Core.networkManager.SendHoldGrabable(val2, 1);
				}
				Core.networkManager.SendJiminyRibbonState(lastJiminyState);
				Core.networkManager.SendCollisionToggle(ModSettings.player.Collisions.Value);
				_sentInitialState = true;
			}
			else
			{
				if ((Object)(object)jiminyRibbon == (Object)null)
				{
					lastJiminyState = false;
				}
				else if (lastJiminyState != jiminyRibbon.active)
				{
					lastJiminyState = jiminyRibbon.active;
					Core.networkManager.SendJiminyRibbonState(lastJiminyState);
				}
				Grabable val3 = ((Il2CppArrayBase<Grabable>)(object)playerMovement.handItems)[1];
				Grabable val4 = ((Il2CppArrayBase<Grabable>)(object)playerMovement.handItems)[0];
				if ((Object)(object)lastLeftHandItem != (Object)(object)val3)
				{
					lastLeftHandItem = val3;
					if ((Object)(object)val3 != (Object)null)
					{
						Core.DebugMsg("Left Hand Pickup!");
						Core.networkManager.SendHoldGrabable(val3, 1);
					}
					else
					{
						Core.DebugMsg("Left Hand Drop!");
						Core.networkManager.SendDropGrabable(1);
					}
				}
				if ((Object)(object)lastRightHandItem != (Object)(object)val4)
				{
					lastRightHandItem = val4;
					if ((Object)(object)val4 != (Object)null)
					{
						Core.DebugMsg("Right Hand Pickup!");
						Core.networkManager.SendHoldGrabable(val4, 0);
					}
					else
					{
						Core.DebugMsg("Right Hand Drop!");
						Core.networkManager.SendDropGrabable(0);
					}
				}
				Hat currentHat2 = playerMovement.currentHat;
				if ((Object)(object)lastHat != (Object)(object)currentHat2)
				{
					lastHat = currentHat2;
					if ((Object)(object)currentHat2 != (Object)null)
					{
						Core.DebugMsg("Hat Don!");
						Core.networkManager.SendDonHat(currentHat2);
					}
					else
					{
						Core.DebugMsg("Hat Doff!");
						Core.networkManager.SendDoffHat();
					}
				}
			}
			UpdateRainbowSuit();
		}

		private void UpdateRainbowSuit()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Core.networkManager != null && Core.networkManager.IsEasterEggActive;
			if (flag != rainbowSuitActive)
			{
				rainbowSuitActive = flag;
				if (!rainbowSuitActive)
				{
					ApplySuitColor();
				}
			}
			if (rainbowSuitActive)
			{
				SetSuitColor(BasePlayer.GetRainbowColor(Time.time));
			}
		}

		public override void LateUpdate()
		{
			if (!_sentInitialState || !Core.networkManager.IsConnected || (Object)(object)playerMovement == (Object)null || boneChildren == null)
			{
				return;
			}
			if (IsMicrophoneEnabled() != ModSettings.audio.MicrophoneEnabled.Value)
			{
				SetMicrophoneEnabled(ModSettings.audio.MicrophoneEnabled.Value);
			}
			if (GetMicrophoneDevice() != ModSettings.audio.SelectedMicrophoneIndex.Value)
			{
				SetMicrophoneDevice(ModSettings.audio.SelectedMicrophoneIndex.Value);
			}
			if (micEnabled && mic != null && mic.IsRecording())
			{
				bool flag = true;
				if (pushToTalkEnabled)
				{
					if (GetPushToTalkBinding() != ModSettings.audio.PushToTalkKey.Value)
					{
						SetPushToTalkBinding(ModSettings.audio.PushToTalkKey.Value);
					}
					flag = InputBindingHelper.IsPressed(pushToTalkBinding);
				}
				if (flag)
				{
					latestAudioFrame = mic.GetOpusPacket();
					if (latestAudioFrame != null && latestAudioFrame.Length != 0)
					{
						Core.networkManager.SendAudioFrame(latestAudioFrame);
						_currentJawTarget = mic.GetAmplitude();
						_isSpeaking = true;
						SetMouthOpen(_currentJawTarget);
					}
					else
					{
						_isSpeaking = false;
					}
				}
				else
				{
					_isSpeaking = false;
				}
			}
			else
			{
				_isSpeaking = false;
			}
			UpdateLineOfSight();
			if (!(Time.realtimeSinceStartup - lastBoneSendTime < 0.033f))
			{
				lastBoneSendTime = Time.realtimeSinceStartup;
				TransformNet[] bones = TransformNet.ToNet(boneChildren);
				Core.networkManager.SendBones(bones, 0);
			}
		}

		private void UpdateLineOfSight()
		{
			//IL_007e: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			if (lineOfSightManager == null || Time.realtimeSinceStartup - lastGazableUpdateTime < 0.1f)
			{
				return;
			}
			lastGazableUpdateTime = Time.realtimeSinceStartup;
			foreach (RemotePlayer item in RemotePlayer.GlobalPool)
			{
				if (item != null && !((Object)(object)item.headBone == (Object)null) && !((Object)(object)item.gazable == (Object)null))
				{
					Vector3 position = item.headBone.position;
					bool flag = lineOfSightManager.CanSee(position);
					if (((Behaviour)item.gazable).enabled != flag)
					{
						((Behaviour)item.gazable).enabled = flag;
					}
				}
			}
		}

		public LineOfSightManager GetLineOfSightManager()
		{
			return lineOfSightManager;
		}

		public LocalPlayer()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			KeyCode val = (KeyCode)118;
			pushToTalkBinding = ((object)(KeyCode)(ref val)).ToString();
			lastGazableUpdateTime = 0f;
			base..ctor();
		}
	}
	public class NameTagUI
	{
		public GameObject baseObject;

		public TextMeshPro textMeshPro;

		public Vector3 positionOffset = new Vector3(0f, 0.5f, 0f);

		public NameTagUI(Transform parent)
		{
			//IL_0010: 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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			baseObject = new GameObject("Nametag");
			SetParent(parent);
			textMeshPro = baseObject.AddComponent<TextMeshPro>();
			((TMP_Text)textMeshPro).alignment = (TextAlignmentOptions)514;
			((TMP_Text)textMeshPro).fontSize = 1.5f;
			Shader val = Shader.Find("TextMeshPro/Distance Field Overlay");
			if ((Object)(object)val != (Object)null)
			{
				Material val2 = new Material(val);
				val2.mainTexture = ((TMP_Asset)((TMP_Text)textMeshPro).font).material.mainTexture;
				((TMP_Text)textMeshPro).fontMaterial = val2;
			}
			else
			{
				Core.logger.Warning("Could not find TMP Distance Field Overlay shader!");
			}
			SetColor(Color.white);
			SetText("Nate");
		}

		public void Destroy()
		{
			if ((Object)(object)baseObject != (Object)null)
			{
				Object.Destroy((Object)(object)baseObject);
			}
		}

		public void LateUpdate()
		{
			//IL_003d: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)baseObject == (Object)null) && LocalPlayer.Instance != null)
			{
				GameObject cameraObject = LocalPlayer.Instance.GetCameraObject();
				if ((Object)(object)cameraObject != (Object)null)
				{
					float num = Vector3.Distance(cameraObject.transform.position, baseObject.transform.position);
					SetActive(num <= 100f);
					RotateTowardsCamera(cameraObject.transform.position);
				}
			}
		}

		public void SetActive(bool active)
		{
			if (!((Object)(object)baseObject == (Object)null) && baseObject.active != active)
			{
				baseObject.active = active;
			}
		}

		public void SetParent(Transform parent)
		{
			//IL_0032: 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)
			if ((Object)(object)baseObject == (Object)null)
			{
				return;
			}
			baseObject.transform.SetParent(parent, false);
			baseObject.transform.localPosition = positionOffset;
			if (LocalPlayer.Instance != null)
			{
				GameObject cameraObject = LocalPlayer.Instance.GetCameraObject();
				if ((Object)(object)cameraObject != (Object)null)
				{
					RotateTowardsCamera(cameraObject.transform.position);
				}
			}
		}

		public void SetText(string text)
		{
			if (!((Object)(object)textMeshPro == (Object)null) && !(((TMP_Text)textMeshPro).text == text))
			{
				((TMP_Text)textMeshPro).text = text;
				((Graphic)textMeshPro).SetAllDirty();
			}
		}

		public void SetColor(Color color)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)textMeshPro == (Object)null) && !(((Graphic)textMeshPro).color == color))
			{
				((Graphic)textMeshPro).color = color;
				((Graphic)textMeshPro).SetAllDirty();
			}
		}

		public Color GetColor()
		{
			//IL_0023: 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_0013: 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_001a: 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 ((Object)(object)textMeshPro == (Object)null)
			{
				return default(Color);
			}
			return ((Graphic)textMeshPro).color;
		}

		private void RotateTowardsCamera(Vector3 cameraPosition)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((Object)(object)baseObject == (Object)null) && baseObject.activeSelf)
			{
				baseObject.transform.rotation = Quaternion.LookRotation(baseObject.transform.position - cameraPosition);
			}
		}
	}
	public class RemotePlayer : BasePlayer
	{
		[CompilerGenerated]
		private sealed class <DelayedComponentStrip>d__40 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Transform mesh;

			private IEnumerator<Component> <>s__1;

			private Component <component>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedComponentStrip>d__40(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<component>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)mesh != (Object)null)
					{
						<>s__1 = ((Component)mesh).GetComponents<Component>().GetEnumerator();
						try
						{
							while (<>s__1.MoveNext())
							{
								<component>5__2 = <>s__1.Current;
								if (!(<component>5__2 is Transform))
								{
									Object.Destroy((Object)(object)<component>5__2);
								}
								<component>5__2 = null;
							}
						}
						finally
						{
							if (<>s__1 != null)
							{
								<>s__1.Dispose();
							}
						}
						<>s__1 = null;
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedGazableFillin>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Gazable _gazable;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedGazableFillin>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					_gazable.wontMove = false;
					_gazable.sqrRad = 5f;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedSpecificComponentStrip>d__41<T> : IEnumerator<object>, IEnumerator, IDisposable where T : Component
		{
			private int <>1__state;

			private object <>2__current;

			public Transform bone;

			private Il2CppArrayBase<T> <components>5__1;

			private IEnumerator<T> <>s__2;

			private T <c>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedSpecificComponentStrip>d__41(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<components>5__1 = null;
				<>s__2 = null;
				<c>5__3 = default(T);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)bone != (Object)null)
					{
						<components>5__1 = ((Component)bone).GetComponentsInChildren<T>(true);
						if (<components>5__1 != null)
						{
							<>s__2 = <components>5__1.GetEnumerator();
							try
							{
								while (<>s__2.MoveNext())
								{
									<c>5__3 = <>s__2.Current;
									if ((Object)(object)<c>5__3 != (Object)null)
									{
										Object.Destroy((Object)(object)<c>5__3);
									}
									<c>5__3 = default(T);
								}
							}
							finally
							{
								if (<>s__2 != null)
								{
									<>s__2.Dispose();
								}
							}
							<>s__2 = null;
						}
						<components>5__1 = null;
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EnableCollisionCoroutine>d__43 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RemotePlayer <>4__this;

			private Dictionary<string, (Rigidbody, CapsuleCollider)>.ValueCollection.Enumerator <>s__1;

			private (Rigidbody, CapsuleCollider) <val>5__2;

			private Collider[] <>s__3;

			private int <>s__4;

			private Collider <val>5__5;

			private Collider[] <>s__6;

			private int <>s__7;

			private Collider <val>5__8;

			private Collider[] <>s__9;

			private int <>s__10;

			private Collider <val>5__11;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnableCollisionCoroutine>d__43(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(Dictionary<string, (Rigidbody, CapsuleCollider)>.ValueCollection.Enumerator);
				<val>5__2 = default((Rigidbody, CapsuleCollider));
				<>s__3 = null;
				<val>5__5 = null;
				<>s__6 = null;
				<val>5__8 = null;
				<>s__9 = null;
				<val>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0044;
				case 1:
					<>1__state = -1;
					goto IL_0044;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0044:
					if (!<>4__this.firstBoneInterpRan)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					break;
				}
				if (<>4__this.distanceFromPlayer <= 0.6f)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if (<>4__this.boneColliders != null)
				{
					<>s__1 = <>4__this.boneColliders.Values.GetEnumerator();
					try
					{
						while (<>s__1.MoveNext())
						{
							<val>5__2 = <>s__1.Current;
							if (!((Object)(object)<val>5__2.Item2 == (Object)null))
							{
								((Collider)<val>5__2.Item2).enabled = true;
								<val>5__2 = default((Rigidbody, CapsuleCollider));
							}
						}
					}
					finally
					{
						((IDisposable)<>s__1).Dispose();
					}
					<>s__1 = default(Dictionary<string, (Rigidbody, CapsuleCollider)>.ValueCollection.Enumerator);
				}
				if (<>4__this.hatColliders != null)
				{
					<>s__3 = <>4__this.hatColliders;
					for (<>s__4 = 0; <>s__4 < <>s__3.Length; <>s__4++)
					{
						<val>5__5 = <>s__3[<>s__4];
						if (!((Object)(object)<val>5__5 == (Object)null))
						{
							<val>5__5.enabled = true;
							<val>5__5 = null;
						}
					}
					<>s__3 = null;
				}
				if (<>4__this.heldItemColliders.Item1 != null)
				{
					<>s__6 = <>4__this.heldItemColliders.Item1;
					for (<>s__7 = 0; <>s__7 < <>s__6.Length; <>s__7++)
					{
						<val>5__8 = <>s__6[<>s__7];
						if (!((Object)(object)<val>5__8 == (Object)null))
						{
							<val>5__8.enabled = true;
							<val>5__8 = null;
						}
					}
					<>s__6 = null;
				}
				if (<>4__this.heldItemColliders.Item2 != null)
				{
					<>s__9 = <>4__this.heldItemColliders.Item2;
					for (<>s__10 = 0; <>s__10 < <>s__9.Length; <>s__10++)
					{
						<val>5__11 = <>s__9[<>s__10];
						if (!((Object)(object)<val>5__11 == (Object)null))
						{
							<val>5__11.enabled = true;
							<val>5__11 = null;
						}
					}
					<>s__9 = null;
				}
				<>4__this.collisionCoroutineToken = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ConcurrentBag<RemotePlayer> GlobalPool = new ConcurrentBag<RemotePlayer>();

		private static Dictionary<string, GameObject> savablePrefabs = new Dictionary<string, GameObject>();

		public static Texture2D suitTexture;

		public NameTagUI nameTag;

		public Gazable gazable;

		public Dictionary<string, (Rigidbody, CapsuleCollider)> boneColliders;

		public Dictionary<Transform, Transform> boneCrushers;

		public Hat hat;

		public Collider[] hatColliders;

		public BBSAudioSource audioSource;

		public (Grabable, Grabable) heldItems;

		public (Collider[], Collider[]) heldItemColliders;

		public (FootData, FootData) feetData;

		public string displayName = "Nate";

		private bool rainbowSuitActive;

		private Color baseSuitColor = Color.white;

		private BoneSnapshot currentBoneGroup;

		private ConcurrentQueue<BoneSnapshot> snapshotBuffer = new ConcurrentQueue<BoneSnapshot>();

		private const double INTERPDELAY = 0.1;

		public bool netCollisionsEnabled;

		private bool firstBoneInterpRan;

		private object collisionCoroutineToken;

		public float distanceFromPlayer;

		public bool firstAppearanceApplication;

		public static readonly Dictionary<string, (Vector3 center, float radius, float height, int direction)> colliderTemplate = new Dictionary<string, (Vector3, float, float, int)>
		{
			{
				"head.x",
				(new Vector3(0f, 0.1f, 0.05f), 0.13f, 0.35f, 1)
			},
			{
				"spine_02.x",
				(new Vector3(0f, 0.21f, 0f), 0.15f, 0.42f, 0)
			},
			{
				"spine_01.x",
				(new Vector3(0f, 0.1f, 0f), 0.1636f, 0.45f, 0)
			},
			{
				"root.x",
				(new Vector3(0f, 0f, -0.025f), 0.175f, 0.5f, 0)
			},
			{
				"arm_stretch.l",
				(new Vector3(0f, 0.13f, 0f), 0.07f, 0.38f, 1)
			},
			{
				"forearm_stretch.l",
				(new Vector3(0f, 0.15f, 0f), 0.05f, 0.35f, 1)
			},
			{
				"hand.l",
				(new Vector3(0f, 0.07f, 0f), 0.05f, 0.2f, 1)
			},
			{
				"arm_stretch.r",
				(new Vector3(0f, 0.13f, 0f), 0.07f, 0.38f, 1)
			},
			{
				"forearm_stretch.r",
				(new Vector3(0f, 0.15f, 0f), 0.05f, 0.35f, 1)
			},
			{
				"hand.r",
				(new Vector3(0f, 0.07f, 0f), 0.05f, 0.2f, 1)
			},
			{
				"thigh_stretch.l",
				(new Vector3(0.01f, 0.15f, 0f), 0.121f, 0.6f, 1)
			},
			{
				"leg_stretch.l",
				(new Vector3(0f, 0.15f, 0f), 0.075f, 0.455f, 1)
			},
			{
				"foot.l",
				(new Vector3(0f, 0.1f, -0.02f), 0.06f, 0.3f, 1)
			},
			{
				"thigh_stretch.r",
				(new Vector3(0.01f, 0.15f, 0f), 0.121f, 0.6f, 1)
			},
			{
				"leg_stretch.r",
				(new Vector3(0f, 0.15f, 0f), 0.075f, 0.455f, 1)
			},
			{
				"foot.r",
				(new Vector3(0f, 0.1f, -0.02f), 0.06f, 0.3f, 1)
			}
		};

		public Color BaseSuitColor => baseSuitColor;

		public void Initialize(int numClones)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			if (LocalPlayer.Instance == null)
			{
				return;
			}
			if ((Object)(object)suitTexture == (Object)null)
			{
				LocalPlayer.Instance.CleanCompletely();
				suitTexture = LocalPlayer.Instance.CloneSuitTexture();
			}
			baseObject = new GameObject($"NateClone{numClones}");
			nameTag = new NameTagUI(baseObject.transform);
			if ((Object)(object)LocalPlayer.Instance.baseMesh != (Object)null)
			{
				baseMesh = Object.Instantiate<Transform>(LocalPlayer.Instance.baseMesh);
				((Object)baseMesh).name = "NateMesh";
				baseMesh.parent = baseObject.transform;
				((Component)baseMesh).transform.position = Vector3.zero;
				MelonCoroutines.Start(DelayedComponentStrip(baseMesh));
			}
			if ((Object)(object)LocalPlayer.Instance.particleCrushers != (Object)null)
			{
				particleCrushers = Object.Instantiate<Transform>(LocalPlayer.Instance.particleCrushers);
				particleCrushers.parent = baseObject.transform;
			}
			Initialize();
			if ((Object)(object)skinnedMeshRenderer != (Object)null)
			{
				meshMaterials = Il2CppArrayBase<Material>.op_Implicit((Il2CppArrayBase<Material>)(object)((Renderer)skinnedMeshRenderer).materials);
			}
			SetupBonesAndMaterials();
			foreach (Transform boneChild in boneChildren)
			{
				MelonCoroutines.Start(DelayedSpecificComponentStrip<NateShaper>(boneChild));
			}
			Transform bone = baseMesh.Find("Nathan.001");
			MelonCoroutines.Start(DelayedSpecificComponentStrip<StencilWriter>(bone));
			if ((Object)(object)nateGlasses != (Object)null)
			{
				Il2CppReferenceArray<Material> materials = ((Renderer)nateGlasses).materials;
				for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)materials).Length; i++)
				{
					if ((Object)(object)((Il2CppArrayBase<Material>)(object)materials)[i] != (Object)null && ((Il2CppArrayBase<Material>)(object)materials)[i].HasProperty("_DitherAlpha"))
					{
						MaterialKeywordHelper(((Il2CppArrayBase<Material>)(object)materials)[i]);
					}
				}
			}
			if ((Object)(object)jiminyRibbon != (Object)null)
			{
				jiminyRibbon.active = false;
			}
			if (meshMaterials != null)
			{
				for (int j = 0; j < meshMaterials.Length; j++)
				{
					Material val = meshMaterials[j];
					if (!((Object)(object)val == (Object)null) && val.HasProperty("_DitherAlpha") && !(((Object)val.shader).name == "Better Lit/DuderSuit"))
					{
						MaterialKeywordHelper(val);
					}
				}
			}
			if ((Object)(object)suitMaterial != (Object)null)
			{
				if ((Object)(object)suitTexture != (Object)null)
				{
					suitMaterial.SetTexture("_AlbedoMap", (Texture)(object)suitTexture);
				}
				suitMaterial.SetTexture("_WetnessTexture", (Texture)null);
				suitMaterial.SetTexture("_RainDropTexture", (Texture)null);
			}
			SetHairHat(1f, new Vector4(0f, 1f, 1f, 0f));
			((Component)eyeBalls.Item1).gameObject.active = true;
			((Component)eyeBalls.Item2).gameObject.active = true;
			((Component)eyeLids.Item1).gameObject.active = true;
			((Component)eyeLids.Item2).gameObject.active = true;
			((Component)nateGlasses).gameObject.active = true;
			if ((Object)(object)eyeBalls.Item1 != (Object)null)
			{
				eyeBalls.Item1.localRotation = Quaternion.identity;
			}
			if ((Object)(object)eyeBalls.Item2 != (Object)null)
			{
				eyeBalls.Item2.localRotation = Quaternion.identity;
			}
			if ((Object)(object)eyeBallRenderers.Item1 != (Object)null)
			{
				StdMatSetup(((Renderer)eyeBallRenderers.Item1).material);
			}
			if ((Object)(object)eyeBallRenderers.Item2 != (Object)null)
			{
				StdMatSetup(((Renderer)eyeBallRenderers.Item2).material);
			}
			if ((Object)(object)eyeLids.Item1 != (Object)null)
			{
				((Component)eyeLids.Item1).gameObject.SetActive(false);
			}
			if ((Object)(object)eyeLids.Item2 != (Object)null)
			{
				((Component)eyeLids.Item2).gameObject.SetActive(false);
			}
			if ((Object)(object)headBone != (Object)null && nameTag != null)
			{
				nameTag.SetParent(headBone);
			}
			if ((Object)(object)headBone != (Object)null)
			{
				gazable = ((Component)headBone).gameObject.AddComponent<Gazable>();
				MelonCoroutines.Start(DelayedGazableFillin(gazable));
			}
			if ((Object)(object)nateGlasses != (Object)null)
			{
				MaterialKeywordHelper(((Renderer)nateGlasses).material);
			}
			ResetPosition();
			ResetBonesToBind();
			SetupBones();
			CreateParticleCrushers();
			CreateFootData();
		}

		[IteratorStateMachine(typeof(<DelayedGazableFillin>d__28))]
		private static IEnumerator DelayedGazableFillin(Gazable _gazable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedGazableFillin>d__28(0)
			{
				_gazable = _gazable
			};
		}

		public void InitializeAudioSource()
		{
			if ((Object)(object)headBone == (Object)null)
			{
				Core.DebugMsg("Cannot initialize audio source: headBone is null");
				return;
			}
			if (audioSource != null)
			{
				audioSource.Dispose();
				audioSource = null;
			}
			audioSource = new BBSAudioSource(headBone);
			audioSource.Initialize();
		}

		private bool EnsureAudioSourceValid()
		{
			if (audioSource == null)
			{
				Core.DebugMsg("Audio source is null, attempting to reinitialize");
				InitializeAudioSource();
			}
			return audioSource != null;
		}

		public override void Dispose()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			RemoveHat();
			DropItem(0);
			DropItem(1);
			ResetBonesToBind();
			DisableCollision();
			SetActive(active: false);
			SetOpacity(0f);
			ResetPosition();
			SetDisplayName("Nate");
			if (audioSource != null)
			{
				audioSource.Dispose();
				audioSource = null;
			}
			distanceFromPlayer = 0f;
			firstBoneInterpRan = false;
			netCollisionsEnabled = false;
			firstAppearanceApplication = false;
			rainbowSuitActive = false;
			baseSuitColor = Color.white;
			snapshotBuffer.Clear();
			GlobalPool.Add(this);
		}

		public void ResetPosition()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rootBone == (Object)null))
			{
				((Component)rootBone).transform.position = Vector3.zero;
			}
		}

		public override void LateUpdate()
		{
			//IL_0073: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			if (nameTag != null)
			{
				nameTag.LateUpdate();
			}
			InterpolateBoneTransforms();
			UpdateRainbowSuit();
			if ((Object)(object)rootBone != (Object)null && LocalPlayer.Instance != null)
			{
				if ((Object)(object)LocalPlayer.Instance.rootBone != (Object)null && firstBoneInterpRan)
				{
					distanceFromPlayer = Vector3.Distance(LocalPlayer.Instance.rootBone.position, ((Component)rootBone).transform.position);
				}
				GameObject cameraObject = LocalPlayer.Instance.GetCameraObject();
				if ((Object)(object)cameraObject != (Object)null)
				{
					float distance = Vector3.Distance(cameraObject.transform.position, ((Component)rootBone).transform.position);
					if (!ModSettings.player.Collisions.Value || !netCollisionsEnabled)
					{
						SetOpacity(0.75f);
					}
					else if (ModSettings.player.CutscenePlayerVisibility.Value && (Object)(object)LocalPlayer.Instance.playerMovement != (Object)null && LocalPlayer.Instance.playerMovement.inCutscene)
					{
						SetOpacity(0f);
					}
					else if ((Object)(object)LocalPlayer.Instance.playerMovement != (Object)null && (Object)(object)LocalPlayer.Instance.playerMovement.currentHat != (Object)null && ((Object)LocalPlayer.Instance.playerMovement.currentHat).name != null && ((Object)LocalPlayer.Instance.playerMovement.currentHat).name.IndexOf("CrashHelmet", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						SetOpacity(1f);
					}
					else
					{
						FadeByDistance(distance);
					}
				}
			}
			if (EnsureAudioSourceValid())
			{
				audioSource.Update();
				float amplitude = audioSource.GetAmplitude();
				float mouthOpen = Mathf.Clamp01(amplitude);
				SetMouthOpen(mouthOpen);
			}
			else
			{
				CloseMouth();
			}
		}

		public void UpdateBaseSuitColor(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			baseSuitColor = color;
			if (!rainbowSuitActive)
			{
				SetSuitColor(color);
			}
		}

		public void SetRainbowSuitActive(bool active)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (rainbowSuitActive != active)
			{
				rainbowSuitActive = active;
				if (!rainbowSuitActive)
				{
					SetSuitColor(baseSuitColor);
				}
			}
		}

		private void UpdateRainbowSuit()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (rainbowSuitActive)
			{
				SetSuitColor(BasePlayer.GetRainbowColor(Time.time));
			}
		}

		public void SetDisplayName(string name)
		{
			if (nameTag != null)
			{
				displayName = name;
				nameTag.SetText(name);
			}
		}

		public override void SetOpacity(float opacity)
		{
			//IL_001d: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			base.SetOpacity(opacity);
			if (nameTag != null)
			{
				Color color = nameTag.GetColor();
				float a = 0f;
				if (ModSettings.player.ShowNametags.Value)
				{
					a = opacity;
				}
				color.a = a;
				nameTag.SetColor(color);
			}
		}

		public void SetActive(bool active)
		{
			if (!((Object)(object)baseObject == (Object)null))
			{
				baseObject.active = active;
			}
		}

		[IteratorStateMachine(typeof(<DelayedComponentStrip>d__40))]
		private static IEnumerator DelayedComponentStrip(Transform mesh)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedComponentStrip>d__40(0)
			{
				mesh = mesh
			};
		}

		[IteratorStateMachine(typeof(<DelayedSpecificComponentStrip>d__41<>))]
		private static IEnumerator DelayedSpecificComponentStrip<T>(Transform bone) where T : Component
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedSpecificComponentStrip>d__41<T>(0)
			{
				bone = bone
			};
		}

		public void EnableCollision()
		{
			if (collisionCoroutineToken != null)
			{
				MelonCoroutines.Stop(collisionCoroutineToken);
			}
			collisionCoroutineToken = MelonCoroutines.Start(EnableCollisionCoroutine());
		}

		[IteratorStateMachine(typeof(<EnableCollisionCoroutine>d__43))]
		private IEnumerator EnableCollisionCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnableCollisionCoroutine>d__43(0)
			{
				<>4__this = this
			};
		}

		public void DisableCollision()
		{
			if (collisionCoroutineToken != null)
			{
				MelonCoroutines.Stop(collisionCoroutineToken);
				collisionCoroutineToken = null;
			}
			if (boneColliders != null)
			{
				foreach (var value in boneColliders.Values)
				{
					if (!((Object)(object)value.Item2 == (Object)null))
					{
						((Collider)value.Item2).enabled = false;
					}
				}
			}
			if ((Object)(object)hat != (Object)null)
			{
				Il2CppArrayBase<Collider> componentsInChildren = ((Component)hat).GetComponentsInChildren<Collider>();
				foreach (Collider item3 in componentsInChildren)
				{
					if (!((Object)(object)item3 == (Object)null))
					{
						item3.enabled = false;
					}
				}
			}
			if (heldItemColliders.Item1 != null)
			{
				Collider[] item = heldItemColliders.Item1;
				foreach (Collider val in item)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.enabled = false;
					}
				}
			}
			if (heldItemColliders.Item2 == null)
			{
				return;
			}
			Collider[] item2 = heldItemColliders.Item2;
			foreach (Collider val2 in item2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val2.enabled = false;
				}
			}
		}

		private void StdMatSetup(Material mat)
		{
			mat.SetInt("_SrcBlend", 5);
			mat.SetInt("_DstBlend", 10);
			mat.SetInt("_ZWrite", 1);
			mat.DisableKeyword("_ALPHATEST_ON");
			mat.DisableKeyword("_ALPHABLEND_ON");
			mat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
			mat.renderQueue = 3000;
		}

		private static void MaterialKeywordHelper(Material mat)
		{
			if (!((Object)(object)mat == (Object)null))
			{
				mat.EnableKeyword("_DITHERCONSTANT");
				mat.EnableKeyword("_SPECULAR");
				mat.EnableKeyword("_CHEAPSSS");
				mat.EnableKeyword("_CHEAPSSSTEXTURE");
				mat.DisableKeyword("_ALPHACUT");
				mat.EnableKeyword("_NORMALMAP");
				mat.EnableKeyword("_MASKMAP");
				mat.EnableKeyword("_EMISSION");
				mat.EnableKeyword("_METALLICGLOSSMAP");
			}
		}

		private void SetupBones()
		{
			if (boneChildren == null)
			{
				return;
			}
			if (boneColliders == null)
			{
				boneColliders = new Dictionary<string, (Rigidbody, CapsuleCollider)>();
			}
			foreach (Transform boneChild in boneChildren)
			{
				if (!((Object)(object)boneChild == (Object)null))
				{
					((Component)boneChild).gameObject.layer = 23;
					CreateBoneCollider(boneChild);
					CreateBoneMudMesh(boneChild);
				}
			}
		}

		private void CreateBoneCollider(Transform bone)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			if ((Object)(object)bone == (Object)null)
			{
				return;
			}
			string name = ((Object)bone).name;
			if (colliderTemplate.TryGetValue(((Object)bone).name, out (Vector3, float, float, int) value))
			{
				if (name.Contains("spine_01") || name.Contains("root"))
				{
					((Component)bone).gameObject.layer = 6;
				}
				Rigidbody val = ((Component)bone).gameObject.GetComponent<Rigidbody>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)bone).gameObject.AddComponent<Rigidbody>();
					val.mass = 0.5f;
				}
				val.useGravity = false;
				val.isKinematic = true;
				CapsuleCollider val2 = ((Component)bone).gameObject.GetComponent<CapsuleCollider>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)bone).gameObject.AddComponent<CapsuleCollider>();
					val2.center = value.Item1;
					val2.radius = value.Item2 * 0.7f;
					val2.height = value.Item3;
					val2.direction = value.Item4;
					((Collider)val2).isTrigger = false;
					((Collider)val2).material = new PhysicMaterial("PlayerSticky")
					{
						bounciness = 0f,
						bounceCombine = (PhysicMaterialCombine)2,
						frictionCombine = (PhysicMaterialCombine)3,
						dynamicFriction = 1f,
						staticFriction = 1f
					};
				}
				((Collider)val2).enabled = false;
				boneColliders.Add(name, (val, val2));
			}
		}

		private void CreateBoneMudMesh(Transform bone)
		{
			//IL_00a4: 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)
			if ((Object)(object)bone == (Object)null || LocalPlayer.Instance == null || LocalPlayer.Instance.boneMudMeshes == null)
			{
				return;
			}
			string name = ((Object)bone).name;
			if (LocalPlayer.Instance.boneMudMeshes.TryGetValue(name, out var value))
			{
				if (boneMudMeshes == null)
				{
					boneMudMeshes = new Dictionary<string, Transform>();
				}
				GameObject val = Object.Instantiate<GameObject>(((Component)value).gameObject);
				val.transform.SetParent(bone);
				val.transform.localPosition = ((Component)value).transform.localPosition;
				val.transform.localRotation = ((Component)value).transform.localRotation;
				WaterObject component = val.GetComponent<WaterObject>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				boneMudMeshes[name] = val.transform;
			}
		}

		private void CreateParticleCrushers()
		{
			if ((Object)(object)particleCrushers == (Object)null)
			{
				return;
			}
			if (boneCrushers == null)
			{
				boneCrushers = new Dictionary<Transform, Transform>();
			}
			if ((Object)(object)rootBone != (Object)null)
			{
				Transform value = null;
				if ((Object)(object)particleCrushers != (Object)null)
				{
					value = particleCrushers.GetChild(0);
				}
				boneCrushers.Add(rootBone, value);
			}
			if ((Object)(object)spineBone != (Object)null)
			{
				Transform value2 = null;
				if ((Object)(object)particleCrushers != (Object)null)
				{
					value2 = particleCrushers.GetChild(1);
				}
				boneCrushers.Add(spineBone, value2);
			}
			if ((Object)(object)headBone != (Object)null)
			{
				Transform value3 = null;
				if ((Object)(object)particleCrushers != (Object)null)
				{
					value3 = particleCrushers.GetChild(2);
				}
				boneCrushers.Add(headBone, value3);
			}
		}

		private void CreateFootData()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			feetData.Item1 = new FootData();
			if ((Object)(object)footBones.Item1 != (Object)null)
			{
				feetData.Item1.bone = footBones.Item1;
				string name = ((Object)footBones.Item1).name;
				if (boneColliders.TryGetValue(name, out var value))
				{
					feetData.Item1.rb = value.Item1;
				}
			}
			feetData.Item2 = new FootData();
			if ((Object)(object)footBones.Item1 != (Object)null)
			{
				feetData.Item2.bone = footBones.Item1;
				string name2 = ((Object)footBones.Item1).name;
				if (boneColliders.TryGetValue(name2, out var value2))
				{
					feetData.Item2.rb = value2.Item1;
				}
			}
		}

		public void WearHat(string hatName, Vector3 localPosition, Quaternion localRotation)
		{
			//IL_010b: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hat != (Object)null)
			{
				RemoveHat();
			}
			if ((Object)(object)headBone == (Object)null)
			{
				return;
			}
			if (!savablePrefabs.TryGetValue(hatName, out var value))
			{
				GameObject val = GameObject.Find("BigManagerPrefab/GlobalObjectParent/Savables");
				Transform val2 = val.transform.FindChildByKeyword(hatName);
				GlobalObjectLoader component = ((Component)val2).GetComponent<GlobalObjectLoader>();
				AssetReference loadee = component.loadee;
				value = loadee.LoadAssetAsync<GameObject>().WaitForCompletion();
				savablePrefabs[hatName] = value;
			}
			GameObject val3 = Object.Instantiate<GameObject>(value, headBone);
			Hat componentInChildren = ((Component)val3.transform).GetComponentInChildren<Hat>();
			Transform val4 = val3.transform.FindChildByKeyword("FruitShine");
			if ((Object)(object)val4 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val4).gameObject);
			}
			WaterObject componentInChildren2 = val3.GetComponentInChildren<WaterObject>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				Object.Destroy((Object)(object)componentInChildren2);
			}
			((Grabable)componentInChildren).grabable = false;
			Object.Destroy((Object)(object)((Savable)componentInChildren).rb);
			val3.transform.localPosition = localPosition;
			val3.transform.localRotation = localRotation;
			SetHairHat(componentInChildren.hairAmt, Vector4.op_Implicit(componentInChildren.hairlineUpVec));
			hat = componentInChildren;
			hatColliders = Il2CppArrayBase<Collider>.op_Implicit(((Component)hat).GetComponentsInChildren<Collider>());
			Collider[] array = hatColliders;
			foreach (Collider val5 in array)
			{
				if (!((Object)(object)val5 == (Object)null))
				{
					val5.enabled = false;
				}
			}
		}

		public void RemoveHat()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hat != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)hat).gameObject);
				hat = null;
				SetHairHat(1f, new Vector4(0f, 1f, 1f, 0f));
				hatColliders = null;
			}
		}

		public void HoldItem(string grabableName, int handIndex, Vector3 localPosition, Quaternion localRotation)
		{
			//IL_0118: 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)
			Grabable val;
			Transform val2;
			if (handIndex == 0)
			{
				val = heldItems.Item1;
				val2 = handBones.Item1;
			}
			else
			{
				val = heldItems.Item2;
				val2 = handBones.Item2;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			if ((Object)(object)val != (Object)null)
			{
				DropItem(handIndex);
			}
			if (!savablePrefabs.TryGetValue(grabableName, out var value))
			{
				GameObject val3 = GameObject.Find("BigManagerPrefab/GlobalObjectParent/Savables");
				Transform val4 = val3.transform.FindChildByKeyword(grabableName);
				GlobalObjectLoader component = ((Component)val4).GetComponent<GlobalObjectLoader>();
				AssetReference loadee = component.loadee;
				value = loadee.LoadAssetAsync<GameObject>().WaitForCompletion();
				savablePrefabs[grabableName] = value;
			}
			GameObject val5 = Object.Instantiate<GameObject>(value, val2);
			Grabable componentInChildren = ((Component)val5.transform).GetComponentInChildren<Grabable>();
			componentInChildren.grabable = false;
			Object.Destroy((Object)(object)((Savable)componentInChildren).rb);
			Pedometer component2 = ((Component)componentInChildren).GetComponent<Pedometer>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			((Component)componentInChildren).transform.localPosition = localPosition;
			((Component)componentInChildren).transform.localRotation = localRotation;
			Collider[] array = null;
			if (handIndex == 0)
			{
				heldItems.Item1 = componentInChildren;
				heldItemColliders.Item1 = Il2CppArrayBase<Collider>.op_Implicit(((Component)componentInChildren).GetComponentsInChildren<Collider>());
				array = heldItemColliders.Item1;
			}
			else
			{
				heldItems.Item2 = componentInChildren;
				heldItemColliders.Item2 = Il2CppArrayBase<Collider>.op_Implicit(((Component)componentInChildren).GetComponentsInChildren<Collider>());
				array = heldItemColliders.Item2;
			}
			Collider[] array2 = array;
			foreach (Collider val6 in array2)
			{
				if (!((Object)(object)val6 == (Object)null))
				{
					val6.enabled = false;
				}
			}
			Transform val7 = val5.transform.FindChildByKeyword("FruitShine");
			if ((Object)(object)val7 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val7).gameObject);
			}
			WaterObject componentInChildren2 = val5.GetComponentInChildren<WaterObject>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				Object.Destroy((Object)(object)componentInChildren2);
			}
		}

		public void DropItem(int handIndex)
		{
			if (handIndex == 0 && (Object)(object)heldItems.Item1 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)heldItems.Item1).gameObject);
				heldItems.Item1 = null;
				heldItemColliders.Item1 = null;
			}
			else if (handIndex == 1 && (Object)(object)heldItems.Item2 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)heldItems.Item2).gameObject);
				heldItems.Item2 = null;
				heldItemColliders.Item2 = null;
			}
		}

		private void ApplySnapshotInstant(BoneSnapshot latest)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position2 = default(Vector3);
			Quaternion rotation2 = default(Quaternion);
			for (int i = 0; i < latest.transformNets.Length; i++)
			{
				TransformNet transformNet = latest.transformNets[i];
				if (transformNet == null)
				{
					continue;
				}
				int heirarchyIndex = transformNet.heirarchyIndex;
				if (heirarchyIndex >= 0 && heirarchyIndex < boneChildren.Count)
				{
					Transform val = boneChildren[heirarchyIndex];
					if (!((Object)(object)val == (Object)null))
					{
						Vector3 position = transformNet.position;
						((Vector3)(ref position2))..ctor(position.X, position.Y, position.Z);
						Quaternion rotation = transformNet.rotation;
						((Quaternion)(ref rotation2))..ctor(rotation.X, rotation.Y, rotation.Z, rotation.W);
						val.position = position2;
						val.rotation = rotation2;
					}
				}
			}
		}

		public void UpdateBones(TransformNet[] bonesToUpdate, int kickoffPoint)
		{
			if (boneChildren == null || bonesToUpdate == null)
			{
				return;
			}
			BoneSnapshot boneSnapshot;
			if (kickoffPoint != 0)
			{
				boneSnapshot = currentBoneGroup;
			}
			else
			{
				if (currentBoneGroup != null)
				{
					snapshotBuffer.Enqueue(currentBoneGroup);
					while (snapshotBuffer.Count > 10)
					{
						snapshotBuffer.TryDequeue(out var _);
					}
				}
				boneSnapshot = new BoneSnapshot(boneChildren.Count);
				boneSnapshot.time = Time.timeAsDouble;
			}
			if (boneSnapshot == null)
			{
				if (currentBoneGroup != null)
				{
					snapshotBuffer.Enqueue(currentBoneGroup);
				}
				boneSnapshot = new BoneSnapshot(boneChildren.Count);
				boneSnapshot.time = Time.timeAsDouble;
			}
			for (int i = kickoffPoint; i < bonesToUpdate.Length; i++)
			{
				TransformNet transformNet = bonesToUpdate[i];
				if (!((Object)(object)boneChildren[transformNet.heirarchyIndex] == (Object)null))
				{
					boneSnapshot.transformNets[transformNet.heirarchyIndex] = transformNet;
				}
			}
			currentBoneGroup = boneSnapshot;
		}

		private void InterpolateBoneTransforms()
		{
			//IL_03f5: 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_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			if (boneChildren == null || boneColliders == null)
			{
				return;
			}
			if (!firstBoneInterpRan && snapshotBuffer.Count > 0)
			{
				BoneSnapshot result = null;
				while (snapshotBuffer.Count > 0)
				{
					snapshotBuffer.TryDequeue(out result);
				}
				ApplySnapshotInstant(result);
				bool collisionsEnabled = ModSettings.player.Collisions.Value && netCollisionsEnabled;
				Core.networkManager.ApplyCollisionToggle(this, collisionsEnabled);
				firstBoneInterpRan = true;
				return;
			}
			if (snapshotBuffer.Count < 2)
			{
				if ((Object)(object)skinnedMeshRenderer != (Object)null)
				{
					((Component)skinnedMeshRenderer).gameObject.active = false;
				}
				if (nameTag != null)
				{
					nameTag.SetActive(active: false);
				}
				return;
			}
			if ((Object)(object)skinnedMeshRenderer != (Object)null && !((Component)skinnedMeshRenderer).gameObject.active)
			{
				((Component)skinnedMeshRenderer).gameObject.active = true;
				if (nameTag != null)
				{
					nameTag.SetActive(active: true);
				}
			}
			double num = Time.timeAsDouble - 0.1;
			BoneSnapshot boneSnapshot = null;
			BoneSnapshot boneSnapshot2 = null;
			foreach (BoneSnapshot item in snapshotBuffer)
			{
				if (item.time <= num)
				{
					boneSnapshot = item;
				}
				if (item.time > num)
				{
					boneSnapshot2 = item;
					break;
				}
			}
			if (boneSnapshot == null)
			{
				return;
			}
			if (boneSnapshot2 == null)
			{
				ApplySnapshotInstant(boneSnapshot);
				return;
			}
			double num2 = (num - boneSnapshot.time) / (boneSnapshot2.time - boneSnapshot.time);
			float num3 = Mathf.Clamp01((float)num2);
			Vector3 val2 = default(Vector3);
			Vector3 val3 = default(Vector3);
			Quaternion val4 = default(Quaternion);
			Quaternion val5 = default(Quaternion);
			for (int i = 0; i < boneSnapshot.transformNets.Length; i++)
			{
				TransformNet transformNet = boneSnapshot.transformNets[i];
				TransformNet transformNet2 = boneSnapshot2.transformNets[i];
				if (transformNet == null || transformNet2 == null)
				{
					continue;
				}
				int heirarchyIndex = transformNet.heirarchyIndex;
				if (heirarchyIndex >= 0 && heirarchyIndex < boneChildren.Count)
				{
					Transform val = boneChildren[heirarchyIndex];
					if (!((Object)(object)val == (Object)null))
					{
						Vector3 position = boneSnapshot.transformNets[i].position;
						((Vector3)(ref val2))..ctor(position.X, position.Y, position.Z);
						Vector3 position2 = boneSnapshot2.transformNets[i].position;
						((Vector3)(ref val3))..ctor(position2.X, position2.Y, position2.Z);
						Quaternion rotation = boneSnapshot.transformNets[i].rotation;
						((Quaternion)(ref val4))..ctor(rotation.X, rotation.Y, rotation.Z, rotation.W);
						Quaternion rotation2 = boneSnapshot2.transformNets[i].rotation;
						((Quaternion)(ref val5))..ctor(rotation2.X, rotation2.Y, rotation2.Z, rotation2.W);
						val.position = Vector3.Lerp(val2, val3, num3);
						val.rotation = Quaternion.Slerp(val4, val5, num3);
					}
				}
			}
			foreach (KeyValuePair<Transform, Transform> boneCrusher in boneCrushers)
			{
				if (!((Object)(object)boneCrusher.Key == (Object)null) && !((Object)(object)boneCrusher.Value == (Object)null))
				{
					boneCrusher.Value.position = boneCrusher.Key.position;
				}
			}
		}
	}
}
namespace BabyStepsMultiplayerClient.Patches
{
	[HarmonyPatch]
	internal class Patch_SaveGod
	{
		[HarmonyTargetMethod]
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(SaveGod), "TryLoadSave", (Type[])null, (Type[])null) ?? AccessTools.Method(typeof(SaveGod), "LoadSave", (Type[])null, (Type[])null) ?? AccessTools.Method(typeof(SaveGod), "TryLoad", (Type[])null, (Type[])null);
		}

		[HarmonyPrefix]
		private static bool TryLoadSave_Prefix(SaveGod __instance)
		{
			return true;
		}

		[HarmonyPostfix]
		private static void TryLoadSave_Postfix()
		{
			NetworkManager networkManager = Core.networkManager;
			if (networkManager != null && networkManager.IsConnected)
			{
				Core.logger.Msg("[SaveGod] Save loaded while connected — clearing remote state and requesting resync");
				Core.networkManager.RequestStateResync();
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_UIClickDedup
	{
		private static readonly Dictionary<int, int> _toggleClickFrame = new Dictionary<int, int>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Button), "OnSubmit")]
		private static bool Button_OnSubmit(BaseEventData eventData)
		{
			return !Input.GetMouseButtonDown(0);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Toggle), "OnPointerClick")]
		private static bool Toggle_OnPointerClick(Toggle __instance, PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)eventData.button > 0)
			{
				return false;
			}
			int frameCount = Time.frameCount;
			int instanceID = ((Object)__instance).GetInstanceID();
			if (_toggleClickFrame.TryGetValue(instanceID, out var value) && value == frameCount)
			{
				return false;
			}
			_toggleClickFrame[instanceID] = frameCount;
			if (((UIBehaviour)__instance).IsActive() && ((Selectable)__instance).IsInteractable())
			{
				__instance.Set(!__instance.isOn, true);
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Toggle), "OnPointerClick")]
		private static void Toggle_OnPointerClick_Post(Toggle __instance, PointerEventData eventData)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)eventData.button <= 0)
			{
			}
		}
	}
}
namespace BabyStepsMultiplayerClient.Networking
{
	public static class DedicatedServerQuery
	{
		private static readonly byte[] QueryBytes = new byte[4] { 66, 66, 83, 81 };

		private static readonly byte[] ResponseMagic = new byte[4] { 66, 66, 83, 82 };

		public static Task<(int PlayerCount, int MaxPlayers, bool IsLocked)?> QueryAsync(string host, int statusPort, int timeoutMs = 1000)
		{
			return Task.Run(() => QueryBlocking(host, statusPort, timeoutMs));
		}

		private static (int PlayerCount, int MaxPlayers, bool IsLocked)? QueryBlocking(string host, int statusPort, int timeoutMs)
		{
			try
			{
				using UdpClient udpClient = new UdpClient();
				udpClient.Client.ReceiveTimeout = timeoutMs;
				udpClient.Send(QueryBytes, QueryBytes.Length, host, statusPort);
				IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
				return ParseResponse(udpClient.Receive(ref remoteEP));
			}
			catch
			{
				return null;
			}
		}

		private static (int, int, bool)? ParseResponse(byte[] data)
		{
			if (data == null || data.Length < 7)
			{
				return null;
			}
			if (data[0] != ResponseMagic[0] || data[1] != ResponseMagic[1] || data[2] != ResponseMagic[2] || data[3] != ResponseMagic[3])
			{
				return null;
			}
			return (data[4], data[5], (data[6] & 1) != 0);
		}
	}
	public class FootDataHelpers
	{
		public static FootData DeserializeFootData(byte[] data, RemotePlayer player)
		{
			//IL_0056: 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_0116: 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_016a: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: 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_02a9: 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)
			int num = 0;
			bool flag = BitConverter.ToBoolean(data, num);
			num++;
			FootData val = player.feetData.Item1;
			if (val == null)
			{
				return null;
			}
			if (flag)
			{
				val = player.feetData.Item2;
			}
			val.achillesIsConstraining = BitConverter.ToBoolean(data, num);
			num++;
			val.appliedAccel = DeserializeVector3(data, ref num);
			val.curDropSpd = BitConverter.ToSingle(data, num);
			num += 4;
			val.curPlantedRotSpd = BitConverter.ToSingle(data, num);
			num += 4;
			val.currentSlipVector = DeserializeVector3(data, ref num);
			val.curTractionCoef = BitConverter.ToSingle(data, num);
			num += 4;
			val.fatigue = BitConverter.ToSingle(data, num);
			num += 4;
			val.fatiguePokeTimer = BitConverter.ToSingle(data, num);
			num += 4;
			val.freshPlantInput = BitConverter.ToBoolean(data, num);
			num++;
			val.heightOnTrigRelease = BitConverter.ToSingle(data, num);
			num += 4;
			val.hitLiftedConstraint = BitConverter.ToBoolean(data, num);
			num++;
			val.isLifting = BitConverter.ToBoolean(data, num);
			num++;
			val.lastAppliedTorque = DeserializeVector3(data, ref num);
			val.liftedTime = BitConverter.ToSingle(data, num);
			num += 4;
			val.maxExert = BitConverter.ToSingle(data, num);
			num += 4;
			val.nextPoke = BitConverter.ToSingle(data, num);
			num += 4;
			val.originalPlantSpot = DeserializeVector3(data, ref num);
			val.pivotPt = DeserializeVector3(data, ref num);
			val.planted = BitConverter.ToBoolean(data, num);
			num++;
			val.plantedSinceStoodUp = BitConverter.ToBoolean(data, num);
			num++;
			val.plantedTime = BitConverter.ToSingle(data, num);
			num += 4;
			val.plantNormal = DeserializeVector3(data, ref num);
			val.prevPlanted = BitConverter.ToBoolean(data, num);
			num++;
			val.prevPos = DeserializeVector3(data, ref num);
			val.prevSteppedOnLocalPos = DeserializeVector3(data, ref num);
			val.prevSteppedOnWorldPos = DeserializeVector3(data, ref num);
			val.pushedBackByCollision = BitConverter.ToBoolean(data, num);
			num++;
			val.side = BitConverter.ToInt32(data, num);
			num += 4;
			val.slipping = BitConverter.ToBoolean(data, num);
			num++;
			val.slipTimer = BitConverter.ToSingle(data, num);
			num += 4;
			val.slipVel = DeserializeVector3(data, ref num);
			val.steppedOnLocalPos = DeserializeVector3(data, ref num);
			float num2 = BitConverter.ToSingle(data, num);
			num += 4;
			float num3 = BitConverter.ToSingle(data, num);
			num += 4;
			float num4 = BitConverter.ToSingle(data, num);
			num += 4;
			float num5 = BitConverter.ToSingle(data, num);
			num += 4;
			val.steppedOnRotation = new Quaternion(num3, num4, num5, num2);
			val.steppedOnWorldPos = DeserializeVector3(data, ref num);
			val.stickedMove = DeserializeVector3(data, ref num);
			val.trigPressedTimer = BitConverter.ToSingle(data, num);
			num += 4;
			val.wantsToLift = BitConverter.ToBoolean(data, num);
			num++;
			return val;
		}

		public static Vector3 DeserializeVector3(byte[] data, ref int offset)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			float num = BitConverter.ToSingle(data, offset);
			offset += 4;
			float num2 = BitConverter.ToSingle(data, offset);
			offset += 4;
			float num3 = BitConverter.ToSingle(data, offset);
			offset += 4;
			return new Vector3(num, num2, num3);
		}

		public static byte[] SerializeFootData(FootData fd)
		{
			//IL_0045: 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_010b: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: 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_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			List<byte> list = new List<byte>();
			bool value = false;
			if (((Object)fd.bone).name == "foot.r")
			{
				value = true;
			}
			list.AddRange(BitConverter.GetBytes(value));
			list.AddRange(BitConverter.GetBytes(fd.achillesIsConstraining));
			list.AddRange(SerializeVector3(fd.appliedAccel));
			list.AddRange(BitConverter.GetBytes(fd.curDropSpd));
			list.AddRange(BitConverter.GetBytes(fd.curPlantedRotSpd));
			list.AddRange(SerializeVector3(fd.currentSlipVector));
			list.AddRange(BitConverter.GetBytes(fd.curTractionCoef));
			list.AddRange(BitConverter.GetBytes(fd.fatigue));
			list.AddRange(BitConverter.GetBytes(fd.fatiguePokeTimer));
			list.AddRange(BitConverter.GetBytes(fd.freshPlantInput));
			list.AddRange(BitConverter.GetBytes(fd.heightOnTrigRelease));
			list.AddRange(BitConverter.GetBytes(fd.hitLiftedConstraint));
			list.AddRange(BitConverter.GetBytes(fd.isLifting));
			list.AddRange(SerializeVector3(fd.lastAppliedTorque));
			list.AddRange(BitConverter.GetBytes(fd.liftedTime));
			list.AddRange(BitConverter.GetBytes(fd.maxExert));
			list.AddRange(BitConverter.GetBytes(fd.nextPoke));
			list.AddRange(SerializeVector3(fd.originalPlantSpot));
			list.AddRange(SerializeVector3(fd.pivotPt));
			list.AddRange(BitConverter.GetBytes(fd.planted));
			list.AddRange(BitConverter.GetBytes(fd.plantedSinceStoodUp));
			list.AddRange(BitConverter.GetBytes(fd.plantedTime));
			list.AddRange(SerializeVector3(fd.plantNormal));
			list.AddRange(BitConverter.GetBytes(fd.prevPlanted));
			list.AddRange(SerializeVector3(fd.prevPos));
			list.AddRange(SerializeVector3(fd.prevSteppedOnLocalPos));
			list.AddRange(SerializeVector3(fd.prevSteppedOnWorldPos));
			list.AddRange(BitConverter.GetBytes(fd.pushedBackByCollision));
			list.AddRange(BitConverter.GetBytes(fd.side));
			list.AddRange(BitConverter.GetBytes(fd.slipping));
			list.AddRange(BitConverter.GetBytes(fd.slipTimer));
			list.AddRange(SerializeVector3(fd.slipVel));
			list.AddRange(SerializeVector3(fd.steppedOnLocalPos));
			list.AddRange(BitConverter.GetBytes(fd.steppedOnRotation.w));
			list.AddRange(BitConverter.GetBytes(fd.steppedOnRotation.x));
			list.AddRange(BitConverter.GetBytes(fd.steppedOnRotation.y));
			list.AddRange(BitConverter.GetBytes(fd.steppedOnRotation.z));
			list.AddRange(SerializeVector3(fd.steppedOnWorldPos));
			list.AddRange(SerializeVector3(fd.stickedMove));
			list.AddRange(SerializeVector3(Vector3.zero));
			list.AddRange(BitConverter.GetBytes(fd.trigPressedTimer));
			list.AddRange(BitConverter.GetBytes(fd.wantsToLift));
			return list.ToArray();
		}

		private static byte[] SerializeVector3(Vector3 v)
		{
			//IL_0008: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			List<byte> list = new List<byte>();
			list.AddRange(BitConverter.GetBytes(v.x));
			list.AddRange(BitConverter.GetBytes(v.y));
			list.AddRange(BitConverter.GetBytes(v.z));
			return list.ToArray();
		}
	}
	public class InGameHost
	{
		private NetworkHost _host;

		public bool IsRunning
		{
			get
			{
				NetworkHost host = _host;
				return host != null && host.IsRunning;
			}
		}

		public int PlayerCount
		{
			get
			{
				NetworkHost host = _host;
				return (host != null) ? host.Clients.Count : 0;
			}
		}

		public NetworkHost? Host => _host;

		public event Action<string>? Log;

		public event Action<string>? PlayerJoined;

		public event Action<string>? PlayerLeft;

		public event Action<string>? LobbyCreated;

		public void Start(int port = 7777, string password = "")
		{
			//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_000e: 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_0031: 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_0046: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			HostSettings val = new HostSettings
			{
				Port = port,
				Password = (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password),
				ServerVersion = "108",
				VoiceChatEnabled = true,
				MaxBandwidthKbps = 512f
			};
			LiteNetLibServerTransport val2 = new LiteNetLibServerTransport();
			_host = new NetworkHost((IServerTransport)(object)val2, val, 60);
			_host.Log += delegate(string msg)
			{
				this.Log?.Invoke(msg);
			};
			_host.ClientConnected += OnClientConnected;
			_host.ClientDisconnected += OnClientDisconnected;
			RegisterHandlers();
			_host.Start();
		}

		public LocalLoopbackClientTransport StartSteam(string password = "")
		{
			BBSSteamServerTransport bBSSteamServerTransport = new BBSSteamServerTransport();
			bBSSteamServerTransport.IsPasswordProtected = !string.IsNullOrEmpty(password);
			((SteamServerTransport)bBSSteamServerTransport).LobbyCreated += delegate(string lobbyId)
			{
				this.Log?.Invoke("Steam lobby ready: " + lobbyId);
				this.LobbyCreated?.Invoke(lobbyId);
			};
			return StartSteam((SteamServerTransport)(object)bBSSteamServerTransport, password);
		}

		public LocalLoopbackClientTransport StartSteam(SteamServerTransport steamTransport, string password = "")
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			ValueTuple<LocalLoopbackServerTransport, LocalLoopbackClientTransport> valueTuple = LocalLoopbackTransportPair.Create();
			LocalLoopbackServerTransport item = valueTuple.Item1;
			LocalLoopbackClientTransport item2 = valueTuple.Item2;
			string text = "108" + (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password);
			steamTransport.StartListening(0, text);
			item.StartListening(0, text);
			CompositeServerTransport val = new CompositeServerTransport((IServerTransport[])(object)new IServerTransport[2]
			{
				(IServerTransport)steamTransport,
				(IServerTransport)item
			});
			HostSettings val2 = new HostSettings
			{
				Password = (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password),
				ServerVersion = "108",
				VoiceChatEnabled = true,
				MaxBandwidthKbps = 512f
			};
			_host = new NetworkHost((IServerTransport)(object)val, val2, 60);
			_host.Log += delegate(string msg)
			{
				this.Log?.Invoke(msg);
			};
			_host.ClientConnected += OnClientConnected;
			_host.ClientDisconnected += OnClientDisconnected;
			if (steamTransport is BBSSteamServerTransport bBSSteamServerTransport)
			{
				bBSSteamServerTransport.TotalPlayerCountProvider = delegate
				{
					NetworkHost host = _host;
					return (host != null) ? host.Clients.Count : 0;
				};
			}
			RegisterHandlers();
			_host.StartWithoutListening();
			return item2;
		}

		public void Stop()
		{
			NetworkHost host = _host;
			if (host != null)
			{
				host.Stop();
			}
			_host = null;
		}

		public void Tick(float deltaMs)
		{
			NetworkHost host = _host;
			if (host != null)
			{
				host.Tick(deltaMs);
			}
		}

		private void RegisterHandlers()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			_host.RegisterHandler((CoreClientToServerOpcode)1, new ServerPacketHandler(HandleBoneUpdate));
			_host.RegisterHandler((CoreClientToServerOpcode)2, new ServerPacketHandler(HandlePlayerInfo));
			_host.RegisterHandler((CoreClientToServerOpcode)3, new ServerPacketHandler(HandleWorldEvent));
			_host.RegisterHandler((CoreClientToServerOpcode)4, new ServerPacketHandler(HandleAccessoryAdd));
			_host.RegisterHandler((CoreClientToServerOpcode)5, new ServerPacketHandler(HandleAccessoryRemove));
			_host.RegisterHandler((CoreClientToServerOpcode)6, new ServerPacketHandler(HandleJiminyUpdate));
			_host.RegisterHandler((CoreClientToServerOpcode)7, new ServerPacketHandler(HandleCollisionToggle));
			_host.RegisterHandler((CoreClientToServerOpcode)8, new ServerPacketHandler(HandleChatMessage));
			_host.RegisterHandler((CoreClientToServerOpcode)9, new ServerPacketHandler(HandleAudioFrame));
			_host.RegisterHandler((CoreClientToServerOpcode)11, new ServerPacketHandler(HandleRequestState));
		}

		private void OnClientConnected(ConnectedClient client)
		{
		}

		private void OnClientDisconnected(ConnectedClient client)
		{
			this.PlayerLeft?.Invoke(client.DisplayName ?? "Unknown");
		}

		private void HandleBoneUpdate(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (!sender.IsInitialized || data.Length < 4)
			{
				return;
			}
			byte kickoff = data[0];
			ushort seq = BitConverter.ToUInt16(data, 1);
			byte[] raw = data[3..];
			if (host.IsNewerSequence(sender.Uuid, seq))
			{
				sender.LastBoneKickoffPoint = kickoff;
				sender.LatestRawBoneData = raw;
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)5, (Action<List<byte>>)delegate(List<byte> bytes)
				{
					bytes.Add(sender.Uuid);
					bytes.Add(kickoff);
					bytes.AddRange(BitConverter.GetBytes(seq));
					bytes.AddRange(raw);
					bytes.AddRange(BitConverter.GetBytes(host.UptimeMs));
				});
				host.EnqueueBoneUpdate(sender.PeerId, array);
			}
		}

		private void HandlePlayerInfo(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (data.Length >= 3)
			{
				bool flag = !sender.IsInitialized;
				sender.Color = new RGBColor(data[0], data[1], data[2]);
				string @string = Encoding.UTF8.GetString(data, 3, data.Length - 3);
				if (sender.DisplayName == null)
				{
					sender.DisplayName = @string;
					this.PlayerJoined?.Invoke(@string);
				}
				else if (sender.DisplayName != @string)
				{
					sender.DisplayName = @string;
				}
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)4, (Action<List<byte>>)delegate(List<byte> bytes)
				{
					//IL_0022: 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_0060: Unknown result type (might be due to invalid IL or missing references)
					bytes.Add(sender.Uuid);
					bytes.Add(sender.Color.Value.R);
					bytes.Add(sender.Color.Value.G);
					bytes.Add(sender.Color.Value.B);
					bytes.AddRange(Encoding.UTF8.GetBytes(sender.DisplayName));
				});
				sender.InfoPacket = array;
				if (flag)
				{
					host.Broadcast(PacketBuilder.Build((CoreServerToClientOpcode)2, new byte[1] { sender.Uuid }), (PacketDelivery)2, sender.PeerId);
				}
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleWorldEvent(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length < 2)
			{
				return;
			}
			ushort num = BitConverter.ToUInt16(data, 0);
			if (host.IsNewerSequence(sender.Uuid, num))
			{
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)6, (Action<List<byte>>)delegate(List<byte> b)
				{
					b.Add(sender.Uuid);
					b.AddRange(data);
				});
				host.EnqueueHighPriority(sender.PeerId, array);
			}
		}

		private void HandleAccessoryAdd(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length >= 1)
			{
				byte key = data[0];
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)7, (Action<List<byte>>)delegate(List<byte> b)
				{
					b.Add(sender.Uuid);
					b.AddRange(data);
				});
				sender.SavedPackets[key] = array;
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleAccessoryRemove(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length >= 1)
			{
				byte key = data[0];
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)8, (Action<List<byte>>)delegate(List<byte> b)
				{
					b.Add(sender.Uuid);
					b.AddRange(data);
				});
				sender.SavedPackets[key] = null;
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleJiminyUpdate(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length >= 1)
			{
				sender.JiminyState = data[0] != 0;
				byte[] array = new byte[3]
				{
					9,
					sender.Uuid,
					Convert.ToByte(sender.JiminyState)
				};
				sender.SavedPackets[2] = array;
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleCollisionToggle(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length >= 1)
			{
				sender.CollisionsEnabled = data[0] != 0;
				byte[] array = new byte[3]
				{
					10,
					sender.Uuid,
					Convert.ToByte(sender.CollisionsEnabled)
				};
				sender.SavedPackets[3] = array;
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleChatMessage(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			if (data.Length >= 1)
			{
				byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)11, (Action<List<byte>>)delegate(List<byte> b)
				{
					b.Add(sender.Uuid);
					b.AddRange(data);
				});
				host.Broadcast(array, (PacketDelivery)2, sender.PeerId);
			}
		}

		private void HandleAudioFrame(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			byte[] array = PacketBuilder.Build((CoreServerToClientOpcode)12, (Action<List<byte>>)delegate(List<byte> b)
			{
				b.Add(sender.Uuid);
				b.AddRange(data);
			});
			host.EnqueueAudio(sender.PeerId, array);
		}

		private void HandleRequestState(ConnectedClient sender, byte[] data, NetworkHost host)
		{
			int num = 0;
			foreach (ConnectedClient value in host.Clients.Values)
			{
				if (value.PeerId == sender.PeerId || value.InfoPacket == null)
				{
					continue;
				}
				foreach (byte[] value2 in value.SavedPackets.Values)
				{
					if (value2 != null)
					{
						host.Send(sender.PeerId, value2, (PacketDelivery)2);
						num++;
					}
				}
			}
			Core.logger.Msg($"[Host] RequestState from peer {sender.PeerId}: re-sent {num} state packet(s)");
		}
	}
	public class NetworkManager
	{
		private NetworkClient _networkClient;

		private PlayerPacketQueue<byte, byte[]> pendingPlayerJoins = new PlayerPacketQueue<byte, byte[]>();

		private PlayerPacketQueue<byte, byte[]> pendingPlayerUpdates = new PlayerPacketQueue<byte, byte[]>();

		private ConcurrentDictionary<byte, ushort> lastSeenBoneSequences = new ConcurrentDictionary<byte, ushort>();

		private ConcurrentDictionary<byte, ushort> lastSeenAudioFrameSequences = new ConcurrentDictionary<byte, ushort>();

		private ushort localBoneSequenceNumber = 0;

		private HashSet<byte> _playersWithFirstBoneUpdate = new HashSet<byte>();

		private Dictionary<byte, bool> _pendingCollisionState = new Dictionary<byte, bool>();

		private ushort localAudioFrameSequenceNumber = 0;

		public bool isRunningNetParticle = false;

		public const int maxPacketSize = 1024;

		public ConcurrentDictionary<byte, RemotePlayer> players = new ConcurrentDictionary<byte, RemotePlayer>();

		private int numClones = 1;

		private byte uuid;

		private const string EasterEggMarker = "\u2063";

		private IPAddress connectedServerAddress;

		private string _disconnectReason;

		private bool _uuidReceived = false;

		private bool _connectedViaLoopback = false;

		public bool IsConnected
		{
			get
			{
				NetworkClient networkClient = _networkClient;
				return networkClient != null && networkClient.IsConnected;
			}
		}

		public bool HasReceivedUUID => _uuidReceived;

		public bool IsEasterEggActive { get; private set; }

		private bool IsNewer(ushort current, ushort previous)
		{
			return (ushort)(current - previous) < 32768;
		}

		public NetworkManager()
		{
			Physics.IgnoreLayerCollision(6, 6, true);
			Physics.IgnoreLayerCollision(6, 11, false);
			Physics.IgnoreLayerCollision(6, 19, true);
			Physics.IgnoreLayerCollision(23, 23, true);
			Physics.IgnoreLayerCollision(23, 11, false);
			Physics.IgnoreLayerCollision(23, 19, true);
		}

		private void OnDisconnected(string reason)
		{
			if (!string.IsNullOrEmpty(reason) && reason != "Disconnected" && reason != "Server disconnected" && reason != "Client disconnected")
			{
				_disconnectReason = reason;
			}
			Disconnect();
		}

		public void ConnectLoopback(LocalLoopbackClientTransport loopback)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			Disconnect();
			_connectedViaLoopback = true;
			Core.uiManager.notificationsUI.AddMessage("Connecting to local session…");
			_networkClient = new NetworkClient((IClientTransport)(object)loopback);
			_networkClient.Connected += OnConnected;
			_networkClient.Disconnected += OnDisconnected;
			RegisterHandlers();
			loopback.Connect("loopback", 0, string.Empty);
		}

		public void ConnectSteam(string hostSteamId64, string password)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			if (ulong.TryParse(hostSteamId64, out var result) && result == NativeSteamAPI.GetLocalSteamId())
			{
				Core.uiManager.notificationsUI.AddMessage(IsConnected ? "You are already connected to this session." : "Cannot join your own session from the same account.");
				return;
			}
			Disconnect();
			Core.uiManager.notificationsUI.AddMessage("Connecting via Steam P2P…");
			BBSSteamClientTransport bBSSteamClientTransport = new BBSSteamClientTransport();
			_networkClient = new NetworkClient((IClientTransport)(object)bBSSteamClientTransport);
			_networkClient.Connected += OnConnected;
			_networkClient.Disconnected += OnDisconnected;
			RegisterHandlers();
			string text = "108" + (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password);
			_networkClient.Connect(hostSteamId64, 0, text);
		}

		public void Connect(string serverIP, int serverPort, string password)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			Disconnect();
			Core.uiManager.notificationsUI.AddMessage("Connecting to server...");
			LiteNetLibClientTransport val = new LiteNetLibClientTransport();
			_networkClient = new NetworkClient((IClientTransport)(object)val);
			_networkClient.Connected += OnConnected;
			_networkClient.Disconnected += OnDisconnected;
			RegisterHandlers();
			string text = "108" + (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password);
			_networkClient.Connect(serverIP, serverPort, text);
		}

		private void RegisterHandlers()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			_networkClient.RegisterHandler((CoreServerToClientOpcode)1, new ClientPacketHandler(HandleAssignUUID));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)2, new ClientPacketHandler(HandlePlayerJoined));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)3, new ClientPacketHandler(HandlePlayerLeft));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)4, new ClientPacketHandler(HandlePlayerInfoUpdate));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)5, new ClientPacketHandler(HandleBoneUpdate));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)6, new ClientPacketHandler(HandleWorldEvent));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)7, new ClientPacketHandler(HandleAccessoryAdd));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)8, new ClientPacketHandler(HandleAccessoryRemove));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)9, new ClientPacketHandler(HandleJiminyRibbon));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)10, new ClientPacketHandler(HandleCollisionToggle));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)11, new ClientPacketHandler(HandleChatMessage));
			_networkClient.RegisterHandler((CoreServerToClientOpcode)12, new ClientPacketHandler(HandleAudioFrame));
		}

		private void OnConnected()
		{
		}

		public void Disconnect()
		{
			if (_networkClient == null)
			{
				return;
			}
			_networkClient.Disconnect();
			_networkClient = null;
			connectedServerAddress = null;
			IsEasterEggActive = false;
			localBoneSequenceNumber = 0;
			localAudioFrameSequenceNumber = 0;
			uuid = 0;
			numClones = 0;
			_uuidReceived = false;
			_connectedViaLoopback = false;
			pendingPlayerJoins.Clear();
			pendingPlayerUpdates.Clear();
			lastSeenBoneSequences.Clear();
			lastSeenAudioFrameSequences.Clear();
			_playersWithFirstBoneUpdate.Clear();
			_pendingCollisionState.Clear();
			foreach (KeyValuePair<byte, RemotePlayer> player in players)
			{
				player.Value.Dispose();
			}
			players.Clear();
			if (LocalPlayer.Instance != null)
			{
				LocalPlayer.Instance.Dispose();
			}
			LocalPlayer.Instance = null;
			WorldObjectSyncManager.ReleaseCachedWheels();
			WorldObjectSyncManager.ClearCachedWheels();
			string message = _disconnectReason ?? "Disconnected from server";
			_disconnectReason = null;
			Core.uiManager.notificationsUI.AddMessage(message);
			Core.OnConnectionStateChanged?.Invoke();
		}

		public void Update()
		{
			if (_networkClient == null)
			{
				return;
			}
			if (Core.HasLoadedGame())
			{
				if (LocalPlayer.Instance == null)
				{
					LocalPlayer.Instance = new LocalPlayer();
					LocalPlayer.Instance.Initialize();
					return;
				}
				pendingPlayerJoins.Process(delegate(byte[] pktData)
				{
					if (pktData.Length >= 1)
					{
						SpawnRemotePlayer(pktData[0]);
					}
				});
			}
			_networkClient.Tick();
			if (_networkClient != null)
			{
				WorldObjectSyncManager.Update();
			}
		}

		public void LateUpdate()
		{
			if (_networkClient == null || players == null)
			{
				return;
			}
			foreach (RemotePlayer value in players.Values)
			{
				value?.LateUpdate();
			}
		}

		private void HandleAssignUUID(byte[] data, NetworkClient _)
		{
			if (data.Length >= 9)
			{
				uuid = data[0];
				long serverUptimeMs = BitConverter.ToInt64(data, 1);
				WorldObjectSyncManager.OnServerTimeSample(serverUptimeMs);
				if (!_uuidReceived)
				{
					_uuidReceived = true;
					SendPlayerInformation();
					ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
					Core.uiManager.notificationsUI.AddMessage(currentLanguage.ConnectedToServer);
					Core.uiManager.notificationsUI.AddMessage("Press the 'T' key to send a message");
					Core.OnConnectionStateChanged?.Invoke();
				}
			}
		}

		private void HandlePlayerJoined(byte[] data, NetworkClient _)
		{
			if (data.Length < 1)
			{
				return;
			}
			byte b = data[0];
			if (!players.ContainsKey(b))
			{
				if (!Core.HasLoadedGame() || LocalPlayer.Instance == null)
				{
					pendingPlayerJoins.Enqueue(b, new byte[1] { b });
				}
				else
				{
					SpawnRemotePlayer(b);
				}
			}
		}

		private void SpawnRemotePlayer(byte newUUID)
		{
			RemotePlayer result = null;
			if (!RemotePlayer.GlobalPool.TryTake(out result))
			{
				result = new RemotePlayer();
				result.Initialize(numClones++);
			}
			result.SetActive(active: true);
			result.SetOpacity(1f);
			result.RemoveHat();
			result.ResetBonesToBind();
			_playersWithFirstBoneUpdate.Remove(newUUID);
			_pendingCollisionState.Remove(newUUID);
			ApplyCollisionToggle(result, collisionsEnabled: false);
			result.InitializeAudioSource();
			players[newUUID] = result;
			pendingPlayerUpdates.Process(newUUID, DispatchPlayerUpdate);
		}

		private void HandlePlayerLeft(byte[] data, NetworkClient _)
		{
			if (data.Length < 1)
			{
				return;
			}
			byte b = data[0];
			if (players.TryGetValue(b, out var value))
			{
				ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
				players.TryRemove(b, out var _);
				lastSeenBoneSequences.TryRemove(b, out var _);
				lastSeenAudioFrameSequences.TryRemove(b, out var _);
				if (value.firstAppearanceApplication)
				{
					Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage.HasDisconnected, value.displayName));
				}
				value.Dispose();
			}
			pendingPlayerJoins.Clear(b);
			pendingPlayerUpdates.Clear(b);
			_playersWithFirstBoneUpdate.Remove(b);
			_pendingCollisionState.Remove(b);
		}

		private void HandlePlayerInfoUpdate(byte[] data, NetworkClient _)
		{
			if (data.Length >= 5)
			{
				byte key = data[0];
				if (players.TryGetValue(key, out var value))
				{
					ApplyAppearanceUpdate(value, data);
				}
				else
				{
					pendingPlayerUpdates.Enqueue(key, WithOpcode((CoreServerToClientOpcode)4, data));
				}
			}
		}

		private void HandleBoneUpdate(byte[] data, NetworkClient _)
		{
			if (data.Length < 5)
			{
				return;
			}
			byte b = data[0];
			if (players.TryGetValue(b, out var value))
			{
				byte kickoffPoint = data[1];
				ushort num = BitConverter.ToUInt16(data, 2);
				byte[] array = data.Skip(4).ToArray();
				long serverUptimeMs = BitConverter.ToInt64(array, array.Length - 8);
				WorldObjectSyncManager.OnServerTimeSample(serverUptimeMs);
				byte[] data2 = array.Take(array.Length - 8).ToArray();
				if (!lastSeenBoneSequences.TryGetValue(b, out var value2) || IsNewer(num, value2))
				{
					lastSeenBoneSequences[b] = num;
					TransformNet[] array2 = TransformNet.Deserialize(data2);
					if (array2 != null && array2.Length != 0)
					{
						value.UpdateBones(array2, kickoffPoint);
					}
				}
				if (!_playersWithFirstBoneUpdate.Contains(b))
				{
					_playersWithFirstBoneUpdate.Add(b);
					if (_pendingCollisionState.TryGetValue(b, out var value3))
					{
						_pendingCollisionState.Remove(b);
						ApplyCollisionToggle(value, value3);
						Core.logger.Msg($"[Net] Applied deferred collision={value3} for UUID {b} after first bone update");
					}
				}
			}
			else
			{
				pendingPlayerUpdates.Enqueue(b, WithOpcode((CoreServerToClientOpcode)5, data));
			}
		}

		private void HandleWorldEvent(byte[] data, NetworkClient _)
		{
			if (data.Length < 3)
			{
				return;
			}
			byte key = data[0];
			ushort current = BitConverter.ToUInt16(data, 1);
			byte[] array = data.Skip(3).ToArray();
			if ((lastSeenBoneSequences.TryGetValue(key, out var value) && !IsNewer(current, value)) || array.Length < 2 || array[0] != 0 || !((Object)(object)LocalPlayer.Instance?.particleParty != (Object)null))
			{
				return;
			}
			FootData val = FootDataHelpers.DeserializeFootData(array.Skip(2).ToArray(), players.ContainsKey(key) ? players[key] : null);
			if (val != null)
			{
				isRunningNetParticle = true;
				if (array[1] == 0)
				{
					LocalPlayer.Instance.particleParty.OnPlant(val);
				}
				else if (array[1] == 1)
				{
					LocalPlayer.Instance.particleParty.OnSlip(val);
				}
			}
		}

		private void HandleAccessoryAdd(byte[] data, NetworkClient _)
		{
			if (data.Length >= 2)
			{
				byte key = data[0];
				if (players.TryGetValue(key, out var value))
				{
					ApplyAccessoryDon(value, data);
					ApplyCollisionToggle(value, value.netCollisionsEnabled);
				}
				else
				{
					pendingPlayerUpdates.Enqueue(key, WithOpcode((CoreServerToClientOpcode)7, data));
				}
			}
		}

		private void HandleAccessoryRemove(byte[] data, NetworkClient _)
		{
			if (data.Length < 2)
			{
				return;
			}
			byte key = data[0];
			byte b = data[1];
			if (players.TryGetValue(key, out var value))
			{
				switch (b)
				{
				case 0:
					value.RemoveHat();
					break;
				case 1:
					if (data.Length >= 3)
					{
						value.DropItem(data[2]);
					}
					break;
				default:
					Core.logger.Msg($"Unknown Accessory type: {b}");
					break;
				}
			}
			else
			{
				pendingPlayerUpdates.Enqueue(key, WithOpcode((CoreServerToClientOpcode)8, data));
			}
		}

		private void HandleJiminyRibbon(byte[] data, NetworkClient _)
		{
			if (data.Length >= 2)
			{
				byte key = data[0];
				bool jiminyState = data[1] != 0;
				if (players.TryGetValue(key, out var value))
				{
					ApplyJiminyRibbonStateChange(value, jiminyState);
				}
				else
				{
					pendingPlayerUpdates.Enqueue(key, WithOpcode((CoreServerToClientOpcode)9, data));
				}
			}
		}

		private void HandleCollisionToggle(byte[] data, NetworkClient _)
		{
			if (data.Length < 2)
			{
				return;
			}
			byte b = data[0];
			bool flag = data[1] != 0;
			if (players.TryGetValue(b, out var value))
			{
				if (flag && !_playersWithFirstBoneUpdate.Contains(b))
				{
					_pendingCollisionState[b] = true;
					Core.logger.Msg($"[Net] Deferring collision enable for UUID {b} (no bone update yet)");
				}
				else
				{
					_pendingCollisionState.Remove(b);
					ApplyCollisionToggle(value, flag);
					if (_playersWithFirstBoneUpdate.Contains(b))
					{
						Core.uiManager.notificationsUI.AddMessage(value.displayName + " has " + (flag ? "enabled" : "disabled") + " collisions");
					}
				}
			}
			else
			{
				pendingPlayerUpdates.Enqueue(b, WithOpcode((CoreServerToClientOpcode)10, data));
			}
		}

		private void HandleChatMessage(byte[] data, NetworkClient _)
		{
			if (data.Length >= 2)
			{
				byte key = data[0];
				string @string = Encoding.UTF8.GetString(data, 1, data.Length - 1);
				if (players.TryGetValue(key, out var value))
				{
					int num = @string.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
					float value2 = Mathf.Max(3f, 3f + (float)num - 5f) * 0.5f;
					Core.uiManager.notificationsUI.AddMessage(value.displayName + ": " + @string, value2);
				}
				else
				{
					pendingPlayerUpdates.Enqueue(key, WithOpcode((CoreServerToClientOpcode)11, data));
				}
			}
		}

		private void HandleAudioFrame(byte[] data, NetworkClient _)
		{
			if (ModSettings.audio.Deafened.Value || data.Length < 4)
			{
				return;
			}
			byte key = data[0];
			if (players.TryGetValue(key, out var value))
			{
				ushort num = BitConverter.ToUInt16(data, 1);
				if (!lastSeenAudioFrameSequences.TryGetValue(key, out var value2) || IsNewer(num, value2))
				{
					lastSeenAudioFrameSequences[key] = num;
					value.audioSource.QueueOpusPacket(data[3..]);
				}
			}
		}

		private void DispatchPlayerUpdate(byte[] pktData)
		{
			if (pktData.Length >= 1)
			{
				byte b = pktData[0];
				byte[] data = ((pktData.Length > 1) ? pktData[1..] : Array.Empty<byte>());
				switch (b)
				{
				case 4:
					HandlePlayerInfoUpdate(data, null);
					break;
				case 5:
					HandleBoneUpdate(data, null);
					break;
				case 7:
					HandleAccessoryAdd(data, null);
					break;
				case 8:
					HandleAccessoryRemove(data, null);
					break;
				case 9:
					HandleJiminyRibbon(data, null);
					break;
				case 10:
					HandleCollisionToggle(data, null);
					break;
				case 11:
					HandleChatMessage(data, null);
					break;
				case 6:
					break;
				}
			}
		}

		private static byte[] WithOpcode(CoreServerToClientOpcode opcode, byte[] data)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected I4, but got Unknown
			byte[] array = new byte[1 + data.Length];
			array[0] = (byte)(int)opcode;
			Buffer.BlockCopy(data, 0, array, 1, data.Length);
			return array;
		}

		private void ApplyJiminyRibbonStateChange(RemotePlayer player, bool jiminyState)
		{
			if ((Object)(object)player.jiminyRibbon != (Object)null)
			{
				player.jiminyRibbon.active = jiminyState;
			}
		}

		internal void ApplyCollisionToggle(RemotePlayer player, bool collisionsEnabled)
		{
			if (collisionsEnabled)
			{
				player.netCollisionsEnabled = true;
				if (ModSettings.player.Collisions.Value)
				{
					player.EnableCollision();
				}
				else
				{
					player.DisableCollision();
				}
			}
			else
			{
				player.netCollisionsEnabled = false;
				player.DisableCollision();
			}
		}

		private void ApplyAppearanceUpdate(RemotePlayer player, byte[] data)
		{
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			Color val = default(Color);
			((Color)(ref val))..ctor((float)(int)data[1] / 255f, (float)(int)data[2] / 255f, (float)(int)data[3] / 255f);
			bool flag = player.BaseSuitColor != val;
			player.UpdateBaseSuitColor(val);
			bool rainbowSuitActive = data.Length > 4 && data[4] != 0;
			int num = ((data.Length > 5) ? (data.Length - 5) : 0);
			string text = ((num > 0) ? Encoding.UTF8.GetString(data, 5, num) : string.Empty);
			player.SetRainbowSuitActive(rainbowSuitActive);
			if (!player.firstAppearanceApplication)
			{
				if (!string.IsNullOrEmpty(text))
				{
					Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage.HasConnected, text));
				}
				player.firstAppearanceApplication = true;
			}
			else
			{
				if (!string.IsNullOrEmpty(text) && player.displayName != text)
				{
					Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage.HasChangedNicknameTo, player.displayName, text));
				}
				if (flag)
				{
					Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage.HasUpdatedTheirColor, player.displayName));
				}
			}
			player.SetDisplayName(text);
		}

		private void ApplyAccessoryDon(RemotePlayer player, byte[] data)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			if (data.Length < 2)
			{
				return;
			}
			byte b = data[1];
			int num = 2;
			switch (b)
			{
			case 0:
				if (data.Length >= num + 28)
				{
					float num9 = BitConverter.ToSingle(data, num);
					num += 4;
					float num10 = BitConverter.ToSingle(data, num);
					num += 4;
					float num11 = BitConverter.ToSingle(data, num);
					num += 4;
					float num12 = BitConverter.ToSingle(data, num);
					num += 4;
					float num13 = BitConverter.ToSingle(data, num);
					num += 4;
					float num14 = BitConverter.ToSingle(data, num);
					num += 4;
					float num15 = BitConverter.ToSingle(data, num);
					num += 4;
					string string2 = Encoding.UTF8.GetString(data, num, data.Length - num);
					player.WearHat(string2, new Vector3(0f, 0.21f, -0.02f), new Quaternion(-0.21517f, 6.89E-05f, -0.0003178f, 0.97627f));
					Core.uiManager.notificationsUI.AddMessage(player.displayName + " has donned the " + string2);
				}
				break;
			case 1:
				if (data.Length >= num + 1 + 28)
				{
					int handIndex = data[num];
					num++;
					float num2 = BitConverter.ToSingle(data, num);
					num += 4;
					float num3 = BitConverter.ToSingle(data, num);
					num += 4;
					float num4 = BitConverter.ToSingle(data, num);
					num += 4;
					float num5 = BitConverter.ToSingle(data, num);
					num += 4;
					float num6 = BitConverter.ToSingle(data, num);
					num += 4;
					float num7 = BitConverter.ToSingle(data, num);
					num += 4;
					float num8 = BitConverter.ToSingle(data, num);
					num += 4;
					string @string = Encoding.UTF8.GetString(data, num, data.Length - num);
					player.HoldItem(@string, handIndex, new Vector3(num2, num3, num4), new Quaternion(num5, num6, num7, num8));
					Core.uiManager.notificationsUI.AddMessage(player.displayName + " has picked up the " + @string);
				}
				break;
			default:
				Core.logger.Msg($"Unknown Accessory type: {b}");
				break;
			}
		}

		public static bool HasEasterEggMarker(string name)
		{
			return !string.IsNullOrEmpty(name) && name.Contains("\u2063", StringComparison.Ordinal);
		}

		public static string StripEasterEggMarker(string name)
		{
			return string.IsNullOrEmpty(name) ? name : name.Replace("\u2063", string.Empty, StringComparison.Ordinal);
		}

		private void UpdateEasterEggState()
		{
			bool isEasterEggActive = false;
			string value = ModSettings.player.Nickname.Value;
			if (!string.IsNullOrWhiteSpace(value) && string.Equals(value, "Caleb", StringComparison.Ordinal))
			{
				if (_connectedViaLoopback)
				{
					isEasterEggActive = true;
				}
				else
				{
					IPAddress iPAddress = ResolveServerAddress(ModSettings.connection.Address.Value);
					if (iPAddress != null)
					{
						connectedServerAddress = iPAddress;
					}
					if (connectedServerAddress != null)
					{
						isEasterEggActive = IsLocalAddress(connectedServerAddress);
					}
				}
			}
			IsEasterEggActive = isEasterEggActive;
		}

		public void SendBones(TransformNet[] bones, int kickoffPoint)
		{
			List<byte> list = new List<byte>(1024)
			{
				1,
				(byte)kickoffPoint
			};
			list.AddRange(BitConverter.GetBytes(localBoneSequenceNumber++));
			list.AddRange(TransformNet.Serialize(bones));
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)0);
			}
		}

		public void SendPlayerInformation()
		{
			//IL_003e: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			UpdateEasterEggState();
			string s = StripEasterEggMarker(ModSettings.player.Nickname.Value ?? string.Empty);
			List<byte> list = new List<byte>
			{
				2,
				(byte)(ModSettings.player.SuitColor.Value.r * 255f),
				(byte)(ModSettings.player.SuitColor.Value.g * 255f),
				(byte)(ModSettings.player.SuitColor.Value.b * 255f),
				(byte)(IsEasterEggActive ? 1u : 0u)
			};
			list.AddRange(Encoding.UTF8.GetBytes(s));
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)2);
			}
		}

		public void SendAudioFrame(byte[] encodedData)
		{
			List<byte> list = new List<byte> { 9 };
			list.AddRange(BitConverter.GetBytes(localAudioFrameSequenceNumber++));
			list.AddRange(encodedData);
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)0);
			}
		}

		public void SendChatMessage(string message)
		{
			List<byte> list = new List<byte> { 8 };
			list.AddRange(Encoding.UTF8.GetBytes(message));
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)2);
			}
		}

		public void SendCollisionToggle(bool state)
		{
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(new byte[2]
				{
					7,
					Convert.ToByte(state)
				}, (PacketDelivery)2);
			}
		}

		public void RequestStateResync()
		{
			if (!IsConnected)
			{
				return;
			}
			SendDoffHat();
			SendDropGrabable(0);
			SendDropGrabable(1);
			foreach (RemotePlayer value in players.Values)
			{
				value.RemoveHat();
				value.DropItem(0);
				value.DropItem(1);
			}
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(new byte[1] { 11 }, (PacketDelivery)2);
			}
			if (LocalPlayer.Instance != null)
			{
				try
				{
					LocalPlayer.Instance.Dispose();
				}
				catch
				{
				}
				LocalPlayer.Instance = null;
			}
			Core.logger.Msg("[Net] State resync requested after save load");
		}

		public void SendJiminyRibbonState(bool state)
		{
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(new byte[2]
				{
					6,
					Convert.ToByte(state)
				}, (PacketDelivery)2);
			}
		}

		public void SendHoldGrabable(Grabable grabable, int handIndex)
		{
			//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_0058: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (LocalPlayer.Instance == null)
			{
				return;
			}
			Transform val = ((handIndex == 0) ? LocalPlayer.Instance.handBones.Item1 : LocalPlayer.Instance.handBones.Item2);
			if (!((Object)(object)val == (Object)null))
			{
				Vector3 pos = val.InverseTransformPoint(((Component)grabable).transform.position);
				Quaternion rot = Quaternion.Inverse(val.rotation) * ((Component)grabable).transform.rotation;
				string text = ((Object)grabable).name;
				if (text.EndsWith("(Clone)"))
				{
					string text2 = text;
					int length = "(Clone)".Length;
					text = text2.Substring(0, text2.Length - length);
				}
				SendAddAccessory(1, text, pos, rot, handIndex);
			}
		}

		public void SendDropGrabable(int handIndex)
		{
			SendRemoveAccessory(1, handIndex);
		}

		public void SendDonHat(Hat hat)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_0060: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LocalPlayer.Instance?.headBone == (Object)null))
			{
				Vector3 pos = LocalPlayer.Instance.headBone.InverseTransformPoint(((Component)hat).transform.position);
				Quaternion rot = Quaternion.Inverse(LocalPlayer.Instance.headBone.rotation) * ((Component)hat).transform.rotation;
				string text = ((Object)hat).name;
				if (text.EndsWith("(Clone)"))
				{
					string text2 = text;
					int length = "(Clone)".Length;
					text = text2.Substring(0, text2.Length - length);
				}
				SendAddAccessory(0, text, pos, rot);
			}
		}

		public void SendDoffHat()
		{
			SendRemoveAccessory(0);
		}

		private void SendAddAccessory(byte itemType, string itemName, Vector3 pos, Quaternion rot, int handIndex = 0)
		{
			//IL_002a: 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_004e: 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_0073: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			List<byte> list = new List<byte> { 4, itemType };
			if (itemType == 1)
			{
				list.Add((byte)handIndex);
			}
			list.AddRange(BitConverter.GetBytes(pos.x));
			list.AddRange(BitConverter.GetBytes(pos.y));
			list.AddRange(BitConverter.GetBytes(pos.z));
			list.AddRange(BitConverter.GetBytes(rot.x));
			list.AddRange(BitConverter.GetBytes(rot.y));
			list.AddRange(BitConverter.GetBytes(rot.z));
			list.AddRange(BitConverter.GetBytes(rot.w));
			list.AddRange(Encoding.UTF8.GetBytes(itemName));
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)2);
			}
		}

		private void SendRemoveAccessory(byte itemType, int handIndex = 0)
		{
			List<byte> list = new List<byte> { 5, itemType };
			if (itemType == 1)
			{
				list.Add((byte)handIndex);
			}
			NetworkClient networkClient = _networkClient;
			if (networkClient != null)
			{
				networkClient.Send(list.ToArray(), (PacketDelivery)2);
			}
		}

		private static IPAddress ResolveServerAddress(string addr)
		{
			if (string.IsNullOrWhiteSpace(addr))
			{
				return null;
			}
			if (string.Equals(addr, "localhost", StringComparison.OrdinalIgnoreCase))
			{
				return IPAddress.Loopback;
			}
			if (IPAddress.TryParse(addr, out IPAddress address))
			{
				return address;
			}
			try
			{
				return Dns.GetHostAddresses(addr).FirstOrDefault();
			}
			catch
			{
				return null;
			}
		}

		private static bool IsLocalAddress(IPAddress address)
		{
			if (address == null)
			{
				return false;
			}
			if (IPAddress.IsLoopback(address))
			{
				return true;
			}
			try
			{
				NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
				foreach (NetworkInterface networkInterface in allNetworkInterfaces)
				{
					if (networkInterface.OperationalStatus != OperationalStatus.Up)
					{
						continue;
					}
					foreach (UnicastIPAddressInformation unicastAddress in networkInterface.GetIPProperties().UnicastAddresses)
					{
						if (unicastAddress.Address != null)
						{
							if (unicastAddress.Address.Equals(address))
							{
								return true;
							}
							if (unicastAddress.IPv4Mask != null && unicastAddress.Address.AddressFamily == AddressFamily.InterNetwork && address.AddressFamily == AddressFamily.InterNetwork && IsInSameSubnet(address, unicastAddress.Address, unicastAddress.IPv4Mask))
							{
								return true;
							}
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsInSameSubnet(IPAddress a, IPAddress subnet, IPAddress mask)
		{
			byte[] addressBytes = a.GetAddressBytes();
			byte[] addressBytes2 = subnet.GetAddressBytes();
			byte[] addressBytes3 = mask.GetAddressBytes();
			if (addressBytes.Length != addressBytes2.Length || addressBytes.Length != addressBytes3.Length)
			{
				return false;
			}
			for (int i = 0; i < addressBytes.Length; i++)
			{
				if ((addressBytes[i] & addressBytes3[i]) != (addressBytes2[i] & addressBytes3[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal class PlayerPacketQueue<TKey, TPacket>
	{
		private ConcurrentDictionary<TKey, ConcurrentQueue<TPacket>> _queue = new ConcurrentDictionary<TKey, ConcurrentQueue<TPacket>>();

		internal void Clear()
		{
			if (_queue.Count > 0)
			{
				TKey[] array = _queue.Keys.ToArray();
				foreach (TKey key in array)
				{
					Clear(key);
				}
				_queue.Clear();
			}
		}

		internal void Clear(TKey key)
		{
			if (_queue.TryRemove(key, out var value) && value != null && value.Count <= 0)
			{
				value.Clear();
			}
		}

		internal void Enqueue(TKey key, TPacket packet)
		{
			if (!_queue.TryGetValue(key, out var value) || value == null)
			{
				ConcurrentQueue<TPacket> concurrentQueue2 = (_queue[key] = new ConcurrentQueue<TPacket>());
				value = concurrentQueue2;
			}
			value.Enqueue(packet);
		}

		internal void Process(Action<TPacket> callback)
		{
			if (_queue.Count > 0)
			{
				KeyValuePair<TKey, ConcurrentQueue<TPacket>>[] array = _queue.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					KeyValuePair<TKey, ConcurrentQueue<TPacket>> keyValuePair = array[i];
					Process(keyValuePair.Value, callback);
					_queue.Remove(keyValuePair.Key, out var _);
				}
			}
		}

		internal void Process(TKey key, Action<TPacket> callback)
		{
			if (_queue.Count > 0 && _queue.TryRemove(key, out var value))
			{
				Process(value, callback);
			}
		}

		private void Process(ConcurrentQueue<TPacket> packetQueue, Action<TPacket> callback)
		{
			if (packetQueue == null)
			{
				return;
			}
			TPacket result;
			while (packetQueue.TryDequeue(out result))
			{
				try
				{
					callback?.Invoke(result);
				}
				catch (Exception ex)
				{
					Core.logger.Error(ex.ToString());
				}
			}
		}
	}
	public class BoneSnapshot
	{
		public double time;

		public TransformNet[] transformNets;

		public BoneSnapshot(int boneCount)
		{
			transformNets = new TransformNet[boneCount];
		}
	}
	public class TransformNet
	{
		private const float loopWidth = 512f;

		public Vector3 position;

		public Quaternion rotation;

		public int heirarchyIndex;

		public TransformNet(int index, Vector3 Position, Quaternion Rotation)
		{
			heirarchyIndex = index;
			position = Position;
			rotation = Rotation;
		}

		public static TransformNet[] ToNet(List<Transform> bones)
		{
			//IL_002f: 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_0045: 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)
			//IL_0060: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			int count = bones.Count;
			TransformNet[] array = new TransformNet[count];
			for (int i = 0; i < count; i++)
			{
				Transform val = bones[i];
				if (!((Object)(object)val == (Object)null))
				{
					array[i] = new TransformNet(i, new Vector3(val.position.x, val.position.y, val.position.z), new Quaternion(val.rotation.x, val.rotation.y, val.rotation.z, val.rotation.w));
				}
			}
			return array;
		}

		public static byte[] Serialize(TransformNet[] bones)
		{
			List<byte> list = new List<byte>();
			sbyte b = (sbyte)Mathf.FloorToInt((bones[0].position.X + 256f) / 512f);
			list.Add((byte)b);
			foreach (TransformNet transformNet in bones)
			{
				float num = (transformNet.position.X + 256f) % 512f;
				float num2 = num / 512f;
				int num3 = (int)(num2 * 16777215f);
				byte item = (byte)((uint)num3 & 0xFFu);
				byte item2 = (byte)((uint)(num3 >> 8) & 0xFFu);
				byte item3 = (byte)((uint)(num3 >> 16) & 0xFFu);
				list.Add(item);
				list.Add(item2);
				list.Add(item3);
				list.AddRange(BitConverter.GetBytes(transformNet.position.Y));
				list.AddRange(BitConverter.GetBytes(transformNet.position.Z));
				Quaternion quaternion = transformNet.rotation;
				if (quaternion.W < 0f)
				{
					quaternion = new Quaternion(0f - quaternion.X, 0f - quaternion.Y, 0f - quaternion.Z, 0f - quaternion.W);
				}
				short value = (short)Mathf.RoundToInt(quaternion.X * 32767f);
				short value2 = (short)Mathf.RoundToInt(quaternion.Y * 32767f);
				short value3 = (short)Mathf.RoundToInt(quaternion.Z * 32767f);
				list.AddRange(BitConverter.GetBytes(value));
				list.AddRange(BitConverter.GetBytes(value2));
				list.AddRange(BitConverter.GetBytes(value3));
			}
			return list.ToArray();
		}

		public static TransformNet[] Deserialize(byte[] data, float loopWidth = 512f)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			int num = 17;
			int num2 = data.Length / num;
			TransformNet[] array = new TransformNet[num2];
			sbyte b = (sbyte)data[0];
			for (int i = 0; i < num2; i++)
			{
				int num3 = i * num + 1;
				byte b2 = data[num3];
				byte b3 = data[num3 + 1];
				byte b4 = data[num3 + 2];
				int num4 = b2 | (b3 << 8) | (b4 << 16);
				float num5 = (float)num4 / 16777215f;
				float num6 = num5 * loopWidth - loopWidth / 2f + (float)b * loopWidth;
				float num7 = num6;
				float num8 = ((LocalPlayer.Instance != null && (Object)(object)LocalPlayer.Instance.rootBone != (Object)null) ? LocalPlayer.Instance.rootBone.position.x : 0f);
				float num9 = num8 - loopWidth * 0.5f;
				float num10 = num7 - num9;
				num10 = (num10 % loopWidth + loopWidth) % loopWidth;
				num7 = num10 + num9;
				float y = BitConverter.ToSingle(data, num3 + 3);
				float z = BitConverter.ToSingle(data, num3 + 7);
				short num11 = BitConverter.ToInt16(data, num3 + 11);
				short num12 = BitConverter.ToInt16(data, num3 + 13);
				short num13 = BitConverter.ToInt16(data, num3 + 15);
				float num14 = (float)num11 / 32767f;
				float num15 = (float)num12 / 32767f;
				float num16 = (float)num13 / 32767f;
				float num17 = 1f - (num14 * num14 + num15 * num15 + num16 * num16);
				float w = ((num17 > 0f) ? MathF.Sqrt(num17) : 0f);
				array[i] = new TransformNet(i, new Vector3(num7, y, z), new Quaternion(num14, num15, num16, w));
			}
			return array;
		}
	}
	public class VersionCheck
	{
		public static Version GetAssemblyVersion()
		{
			return Assembly.GetExecutingAssembly().GetName().Version;
		}

		public static string GetLatestTag()
		{
			using HttpClient httpClient = new HttpClient();
			httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("BBSMMClient/" + GetAssemblyVersion().ToString());
			string result = httpClient.GetStringAsync("https://api.github.com/repos/caleborchard/Baby-Steps-Multiplayer-Mod-Client/tags").Result;
			using JsonDocument jsonDocument = JsonDocument.Parse(result);
			return (from tag in jsonDocument.RootElement.EnumerateArray()
				select tag.GetProperty("name").GetString()).FirstOrDefault();
		}

		public static void CheckForUpdate()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string latestTag = GetLatestTag();
				Version assemblyVersion = GetAssemblyVersion();
				if (Version.TryParse(latestTag, out Version result))
				{
					Version version = new Version(assemblyVersion.Major, assemblyVersion.Minor, assemblyVersion.Build);
					Version version2 = new Version(result.Major, result.Minor, result.Build);
					MelonLogger.Msg("Our version: " + version.ToString());
					MelonLogger.Msg("Latest version: " + version2.ToString());
					if (version < version2)
					{
						Core.uiManager.notificationsUI.AddMessage("You are on an outdated client version! Please update to connect to the official server!", 10f, Color.red);
					}
					else if (version > version2)
					{
						Core.uiManager.notificationsUI.AddMessage("Your client is a development build.", 3f, Color.blue);
					}
					else
					{
						Core.uiManager.notificationsUI.AddMessage("Your client is up to date!", 3f, Color.green);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("Error checking for update: " + ex.Message);
			}
		}
	}
	public static class WorldObjectSyncManager
	{
		private const float REFRESH_INTERVAL = 2f;

		private const float WHEEL_SPEED = 9f;

		private static float lastRefreshTime = 0f;

		private static double currentTimeMs = 0.0;

		private static float lastUpdateTime = 0f;

		private static List<WaterWheel> cachedWaterWheels = new List<WaterWheel>();

		private static Dictionary<Rigidbody, Quaternion> wheelBaseRotation = new Dictionary<Rigidbody, Quaternion>();

		private static Dictionary<WaterWheel, (Rigidbody wheelRb, Rigidbody axelRb)> wheelComponents = new Dictionary<WaterWheel, (Rigidbody, Rigidbody)>();

		public static void Update()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float num = realtimeSinceStartup - lastUpdateTime;
			lastUpdateTime = realtimeSinceStartup;
			currentTimeMs += (double)num * 1000.0;
			if (Time.time - lastRefreshTime > 2f)
			{
				RefreshWaterWheelCache();
				lastRefreshTime = Time.time;
			}
			SyncWaterWheels();
		}

		public static void OnServerTimeSample(long serverUptimeMs)
		{
			currentTimeMs = serverUptimeMs;
		}

		private static void RefreshWaterWheelCache()
		{
			cachedWaterWheels.RemoveAll((WaterWheel w) => (Object)(object)w == (Object)null);
			Il2CppArrayBase<WaterWheel> val = Object.FindObjectsOfType<WaterWheel>();
			foreach (WaterWheel item in val)
			{
				if (!cachedWaterWheels.Contains(item))
				{
					cachedWaterWheels.Add(item);
					((Behaviour)item).enabled = false;
					Core.DebugMsg("Found new WaterWheel");
				}
			}
		}

		private static void SyncWaterWheels()
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_0166: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			if (cachedWaterWheels.Count == 0)
			{
				return;
			}
			float num = (float)(currentTimeMs / 1000.0);
			float num2 = 9f * num % 360f;
			foreach (WaterWheel cachedWaterWheel in cachedWaterWheels)
			{
				if ((Object)(object)cachedWaterWheel == (Object)null)
				{
					continue;
				}
				if (!wheelComponents.TryGetValue(cachedWaterWheel, out (Rigidbody, Rigidbody) value))
				{
					Rigidbody component = ((Component)cachedWaterWheel).GetComponent<Rigidbody>();
					Rigidbody item = (((Object)(object)cachedWaterWheel.workAxel != (Object)null) ? ((Component)cachedWaterWheel.workAxel).GetComponent<Rigidbody>() : null);
					value = (component, item);
					wheelComponents[cachedWaterWheel] = value;
				}
				if ((Object)(object)value.Item1 == (Object)null)
				{
					continue;
				}
				if (!wheelBaseRotation.TryGetValue(value.Item1, out var value2))
				{
					value2 = ((Component)cachedWaterWheel).transform.rotation;
					wheelBaseRotation[value.Item1] = value2;
				}
				float num3 = Mathf.Sign(cachedWaterWheel.speed);
				float num4 = num2 * num3;
				Quaternion val = Quaternion.AngleAxis(num4, value2 * Vector3.right);
				Vector3 eulerAngles = ((Quaternion)(ref value2)).eulerAngles;
				Quaternion val2 = Quaternion.Euler(0f, eulerAngles.y, eulerAngles.z);
				Quaternion val3 = val * val2;
				value.Item1.MoveRotation(val3);
				if ((Object)(object)value.Item2 != (Object)null)
				{
					if (!wheelBaseRotation.TryGetValue(value.Item2, out var value3))
					{
						value3 = ((Component)cachedWaterWheel.workAxel).transform.rotation;
						wheelBaseRotation[value.Item2] = value3;
					}
					Vector3 eulerAngles2 = ((Quaternion)(ref value3)).eulerAngles;
					Quaternion val4 = Quaternion.Euler(num4, eulerAngles2.y, eulerAngles2.z);
					value.Item2.MoveRotation(val4);
				}
			}
		}

		public static void ReleaseCachedWheels()
		{
			foreach (WaterWheel cachedWaterWheel in cachedWaterWheels)
			{
				if ((Object)(object)cachedWaterWheel != (Object)null)
				{
					((Behaviour)cachedWaterWheel).enabled = true;
				}
			}
		}

		public static void ClearCachedWheels()
		{
			cachedWaterWheels.Clear();
			wheelBaseRotation.Clear();
			wheelComponents.Clear();
		}
	}
}
namespace BabyStepsMultiplayerClient.Networking.Steam
{
	internal static class NativeSteamAPI
	{
		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void NativeRunDelegate(IntPtr thisPtr, IntPtr pvParam);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void NativeRunExDelegate(IntPtr thisPtr, IntPtr pvParam, [MarshalAs(UnmanagedType.I1)] bool bFail, ulong hCall);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate int NativeGetSizeDelegate(IntPtr thisPtr);

		[StructLayout(LayoutKind.Explicit, Size = 16)]
		public struct LobbyCreated_t
		{
			[FieldOffset(0)]
			public int m_eResult;

			[FieldOffset(8)]
			public ulong m_ulSteamIDLobby;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		public struct LobbyMatchList_t
		{
			public uint m_nLobbiesMatching;
		}

		private const string Dll = "steam_api64";

		private const int k_EFriendFlagImmediate = 4;

		private static IntPtr _apps = IntPtr.Zero;

		private static IntPtr _net = IntPtr.Zero;

		private static IntPtr _mm = IntPtr.Zero;

		private static IntPtr _utils = IntPtr.Zero;

		private static IntPtr _user = IntPtr.Zero;

		private static IntPtr _friends = IntPtr.Zero;

		public const int k_LobbyCreated = 513;

		public const int k_LobbyMatchList = 510;

		private const int k_GameLobbyJoinRequested = 333;

		private static NativeRunDelegate _lobbyJoinRun;

		private static NativeRunExDelegate _lobbyJoinRunEx;

		private static NativeGetSizeDelegate _lobbyJoinGetSize;

		private static IntPtr _lobbyJoinVtable = IntPtr.Zero;

		private static IntPtr _lobbyJoinCallbackObj = IntPtr.Zero;

		private const int k_GameRichPresenceJoinRequested = 337;

		private static NativeRunDelegate _joinRun;

		private static NativeRunExDelegate _joinRunEx;

		private static NativeGetSizeDelegate _joinGetSize;

		private static IntPtr _joinVtable = IntPtr.Zero;

		private static IntPtr _joinCallbackObj = IntPtr.Zero;

		private const int k_P2PSessionRequest = 1202;

		private static NativeRunDelegate _p2pRun;

		private static NativeRunExDelegate _p2pRunEx;

		private static NativeGetSizeDelegate _p2pGetSize;

		private static IntPtr _p2pVtable = IntPtr.Zero;

		private static IntPtr _p2pCallbackObj = IntPtr.Zero;

		private static IntPtr Apps => (_apps != IntPtr.Zero) ? _apps : (_apps = SteamAPI_SteamApps_v008());

		private static IntPtr Net => (_net != IntPtr.Zero) ? _net : (_net = SteamAPI_SteamNetworking_v006());

		private static IntPtr MM => (_mm != IntPtr.Zero) ? _mm : (_mm = SteamAPI_SteamMatchmaking_v009());

		private static IntPtr Utils => (_utils != IntPtr.Zero) ? _utils : (_utils = SteamAPI_SteamUtils_v010());

		private static IntPtr User => (_user != IntPtr.Zero) ? _user : (_user = SteamAPI_SteamUser_v021());

		private static IntPtr Friends => (_friends != IntPtr.Zero) ? _friends : (_friends = SteamAPI_SteamFriends_v017());

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamNetworking_v006();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamMatchmaking_v009();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamUtils_v010();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamUser_v021();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamFriends_v017();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_RunCallbacks")]
		public static extern void RunCallbacks();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_SteamApps_v008();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern int SteamAPI_ISteamApps_GetLaunchCommandLine(IntPtr self, [Out] byte[] pchCommandLine, int cubCommandLine);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamNetworking_SendP2PPacket(IntPtr self, ulong steamIDRemote, [In] byte[] pubData, uint cubData, int eP2PSendType, int nChannel);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamNetworking_IsP2PPacketAvailable(IntPtr self, out uint pcubMsgSize, int nChannel);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamNetworking_ReadP2PPacket(IntPtr self, [Out] byte[] pubDest, uint cubDest, out uint pcubMsgSize, out ulong psteamIDRemote, int nChannel);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(IntPtr self, ulong steamIDRemote);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_CreateLobby(IntPtr self, int eLobbyType, int cMaxMembers);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamMatchmaking_SetLobbyData(IntPtr self, ulong steamIDLobby, [MarshalAs(UnmanagedType.LPStr)] string pchKey, [MarshalAs(UnmanagedType.LPStr)] string pchValue);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_ISteamMatchmaking_GetLobbyData(IntPtr self, ulong steamIDLobby, [MarshalAs(UnmanagedType.LPStr)] string pchKey);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamMatchmaking_LeaveLobby(IntPtr self, ulong steamIDLobby);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_GetLobbyOwner(IntPtr self, ulong steamIDLobby);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern int SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(IntPtr self, ulong steamIDLobby);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern void SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter(IntPtr self, [MarshalAs(UnmanagedType.LPStr)] string pchKeyToMatch, [MarshalAs(UnmanagedType.LPStr)] string pchValueToMatch, int eComparisonType);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern void SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter(IntPtr self, int eLobbyDistanceFilter);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamMatchmaking_SetLobbyJoinable(IntPtr self, ulong steamIDLobby, bool bLobbyJoinable);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_RequestLobbyList(IntPtr self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_GetLobbyByIndex(IntPtr self, int iLobby);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamUtils_IsAPICallCompleted(IntPtr self, ulong hSteamAPICall, out bool pbFailed);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamUtils_GetAPICallResult(IntPtr self, ulong hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, out bool pbFailed);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamUser_GetSteamID(IntPtr self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern int SteamAPI_ISteamFriends_GetFriendCount(IntPtr self, int iFriendFlags);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamFriends_GetFriendByIndex(IntPtr self, int iFriend, int iFriendFlags);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_ISteamFriends_GetPersonaName(IntPtr self);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern IntPtr SteamAPI_ISteamFriends_GetFriendPersonaName(IntPtr self, ulong steamIDFriend);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamFriends_InviteUserToGame(IntPtr self, ulong steamIDFriend, [MarshalAs(UnmanagedType.LPStr)] string pchConnectString);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern bool SteamAPI_ISteamMatchmaking_InviteUserToLobby(IntPtr self, ulong steamIDLobby, ulong steamIDInvitee);

		public static bool SendP2PPacket(ulong steamId, byte[] data, int sendType, int channel)
		{
			return SteamAPI_ISteamNetworking_SendP2PPacket(Net, steamId, data, (uint)data.Length, sendType, channel);
		}

		public static bool IsP2PPacketAvailable(out uint size, int channel)
		{
			return SteamAPI_ISteamNetworking_IsP2PPacketAvailable(Net, out size, channel);
		}

		public static bool ReadP2PPacket(byte[] buf, out uint bytesRead, out ulong from, int channel)
		{
			return SteamAPI_ISteamNetworking_ReadP2PPacket(Net, buf, (uint)buf.Length, out bytesRead, out from, channel);
		}

		public static void AcceptP2PSession(ulong steamId)
		{
			SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(Net, steamId);
		}

		public static ulong CreateLobby(int lobbyType = 2, int maxMembers = 16)
		{
			return SteamAPI_ISteamMatchmaking_CreateLobby(MM, lobbyType, maxMembers);
		}

		public static bool SetLobbyData(ulong lobbyId, string key, string value)
		{
			return SteamAPI_ISteamMatchmaking_SetLobbyData(MM, lobbyId, key, value);
		}

		public static string GetLobbyData(ulong lobbyId, string key)
		{
			IntPtr intPtr = SteamAPI_ISteamMatchmaking_GetLobbyData(MM, lobbyId, key);
			return (intPtr != IntPtr.Zero) ? (Marshal.PtrToStringAnsi(intPtr) ?? "") : "";
		}

		public static void LeaveLobby(ulong lobbyId)
		{
			SteamAPI_ISteamMatchmaking_LeaveLobby(MM, lobbyId);
		}

		public static ulong GetLobbyOwner(ulong lobbyId)
		{
			return SteamAPI_ISteamMatchmaking_GetLobbyOwner(MM, lobbyId);
		}

		public static int GetLobbyMemberCount(ulong lobbyId)
		{
			return SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(MM, lobbyId);
		}

		public static void AddLobbyFilter(string key, string value)
		{
			SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter(MM, key, value, 0);
		}

		public static void SetLobbyDistanceWorldwide()
		{
			SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter(MM, 3);
		}

		public static bool SetLobbyJoinable(ulong lobbyId, bool joinable)
		{
			return SteamAPI_ISteamMatchmaking_SetLobbyJoinable(MM, lobbyId, joinable);
		}

		public static ulong RequestLobbyList()
		{
			return SteamAPI_ISteamMatchmaking_RequestLobbyList(MM);
		}

		public static ulong GetLobbyByIndex(int index)
		{
			return SteamAPI_ISteamMatchmaking_GetLobbyByIndex(MM, index);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(IntPtr self, ulong steamIDLobby, int iMember);

		public static ulong GetLobbyMemberByIndex(ulong lobbyId, int index)
		{
			return SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(MM, lobbyId, index);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern ulong SteamAPI_ISteamMatchmaking_JoinLobby(IntPtr self, ulong steamIDLobby);

		public static ulong JoinLobby(ulong lobbyId)
		{
			return SteamAPI_ISteamMatchmaking_JoinLobby(MM, lobbyId);
		}

		public static bool IsAPICallCompleted(ulong handle, out bool failed)
		{
			return SteamAPI_ISteamUtils_IsAPICallCompleted(Utils, handle, out failed);
		}

		public unsafe static bool GetAPICallResult<T>(ulong handle, int callbackId, out T result) where T : unmanaged
		{
			result = default(T);
			fixed (T* ptr = &result)
			{
				bool pbFailed;
				return SteamAPI_ISteamUtils_GetAPICallResult(Utils, handle, (IntPtr)ptr, sizeof(T), callbackId, out pbFailed) && !pbFailed;
			}
		}

		public static ulong GetLocalSteamId()
		{
			return SteamAPI_ISteamUser_GetSteamID(User);
		}

		public static string GetPersonaName()
		{
			IntPtr intPtr = SteamAPI_ISteamFriends_GetPersonaName(Friends);
			return (intPtr != IntPtr.Zero) ? (Marshal.PtrToStringAnsi(intPtr) ?? "") : "";
		}

		public static bool InviteUserToGame(ulong steamId, string connectString = "")
		{
			return SteamAPI_ISteamFriends_InviteUserToGame(Friends, steamId, connectString);
		}

		public static bool InviteUserToLobby(ulong lobbyId, ulong friendSteamId)
		{
			return SteamAPI_ISteamMatchmaking_InviteUserToLobby(MM, lobbyId, friendSteamId);
		}

		public static string GetLaunchCommandLine()
		{
			byte[] array = new byte[512];
			SteamAPI_ISteamApps_GetLaunchCommandLine(Apps, array, array.Length);
			return Encoding.UTF8.GetString(array).TrimEnd('\0');
		}

		public static void RegisterLobbyJoinRequestedCallback(Action<ulong> onLobbyId)
		{
			if (_lobbyJoinCallbackObj != IntPtr.Zero)
			{
				return;
			}
			_lobbyJoinRun = delegate(IntPtr thisPtr, IntPtr pvParam)
			{
				if (!(pvParam == IntPtr.Zero))
				{
					ulong num = (ulong)Marshal.ReadInt64(pvParam);
					if (num != 0)
					{
						onLobbyId(num);
					}
				}
			};
			_lobbyJoinRunEx = delegate
			{
			};
			_lobbyJoinGetSize = (IntPtr thisPtr) => 16;
			_lobbyJoinVtable = Marshal.AllocHGlobal(24);
			Marshal.WriteIntPtr(_lobbyJoinVtable, 0, Marshal.GetFunctionPointerForDelegate(_lobbyJoinRun));
			Marshal.WriteIntPtr(_lobbyJoinVtable, 8, Marshal.GetFunctionPointerForDelegate(_lobbyJoinRunEx));
			Marshal.WriteIntPtr(_lobbyJoinVtable, 16, Marshal.GetFunctionPointerForDelegate(_lobbyJoinGetSize));
			_lobbyJoinCallbackObj = Marshal.AllocHGlobal(16);
			for (int i = 0; i < 16; i++)
			{
				Marshal.WriteByte(_lobbyJoinCallbackObj, i, 0);
			}
			Marshal.WriteIntPtr(_lobbyJoinCallbackObj, 0, _lobbyJoinVtable);
			Marshal.WriteInt32(_lobbyJoinCallbackObj, 12, 333);
			SteamAPI_RegisterCallback(_lobbyJoinCallbackObj, 333);
		}

		public static void RegisterJoinRequestedCallback(Action<string> onConnect)
		{
			if (_joinCallbackObj != IntPtr.Zero)
			{
				return;
			}
			_joinRun = delegate(IntPtr thisPtr, IntPtr pvParam)
			{
				if (!(pvParam == IntPtr.Zero))
				{
					string text = Marshal.PtrToStringAnsi(new IntPtr(pvParam.ToInt64() + 8)) ?? "";
					if (!string.IsNullOrWhiteSpace(text))
					{
						onConnect(text);
					}
				}
			};
			_joinRunEx = delegate
			{
			};
			_joinGetSize = (IntPtr thisPtr) => 264;
			_joinVtable = Marshal.AllocHGlobal(24);
			Marshal.WriteIntPtr(_joinVtable, 0, Marshal.GetFunctionPointerForDelegate(_joinRun));
			Marshal.WriteIntPtr(_joinVtable, 8, Marshal.GetFunctionPointerForDelegate(_joinRunEx));
			Marshal.WriteIntPtr(_joinVtable, 16, Marshal.GetFunctionPointerForDelegate(_joinGetSize));
			_joinCallbackObj = Marshal.AllocHGlobal(16);
			for (int i = 0; i < 16; i++)
			{
				Marshal.WriteByte(_joinCallbackObj, i, 0);
			}
			Marshal.WriteIntPtr(_joinCallbackObj, 0, _joinVtable);
			Marshal.WriteInt32(_joinCallbackObj, 12, 337);
			SteamAPI_RegisterCallback(_joinCallbackObj, 337);
		}

		public static string GetFriendPersonaName(ulong steamId)
		{
			IntPtr intPtr = SteamAPI_ISteamFriends_GetFriendPersonaName(Friends, steamId);
			return (intPtr != IntPtr.Zero) ? (Marshal.PtrToStringAnsi(intPtr) ?? "") : "";
		}

		public static int GetFriendCount()
		{
			return SteamAPI_ISteamFriends_GetFriendCount(Friends, 4);
		}

		public static ulong GetFriendByIndex(int index)
		{
			return SteamAPI_ISteamFriends_GetFriendByIndex(Friends, index, 4);
		}

		public static int PreAcceptFriends()
		{
			int num = SteamAPI_ISteamFriends_GetFriendCount(Friends, 4);
			if (num <= 0)
			{
				return 0;
			}
			for (int i = 0; i < num; i++)
			{
				ulong num2 = SteamAPI_ISteamFriends_GetFriendByIndex(Friends, i, 4);
				if (num2 != 0)
				{
					AcceptP2PSession(num2);
				}
			}
			return num;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern void SteamAPI_RegisterCallback(IntPtr pCallback, int nCallbackExpected);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		private static extern void SteamAPI_UnregisterCallback(IntPtr pCallback);

		public static void RegisterP2PSessionRequestCallback(Action<ulong> onRequest)
		{
			if (_p2pCallbackObj != IntPtr.Zero)
			{
				return;
			}
			_p2pRun = delegate(IntPtr thisPtr, IntPtr pvParam)
			{
				if (pvParam != IntPtr.Zero)
				{
					onRequest((ulong)Marshal.ReadInt64(pvParam));
				}
			};
			_p2pRunEx = delegate
			{
			};
			_p2pGetSize = (IntPtr thisPtr) => 8;
			_p2pVtable = Marshal.AllocHGlobal(24);
			Marshal.WriteIntPtr(_p2pVtable, 0, Marshal.GetFunctionPointerForDelegate(_p2pRun));
			Marshal.WriteIntPtr(_p2pVtable, 8, Marshal.GetFunctionPointerForDelegate(_p2pRunEx));
			Marshal.WriteIntPtr(_p2pVtable, 16, Marshal.GetFunctionPointerForDelegate(_p2pGetSize));
			_p2pCallbackObj = Marshal.AllocHGlobal(16);
			for (int i = 0; i < 16; i++)
			{
				Marshal.WriteByte(_p2pCallbackObj, i, 0);
			}
			Marshal.WriteIntPtr(_p2pCallbackObj, 0, _p2pVtable);
			Marshal.WriteInt32(_p2pCallbackObj, 12, 1202);
			SteamAPI_RegisterCallback(_p2pCallbackObj, 1202);
		}

		public static void UnregisterP2PSessionRequestCallback()
		{
			if (!(_p2pCallbackObj == IntPtr.Zero))
			{
				SteamAPI_UnregisterCallback(_p2pCallbackObj);
				Marshal.FreeHGlobal(_p2pCallbackObj);
				Marshal.FreeHGlobal(_p2pVtable);
				_p2pCallbackObj = IntPtr.Zero;
				_p2pVtable = IntPtr.Zero;
			}
		}
	}
	public sealed class BBSSteamClientTransport : SteamClientTransport
	{
		private const int Channel = 113;

		private const byte AuthByte = 253;

		private ulong _hostId = 0uL;

		private bool _connected = false;

		private long _connectTimeMs = 0L;

		private bool _receivedFirstPacket = false;

		public override bool IsConnected => _connected;

		public override event Action? Connected;

		public override event Action<string>? Disconnected;

		public override event Action<byte[]>? PacketReceived;

		public override void Connect(string address, int port, string connectionKey)
		{
			if (!ulong.TryParse(address, out _hostId) || _hostId == 0)
			{
				Core.logger.Error("[Steam Client] Invalid or zero host SteamID64: '" + address + "'");
				return;
			}
			NativeSteamAPI.AcceptP2PSession(_hostId);
			NativeSteamAPI.SendP2PPacket(_hostId, new byte[1] { 255 }, 0, 113);
			byte[] bytes = Encoding.UTF8.GetBytes(connectionKey);
			byte[] array = new byte[1 + bytes.Length];
			array[0] = 253;
			Buffer.BlockCopy(bytes, 0, array, 1, bytes.Length);
			NativeSteamAPI.SendP2PPacket(_hostId, array, 2, 113);
			_connectTimeMs = Environment.TickCount64;
			_connected = true;
			this.Connected?.Invoke();
		}

		public override void Disconnect()
		{
			if (_connected)
			{
				NativeSteamAPI.SendP2PPacket(_hostId, new byte[1] { 254 }, 2, 113);
				_connected = false;
				_hostId = 0uL;
				_receivedFirstPacket = false;
				this.Disconnected?.Invoke("Disconnected");
			}
		}

		public override void Poll()
		{
			if (!_connected)
			{
				return;
			}
			uint size;
			while (NativeSteamAPI.IsP2PPacketAvailable(out size, 113))
			{
				byte[] array = new byte[size];
				if (!NativeSteamAPI.ReadP2PPacket(array, out var _, out var from, 113))
				{
					continue;
				}
				if (from != _hostId)
				{
					Core.logger.Msg($"[Steam Client] Dropping packet from unexpected SteamID={from} (expected {_hostId})");
					continue;
				}
				if (!_receivedFirstPacket)
				{
					_receivedFirstPacket = true;
				}
				NativeSteamAPI.AcceptP2PSession(_hostId);
				if (array.Length == 1 && array[0] == 254)
				{
					long num = Environment.TickCount64 - _connectTimeMs;
					if (num >= 500)
					{
						Core.logger.Msg("[Steam Client] Server sent graceful disconnect");
						_connected = false;
						_hostId = 0uL;
						_receivedFirstPacket = false;
						this.Disconnected?.Invoke("Server disconnected");
						break;
					}
					Core.logger.Msg($"[Steam Client] Discarding stale 0xFE ({num}ms after connect — previous session residue)");
				}
				else
				{
					if (array.Length == 1 && array[0] == 252)
					{
						long value = Environment.TickCount64 - _connectTimeMs;
						Core.logger.Msg($"[Steam Client] Connection rejected by server ({value}ms after connect)");
						_connected = false;
						_hostId = 0uL;
						_receivedFirstPacket = false;
						this.Disconnected?.Invoke("Wrong password");
						break;
					}
					this.PacketReceived?.Invoke(array);
				}
			}
		}

		public override void Send(byte[] payload, PacketDelivery delivery)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (_connected)
			{
				NativeSteamAPI.SendP2PPacket(_hostId, payload, ToSendType(delivery), 113);
			}
		}

		private static int ToSendType(PacketDelivery d)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ((int)d != 0) ? 2 : 0;
		}
	}
	public sealed class SteamLobbyBrowser : SteamLobbyBrowserSource
	{
		private ulong _pendingCall = 0uL;

		public override event Action<IReadOnlyList<ServerInfo>>? ServersFound;

		public override void Refresh()
		{
			NativeSteamAPI.AddLobbyFilter("bbs_game", "1");
			NativeSteamAPI.SetLobbyDistanceWorldwide();
			_pendingCall = NativeSteamAPI.RequestLobbyList();
			Core.logger.Msg($"[Steam Browser] RequestLobbyList fired, handle={_pendingCall}");
		}

		public void Poll()
		{
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Expected O, but got Unknown
			if (_pendingCall == 0 || !NativeSteamAPI.IsAPICallCompleted(_pendingCall, out var failed))
			{
				return;
			}
			ulong pendingCall = _pendingCall;
			_pendingCall = 0uL;
			Core.logger.Msg($"[Steam Browser] LobbyList call completed. handle={pendingCall} failed={failed}");
			if (failed)
			{
				Core.logger.Msg("[Steam Browser] Call failed.");
				this.ServersFound?.Invoke(Array.Empty<ServerInfo>());
				return;
			}
			if (!NativeSteamAPI.GetAPICallResult<NativeSteamAPI.LobbyMatchList_t>(pendingCall, 510, out var result))
			{
				Core.logger.Msg("[Steam Browser] GetAPICallResult returned false.");
				this.ServersFound?.Invoke(Array.Empty<ServerInfo>());
				return;
			}
			Core.logger.Msg($"[Steam Browser] m_nLobbiesMatching={result.m_nLobbiesMatching}");
			List<ServerInfo> list = new List<ServerInfo>((int)result.m_nLobbiesMatching);
			for (int i = 0; i < (int)result.m_nLobbiesMatching; i++)
			{
				ulong lobbyByIndex = NativeSteamAPI.GetLobbyByIndex(i);
				Core.logger.Msg($"[Steam Browser] lobby[{i}] id={lobbyByIndex}");
				if (lobbyByIndex != 0)
				{
					string lobbyData = NativeSteamAPI.GetLobbyData(lobbyByIndex, "bbs_game");
					string text = NativeSteamAPI.GetLobbyData(lobbyByIndex, "bbs_name");
					string text2 = NativeSteamAPI.GetLobbyData(lobbyByIndex, "bbs_host");
					bool flag = NativeSteamAPI.GetLobbyData(lobbyByIndex, "bbs_locked") == "1";
					Core.logger.Msg($"[Steam Browser]   bbs_game='{lobbyData}' bbs_name='{text}' bbs_host='{text2}' locked={flag}");
					if (string.IsNullOrEmpty(text))
					{
						text = $"Game {lobbyByIndex}";
					}
					if (string.IsNullOrEmpty(text2) || text2 == "0")
					{
						text2 = NativeSteamAPI.GetLobbyOwner(lobbyByIndex).ToString();
						Core.logger.Msg("[Steam Browser]   bbs_host missing, using GetLobbyOwner: " + text2);
					}
					if (!ulong.TryParse(text2, out var result2) || result2 == 0)
					{
						Core.logger.Warning($"[Steam Browser]   Could not resolve host SteamID for lobby {lobbyByIndex}, skipping");
						continue;
					}
					int.TryParse(NativeSteamAPI.GetLobbyData(lobbyByIndex, "bbs_players"), out var result3);
					list.Add(new ServerInfo
					{
						Name = (flag ? "\ud83d\udd12 " : "") + text,
						Address = result2.ToString(),
						SessionId = lobbyByIndex.ToString(),
						PlayerCount = result3,
						MaxPlayers = 16,
						Type = (ServerType)1,
						IsPasswordProtected = flag
					});
				}
			}
			this.ServersFound?.Invoke(list);
		}
	}
	public static class SteamP2PTest
	{
		private static bool _listening = false;

		private static readonly int[] ScanChannels = Enumerable.Range(0, 11).Append(50).Append(100)
			.Append(113)
			.Append(200)
			.Append(255)
			.ToArray();

		public static bool IsListening => _listening;

		public static void StartListening()
		{
			_listening = true;
			Core.logger.Msg("[P2PTest] Listening mode ON — scanning channels: " + string.Join(", ", ScanChannels));
		}

		public static void StopListening()
		{
			_listening = false;
			Core.logger.Msg("[P2PTest] Listening mode OFF");
		}

		public static void SendPing(ulong targetId)
		{
			if (targetId == 0)
			{
				Core.logger.Warning("[P2PTest] No target SteamID set");
				return;
			}
			Core.logger.Msg($"[P2PTest] Sending ping to SteamID={targetId} on {ScanChannels.Length} channels");
			int[] scanChannels = ScanChannels;
			foreach (int num in scanChannels)
			{
				if (!NativeSteamAPI.SendP2PPacket(targetId, new byte[2]
				{
					187,
					(byte)((uint)num & 0xFFu)
				}, 0, num))
				{
					Core.logger.Msg($"[P2PTest]   channel {num}: SendP2PPacket returned false");
				}
			}
			Core.logger.Msg("[P2PTest] All pings sent");
		}

		public static void Poll()
		{
			if (!_listening)
			{
				return;
			}
			int[] scanChannels = ScanChannels;
			foreach (int num in scanChannels)
			{
				if (!NativeSteamAPI.IsP2PPacketAvailable(out var size, num))
				{
					continue;
				}
				byte[] array = new byte[size];
				if (NativeSteamAPI.ReadP2PPacket(array, out var _, out var from, num))
				{
					string value = string.Join(" ", array.Select((byte b) => $"{b:X2}"));
					Core.logger.Msg($"[P2PTest] *** PACKET RECEIVED *** channel={num} from={from} len={size} bytes=[{value}]");
					NativeSteamAPI.AcceptP2PSession(from);
				}
			}
		}
	}
	public sealed class BBSSteamServerTransport : SteamServerTransport
	{
		private const int Channel = 113;

		private const byte AuthByte = 253;

		private readonly Dictionary<ulong, int> _steamToId = new Dictionary<ulong, int>();

		private readonly Dictionary<int, ulong> _idToSteam = new Dictionary<int, ulong>();

		private readonly HashSet<int> _authed = new HashSet<int>();

		private readonly Dictionary<int, double> _lastHeard = new Dictionary<int, double>();

		private const double TimeoutMs = 15000.0;

		private int _nextId = 0;

		private bool _facepunchReady = false;

		private string _key = string.Empty;

		private string _inviteKey = string.Empty;

		private bool _running = false;

		private ulong _lobbyId = 0uL;

		private ulong _pendingLobbyCall = 0uL;

		private ulong _localSteamId = 0uL;

		private long _lastPlayerCountTick = 0L;

		public Func<int>? TotalPlayerCountProvider { get; set; }

		public bool IsPasswordProtected { get; set; }

		public override IEnumerable<int> ConnectedPeerIds => _authed;

		public override bool IsRunning => _running;

		public override event Action<int>? PeerConnected;

		public override event Action<int, string>? PeerDisconnected;

		public override event Action<int, byte[]>? PacketReceived;

		public override void StartListening(int port, string connectionKey)
		{
			_key = connectionKey;
			_running = true;
			_localSteamId = NativeSteamAPI.GetLocalSteamId();
			try
			{
				SteamClient.Init(0u, false);
				_facepunchReady = true;
				Core.logger.Msg("[Steam Server] Facepunch full init OK");
			}
			catch (Exception ex) when (ex.Message.Contains("SteamAPI_SteamInput") || ex.Message.Contains("entry point") || ex.Message.Contains("SteamInput"))
			{
				_facepunchReady = true;
				Core.logger.Msg("[Steam Server] Facepunch partial init (SteamInput unavailable — benign): " + ex.Message);
			}
			catch (Exception ex2) when (ex2.Message.Contains("already initialized"))
			{
				_facepunchReady = true;
				Core.logger.Msg("[Steam Server] Facepunch already initialized — reusing existing instance");
			}
			catch (Exception ex3)
			{
				Core.logger.Warning("[Steam Server] Facepunch init failed: " + ex3.Message);
			}
			int value = NativeSteamAPI.PreAcceptFriends();
			Core.logger.Msg($"[Steam Server] Pre-accepted P2P sessions for {value} Steam friends");
			NativeSteamAPI.RegisterP2PSessionRequestCallback(delegate(ulong sid)
			{
				Core.logger.Msg($"[Steam Server] P2PSessionRequest from {sid} (native) — accepting");
				NativeSteamAPI.AcceptP2PSession(sid);
			});
			Core.logger.Msg("[Steam Server] P2PSessionRequest native callback registered");
			if (_facepunchReady)
			{
				try
				{
					SteamNetworking.OnP2PSessionRequest = (Action<SteamId>)Delegate.Combine(SteamNetworking.OnP2PSessionRequest, (Action<SteamId>)delegate(SteamId sid)
					{
						//IL_001f: 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)
						Core.logger.Msg($"[Steam Server] P2PSessionRequest from {sid.Value} (Facepunch) — accepting");
						NativeSteamAPI.AcceptP2PSession(sid.Value);
					});
					Core.logger.Msg("[Steam Server] OnP2PSessionRequest hooked via Facepunch");
				}
				catch (Exception ex4)
				{
					Core.logger.Msg("[Steam Server] Facepunch OnP2PSessionRequest hook skipped: " + ex4.Message);
				}
				try
				{
					SteamMatchmaking.OnLobbyMemberJoined += delegate(Lobby lobby, Friend member)
					{
						//IL_0003: 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_001f: Unknown result type (might be due to invalid IL or missing references)
						if (SteamId.op_Implicit(((Lobby)(ref lobby)).Id) == _lobbyId)
						{
							ulong value2 = member.Id.Value;
							if (value2 != _localSteamId)
							{
								Core.logger.Msg($"[Steam Server] Lobby member joined: {value2} — pre-accepting P2P session");
								NativeSteamAPI.AcceptP2PSession(value2);
							}
						}
					};
					Core.logger.Msg("[Steam Server] OnLobbyMemberJoined hooked");
				}
				catch (Exception ex5)
				{
					Core.logger.Msg("[Steam Server] Facepunch OnLobbyMemberJoined hook skipped: " + ex5.Message);
				}
			}
			_pendingLobbyCall = NativeSteamAPI.CreateLobby();
		}

		public override void Stop()
		{
			if (!_running)
			{
				return;
			}
			_running = false;
			NativeSteamAPI.UnregisterP2PSessionRequestCallback();
			byte[] data = new byte[1] { 254 };
			foreach (var (item, steamId) in _idToSteam)
			{
				if (_authed.Contains(item))
				{
					NativeSteamAPI.SendP2PPacket(steamId, data, 2, 113);
				}
			}
			if (_lobbyId != 0)
			{
				NativeSteamAPI.LeaveLobby(_lobbyId);
			}
			_lobbyId = 0uL;
			_pendingLobbyCall = 0uL;
			_inviteKey = string.Empty;
			_steamToId.Clear();
			_idToSteam.Clear();
			_authed.Clear();
		}

		public override void Poll()
		{
			if (!_running)
			{
				return;
			}
			long tickCount = Environment.TickCount64;
			if (_pendingLobbyCall != 0L && _lobbyId == 0 && NativeSteamAPI.IsAPICallCompleted(_pendingLobbyCall, out var failed))
			{
				Core.logger.Msg($"[Steam] Lobby creation call completed. failed={failed}");
				if (!failed && NativeSteamAPI.GetAPICallResult<NativeSteamAPI.LobbyCreated_t>(_pendingLobbyCall, 513, out var result))
				{
					Core.logger.Msg($"[Steam] LobbyCreated_t: eResult={result.m_eResult} lobbyId={result.m_ulSteamIDLobby}");
					if (result.m_eResult == 1)
					{
						_lobbyId = result.m_ulSteamIDLobby;
						string personaName = NativeSteamAPI.GetPersonaName();
						string value = (string.IsNullOrEmpty(personaName) ? $"Game {_lobbyId}" : (personaName + "'s Session"));
						_inviteKey = Guid.NewGuid().ToString("N").Substring(0, 8);
						bool flag = NativeSteamAPI.SetLobbyJoinable(_lobbyId, joinable: true);
						bool flag2 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_game", "1");
						bool flag3 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_players", "1");
						bool flag4 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_name", value);
						bool flag5 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_host", _localSteamId.ToString());
						bool flag6 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_locked", IsPasswordProtected ? "1" : "0");
						bool flag7 = NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_invite_key", _inviteKey);
						Core.logger.Msg($"[Steam] Lobby ready: '{value}' locked={IsPasswordProtected}");
						string lobbyData = NativeSteamAPI.GetLobbyData(_lobbyId, "bbs_game");
						Core.logger.Msg("[Steam] Verify GetLobbyData(bbs_game)='" + lobbyData + "'");
						((SteamServerTransport)this).OnLobbyCreated(_lobbyId.ToString());
					}
				}
				else if (!failed)
				{
					Core.logger.Msg("[Steam] GetAPICallResult returned false for LobbyCreated");
				}
				_pendingLobbyCall = 0uL;
			}
			if (_lobbyId != 0L && tickCount - _lastPlayerCountTick >= 2000)
			{
				_lastPlayerCountTick = tickCount;
				UpdateLobbyPlayerCount();
			}
			if (_facepunchReady)
			{
				try
				{
					SteamClient.RunCallbacks();
				}
				catch
				{
				}
			}
			DrainChannel(113);
			for (int i = 0; i <= 10; i++)
			{
				if (i != 113)
				{
					DrainChannel(i);
				}
			}
			double num = Environment.TickCount64;
			KeyValuePair<int, double>[] array = _lastHeard.ToArray();
			for (int j = 0; j < array.Length; j++)
			{
				KeyValuePair<int, double> keyValuePair = array[j];
				var (num4, num5) = (KeyValuePair<int, double>)(ref keyValuePair);
				if (_authed.Contains(num4) && num - num5 >= 15000.0)
				{
					Core.logger.Msg($"[Steam Server] Peer {num4} timed out, disconnecting");
					((SteamServerTransport)this).Kick(num4, "Timeout");
					_lastHeard.Remove(num4);
				}
			}
		}

		private void DrainChannel(int ch)
		{
			uint size;
			while (NativeSteamAPI.IsP2PPacketAvailable(out size, ch))
			{
				byte[] array = new byte[size];
				if (NativeSteamAPI.ReadP2PPacket(array, out var _, out var from, ch))
				{
					if (ch != 113)
					{
						Core.logger.Msg($"[Steam Server] Packet on alternate channel {ch} from {from} len={size} — expected channel {113}");
					}
					HandleIncoming(from, array);
				}
			}
		}

		public override void Send(int peerId, byte[] payload, PacketDelivery delivery)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (_idToSteam.TryGetValue(peerId, out var value))
			{
				NativeSteamAPI.SendP2PPacket(value, payload, ToSendType(delivery), 113);
			}
		}

		public override void Broadcast(byte[] payload, PacketDelivery delivery, int excludePeerId = -1)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			int sendType = ToSendType(delivery);
			foreach (var (num3, steamId) in _idToSteam)
			{
				if (num3 != excludePeerId && _authed.Contains(num3))
				{
					NativeSteamAPI.SendP2PPacket(steamId, payload, sendType, 113);
				}
			}
		}

		public override void Kick(int peerId, string reason = "")
		{
			if (_idToSteam.TryGetValue(peerId, out var value))
			{
				_idToSteam.Remove(peerId);
				_steamToId.Remove(value);
				_authed.Remove(peerId);
				_lastHeard.Remove(peerId);
				this.PeerDisconnected?.Invoke(peerId, reason);
				UpdateLobbyPlayerCount();
			}
		}

		private void HandleIncoming(ulong from, byte[] data)
		{
			if (from == _localSteamId)
			{
				return;
			}
			NativeSteamAPI.AcceptP2PSession(from);
			if (!_steamToId.TryGetValue(from, out var value))
			{
				value = _nextId++;
				_steamToId[from] = value;
				_idToSteam[value] = from;
				Core.logger.Msg($"[Steam Server] New peer SteamID={from} assigned localId={value}");
			}
			if (!_authed.Contains(value))
			{
				if (data.Length < 2 || data[0] != 253)
				{
					return;
				}
				string @string = Encoding.UTF8.GetString(data, 1, data.Length - 1);
				bool flag = !string.IsNullOrEmpty(_inviteKey) && @string == "108" + _inviteKey;
				Core.logger.Msg($"[Steam Server] Auth from {from}: keyMatchesPassword={@string == _key} inviteAuth={flag} keyLen={@string.Length} expectedLen={_key.Length}");
				if (@string != _key && !flag)
				{
					Core.logger.Msg($"[Steam Server] Auth FAILED (wrong password) from SteamID={from}");
					NativeSteamAPI.SendP2PPacket(from, new byte[1] { 252 }, 2, 113);
					_steamToId.Remove(from);
					_idToSteam.Remove(value);
					return;
				}
				Core.logger.Msg($"[Steam Server] Auth OK for localId={value} (invite={flag}), firing PeerConnected");
				_authed.Add(value);
				_lastHeard[value] = Environment.TickCount64;
				if (_lobbyId != 0)
				{
					NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_invite_" + from, "0");
				}
				this.PeerConnected?.Invoke(value);
				UpdateLobbyPlayerCount();
				return;
			}
			_lastHeard[value] = Environment.TickCount64;
			if (data.Length == 1 && data[0] == 254)
			{
				Core.logger.Msg($"[Steam Server] Peer {value} sent graceful disconnect");
				((SteamServerTransport)this).Kick(value, "Client disconnected");
				_lastHeard.Remove(value);
			}
			else if (data.Length >= 2 && data[0] == 253)
			{
				Core.logger.Msg($"[Steam Server] Peer {value} reconnecting — resetting auth state");
				_authed.Remove(value);
				this.PeerDisconnected?.Invoke(value, "Reconnect");
				string string2 = Encoding.UTF8.GetString(data, 1, data.Length - 1);
				bool flag2 = !string.IsNullOrEmpty(_inviteKey) && string2 == "108" + _inviteKey;
				if (!(string2 != _key) || flag2)
				{
					_authed.Add(value);
					_lastHeard[value] = Environment.TickCount64;
					this.PeerConnected?.Invoke(value);
					UpdateLobbyPlayerCount();
				}
			}
			else
			{
				this.PacketReceived?.Invoke(value, data);
			}
		}

		private void UpdateLobbyPlayerCount()
		{
			if (_lobbyId != 0)
			{
				int val = ((TotalPlayerCountProvider != null) ? TotalPlayerCountProvider() : _authed.Count);
				val = Math.Max(1, val);
				NativeSteamAPI.SetLobbyData(_lobbyId, "bbs_players", val.ToString());
			}
		}

		private static int ToSendType(PacketDelivery d)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ((int)d != 0) ? 2 : 0;
		}
	}
}
namespace BabyStepsMultiplayerClient.Localization
{
	public enum GameLanguage
	{
		English,
		Spanish,
		French,
		German,
		Japanese,
		Korean,
		ChineseSimplified,
		ChineseTraditional
	}
	public static class LanguageManager
	{
		private static readonly Dictionary<string, Language> _nameToEnum = new Dictionary<string, Language>
		{
			{
				"English",
				(Language)0
			},
			{
				"Spanish",
				(Language)1
			},
			{
				"French",
				(Language)2
			},
			{
				"German",
				(Language)3
			},
			{
				"Japanese",
				(Language)4
			},
			{
				"Korean",
				(Language)7
			},
			{
				"Chinese Simplified",
				(Language)5
			},
			{
				"Chinese Traditional",
				(Language)6
			},
			{
				"Russian",
				(Language)8
			},
			{
				"Portuguese",
				(Language)9
			}
		};

		private static readonly Dictionary<Language, string> _enumToName = new Dictionary<Language, string>
		{
			{
				(Language)0,
				"English"
			},
			{
				(Language)1,
				"Spanish"
			},
			{
				(Language)2,
				"French"
			},
			{
				(Language)3,
				"German"
			},
			{
				(Language)4,
				"Japanese"
			},
			{
				(Language)7,
				"Korean"
			},
			{
				(Language)5,
				"Chinese Simplified"
			},
			{
				(Language)6,
				"Chinese Traditional"
			},
			{
				(Language)8,
				"Russian"
			},
			{
				(Language)9,
				"Portuguese"
			}
		};

		private static readonly Dictionary<string, ILanguage> _languages = new Dictionary<string, ILanguage>
		{
			{
				"English",
				new EnglishLanguage()
			},
			{
				"Spanish",
				new SpanishLanguage()
			},
			{
				"French",
				new FrenchLanguage()
			},
			{
				"German",
				new GermanLanguage()
			},
			{
				"Japanese",
				new JapaneseLanguage()
			},
			{
				"Korean",
				new KoreanLanguage()
			},
			{
				"Chinese Simplified",
				new ChineseSimplifiedLanguage()
			},
			{
				"Chinese Traditional",
				new ChineseTraditionalLanguage()
			},
			{
				"Russian",
				new RussianLanguage()
			},
			{
				"Portuguese",
				new PortugueseLanguage()
			}
		};

		public static string CurrentLanguage
		{
			get
			{
				//IL_0016: 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
				{
					MenuCfg cfg = Menu.cfg;
					Language? val = ((cfg != null) ? new Language?(cfg.language) : null);
					if (val.HasValue && _enumToName.TryGetValue(val.Value, out var value))
					{
						return value;
					}
				}
				catch
				{
				}
				return "English";
			}
		}

		public static ILanguage GetCurrentLanguage()
		{
			string currentLanguage = CurrentLanguage;
			ILanguage value;
			return _languages.TryGetValue(currentLanguage, out value) ? value : _languages["English"];
		}

		public static void SetLanguage(string languageName)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_nameToEnum.TryGetValue(languageName, out var value))
				{
					Menu me = Menu.me;
					if (me != null)
					{
						me.SetLang(value);
					}
				}
			}
			catch (Exception value2)
			{
				Instance logger = Core.logger;
				if (logger != null)
				{
					logger.Warning($"[LanguageManager] SetLanguage failed: {value2}");
				}
			}
		}

		public static string[] GetAvailableLanguages()
		{
			return new string[10] { "English", "Spanish", "French", "German", "Japanese", "Korean", "Chinese Simplified", "Chinese Traditional", "Russian", "Portuguese" };
		}
	}
	public interface ILanguage
	{
		string MultiplayerTitle { get; }

		string Enter { get; }

		string PasswordForSession { get; }

		string TabLobby { get; }

		string TabPlayer { get; }

		string TabGeneral { get; }

		string TabAudio { get; }

		string TabLAN { get; }

		string ButtonBack { get; }

		string HostLobby { get; }

		string StopHosting { get; }

		string LobbyBrowser { get; }

		string Refresh { get; }

		string Refreshing { get; }

		string LobbyPassword { get; }

		string HostLAN { get; }

		string ServerIP { get; }

		string ServerPort { get; }

		string PasswordOptional { get; }

		string Disconnect { get; }

		string Connect { get; }

		string DisableMicrophone { get; }

		string EnableMicrophone { get; }

		string Deafen { get; }

		string Undeafen { get; }

		string EnablePushToTalk { get; }

		string DisablePushToTalk { get; }

		string PushToTalkKey { get; }

		string MicrophoneGain { get; }

		string AudioDevice { get; }

		string NoDevicesFound { get; }

		string EnableCollisions { get; }

		string DisableCollisions { get; }

		string EnablePlayerCutsceneVisibility { get; }

		string DisablePlayerCutsceneVisibility { get; }

		string EnableNametags { get; }

		string DisableNametags { get; }

		string PlayerListKeyLabel { get; }

		string ChatMenuKeyLabel { get; }

		string UpdateNameAndAppearance { get; }

		string Nickname { get; }

		string PressAnyKey { get; }

		string Language { get; }

		string Level { get; }

		string ConnectedPlayers { get; }

		string NoPlayersConnected { get; }

		string You { get; }

		string ConnectedToServer { get; }

		string AppearanceUpdated { get; }

		string JoiningServer { get; }

		string CreatingLobby { get; }

		string StoppedHosting { get; }

		string HostingOnPort { get; }

		string PlayerJoinedSession { get; }

		string PlayerLeftSession { get; }

		string HasConnected { get; }

		string HasDisconnected { get; }

		string HasChangedNicknameTo { get; }

		string HasUpdatedTheirColor { get; }

		string ServerInformation { get; }

		string AudioSettings { get; }

		string MicrophoneDevices { get; }

		string GeneralSettings { get; }

		string PlayerCustomization { get; }

		string SuitTint { get; }

		string Red { get; }

		string Green { get; }

		string Blue { get; }
	}
	public class EnglishLanguage : ILanguage
	{
		public string MultiplayerTitle => "Multiplayer";

		public string Enter => "Enter";

		public string PasswordForSession => "Enter password for:\n{0}";

		public string TabLobby => "LOBBY";

		public string TabPlayer => "Player";

		public string TabGeneral => "General";

		public string TabAudio => "Audio";

		public string TabLAN => "LAN";

		public string ButtonBack => "Back";

		public string HostLobby => "Host Lobby";

		public string StopHosting => "Stop Hosting";

		public string LobbyBrowser => "Lobby Browser";

		public string Refresh => "Refresh";

		public string Refreshing => "Refreshing…";

		public string LobbyPassword => "Lobby password (blank = public)";

		public string HostLAN => "Host (LAN)";

		public string ServerIP => "Server IP:";

		public string ServerPort => "Server Port:";

		public string PasswordOptional => "Password (Optional):";

		public string Disconnect => "Disconnect";

		public string Connect => "Connect";

		public string DisableMicrophone => "Disable Microphone";

		public string EnableMicrophone => "Enable Microphone";

		public string Deafen => "Deafen";

		public string Undeafen => "Undeafen";

		public string EnablePushToTalk => "Enable Push to Talk";

		public string DisablePushToTalk => "Disable Push to Talk";

		public string PushToTalkKey => "Push to Talk Key:";

		public string MicrophoneGain => "Microphone Gain:";

		public string AudioDevice => "Audio Device:";

		public string NoDevicesFound => "No devices found";

		public string EnableCollisions => "Enable Collisions";

		public string DisableCollisions => "Disable Collisions";

		public string EnablePlayerCutsceneVisibility => "Enable Player Cutscene Visibility";

		public string DisablePlayerCutsceneVisibility => "Disable Player Cutscene Visibility";

		public string EnableNametags => "Enable Nametag Visibility";

		public string DisableNametags => "Disable Nametag Visibility";

		public string PlayerListKeyLabel => "Player List Key:";

		public string ChatMenuKeyLabel => "Chat Menu Key:";

		public string UpdateNameAndAppearance => "Update Name & Appearance";

		public string Nickname => "Nickname:";

		public string PressAnyKey => "Press any key…";

		public string Language => "Language:";

		public string Level => "Level:";

		public string ConnectedPlayers => "Connected Players";

		public string NoPlayersConnected => "No players connected.";

		public string You => "You";

		public string ConnectedToServer => "Connected to server";

		public string AppearanceUpdated => "Your appearance has been updated";

		public string JoiningServer => "Joining {0}…";

		public string CreatingLobby => "Creating Steam lobby…";

		public string StoppedHosting => "Stopped hosting";

		public string HostingOnPort => "Hosting on port {0}";

		public string PlayerJoinedSession => "{0} joined your session";

		public string PlayerLeftSession => "{0} left your session";

		public string HasConnected => "{0} has connected";

		public string HasDisconnected => "{0} has disconnected";

		public string HasChangedNicknameTo => "{0} has changed their nickname to {1}";

		public string HasUpdatedTheirColor => "{0} has updated their color";

		public string ServerInformation => "Server Information";

		public string AudioSettings => "Audio Settings";

		public string MicrophoneDevices => "Microphone Devices";

		public string GeneralSettings => "General Settings";

		public string PlayerCustomization => "Player Customization";

		public string SuitTint => "Suit Tint:";

		public string Red => "Red:";

		public string Green => "Green:";

		public string Blue => "Blue:";
	}
	public class SpanishLanguage : ILanguage
	{
		public string MultiplayerTitle => "Multijugador";

		public string Enter => "Aceptar";

		public string PasswordForSession => "Contraseña para:\n{0}";

		public string TabLobby => "SALA";

		public string TabPlayer => "Jugador";

		public string TabGeneral => "General";

		public string TabAudio => "Audio";

		public string TabLAN => "LAN";

		public string ButtonBack => "Atrás";

		public string HostLobby => "Crear sala";

		public string StopHosting => "Detener";

		public string LobbyBrowser => "Explorador";

		public string Refresh => "Actualizar";

		public string Refreshing => "Actualizando…";

		public string LobbyPassword => "Contraseña de sala (vacío = pública)";

		public string HostLAN => "Alojar (LAN)";

		public string ServerIP => "IP del servidor:";

		public string ServerPort => "Puerto:";

		public string PasswordOptional => "Contraseña (opcional):";

		public string Disconnect => "Desconectar";

		public string Connect => "Conectar";

		public string DisableMicrophone => "Desactivar micrófono";

		public string EnableMicrophone => "Activar micrófono";

		public string Deafen => "Ensordecer";

		public string Undeafen => "Quitar ensordecer";

		public string EnablePushToTalk => "Activar pulsar para hablar";

		public string DisablePushToTalk => "Desactivar pulsar para hablar";

		public string PushToTalkKey => "Tecla para hablar:";

		public string MicrophoneGain => "Ganancia:";

		public string AudioDevice => "Dispositivo de audio:";

		public string NoDevicesFound => "No se encontraron dispositivos";

		public string EnableCollisions => "Activar colisiones";

		public string DisableCollisions => "Desactivar colisiones";

		public string EnablePlayerCutsceneVisibility => "Mostrar jugador en cinemáticas";

		public string DisablePlayerCutsceneVisibility => "Ocultar jugador en cinemáticas";

		public string EnableNametags => "Mostrar nombres";

		public string DisableNametags => "Ocultar nombres";

		public string PlayerListKeyLabel => "Tecla lista:";

		public string ChatMenuKeyLabel => "Tecla chat:";

		public string UpdateNameAndAppearance => "Actualizar nombre y apariencia";

		public string Nickname => "Apodo:";

		public string PressAnyKey => "Pulsa una tecla…";

		public string Language => "Idioma:";

		public string Level => "Nivel:";

		public string ConnectedPlayers => "Jugadores conectados";

		public string NoPlayersConnected => "No hay jugadores conectados.";

		public string You => "Tú";

		public string ConnectedToServer => "Conectado al servidor";

		public string AppearanceUpdated => "Tu apariencia se ha actualizado";

		public string JoiningServer => "Uniéndose a {0}…";

		public string CreatingLobby => "Creando sala de Steam…";

		public string StoppedHosting => "Se dejó de alojar";

		public string HostingOnPort => "Alojando en puerto {0}";

		public string PlayerJoinedSession => "{0} se unió a tu sesión";

		public string PlayerLeftSession => "{0} abandonó tu sesión";

		public string HasConnected => "{0} se ha conectado";

		public string HasDisconnected => "{0} se ha desconectado";

		public string HasChangedNicknameTo => "{0} cambió su apodo a {1}";

		public string HasUpdatedTheirColor => "{0} actualizó su color";

		public string ServerInformation => "Información del servidor";

		public string AudioSettings => "Ajustes de audio";

		public string MicrophoneDevices => "Dispositivos de micrófono";

		public string GeneralSettings => "Ajustes generales";

		public string PlayerCustomization => "Personalización";

		public string SuitTint => "Color del traje:";

		public string Red => "Rojo:";

		public string Green => "Verde:";

		public string Blue => "Azul:";
	}
	public class FrenchLanguage : ILanguage
	{
		public string MultiplayerTitle => "Multijoueur";

		public string Enter => "Valider";

		public string PasswordForSession => "Mot de passe pour :\n{0}";

		public string TabLobby => "SALLE";

		public string TabPlayer => "Joueur";

		public string TabGeneral => "Général";

		public string TabAudio => "Audio";

		public string TabLAN => "LAN";

		public string ButtonBack => "Retour";

		public string HostLobby => "Créer une salle";

		public string StopHosting => "Arrêter";

		public string LobbyBrowser => "Navigateur";

		public string Refresh => "Actualiser";

		public string Refreshing => "Actualisation…";

		public string LobbyPassword => "Mot de passe (vide = public)";

		public string HostLAN => "Héberger (LAN)";

		public string ServerIP => "IP du serveur :";

		public string ServerPort => "Port :";

		public string PasswordOptional => "Mot de passe (optionnel) :";

		public string Disconnect => "Se déconnecter";

		public string Connect => "Se connecter";

		public string DisableMicrophone => "Désactiver le micro";

		public string EnableMicrophone => "Activer le micro";

		public string Deafen => "Assourdir";

		public string Undeafen => "Rétablir le son";

		public string EnablePushToTalk => "Activer pousser pour parler";

		public string DisablePushToTalk => "Désactiver pousser pour parler";

		public string PushToTalkKey => "Touche parler :";

		public string MicrophoneGain => "Gain micro :";

		public string AudioDevice => "Périphérique audio :";

		public string NoDevicesFound => "Aucun périphérique";

		public string EnableCollisions => "Activer collisions";

		public string DisableCollisions => "Désactiver collisions";

		public string EnablePlayerCutsceneVisibility => "Afficher joueur en cinématique";

		public string DisablePlayerCutsceneVisibility => "Masquer joueur en cinématique";

		public string EnableNametags => "Afficher noms";

		public string DisableNametags => "Masquer noms";

		public string PlayerListKeyLabel => "Touche joueurs :";

		public string ChatMenuKeyLabel => "Touche chat :";

		public string UpdateNameAndAppearance => "Mettre à jour nom et apparence";

		public string Nickname => "Pseudo :";

		public string PressAnyKey => "Appuyez sur une touche…";

		public string Language => "Langue :";

		public string Level => "Niveau :";

		public string ConnectedPlayers => "Joueurs connectés";

		public string NoPlayersConnected => "Aucun joueur connecté.";

		public string You => "Vous";

		public string ConnectedToServer => "Connecté au serveur";

		public string AppearanceUpdated => "Apparence mise à jour";

		public string JoiningServer => "Connexion à {0}…";

		public string CreatingLobby => "Création du salon Steam…";

		public string StoppedHosting => "Hébergement arrêté";

		public string HostingOnPort => "Port {0}";

		public string PlayerJoinedSession => "{0} a rejoint votre session";

		public string PlayerLeftSession => "{0} a quitté votre session";

		public string HasConnected => "{0} s'est connecté";

		public string HasDisconnected => "{0} s'est déconnecté";

		public string HasChangedNicknameTo => "{0} a changé son pseudo en {1}";

		public string HasUpdatedTheirColor => "{0} a modifié sa couleur";

		public string ServerInformation => "Infos serveur";

		public string AudioSettings => "Paramètres audio";

		public string MicrophoneDevices => "Périphériques micro";

		public string GeneralSettings => "Paramètres généraux";

		public string PlayerCustomization => "Personnalisation";

		public string SuitTint => "Couleur tenue :";

		public string Red => "Rouge :";

		public string Green => "Vert :";

		public string Blue => "Bleu :";
	}
	public class GermanLanguage : ILanguage
	{
		public string MultiplayerTitle => "Mehrspieler";

		public string Enter => "Bestätigen";

		public string PasswordForSession => "Passwort für:\n{0}";

		public string TabLobby => "LOBBY";

		public string TabPlayer => "Spieler";

		public string TabGeneral => "Allgemein";

		public string TabAudio => "Audio";

		public string TabLAN => "LAN";

		public string ButtonBack => "Zurück";

		public string HostLobby => "Lobby erstellen";

		public string StopHosting => "Beenden";

		public string LobbyBrowser => "Browser";

		public string Refresh => "Aktualisieren";

		public string Refreshing => "Wird geladen…";

		public string LobbyPassword => "Lobby-Passwort (leer = öffentlich)";

		public string HostLAN => "Hosten (LAN)";

		public string ServerIP => "Server-IP:";

		public string ServerPort => "Port:";

		public string PasswordOptional => "Passwort (optional):";

		public string Disconnect => "Verbindung trennen";

		public string Connect => "Verbinden";

		public string DisableMicrophone => "Mikrofon deaktivieren";

		public string EnableMicrophone => "Mikrofon aktivieren";

		public string Deafen => "Stummschalten";

		public string Undeafen => "Stummschaltung aufheben";

		public string EnablePushToTalk => "Push-to-Talk aktivieren";

		public string DisablePushToTalk => "Push-to-Talk deaktivieren";

		public string PushToTalkKey => "Push-to-Talk-Taste:";

		public string MicrophoneGain => "Mikrofonpegel:";

		public string AudioDevice => "Audiogerät:";

		public string NoDevicesFound => "Keine Geräte";

		public string EnableCollisions => "Kollisionen aktivieren";

		public string DisableCollisions => "Kollisionen deaktivieren";

		public string EnablePlayerCutsceneVisibility => "Spieler in Zwischensequenzen anzeigen";

		public string DisablePlayerCutsceneVisibility => "Spieler in Zwischensequenzen ausblenden";

		public string EnableNametags => "Namen anzeigen";

		public string DisableNametags => "Namen ausblenden";

		public string PlayerListKeyLabel => "Spielerliste-Taste:";

		public string ChatMenuKeyLabel => "Chat-Taste:";

		public string UpdateNameAndAppearance => "Name und Aussehen aktualisieren";

		public string Nickname => "Spitzname:";

		public string PressAnyKey => "Beliebige Taste drücken…";

		public string Language => "Sprache:";

		public string Level => "Pegel:";

		public string ConnectedPlayers => "Verbundene Spieler";

		public string NoPlayersConnected => "Keine Spieler verbunden.";

		public string You => "Du";

		public string ConnectedToServer => "Mit Server verbunden";

		public string AppearanceUpdated => "Aussehen aktualisiert";

		public string JoiningServer => "{0} wird beigetreten…";

		public string CreatingLobby => "Steam-Lobby wird erstellt…";

		public string StoppedHosting => "Hosting beendet";

		public string HostingOnPort => "Hosting auf Port {0}";

		public string PlayerJoinedSession => "{0} ist deiner Sitzung beigetreten";

		public string PlayerLeftSession => "{0} hat deine Sitzung verlassen";

		public string HasConnected => "{0} ist beigetreten";

		public string HasDisconnected => "{0} hat verlassen";

		public string HasChangedNicknameTo => "{0} heißt jetzt {1}";

		public string HasUpdatedTheirColor => "{0} hat die Farbe geändert";

		public string ServerInformation => "Serverinformationen";

		public string AudioSettings => "Audioeinstellungen";

		public string MicrophoneDevices => "Mikrofone";

		public string GeneralSettings => "Allgemein";

		public string PlayerCustomization => "Anpassung";

		public string SuitTint => "Anzugfarbe:";

		public string Red => "Rot:";

		public string Green => "Grün:";

		public string Blue => "Blau:";
	}
	public class JapaneseLanguage : ILanguage
	{
		public string MultiplayerTitle => "マルチプレイヤー";

		public string Enter => "決定";

		public string PasswordForSession => "パスワードを入力:\n{0}";

		public string TabLobby => "ロビー";

		public string TabPlayer => "プレイヤー";

		public string TabGeneral => "一般";

		public string TabAudio => "音声";

		public string TabLAN => "LAN";

		public string ButtonBack => "戻る";

		public string HostLobby => "ロビー作成";

		public string StopHosting => "終了";

		public string LobbyBrowser => "ロビー一覧";

		public string Refresh => "更新";

		public string Refreshing => "更新中…";

		public string LobbyPassword => "パスワード（空欄=公開）";

		public string HostLAN => "ホスト（LAN）";

		public string ServerIP => "サーバーIP：";

		public string ServerPort => "ポート：";

		public string PasswordOptional => "パスワード（任意）：";

		public string Disconnect => "切断";

		public string Connect => "接続";

		public string DisableMicrophone => "マイクをオフ";

		public string EnableMicrophone => "マイクをオン";

		public string Deafen => "ミュート";

		public string Undeafen => "ミュート解除";

		public string EnablePushToTalk => "プッシュトゥトークを有効化";

		public string DisablePushToTalk => "プッシュトゥトークを無効化";

		public string PushToTalkKey => "PTTキー：";

		public string MicrophoneGain => "マイク音量：";

		public string AudioDevice => "デバイス：";

		public string NoDevicesFound => "デバイスなし";

		public string EnableCollisions => "衝突を有効化";

		public string DisableCollisions => "衝突を無効化";

		public string EnablePlayerCutsceneVisibility => "カットシーンでプレイヤーを表示";

		public string DisablePlayerCutsceneVisibility => "カットシーンでプレイヤーを非表示";

		public string EnableNametags => "ネームタグを表示";

		public string DisableNametags => "ネームタグを非表示";

		public string PlayerListKeyLabel => "リストキー：";

		public string ChatMenuKeyLabel => "チャットキー：";

		public string UpdateNameAndAppearance => "名前と外見を更新";

		public string Nickname => "ニックネーム：";

		public string PressAnyKey => "いずれかのキーを押してください…";

		public string Language => "言語：";

		public string Level => "レベル：";

		public string ConnectedPlayers => "接続中のプレイヤー";

		public string NoPlayersConnected => "接続中のプレイヤーはいません。";

		public string You => "あなた";

		public string ConnectedToServer => "サーバーに接続しました";

		public string AppearanceUpdated => "外見が更新されました";

		public string JoiningServer => "{0} に参加中…";

		public string CreatingLobby => "Steamロビーを作成中…";

		public string StoppedHosting => "ホスト終了";

		public string HostingOnPort => "ポート {0}";

		public string PlayerJoinedSession => "{0} があなたのセッションに参加しました";

		public string PlayerLeftSession => "{0} があなたのセッションから退出しました";

		public string HasConnected => "{0} が接続しました";

		public string HasDisconnected => "{0} が切断しました";

		public string HasChangedNicknameTo => "{0} がニックネームを {1} に変更しました";

		public string HasUpdatedTheirColor => "{0} が色を変更しました";

		public string ServerInformation => "サーバー情報";

		public string AudioSettings => "オーディオ設定";

		public string MicrophoneDevices => "マイクデバイス";

		public string GeneralSettings => "一般設定";

		public string PlayerCustomization => "プレイヤー設定";

		public string SuitTint => "スーツの色：";

		public string Red => "赤：";

		public string Green => "緑：";

		public string Blue => "青：";
	}
	public class KoreanLanguage : ILanguage
	{
		public string MultiplayerTitle => "멀티플레이어";

		public string Enter => "확인";

		public string PasswordForSession => "비밀번호 입력:\n{0}";

		public string TabLobby => "로비";

		public string TabPlayer => "플레이어";

		public string TabGeneral => "일반";

		public string TabAudio => "오디오";

		public string TabLAN => "LAN";

		public string ButtonBack => "뒤로";

		public string HostLobby => "로비 만들기";

		public string StopHosting => "종료";

		public string LobbyBrowser => "로비 목록";

		public string Refresh => "새로 고침";

		public string Refreshing => "로딩 중…";

		public string LobbyPassword => "비밀번호 (빈 칸=공개)";

		public string HostLAN => "호스트 (LAN)";

		public string ServerIP => "서버 IP:";

		public string ServerPort => "포트:";

		public string PasswordOptional => "비밀번호(선택):";

		public string Disconnect => "연결 끊기";

		public string Connect => "연결";

		public string DisableMicrophone => "마이크 끄기";

		public string EnableMicrophone => "마이크 켜기";

		public string Deafen => "소리 끄기";

		public string Undeafen => "소리 켜기";

		public string EnablePushToTalk => "눌러서 말하기 사용";

		public string DisablePushToTalk => "눌러서 말하기 해제";

		public string PushToTalkKey => "말하기 키:";

		public string MicrophoneGain => "마이크 게인:";

		public string AudioDevice => "오디오 장치:";

		public string NoDevicesFound => "장치 없음";

		public string EnableCollisions => "충돌 사용";

		public string DisableCollisions => "충돌 해제";

		public string EnablePlayerCutsceneVisibility => "컷신에서 플레이어 표시";

		public string DisablePlayerCutsceneVisibility => "컷신에서 플레이어 숨김";

		public string EnableNametags => "이름표 표시";

		public string DisableNametags => "이름표 숨김";

		public string PlayerListKeyLabel => "목록 키:";

		public string ChatMenuKeyLabel => "채팅 키:";

		public string UpdateNameAndAppearance => "이름 및 외형 변경";

		public string Nickname => "닉네임:";

		public string PressAnyKey => "아무 키나 누르세요…";

		public string Language => "언어:";

		public string Level => "레벨:";

		public string ConnectedPlayers => "접속 중인 플레이어";

		public string NoPlayersConnected => "접속한 플레이어가 없습니다.";

		public string You => "나";

		public string ConnectedToServer => "서버에 연결됨";

		public string AppearanceUpdated => "외형이 변경되었습니다";

		public string JoiningServer => "{0} 참가 중…";

		public string CreatingLobby => "Steam 로비 생성 중…";

		public string StoppedHosting => "호스팅 중단";

		public string HostingOnPort => "포트 {0}";

		public string PlayerJoinedSession => "{0} 님이 세션에 참가했습니다";

		public string PlayerLeftSession => "{0} 님이 세션을 떠났습니다";

		public string HasConnected => "{0} 님이 접속했습니다";

		public string HasDisconnected => "{0} 님이 퇴장했습니다";

		public string HasChangedNicknameTo => "{0} 님이 이름을 {1}(으)로 변경했습니다";

		public string HasUpdatedTheirColor => "{0} 님이 색상을 변경했습니다";

		public string ServerInformation => "서버 정보";

		public string AudioSettings => "오디오 설정";

		public string MicrophoneDevices => "마이크 장치";

		public string GeneralSettings => "일반 설정";

		public string PlayerCustomization => "플레이어 설정";

		public string SuitTint => "슈트 색상:";

		public string Red => "빨강:";

		public string Green => "초록:";

		public string Blue => "파랑:";
	}
	public class ChineseSimplifiedLanguage : ILanguage
	{
		public string MultiplayerTitle => "多人游戏";

		public string Enter => "确认";

		public string PasswordForSession => "输入密码：\n{0}";

		public string TabLobby => "大厅";

		public string TabPlayer => "玩家";

		public string TabGeneral => "通用";

		public string TabAudio => "音频";

		public string TabLAN => "LAN";

		public string ButtonBack => "返回";

		public string HostLobby => "创建大厅";

		public string StopHosting => "停止托管";

		public string LobbyBrowser => "大厅列表";

		public string Refresh => "刷新";

		public string Refreshing => "刷新中…";

		public string LobbyPassword => "大厅密码（空=公开）";

		public string HostLAN => "托管 (LAN)";

		public string ServerIP => "服务器IP：";

		public string ServerPort => "端口：";

		public string PasswordOptional => "密码（可选）：";

		public string Disconnect => "断开连接";

		public string Connect => "连接";

		public string DisableMicrophone => "关闭麦克风";

		public string EnableMicrophone => "开启麦克风";

		public string Deafen => "关闭声音";

		public string Undeafen => "恢复声音";

		public string EnablePushToTalk => "启用按键说话";

		public string DisablePushToTalk => "禁用按键说话";

		public string PushToTalkKey => "说话按键：";

		public string MicrophoneGain => "麦克风音量：";

		public string AudioDevice => "音频设备：";

		public string NoDevicesFound => "未找到设备";

		public string EnableCollisions => "启用碰撞";

		public string DisableCollisions => "禁用碰撞";

		public string EnablePlayerCutsceneVisibility => "过场动画中显示玩家";

		public string DisablePlayerCutsceneVisibility => "过场动画中隐藏玩家";

		public string EnableNametags => "显示名称";

		public string DisableNametags => "隐藏名称";

		public string PlayerListKeyLabel => "玩家列表键：";

		public string ChatMenuKeyLabel => "聊天键：";

		public string UpdateNameAndAppearance => "更新名称和外观";

		public string Nickname => "昵称：";

		public string PressAnyKey => "按任意键…";

		public string Language => "语言：";

		public string Level => "级别：";

		public string ConnectedPlayers => "已连接玩家";

		public string NoPlayersConnected => "没有玩家连接。";

		public string You => "你";

		public string ConnectedToServer => "已连接到服务器";

		public string AppearanceUpdated => "外观已更新";

		public string JoiningServer => "正在加入 {0}…";

		public string CreatingLobby => "正在创建Steam大厅…";

		public string StoppedHosting => "已停止托管";

		public string HostingOnPort => "端口 {0} 托管";

		public string PlayerJoinedSession => "{0} 加入了你的会话";

		public string PlayerLeftSession => "{0} 离开了你的会话";

		public string HasConnected => "{0} 已连接";

		public string HasDisconnected => "{0} 已断开";

		public string HasChangedNicknameTo => "{0} 将昵称改为 {1}";

		public string HasUpdatedTheirColor => "{0} 更新了颜色";

		public string ServerInformation => "服务器信息";

		public string AudioSettings => "音频设置";

		public string MicrophoneDevices => "麦克风设备";

		public string GeneralSettings => "常规设置";

		public string PlayerCustomization => "玩家自定义";

		public string SuitTint => "服装颜色：";

		public string Red => "红：";

		public string Green => "绿：";

		public string Blue => "蓝：";
	}
	public static class LanguageNativeNames
	{
		private static readonly Dictionary<string, string> _names = new Dictionary<string, string>
		{
			{ "English", "English" },
			{ "Spanish", "Español" },
			{ "French", "Français" },
			{ "German", "Deutsch" },
			{ "Japanese", "日本語" },
			{ "Korean", "한국어" },
			{ "Chinese Simplified", "中文(简体)" },
			{ "Chinese Traditional", "中文(繁體)" },
			{ "ChineseSimplified", "中文(简体)" },
			{ "ChineseTraditional", "中文(繁體)" },
			{ "Russian", "Русский" },
			{ "Portuguese", "Português (BR)" }
		};

		public static string GetNativeName(string key)
		{
			string value;
			return _names.TryGetValue(key, out value) ? value : key;
		}
	}
	public class RussianLanguage : ILanguage
	{
		public string MultiplayerTitle => "Мультиплеер";

		public string Enter => "Подтвердить";

		public string PasswordForSession => "Введите пароль для:\n{0}";

		public string TabLobby => "ЛОББИ";

		public string TabPlayer => "Игрок";

		public string TabGeneral => "Общее";

		public string TabAudio => "Звук";

		public string TabLAN => "LAN";

		public string ButtonBack => "Назад";

		public string HostLobby => "Создать лобби";

		public string StopHosting => "Остановить";

		public string LobbyBrowser => "Список лобби";

		public string Refresh => "Обновить";

		public string Refreshing => "Обновление…";

		public string LobbyPassword => "Пароль лобби (пусто = публичное)";

		public string HostLAN => "Хост (LAN)";

		public string ServerIP => "IP сервера:";

		public string ServerPort => "Порт:";

		public string PasswordOptional => "Пароль (необязательно):";

		public string Disconnect => "Отключиться";

		public string Connect => "Подключиться";

		public string DisableMicrophone => "Выключить микрофон";

		public string EnableMicrophone => "Включить микрофон";

		public string Deafen => "Заглушить";

		public string Undeafen => "Включить звук";

		public string EnablePushToTalk => "Включить Push-to-Talk";

		public string DisablePushToTalk => "Выключить Push-to-Talk";

		public string PushToTalkKey => "Кнопка PTT:";

		public string MicrophoneGain => "Усиление микрофона:";

		public string AudioDevice => "Аудиоустройство:";

		public string NoDevicesFound => "Устройства не найдены";

		public string EnableCollisions => "Включить столкновения";

		public string DisableCollisions => "Выключить столкновения";

		public string EnablePlayerCutsceneVisibility => "Показывать игроков в катсценах";

		public string DisablePlayerCutsceneVisibility => "Скрывать игроков в катсценах";

		public string EnableNametags => "Показывать имена";

		public string DisableNametags => "Скрывать имена";

		public string PlayerListKeyLabel => "Клавиша списка:";

		public string ChatMenuKeyLabel => "Клавиша чата:";

		public string UpdateNameAndAppearance => "Обновить имя и внешность";

		public string Nickname => "Никнейм:";

		public string PressAnyKey => "Нажмите любую клавишу…";

		public string Language => "Язык:";

		public string Level => "Уровень:";

		public string ConnectedPlayers => "Подключённые игроки";

		public string NoPlayersConnected => "Нет подключённых игроков.";

		public string You => "Вы";

		public string ConnectedToServer => "Подключено к серверу";

		public string AppearanceUpdated => "Внешность обновлена";

		public string JoiningServer => "Подключение к {0}…";

		public string CreatingLobby => "Создание лобби Steam…";

		public string StoppedHosting => "Хостинг остановлен";

		public string HostingOnPort => "Хостинг на порту {0}";

		public string PlayerJoinedSession => "{0} присоединился к сессии";

		public string PlayerLeftSession => "{0} покинул сессию";

		public string HasConnected => "{0} подключился";

		public string HasDisconnected => "{0} отключился";

		public string HasChangedNicknameTo => "{0} изменил ник на {1}";

		public string HasUpdatedTheirColor => "{0} изменил цвет";

		public string ServerInformation => "Информация о сервере";

		public string AudioSettings => "Настройки звука";

		public string MicrophoneDevices => "Устройства микрофона";

		public string GeneralSettings => "Общие настройки";

		public string PlayerCustomization => "Настройка персонажа";

		public string SuitTint => "Цвет костюма:";

		public string Red => "Красный:";

		public string Green => "Зелёный:";

		public string Blue => "Синий:";
	}
	public class PortugueseLanguage : ILanguage
	{
		public string MultiplayerTitle => "Multijogador";

		public string Enter => "Confirmar";

		public string PasswordForSession => "Senha para:\n{0}";

		public string TabLobby => "LOBBY";

		public string TabPlayer => "Jogador";

		public string TabGeneral => "Geral";

		public string TabAudio => "Áudio";

		public string TabLAN => "LAN";

		public string ButtonBack => "Voltar";

		public string HostLobby => "Criar Sala";

		public string StopHosting => "Parar";

		public string LobbyBrowser => "Salas";

		public string Refresh => "Atualizar";

		public string Refreshing => "Atualizando…";

		public string LobbyPassword => "Senha da sala (vazio = pública)";

		public string HostLAN => "Hospedar (LAN)";

		public string ServerIP => "IP do servidor:";

		public string ServerPort => "Porta:";

		public string PasswordOptional => "Senha (opcional):";

		public string Disconnect => "Desconectar";

		public string Connect => "Conectar";

		public string DisableMicrophone => "Desativar microfone";

		public string EnableMicrophone => "Ativar microfone";

		public string Deafen => "Silenciar";

		public string Undeafen => "Dessilenciar";

		public string EnablePushToTalk => "Ativar Push to Talk";

		public string DisablePushToTalk => "Desativar Push to Talk";

		public string PushToTalkKey => "Tecla PTT:";

		public string MicrophoneGain => "Ganho do microfone:";

		public string AudioDevice => "Dispositivo de áudio:";

		public string NoDevicesFound => "Nenhum dispositivo";

		public string EnableCollisions => "Ativar colisões";

		public string DisableCollisions => "Desativar colisões";

		public string EnablePlayerCutsceneVisibility => "Mostrar jogador nas cutscenes";

		public string DisablePlayerCutsceneVisibility => "Ocultar jogador nas cutscenes";

		public string EnableNametags => "Mostrar nomes";

		public string DisableNametags => "Ocultar nomes";

		public string PlayerListKeyLabel => "Tecla da lista:";

		public string ChatMenuKeyLabel => "Tecla do chat:";

		public string UpdateNameAndAppearance => "Atualizar nome e aparência";

		public string Nickname => "Apelido:";

		public string PressAnyKey => "Pressione qualquer tecla…";

		public string Language => "Idioma:";

		public string Level => "Nível:";

		public string ConnectedPlayers => "Jogadores conectados";

		public string NoPlayersConnected => "Nenhum jogador conectado.";

		public string You => "Você";

		public string ConnectedToServer => "Conectado ao servidor";

		public string AppearanceUpdated => "Aparência atualizada";

		public string JoiningServer => "Entrando em {0}…";

		public string CreatingLobby => "Criando sala Steam…";

		public string StoppedHosting => "Hospedagem encerrada";

		public string HostingOnPort => "Hospedando na porta {0}";

		public string PlayerJoinedSession => "{0} entrou na sua sessão";

		public string PlayerLeftSession => "{0} saiu da sua sessão";

		public string HasConnected => "{0} conectou-se";

		public string HasDisconnected => "{0} desconectou-se";

		public string HasChangedNicknameTo => "{0} mudou o apelido para {1}";

		public string HasUpdatedTheirColor => "{0} atualizou a cor";

		public string ServerInformation => "Informações do servidor";

		public string AudioSettings => "Configurações de áudio";

		public string MicrophoneDevices => "Dispositivos de microfone";

		public string GeneralSettings => "Configurações gerais";

		public string PlayerCustomization => "Personalização";

		public string SuitTint => "Cor do traje:";

		public string Red => "Vermelho:";

		public string Green => "Verde:";

		public string Blue => "Azul:";
	}
	public class ChineseTraditionalLanguage : ILanguage
	{
		public string MultiplayerTitle => "多人遊戲";

		public string Enter => "確認";

		public string PasswordForSession => "輸入密碼：\n{0}";

		public string TabLobby => "大廳";

		public string TabPlayer => "玩家";

		public string TabGeneral => "通用";

		public string TabAudio => "音訊";

		public string TabLAN => "LAN";

		public string ButtonBack => "返回";

		public string HostLobby => "建立大廳";

		public string StopHosting => "停止托管";

		public string LobbyBrowser => "大廳列表";

		public string Refresh => "重新整理";

		public string Refreshing => "重新整理中…";

		public string LobbyPassword => "大廳密碼（空=公開）";

		public string HostLAN => "托管 (LAN)";

		public string ServerIP => "伺服器IP：";

		public string ServerPort => "連接埠：";

		public string PasswordOptional => "密碼（選填）：";

		public string Disconnect => "中斷連線";

		public string Connect => "連線";

		public string DisableMicrophone => "關閉麥克風";

		public string EnableMicrophone => "開啟麥克風";

		public string Deafen => "關閉聲音";

		public string Undeafen => "恢復聲音";

		public string EnablePushToTalk => "啟用按鍵說話";

		public string DisablePushToTalk => "停用按鍵說話";

		public string PushToTalkKey => "說話按鍵：";

		public string MicrophoneGain => "麥克風音量：";

		public string AudioDevice => "音訊裝置：";

		public string NoDevicesFound => "找不到裝置";

		public string EnableCollisions => "啟用碰撞";

		public string DisableCollisions => "停用碰撞";

		public string EnablePlayerCutsceneVisibility => "過場動畫中顯示玩家";

		public string DisablePlayerCutsceneVisibility => "過場動畫中隱藏玩家";

		public string EnableNametags => "顯示名稱";

		public string DisableNametags => "隱藏名稱";

		public string PlayerListKeyLabel => "玩家清單鍵：";

		public string ChatMenuKeyLabel => "聊天鍵：";

		public string UpdateNameAndAppearance => "更新名稱與外觀";

		public string Nickname => "暱稱：";

		public string PressAnyKey => "按任意鍵…";

		public string Language => "語言：";

		public string Level => "等級：";

		public string ConnectedPlayers => "已連線玩家";

		public string NoPlayersConnected => "沒有玩家連線。";

		public string You => "你";

		public string ConnectedToServer => "已連線至伺服器";

		public string AppearanceUpdated => "外觀已更新";

		public string JoiningServer => "正在加入 {0}…";

		public string CreatingLobby => "正在建立Steam大廳…";

		public string StoppedHosting => "已停止托管";

		public string HostingOnPort => "連接埠 {0} 托管";

		public string PlayerJoinedSession => "{0} 加入了你的工作階段";

		public string PlayerLeftSession => "{0} 離開了你的工作階段";

		public string HasConnected => "{0} 已連線";

		public string HasDisconnected => "{0} 已中斷連線";

		public string HasChangedNicknameTo => "{0} 將暱稱改為 {1}";

		public string HasUpdatedTheirColor => "{0} 更新了顏色";

		public string ServerInformation => "伺服器資訊";

		public string AudioSettings => "音訊設定";

		public string MicrophoneDevices => "麥克風裝置";

		public string GeneralSettings => "一般設定";

		public string PlayerCustomization => "玩家自訂";

		public string SuitTint => "服裝顏色：";

		public string Red => "紅：";

		public string Green => "綠：";

		public string Blue => "藍：";
	}
}
namespace BabyStepsMultiplayerClient.Extensions
{
	public static class MonoBehaviourExtensions
	{
		public static Coroutine StartCoroutine<T>(this T behaviour, IEnumerator enumerator) where T : MonoBehaviour
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return ((MonoBehaviour)behaviour).StartCoroutine(new IEnumerator(((Il2CppObjectBase)new ManagedEnumerator(enumerator)).Pointer));
		}
	}
	public static class TransformExtensions
	{
		public static Transform FindChildByKeyword(this Transform root, string keyword)
		{
			Queue<Transform> queue = new Queue<Transform>();
			queue.Enqueue(root);
			while (queue.Count > 0)
			{
				Transform val = queue.Dequeue();
				if (((Object)val).name.Contains(keyword))
				{
					return val;
				}
				for (int i = 0; i < val.childCount; i++)
				{
					queue.Enqueue(val.GetChild(i));
				}
			}
			return null;
		}

		public static List<Transform> FindMatchingChildren(this Transform puppetMaster, List<Transform> bones)
		{
			List<Transform> list = new List<Transform>();
			Queue<Transform> queue = new Queue<Transform>();
			HashSet<string> hashSet = new HashSet<string>();
			foreach (Transform bone in bones)
			{
				if ((Object)(object)bone != (Object)null)
				{
					hashSet.Add(((Object)bone).name);
				}
			}
			queue.Enqueue(puppetMaster);
			while (queue.Count > 0)
			{
				Transform val = queue.Dequeue();
				if (hashSet.Contains(((Object)val).name))
				{
					list.Add(val);
				}
				for (int i = 0; i < val.childCount; i++)
				{
					queue.Enqueue(val.GetChild(i));
				}
			}
			return list;
		}
	}
}
namespace BabyStepsMultiplayerClient.Config
{
	public class AudioConfig : ConfigCategory
	{
		internal MelonPreferences_Entry<bool> MicrophoneEnabled;

		internal MelonPreferences_Entry<float> MicrophoneGain;

		internal MelonPreferences_Entry<int> SelectedMicrophoneIndex;

		internal MelonPreferences_Entry<bool> PushToTalk;

		internal MelonPreferences_Entry<string> PushToTalkKey;

		internal MelonPreferences_Entry<bool> Deafened;

		public override string ID => "Audio";

		public override void CreatePreferences()
		{
			MicrophoneEnabled = CreatePref("MicrophoneEnabled", "Microphone Enabled", "Enable or disable microphone input", defaultValue: false);
			MicrophoneGain = CreatePref("MicrophoneGain", "Microphone Gain", "Microphone input gain/volume multiplier", 1f);
			SelectedMicrophoneIndex = CreatePref("SelectedMicrophoneIndex", "Selected Microphone Index", "Index of the currently selected microphone device", 0);
			PushToTalk = CreatePref("PushToTalk", "Push to Talk", "Enable push-to-talk mode for microphone", defaultValue: false);
			PushToTalkKey = CreatePref("PushToTalkKey", "Push to Talk Key", "Key to press for push-to-talk", "V");
			Deafened = CreatePref("Deafened", "Deafened", "Mute all incoming voice chat", defaultValue: false);
		}
	}
	public class ConfigCategory
	{
		public static SortedDictionary<string, ConfigCategory> _allCategories = new SortedDictionary<string, ConfigCategory>();

		public MelonPreferences_Category Category;

		public string FileExt = ".cfg";

		public virtual string ID { get; set; }

		public virtual string DisplayName { get; set; }

		public ConfigCategory()
		{
			Setup(MelonEnvironment.UserDataDirectory, "BabyStepsClientConfig", ID, DisplayName);
			if (!_allCategories.ContainsKey(ID))
			{
				_allCategories[ID] = this;
			}
		}

		public ConfigCategory(string folderPath, string fileName, string categoryID, string categoryDisplayName)
		{
			Setup(folderPath, fileName, categoryID, categoryDisplayName);
		}

		public void Setup(string folderPath, string fileName, string categoryID, string categoryDisplayName)
		{
			if (string.IsNullOrEmpty(categoryDisplayName) || string.IsNullOrWhiteSpace(categoryDisplayName))
			{
				categoryDisplayName = categoryID;
			}
			string text = Path.Combine(folderPath, fileName + FileExt);
			if (File.Exists(text))
			{
				try
				{
					TomlDocument val = TomlParser.ParseFile(text);
					if (val == null)
					{
						throw new NullReferenceException();
					}
				}
				catch
				{
					File.Delete(text);
				}
			}
			ID = categoryID;
			DisplayName = categoryDisplayName;
			Category = MelonPreferences.CreateCategory(ID, DisplayName, true, false);
			Category.DestroyFileWatcher();
			Category.SetFilePath(text, true, false);
			CreatePreferences();
			Save();
		}

		public virtual void CreatePreferences()
		{
		}

		public void Load()
		{
			Category.LoadFromFile(false);
		}

		public void Save()
		{
			Category.SaveToFile(false);
		}

		public MelonPreferences_Entry<T> CreatePref<T>(string id, string displayName, string description, T defaultValue = default(T), bool isHidden = false)
		{
			MelonPreferences_Entry<T> entry = Category.GetEntry<T>(id);
			if (entry != null)
			{
				return entry;
			}
			return Category.CreateEntry<T>(id, defaultValue, displayName, description, isHidden, false, (ValueValidator)null);
		}
	}
	public class ConnectionConfig : ConfigCategory
	{
		internal MelonPreferences_Entry<string> Address;

		internal MelonPreferences_Entry<int> Port;

		internal MelonPreferences_Entry<string> Password;

		internal MelonPreferences_Entry<string> HostPassword;

		internal MelonPreferences_Entry<string> PublicMainIpOverride;

		public override string ID => "Connection";

		public override void CreatePreferences()
		{
			Address = CreatePref("address", "IP Address", "IP Address", "bbsmm.mooo.com");
			Port = CreatePref("port", "Port", "Port", 7777);
			Password = CreatePref("password", "Password", "Password", string.Empty);
			HostPassword = CreatePref("host_password", "Host Password", "Host Password", string.Empty);
			PublicMainIpOverride = CreatePref("public_main_ip", "Public Main IP Override", "Override the Public Main server IP shown in the lobby list. Leave blank to use the default (bbsmm.mooo.com).", string.Empty);
		}
	}
	public class PlayerConfig : ConfigCategory
	{
		internal MelonPreferences_Entry<string> Nickname;

		internal MelonPreferences_Entry<Color> SuitColor;

		internal MelonPreferences_Entry<bool> Collisions;

		internal MelonPreferences_Entry<bool> CutscenePlayerVisibility;

		internal MelonPreferences_Entry<bool> ShowNametags;

		internal MelonPreferences_Entry<string> TabMenuKey;

		internal MelonPreferences_Entry<string> ChatMenuKey;

		public override string ID => "Player";

		public override void CreatePreferences()
		{
			//IL_001c: 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)
			Nickname = CreatePref("Nickname", "Nickname", "User Nickname", SteamFriends.Internal.GetFriendPersonaName(SteamUser.Internal.GetSteamID()));
			SuitColor = CreatePref<Color>("SuitColor", "Suit Color", "Suit Color", new Color(1f, 1f, 1f, 1f));
			Collisions = CreatePref("PlayerCollisions", "Player Collisions", "Collisions with Other Players", defaultValue: false);
			CutscenePlayerVisibility = CreatePref("CutscenePlayerVisibility", "Cutscene Player Visibility", "Show Other Players During Cutscenes", defaultValue: false);
			ShowNametags = CreatePref("ShowNametags", "Show Nametags", "Show Nametags Above Other Players", defaultValue: true);
			TabMenuKey = CreatePref("TabMenuKey", "Tab Menu Key", "Key to hold for showing the players tab menu", "Tab");
			ChatMenuKey = CreatePref("ChatMenuKey", "Chat Menu Key", "Key to open chat input", "T");
		}
	}
}
namespace BabyStepsMultiplayerClient.Components
{
	public class ManagedEnumerator : Object
	{
		private readonly IEnumerator enumerator;

		public Object Current
		{
			get
			{
				object current = this.enumerator.Current;
				if (1 == 0)
				{
				}
				Object result;
				if (!(current is IEnumerator enumerator))
				{
					Object val = (Object)((current is Object) ? current : null);
					if (val == null)
					{
						if (current != null)
						{
							throw new NotSupportedException($"{this.enumerator.GetType()}: Unsupported type {this.enumerator.Current.GetType()}");
						}
						result = null;
					}
					else
					{
						result = val;
					}
				}
				else
				{
					result = (Object)(object)new ManagedEnumerator(enumerator);
				}
				if (1 == 0)
				{
				}
				return result;
			}
		}

		internal static bool Register()
		{
			return Core.RegisterComponent<ManagedEnumerator>(new Type[1] { typeof(IEnumerator) });
		}

		public ManagedEnumerator(IntPtr ptr)
			: base(ptr)
		{
		}

		public ManagedEnumerator(IEnumerator _enumerator)
			: base(ClassInjector.DerivedConstructorPointer<ManagedEnumerator>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
			enumerator = _enumerator ?? throw new NullReferenceException("routine is null");
		}

		public bool MoveNext()
		{
			try
			{
				return enumerator.MoveNext();
			}
			catch (Exception ex)
			{
				Core.logger.Error("Unhandled exception in coroutine. It will not continue executing.", ex);
				return false;
			}
		}

		public void Reset()
		{
			enumerator.Reset();
		}
	}
}
namespace BabyStepsMultiplayerClient.Audio
{
	public class BBSAudioSource
	{
		private Transform transform;

		private System fmodSystem;

		private Sound sound;

		private Channel channel;

		private const int SAMPLE_RATE = 24000;

		private const int CHANNELS = 2;

		private const int FRAME_SIZE = 960;

		private const int BUFFER_SIZE = 19200;

		private int writePosition = 0;

		private bool isInitialized = false;

		private Vector3 previousPosition;

		private float previousTime;

		private OpusDecoder opusDecoder;

		private short[] decodedSamples;

		private byte[] stereoBuffer;

		private Queue<byte[]> jitterBuffer = new Queue<byte[]>();

		private const int MIN_JITTER_FRAMES = 2;

		private const int MAX_JITTER_FRAMES = 6;

		private bool isPlaying = false;

		private float currentAmplitude = 0f;

		private const float AMPLITUDE_SMOOTHING = 0.15f;

		public int UnderrunCount { get; private set; }

		public int OverrunCount { get; private set; }

		public int DecodeErrors { get; private set; }

		public float CurrentLatencyMs { get; private set; }

		public BBSAudioSource(Transform transform)
		{
			this.transform = transform;
		}

		public void Initialize()
		{
			//IL_0008: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0045: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_0114: Invalid comparison between Unknown and I4
			//IL_00d5: 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_0163: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Invalid comparison between Unknown and I4
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				fmodSystem = Services.Player.system;
				opusDecoder = new OpusDecoder(24000, 1);
				decodedSamples = new short[960];
				stereoBuffer = new byte[3840];
				CREATESOUNDEXINFO val = default(CREATESOUNDEXINFO);
				val.cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO));
				val.length = 19200u;
				val.numchannels = 2;
				val.defaultfrequency = 24000;
				val.format = (SOUND_FORMAT)2;
				val.decodebuffersize = 960u;
				RESULT val2 = ((System)(ref fmodSystem)).createSound(string.Empty, (MODE)1042, ref val, ref sound);
				if ((int)val2 > 0)
				{
					MelonLogger.Error($"Failed to create FMOD sound: {val2}");
					return;
				}
				((Sound)(ref sound)).set3DMinMaxDistance(5f, 70f);
				ChannelGroup val3 = default(ChannelGroup);
				val2 = ((System)(ref fmodSystem)).getMasterChannelGroup(ref val3);
				if ((int)val2 > 0)
				{
					MelonLogger.Error($"Failed to get master channel group: {val2}");
					return;
				}
				val2 = ((System)(ref fmodSystem)).playSound(sound, val3, true, ref channel);
				if ((int)val2 > 0)
				{
					MelonLogger.Error($"Failed to play FMOD sound: {val2}");
					return;
				}
				((Channel)(ref channel)).setMode((MODE)16);
				((Channel)(ref channel)).setVolume(1.5f);
				previousPosition = transform.position;
				previousTime = Time.realtimeSinceStartup;
				isInitialized = true;
				MelonLogger.Msg("BBSAudioSource initialized successfully with Opus decoder");
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error initializing BBSAudioSource: {value}");
			}
		}

		public void Update()
		{
			//IL_002b: 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_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_006b: 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_0080: 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_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_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_00b4: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0055: 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_005c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized || !((Channel)(ref channel)).hasHandle())
			{
				return;
			}
			try
			{
				Vector3 position = transform.position;
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				float num = realtimeSinceStartup - previousTime;
				Vector3 val = Vector3.zero;
				if (num > 0f)
				{
					val = (position - previousPosition) / num;
				}
				VECTOR val2 = default(VECTOR);
				val2.x = position.x;
				val2.y = position.y;
				val2.z = position.z;
				VECTOR val3 = val2;
				val2 = default(VECTOR);
				val2.x = val.x;
				val2.y = val.y;
				val2.z = val.z;
				VECTOR val4 = val2;
				((Channel)(ref channel)).set3DAttributes(ref val3, ref val4);
				previousPosition = position;
				previousTime = realtimeSinceStartup;
				ProcessJitterBuffer();
				UpdateLatencyStats();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in BBSAudioSource Update: {value}");
			}
		}

		private void ProcessJitterBuffer()
		{
			//IL_0029: 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)
			if (!isPlaying && jitterBuffer.Count >= 2)
			{
				((Channel)(ref channel)).setPaused(false);
				isPlaying = true;
			}
			if (isPlaying && jitterBuffer.Count == 0)
			{
				((Channel)(ref channel)).setPaused(true);
				isPlaying = false;
				UnderrunCount++;
			}
			while (jitterBuffer.Count > 0 && CanWriteFrame())
			{
				byte[] opusPacket = jitterBuffer.Dequeue();
				DecodeAndWriteFrame(opusPacket);
			}
			if (jitterBuffer.Count > 6)
			{
				int num = jitterBuffer.Count - 6;
				for (int i = 0; i < num; i++)
				{
					jitterBuffer.Dequeue();
				}
				OverrunCount++;
			}
		}

		private void DecodeAndWriteFrame(byte[] opusPacket)
		{
			if (opusPacket.Length < 2)
			{
				return;
			}
			try
			{
				int num = opusDecoder.Decode(opusPacket, 0, opusPacket.Length, decodedSamples, 0, 960, false);
				if (num != 960)
				{
					MelonLogger.Warning($"Unexpected decoded length: {num} (expected {960})");
				}
				CalculateAmplitude(decodedSamples, num);
				ConvertMonoToStereo(decodedSamples, stereoBuffer, num);
				WriteAudioDataInternal(stereoBuffer);
			}
			catch (Exception value)
			{
				DecodeErrors++;
				MelonLogger.Error($"Error decoding Opus frame: {value}");
				Array.Clear(stereoBuffer, 0, stereoBuffer.Length);
				WriteAudioDataInternal(stereoBuffer);
			}
		}

		private void ConvertMonoToStereo(short[] monoSamples, byte[] stereoBytes, int sampleCount)
		{
			int num = 0;
			for (int i = 0; i < sampleCount; i++)
			{
				short num2 = monoSamples[i];
				byte b = (byte)((uint)num2 & 0xFFu);
				byte b2 = (byte)((uint)(num2 >> 8) & 0xFFu);
				stereoBytes[num++] = b;
				stereoBytes[num++] = b2;
				stereoBytes[num++] = b;
				stereoBytes[num++] = b2;
			}
		}

		private bool CanWriteFrame()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Channel)(ref channel)).hasHandle() || !((Sound)(ref sound)).hasHandle())
			{
				return false;
			}
			try
			{
				uint num = 0u;
				((Channel)(ref channel)).getPosition(ref num, (TIMEUNIT)4);
				int num2 = writePosition - (int)num;
				if (num2 < 0)
				{
					num2 += 19200;
				}
				int num3 = 11520;
				return num2 < num3;
			}
			catch
			{
				return false;
			}
		}

		private void UpdateLatencyStats()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (((Channel)(ref channel)).hasHandle() && ((Sound)(ref sound)).hasHandle())
				{
					uint num = 0u;
					((Channel)(ref channel)).getPosition(ref num, (TIMEUNIT)4);
					int num2 = writePosition - (int)num;
					if (num2 < 0)
					{
						num2 += 19200;
					}
					int num3 = num2 / 4;
					CurrentLatencyMs = (float)num3 / 24000f * 1000f;
				}
			}
			catch
			{
			}
		}

		public void QueueOpusPacket(byte[] opusPacket)
		{
			if (isInitialized && opusPacket != null && opusPacket.Length != 0)
			{
				jitterBuffer.Enqueue(opusPacket);
			}
		}

		private void WriteAudioDataInternal(byte[] data)
		{
			//IL_0030: 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_0052: 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_0057: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized || !((Sound)(ref sound)).hasHandle())
			{
				return;
			}
			try
			{
				uint num = 0u;
				((Sound)(ref sound)).getLength(ref num, (TIMEUNIT)4);
				IntPtr intPtr = default(IntPtr);
				IntPtr intPtr2 = default(IntPtr);
				uint num2 = default(uint);
				uint num3 = default(uint);
				RESULT val = ((Sound)(ref sound)).@lock((uint)writePosition, (uint)data.Length, ref intPtr, ref intPtr2, ref num2, ref num3);
				if ((int)val == 0)
				{
					if (num2 != 0)
					{
						Marshal.Copy(data, 0, intPtr, (int)num2);
					}
					if (num3 != 0)
					{
						Marshal.Copy(data, (int)num2, intPtr2, (int)num3);
					}
					((Sound)(ref sound)).unlock(intPtr, intPtr2, num2, num3);
					writePosition = (writePosition + data.Length) % (int)num;
				}
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error writing audio data: {value}");
			}
		}

		private void CalculateAmplitude(short[] samples, int sampleCount)
		{
			if (samples == null || sampleCount == 0)
			{
				currentAmplitude = Mathf.Lerp(currentAmplitude, 0f, 0.15f);
				return;
			}
			float num = 0f;
			for (int i = 0; i < sampleCount; i++)
			{
				float num2 = (float)samples[i] / 32768f;
				num += num2 * num2;
			}
			float num3 = Mathf.Sqrt(num / (float)sampleCount);
			currentAmplitude = Mathf.Lerp(currentAmplitude, num3, 0.15f);
		}

		public float GetAmplitude()
		{
			if (!isInitialized || !isPlaying)
			{
				return 0f;
			}
			float num = currentAmplitude * 25f;
			return Mathf.Clamp01(num);
		}

		public void ClearBuffer()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			jitterBuffer.Clear();
			if (isPlaying)
			{
				((Channel)(ref channel)).setPaused(true);
				isPlaying = false;
			}
			currentAmplitude = 0f;
		}

		public void Dispose()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				jitterBuffer.Clear();
				if (((Channel)(ref channel)).hasHandle())
				{
					((Channel)(ref channel)).stop();
				}
				if (((Sound)(ref sound)).hasHandle())
				{
					((Sound)(ref sound)).release();
				}
				opusDecoder = null;
				currentAmplitude = 0f;
				isInitialized = false;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error disposing BBSAudioSource: {value}");
			}
		}
	}
	public class BBSMicrophoneCapture
	{
		private System fmodSystem;

		private Sound recordSound;

		private int selectedDeviceIndex = 0;

		private bool isRecording = false;

		private bool isInitialized = false;

		private const int SAMPLE_RATE = 24000;

		private const int CHANNELS = 1;

		private const int FRAME_SIZE = 960;

		private const int BUFFER_SIZE = 4800;

		private uint lastRecordPos = 0u;

		private float gain = 1f;

		private OpusEncoder opusEncoder;

		private short[] sampleBuffer;

		private byte[] opusPacketBuffer;

		private byte[] frameBuffer;

		private float lastFramePeak = 0f;

		private float currentAmplitude = 0f;

		private const float AMPLITUDE_SMOOTHING = 0.15f;

		public int DroppedFrames { get; private set; }

		public int CapturedFrames { get; private set; }

		public int EncodeErrors { get; private set; }

		public BBSMicrophoneCapture()
		{
			frameBuffer = new byte[1920];
			sampleBuffer = new short[960];
			opusPacketBuffer = new byte[4000];
		}

		public bool Initialize(int deviceIndex = 0)
		{
			//IL_0008: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Invalid comparison between Unknown and I4
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				fmodSystem = Services.Player.system;
				if (!((System)(ref fmodSystem)).hasHandle())
				{
					MelonLogger.Error("FMOD system not available");
					return false;
				}
				int num = default(int);
				int num2 = default(int);
				RESULT recordNumDrivers = ((System)(ref fmodSystem)).getRecordNumDrivers(ref num, ref num2);
				if ((int)recordNumDrivers != 0 || num2 == 0)
				{
					MelonLogger.Error($"No recording devices found: {recordNumDrivers}");
					return false;
				}
				Core.logger.Msg($"Found {num2} recording device(s)");
				if (deviceIndex < 0 || deviceIndex >= num2)
				{
					MelonLogger.Warning($"Invalid device index {deviceIndex}, using device 0");
					deviceIndex = 0;
				}
				selectedDeviceIndex = deviceIndex;
				opusEncoder = new OpusEncoder(24000, 1, (OpusApplication)2048);
				opusEncoder.Bitrate = 16000;
				opusEncoder.Complexity = 6;
				opusEncoder.SignalType = (OpusSignal)3001;
				opusEncoder.UseVBR = true;
				opusEncoder.UseDTX = true;
				opusEncoder.MaxBandwidth = (OpusBandwidth)1103;
				CREATESOUNDEXINFO val = default(CREATESOUNDEXINFO);
				val.cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO));
				val.length = 4800u;
				val.numchannels = 1;
				val.defaultfrequency = 24000;
				val.format = (SOUND_FORMAT)2;
				recordNumDrivers = ((System)(ref fmodSystem)).createSound(string.Empty, (MODE)1026, ref val, ref recordSound);
				if ((int)recordNumDrivers > 0)
				{
					MelonLogger.Error($"Failed to create recording sound: {recordNumDrivers}");
					return false;
				}
				isInitialized = true;
				Core.DebugMsg($"BBSMicrophoneCapture initialized on device {deviceIndex} with Opus encoder");
				return true;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error initializing BBSMicrophoneCapture: {value}");
				return false;
			}
		}

		public bool StartRecording()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized)
			{
				MelonLogger.Error("Cannot start recording - not initialized");
				return false;
			}
			if (isRecording)
			{
				Core.DebugMsg("Warning: Already recording");
				return true;
			}
			try
			{
				RESULT val = ((System)(ref fmodSystem)).recordStart(selectedDeviceIndex, recordSound, true);
				if ((int)val > 0)
				{
					MelonLogger.Error($"Failed to start recording: {val}");
					return false;
				}
				isRecording = true;
				lastRecordPos = 0u;
				DroppedFrames = 0;
				CapturedFrames = 0;
				EncodeErrors = 0;
				Core.DebugMsg("Recording started");
				return true;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error starting recording: {value}");
				return false;
			}
		}

		public void StopRecording()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!isRecording)
			{
				return;
			}
			try
			{
				((System)(ref fmodSystem)).recordStop(selectedDeviceIndex);
				isRecording = false;
				lastFramePeak = 0f;
				currentAmplitude = 0f;
				Core.DebugMsg("Recording stopped");
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error stopping recording: {value}");
			}
		}

		public void SetGain(float newGain)
		{
			gain = Mathf.Max(0f, newGain);
		}

		public float GetGain()
		{
			return gain;
		}

		public float GetGainDB()
		{
			if (gain <= 0f)
			{
				return float.NegativeInfinity;
			}
			return 20f * Mathf.Log10(gain);
		}

		public void SetGainDB(float dB)
		{
			gain = Mathf.Pow(10f, dB / 20f);
		}

		public float GetLastFramePeak()
		{
			return lastFramePeak;
		}

		public float GetAmplitude()
		{
			if (!isInitialized || !isRecording)
			{
				return 0f;
			}
			float num = currentAmplitude * 25f;
			return Mathf.Clamp01(num);
		}

		public byte[] GetOpusPacket()
		{
			byte[] audioFrameInternal = GetAudioFrameInternal();
			if (audioFrameInternal == null)
			{
				return null;
			}
			try
			{
				ConvertBytesToSamples(audioFrameInternal, sampleBuffer);
				CalculateAmplitude(sampleBuffer, 960);
				int num = opusEncoder.Encode(sampleBuffer, 0, 960, opusPacketBuffer, 0, opusPacketBuffer.Length);
				if (num < 0)
				{
					EncodeErrors++;
					MelonLogger.Error($"Opus encoding failed with error code: {num}");
					return null;
				}
				byte[] array = new byte[num];
				Array.Copy(opusPacketBuffer, 0, array, 0, num);
				return array;
			}
			catch (Exception value)
			{
				EncodeErrors++;
				MelonLogger.Error($"Error encoding audio: {value}");
				return null;
			}
		}

		private byte[] GetAudioFrameInternal()
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			if (!isRecording || !((Sound)(ref recordSound)).hasHandle())
			{
				return null;
			}
			try
			{
				uint num = 0u;
				RESULT recordPosition = ((System)(ref fmodSystem)).getRecordPosition(selectedDeviceIndex, ref num);
				if ((int)recordPosition > 0)
				{
					return null;
				}
				uint num2 = num * 2;
				uint num3 = lastRecordPos * 2;
				int num4 = (int)((num2 < num3) ? (4800 - num3 + num2) : (num2 - num3));
				int num5 = 1920;
				if (num4 < num5)
				{
					return null;
				}
				if (num4 > num5 * 2)
				{
					DroppedFrames++;
					int num6 = num4 / num5 - 1;
					num3 = (uint)((int)num3 + num6 * num5) % 4800u;
					num4 = num5;
				}
				IntPtr intPtr = default(IntPtr);
				IntPtr intPtr2 = default(IntPtr);
				uint num7 = default(uint);
				uint num8 = default(uint);
				recordPosition = ((Sound)(ref recordSound)).@lock(num3, (uint)num5, ref intPtr, ref intPtr2, ref num7, ref num8);
				if ((int)recordPosition > 0)
				{
					return null;
				}
				if (num7 != 0)
				{
					Marshal.Copy(intPtr, frameBuffer, 0, (int)num7);
				}
				if (num8 != 0)
				{
					Marshal.Copy(intPtr2, frameBuffer, (int)num7, (int)num8);
				}
				((Sound)(ref recordSound)).unlock(intPtr, intPtr2, num7, num8);
				if (gain != 1f)
				{
					ApplyGain(frameBuffer);
				}
				CalculateFramePeak(frameBuffer);
				lastRecordPos = (uint)((num3 + num5) / 2);
				lastRecordPos %= 2400u;
				CapturedFrames++;
				return frameBuffer;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error capturing audio frame: {value}");
				return null;
			}
		}

		private void CalculateFramePeak(byte[] data)
		{
			float num = 0f;
			for (int i = 0; i < data.Length; i += 2)
			{
				short num2 = (short)(data[i] | (data[i + 1] << 8));
				float num3 = Mathf.Abs((float)num2 / 32768f);
				if (num3 > num)
				{
					num = num3;
				}
			}
			lastFramePeak = num;
		}

		private void CalculateAmplitude(short[] samples, int sampleCount)
		{
			if (samples == null || sampleCount == 0)
			{
				currentAmplitude = Mathf.Lerp(currentAmplitude, 0f, 0.15f);
				return;
			}
			float num = 0f;
			for (int i = 0; i < sampleCount; i++)
			{
				float num2 = (float)samples[i] / 32768f;
				num += num2 * num2;
			}
			float num3 = Mathf.Sqrt(num / (float)sampleCount);
			currentAmplitude = Mathf.Lerp(currentAmplitude, num3, 0.15f);
		}

		private void ConvertBytesToSamples(byte[] bytes, short[] samples)
		{
			for (int i = 0; i < samples.Length; i++)
			{
				samples[i] = (short)(bytes[i * 2] | (bytes[i * 2 + 1] << 8));
			}
		}

		private void ApplyGain(byte[] data)
		{
			for (int i = 0; i < data.Length; i += 2)
			{
				short num = (short)(data[i] | (data[i + 1] << 8));
				int num2 = (int)((float)num * gain);
				num = ((num2 <= 32767) ? ((num2 >= -32768) ? ((short)num2) : short.MinValue) : short.MaxValue);
				data[i] = (byte)((uint)num & 0xFFu);
				data[i + 1] = (byte)((uint)(num >> 8) & 0xFFu);
			}
		}

		public bool IsRecording()
		{
			return isRecording;
		}

		public bool IsInitialized()
		{
			return isInitialized;
		}

		public int GetSelectedDeviceIndex()
		{
			return selectedDeviceIndex;
		}

		public static string[] GetAvailableDevicesStatic()
		{
			//IL_0007: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				System system = Services.Player.system;
				if (!((System)(ref system)).hasHandle())
				{
					return new string[0];
				}
				int num = default(int);
				int num2 = default(int);
				((System)(ref system)).getRecordNumDrivers(ref num, ref num2);
				string[] array = new string[num2];
				string text = default(string);
				Guid val = default(Guid);
				int num3 = default(int);
				SPEAKERMODE val2 = default(SPEAKERMODE);
				int num4 = default(int);
				DRIVER_STATE val3 = default(DRIVER_STATE);
				for (int i = 0; i < num2; i++)
				{
					((System)(ref system)).getRecordDriverInfo(i, ref text, 256, ref val, ref num3, ref val2, ref num4, ref val3);
					array[i] = text;
				}
				return array;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error getting device list: {value}");
				return new string[0];
			}
		}

		public string[] GetAvailableDevices()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!((System)(ref fmodSystem)).hasHandle())
			{
				return new string[0];
			}
			try
			{
				int num = default(int);
				int num2 = default(int);
				((System)(ref fmodSystem)).getRecordNumDrivers(ref num, ref num2);
				string[] array = new string[num2];
				string text = default(string);
				Guid val = default(Guid);
				int num3 = default(int);
				SPEAKERMODE val2 = default(SPEAKERMODE);
				int num4 = default(int);
				DRIVER_STATE val3 = default(DRIVER_STATE);
				for (int i = 0; i < num2; i++)
				{
					((System)(ref fmodSystem)).getRecordDriverInfo(i, ref text, 256, ref val, ref num3, ref val2, ref num4, ref val3);
					array[i] = text;
				}
				return array;
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error getting device list: {value}");
				return new string[0];
			}
		}

		public void Dispose()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StopRecording();
				if (((Sound)(ref recordSound)).hasHandle())
				{
					((Sound)(ref recordSound)).release();
				}
				opusEncoder = null;
				currentAmplitude = 0f;
				isInitialized = false;
				Core.DebugMsg("BBSMicrophoneCapture disposed");
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error disposing BBSMicrophoneCapture: {value}");
			}
		}
	}
}