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 BabyStepsMultiplayerClient;
using BabyStepsMultiplayerClient.Audio;
using BabyStepsMultiplayerClient.Components;
using BabyStepsMultiplayerClient.Config;
using BabyStepsMultiplayerClient.Extensions;
using BabyStepsMultiplayerClient.Localization;
using BabyStepsMultiplayerClient.Networking;
using BabyStepsMultiplayerClient.Player;
using BabyStepsMultiplayerClient.UI;
using BabyStepsMultiplayerClient.UI.Elements;
using Concentus.Enums;
using Concentus.Structs;
using HarmonyLib;
using Il2Cpp;
using Il2CppBabySteps.Core.Audio;
using Il2CppCinemachine;
using Il2CppFMOD;
using Il2CppInterop.Runtime;
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 Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
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.2.4", "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.2.4")]
[assembly: AssemblyInformationalVersion("1.2.4+931a551492ce62dccc6d631d92b57b4fb3a16b8c")]
[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.2.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

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

		public static string CLIENT_VERSION;

		public const string cloneText = "(Clone)";

		public static Instance logger;

		public static UIManager uiManager;

		public static NetworkManager networkManager;

		public static Action OnConnectionStateChanged;

		public override void OnLateInitializeMelon()
		{
			CLIENT_VERSION = ((MelonBase)this).Info.Version;
			logger = ((MelonBase)this).LoggerInstance;
			try
			{
				((MelonBase)this).HarmonyInstance.PatchAll(Assembly.GetExecutingAssembly());
			}
			catch (Exception value)
			{
				logger.Error($"Harmony patching failed: {value}");
			}
			ManagedEnumerator.Register();
			uiManager = new UIManager();
			networkManager = new NetworkManager();
			MultiplayerMenu.Initialize();
			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();
			MultiplayerMenu.Update();
			if (LocalPlayer.Instance != null)
			{
				LocalPlayer.Instance.Update();
			}
			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()
		{
			if (networkManager != null)
			{
				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 MenuInjectionLibrary
	{
		public sealed class RuntimeTabMenu
		{
			private readonly string[] _tabNames;

			private readonly List<Selectable>[] _pageSelectables;

			private int _setTabFrame = -1;

			private Selectable[] _fixedItems;

			public RectTransform Root { get; internal set; }

			public RectTransform Header { get; internal set; }

			public Button[] Tabs { get; internal set; }

			public RectTransform[] Pages { get; internal set; }

			public int ActiveTab { get; private set; }

			public int TabCount
			{
				get
				{
					Button[] tabs = Tabs;
					return (tabs != null) ? tabs.Length : 0;
				}
			}

			internal MenuItemList ManagedItemList { get; set; }

			internal Color NativeHighlightedColor { get; set; } = TabHighlighted;


			internal void SetFixedMenuItems(params Selectable[] items)
			{
				_fixedItems = items;
			}

			internal RuntimeTabMenu(string[] tabNames)
			{
				//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)
				_tabNames = tabNames;
				_pageSelectables = new List<Selectable>[tabNames.Length];
				for (int i = 0; i < tabNames.Length; i++)
				{
					_pageSelectables[i] = new List<Selectable>();
				}
			}

			public RectTransform GetPage(int index)
			{
				return (Pages != null && index >= 0 && index < Pages.Length) ? Pages[index] : null;
			}

			public void OnShown()
			{
				SetActiveTab(ActiveTab);
			}

			internal void RegisterPageSelectable(int page, Selectable s)
			{
				if (!((Object)(object)s == (Object)null) && _pageSelectables != null && page >= 0 && page < _pageSelectables.Length)
				{
					_pageSelectables[page].Add(s);
				}
			}

			public void SetActiveTab(int index)
			{
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: 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_0187: 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_0213: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				if (Tabs == null || Pages == null || index < 0 || index >= TabCount)
				{
					return;
				}
				int frameCount = Time.frameCount;
				if (frameCount == _setTabFrame)
				{
					return;
				}
				_setTabFrame = frameCount;
				ActiveTab = index;
				List<Selectable>[] pageSelectables = _pageSelectables;
				List<Selectable> list = ((pageSelectables != null) ? pageSelectables[index] : null);
				for (int i = 0; i < TabCount; i++)
				{
					bool flag = i == index;
					if ((Object)(object)Pages[i] != (Object)null)
					{
						CanvasGroup component = ((Component)Pages[i]).GetComponent<CanvasGroup>();
						if ((Object)(object)component != (Object)null)
						{
							component.alpha = (flag ? 1f : 0f);
							component.interactable = flag;
							component.blocksRaycasts = flag;
						}
						if (flag)
						{
							Il2CppArrayBase<TMP_Text> componentsInChildren = ((Component)Pages[i]).GetComponentsInChildren<TMP_Text>(true);
							for (int j = 0; j < componentsInChildren.Length; j++)
							{
								if ((Object)(object)componentsInChildren[j] != (Object)null)
								{
									componentsInChildren[j].ForceMeshUpdate(false, false);
								}
							}
						}
					}
					if (!((Object)(object)Tabs[i] != (Object)null))
					{
						continue;
					}
					Color val = (flag ? TabSelected : TabUnselected);
					Image component2 = ((Component)Tabs[i]).GetComponent<Image>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Graphic)component2).color = Color.white;
						((Graphic)component2).CrossFadeColor(val, 0f, true, true);
					}
					TMP_Text componentInChildren = ((Component)Tabs[i]).GetComponentInChildren<TMP_Text>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						if (_tabNames != null && i < _tabNames.Length)
						{
							componentInChildren.text = _tabNames[i];
						}
						((Graphic)componentInChildren).color = TabText;
						componentInChildren.ForceMeshUpdate(false, false);
					}
					ColorBlock colors = ((Selectable)Tabs[i]).colors;
					((ColorBlock)(ref colors)).normalColor = val;
					((ColorBlock)(ref colors)).selectedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).highlightedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).pressedColor = NativeHighlightedColor;
					((ColorBlock)(ref colors)).disabledColor = val;
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((Selectable)Tabs[i]).colors = colors;
				}
				int num = list?.Count ?? 0;
				Selectable[] fixedItems = _fixedItems;
				int num2 = ((fixedItems != null) ? fixedItems.Length : 0);
				List<Selectable> list2 = new List<Selectable>(num + num2);
				for (int k = 0; k < num; k++)
				{
					if ((Object)(object)list[k] != (Object)null)
					{
						list2.Add(list[k]);
					}
				}
				for (int l = 0; l < num2; l++)
				{
					if ((Object)(object)_fixedItems[l] != (Object)null)
					{
						list2.Add(_fixedItems[l]);
					}
				}
				if ((Object)(object)ManagedItemList != (Object)null)
				{
					GameObject[] array = (GameObject[])(object)new GameObject[list2.Count];
					for (int m = 0; m < list2.Count; m++)
					{
						array[m] = ((Component)list2[m]).gameObject;
					}
					ManagedItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit(array);
				}
				for (int n = 0; n < list2.Count; n++)
				{
					Selectable val2 = list2[n];
					Navigation navigation = val2.navigation;
					navigation.mode = (Mode)4;
					navigation.selectOnUp = ((n > 0) ? list2[n - 1] : null);
					navigation.selectOnDown = ((n < list2.Count - 1) ? list2[n + 1] : null);
					navigation.selectOnLeft = null;
					navigation.selectOnRight = null;
					val2.navigation = navigation;
				}
			}
		}

		public sealed class TabBuilder
		{
			internal TabBuilder()
			{
			}

			public TMP_Text AddLabel(string text)
			{
				return MenuInjectionLibrary.AddLabel(text, (RectTransform)null);
			}

			public Button AddButton(string text, UnityAction onClick)
			{
				return MenuInjectionLibrary.AddButton(text, onClick, (RectTransform)null);
			}

			public Toggle AddToggle(string text, bool initial, UnityAction<bool> onChange)
			{
				return MenuInjectionLibrary.AddToggle(text, initial, onChange, (RectTransform)null);
			}

			public Slider AddSlider(string text, float min, float max, float value, UnityAction<float> onChange, bool wholeNumbers = false)
			{
				return MenuInjectionLibrary.AddSlider(text, min, max, value, onChange, wholeNumbers, (RectTransform)null);
			}

			public Button AddInputField(string placeholder = "", UnityAction<string> onChange = null, string initialValue = null)
			{
				return MenuInjectionLibrary.AddInputField(placeholder, onChange, initialValue, (RectTransform)null);
			}

			public Image AddImage(Color color, float height = 52f)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return MenuInjectionLibrary.AddImage(color, height, (RectTransform)null);
			}
		}

		public sealed class MenuBuilder
		{
			internal readonly string _mainButtonLabel;

			internal readonly List<(string name, Action<TabBuilder> configure)> _tabs = new List<(string, Action<TabBuilder>)>();

			internal readonly List<(string label, UnityAction action)> _fixed = new List<(string, UnityAction)>();

			internal float _sideMargin;

			internal float _topMargin;

			internal MenuBuilder(string mainButtonLabel)
			{
				_mainButtonLabel = mainButtonLabel;
			}

			public MenuBuilder AddTab(string name, Action<TabBuilder> configure)
			{
				_tabs.Add((name, configure));
				return this;
			}

			public MenuBuilder AddFixedButton(string label, UnityAction action = null)
			{
				_fixed.Add((label, action));
				return this;
			}

			public MenuBuilder WithMargin(float sideMargin, float topMargin)
			{
				_sideMargin = sideMargin;
				_topMargin = topMargin;
				return this;
			}

			public InjectedMenu Build()
			{
				InjectedMenu injectedMenu = new InjectedMenu(this);
				if (!_registeredMenus.Contains(injectedMenu))
				{
					_registeredMenus.Add(injectedMenu);
				}
				return injectedMenu;
			}
		}

		internal sealed class InputFieldInfo
		{
			public string Value = "";

			public TMP_Text DisplayText;

			public UnityAction<string> OnChanged;

			public string Placeholder = "";

			public RectTransform Viewport;

			public Color ActiveColor = Color.white;

			public Color PlaceholderColor = new Color(1f, 1f, 1f, 0.45f);

			public Button OwnerButton;

			public Image CursorImage;
		}

		public sealed class InjectedMenu
		{
			[CompilerGenerated]
			private sealed class <EnforceKeyboardFontSizesCoroutine>d__73 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public InjectedMenu <>4__this;

				private int <i>5__1;

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

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

				[DebuggerHidden]
				public <EnforceKeyboardFontSizesCoroutine>d__73(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;
						<i>5__1 = 0;
						break;
					case 1:
						<>1__state = -1;
						<i>5__1++;
						break;
					}
					if (<i>5__1 < 3)
					{
						<>4__this.ForceKeyboardFontSizes();
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					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();
				}
			}

			private readonly string _mainButtonLabel;

			private readonly List<(string name, Action<TabBuilder> configure)> _tabDescs;

			private readonly List<(string label, UnityAction action)> _fixedDescs;

			private Menu _activeMenu;

			private RuntimeTabMenu _tabMenu;

			private bool _contentBuilt;

			private bool _hasAttemptedInitialDump;

			private GameObject _mainButtonObj;

			private Button _mainButton;

			private Transform _mainMenuRoot;

			private CanvasGroup _mainMenuCG;

			private MenuItemList _mainMenuItemList;

			private GameObject _submenuObj;

			private CanvasGroup _submenuCG;

			private MenuItemList _submenuItemList;

			private readonly List<Button> _fixedButtonInstances = new List<Button>();

			private GameObject _kbRoot;

			private CanvasGroup _kbCG;

			private Button[][] _kbCharRows;

			private string[][] _kbLowerRows;

			private string[][] _kbUpperRows;

			private Button[] _kbSpecialRow;

			private readonly List<GameObject> _kbAllButtons = new List<GameObject>();

			private bool _kbShift;

			private bool _kbUseLowercaseFontForKeyLabels;

			private Button _kbShiftBtn;

			private InputFieldInfo _kbActiveField;

			private Button _kbReturnButton;

			private Action _kbOnDone;

			private bool _kbBuilt;

			private bool _kbHasEdited;

			private int _kbNavFrame = -1;

			private float _kbCursorTimer = 0f;

			private bool _kbCursorVisible = true;

			private InputFieldInfo _mouseTypingField;

			private bool _mouseTypingActive;

			private int _mouseTypingNavFrame = -1;

			private int _mouseCursorBlinkFrame = -1;

			private bool _mouseHasEdited;

			private float _mouseCursorTimer = 0f;

			private bool _mouseCursorVisible = true;

			private bool _kbUsingOverlay;

			private const float CanvasW = 860f;

			private const float CanvasH = 650f;

			private const float ContentH = 460f;

			private const float ContentPad = 10f;

			private readonly float _sideMargin;

			private readonly float _topMargin;

			private RectTransform _submenuRect;

			internal bool IsMouseTyping => _mouseTypingActive;

			private bool KbVisible => (Object)(object)_kbCG != (Object)null && _kbCG.alpha > 0.5f;

			internal bool IsKeyboardOpen => _kbActiveField != null;

			private bool IsKbButton(GameObject go)
			{
				return (Object)(object)go != (Object)null && _kbAllButtons.Contains(go);
			}

			internal InjectedMenu(MenuBuilder b)
			{
				_mainButtonLabel = b._mainButtonLabel;
				_tabDescs = b._tabs;
				_fixedDescs = b._fixed;
				_sideMargin = b._sideMargin;
				_topMargin = b._topMargin;
			}

			public Button GetFixedButton(int index)
			{
				return (index >= 0 && index < _fixedButtonInstances.Count) ? _fixedButtonInstances[index] : null;
			}

			public void OnMenuAwake(Menu menu)
			{
				_activeMenu = menu;
				TryInject(menu, "Awake");
			}

			public void OnMenuPreUpdate(Menu menu)
			{
				//IL_0485: Unknown result type (might be due to invalid IL or missing references)
				//IL_048b: Invalid comparison between Unknown and I4
				_activeMenu = menu;
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				if ((Object)(object)_mainButtonObj == (Object)null || (Object)(object)_submenuObj == (Object)null)
				{
					TryInject(menu, "PreUpdateRetry");
				}
				bool submenuVisible = GetSubmenuVisible();
				bool kbVisible = KbVisible;
				bool isCapturingKeybind = MultiplayerMenu.IsCapturingKeybind;
				if (kbVisible)
				{
					HandleKeyboardInput(menu, isCapturingKeybind, submenuVisible);
				}
				if (submenuVisible && !kbVisible && !isCapturingKeybind)
				{
					TryHandleCancel(menu);
					if (_mouseTypingActive && _mouseTypingField != null && Time.frameCount != _mouseTypingNavFrame)
					{
						_mouseTypingNavFrame = Time.frameCount;
						bool flag = false;
						string inputString = Input.inputString;
						for (int i = 0; i < inputString.Length; i++)
						{
							char c = inputString[i];
							switch (c)
							{
							case '\b':
								if (_mouseTypingField.Value.Length > 0)
								{
									_mouseTypingField.Value = _mouseTypingField.Value.Substring(0, _mouseTypingField.Value.Length - 1);
									flag = true;
								}
								continue;
							default:
								if (c != '\n')
								{
									_mouseTypingField.Value += c;
									flag = true;
									continue;
								}
								break;
							case '\r':
								break;
							}
							_mouseTypingField.OnChanged?.Invoke(_mouseTypingField.Value);
							CloseMouseTyping(restoreSelection: false);
							flag = false;
							break;
						}
						if (Input.GetKeyDown((KeyCode)27) && _mouseTypingActive)
						{
							CloseMouseTyping();
							flag = false;
						}
						if (Input.GetMouseButtonDown(0) && _mouseTypingActive && (Object)(object)_mouseTypingField?.OwnerButton != (Object)null && !IsPointerOverGameObject(((Component)_mouseTypingField.OwnerButton).gameObject))
						{
							CloseMouseTyping(restoreSelection: false);
							flag = false;
						}
						if (flag && _mouseTypingField != null)
						{
							_mouseHasEdited = true;
							RefreshMouseTypingDisplay();
							_mouseTypingField.OnChanged?.Invoke(_mouseTypingField.Value);
						}
					}
					if (_mouseTypingActive && (Object)(object)_mouseTypingField?.DisplayText != (Object)null && Time.frameCount != _mouseCursorBlinkFrame)
					{
						_mouseCursorBlinkFrame = Time.frameCount;
						_mouseCursorTimer += Time.unscaledDeltaTime;
						if (_mouseCursorTimer >= 0.53f)
						{
							_mouseCursorTimer = 0f;
							_mouseCursorVisible = !_mouseCursorVisible;
							RefreshMouseTypingDisplay();
						}
					}
					if (_tabMenu != null && menu.rwPlayer != null)
					{
						if (menu.rwPlayer.GetButtonDown(18))
						{
							_tabMenu.SetActiveTab((_tabMenu.ActiveTab - 1 + _tabMenu.TabCount) % _tabMenu.TabCount);
						}
						else if (menu.rwPlayer.GetButtonDown(17))
						{
							_tabMenu.SetActiveTab((_tabMenu.ActiveTab + 1) % _tabMenu.TabCount);
						}
					}
				}
				if (kbVisible)
				{
					if (submenuVisible && (Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
				}
				else if (submenuVisible)
				{
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
					if (_mouseTypingActive && (Object)(object)_mouseTypingField?.OwnerButton != (Object)null && (Object)(object)_submenuItemList != (Object)null)
					{
						_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { ((Component)_mouseTypingField.OwnerButton).gameObject });
					}
				}
				else if ((int)menu.currentMenuScreen == 0 && (Object)(object)_mainMenuItemList != (Object)null)
				{
					MenuItemList.active = _mainMenuItemList;
				}
			}

			private void HandleKeyboardInput(Menu menu, bool isCapturingKeybind, bool submenuVisible)
			{
				EventSystem current = EventSystem.current;
				GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
				if (((Object)(object)val == (Object)null || !IsKbButton(val)) && _kbCharRows != null && _kbCharRows.Length != 0)
				{
					val = ((Component)_kbCharRows[0][0]).gameObject;
					if (current != null)
					{
						current.SetSelectedGameObject(val);
					}
				}
				if (!isCapturingKeybind && Time.frameCount != _kbNavFrame)
				{
					_kbNavFrame = Time.frameCount;
					if ((Object)(object)val != (Object)null && IsKbButton(val) && menu.rwPlayer != null)
					{
						float axis = menu.rwPlayer.GetAxis(12);
						float axisPrev = menu.rwPlayer.GetAxisPrev(12);
						float axis2 = menu.rwPlayer.GetAxis(13);
						float axisPrev2 = menu.rwPlayer.GetAxisPrev(13);
						Selectable component = val.GetComponent<Selectable>();
						Selectable val2 = null;
						if (axis2 < -0.5f && axisPrev2 >= -0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnDown : null);
						}
						else if (axis2 > 0.5f && axisPrev2 <= 0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnUp : null);
						}
						else if (axis > 0.5f && axisPrev <= 0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnRight : null);
						}
						else if (axis < -0.5f && axisPrev >= -0.5f)
						{
							val2 = ((component != null) ? component.navigation.selectOnLeft : null);
						}
						if ((Object)(object)val2 != (Object)null)
						{
							if (current != null)
							{
								current.SetSelectedGameObject(((Component)val2).gameObject);
							}
							val = ((Component)val2).gameObject;
						}
						if (_kbUsingOverlay && (Input.GetKeyDown((KeyCode)330) || Input.GetKeyDown((KeyCode)331)))
						{
							Button val3 = ((val != null) ? val.GetComponent<Button>() : null);
							if (val3 != null)
							{
								((UnityEvent)val3.onClick).Invoke();
							}
						}
					}
					if (menu.rwPlayer != null && (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)332) || menu.rwPlayer.GetButtonDown(15)))
					{
						CloseKeyboardOverlay((Object)(object)_kbReturnButton == (Object)null && _kbOnDone != null);
					}
					if ((Object)(object)_kbActiveField?.DisplayText != (Object)null)
					{
						_kbCursorTimer += Time.unscaledDeltaTime;
						if (_kbCursorTimer >= 0.53f)
						{
							_kbCursorTimer = 0f;
							_kbCursorVisible = !_kbCursorVisible;
							KbBlinkCursor();
						}
					}
				}
				if (submenuVisible && (Object)(object)_submenuItemList != (Object)null && (Object)(object)val != (Object)null)
				{
					_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { val });
				}
			}

			public void OnMenuUpdate(Menu menu)
			{
				_activeMenu = menu;
				if (!((Object)(object)menu == (Object)null))
				{
					if (Input.GetKeyDown((KeyCode)289))
					{
					}
					if (Input.GetKeyDown((KeyCode)290))
					{
						Reset();
						TryInject(menu, "Reinject_F9");
					}
					if ((Object)(object)_mainButtonObj == (Object)null || (Object)(object)_submenuObj == (Object)null)
					{
						TryInject(menu, "UpdateRetry");
					}
					UpdateVisibility(menu);
					EnsureSelection();
				}
			}

			private void TryInject(Menu menu, string reason)
			{
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				ResolveExisting(menu);
				if (!_hasAttemptedInitialDump)
				{
					_hasAttemptedInitialDump = true;
				}
				if ((Object)(object)menu.mainMenuCanvas == (Object)null)
				{
					return;
				}
				Button val = FindTemplateButton(menu);
				if (!((Object)(object)val == (Object)null))
				{
					_mainMenuRoot = ((Component)val).transform.parent;
					if ((Object)(object)_mainMenuRoot != (Object)null)
					{
						_mainMenuCG = ((Component)_mainMenuRoot).GetComponent<CanvasGroup>() ?? ((Component)_mainMenuRoot).gameObject.AddComponent<CanvasGroup>();
						_mainMenuItemList = ((Component)_mainMenuRoot).GetComponent<MenuItemList>();
					}
					if ((Object)(object)_mainButtonObj == (Object)null)
					{
						_mainButtonObj = BuildMainButton(menu, val);
					}
					if ((Object)(object)_submenuObj == (Object)null)
					{
						_submenuObj = BuildSubmenu(menu, val);
					}
					IntegrateIntoMainItemList();
					EnsureTabContent(menu, val);
					UpdateVisibility(menu);
				}
			}

			private void EnsureTabContent(Menu menu, Button tmpl)
			{
				if (_contentBuilt || (Object)(object)_submenuObj == (Object)null)
				{
					return;
				}
				Transform obj = _submenuObj.transform.Find("CustomSettingsContentRoot");
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Button nativeTabSource = null;
				Menu me = Menu.me;
				if ((Object)(object)((me != null) ? me.tabs : null) != (Object)null)
				{
					Transform transform = ((Component)Menu.me.tabs).transform;
					for (int i = 0; i < transform.childCount; i++)
					{
						Transform child = transform.GetChild(i);
						Button val2 = ((child != null) ? ((Component)child).GetComponent<Button>() : null);
						if ((Object)(object)val2 != (Object)null)
						{
							nativeTabSource = val2;
							break;
						}
					}
				}
				string[] array = new string[_tabDescs.Count];
				for (int j = 0; j < _tabDescs.Count; j++)
				{
					array[j] = _tabDescs[j].name;
				}
				_tabMenu = BuildNativeTabMenu(array, val, nativeTabSource, tmpl);
				_tabMenu.ManagedItemList = _submenuItemList;
				Selectable[] array2 = (Selectable[])(object)new Selectable[_fixedButtonInstances.Count];
				for (int k = 0; k < _fixedButtonInstances.Count; k++)
				{
					array2[k] = (Selectable)(object)_fixedButtonInstances[k];
				}
				_tabMenu.SetFixedMenuItems(array2);
				Toggle toggle = FindToggleTemplate(menu);
				Slider slider = FindSliderTemplate(menu);
				TabBuilder obj2 = new TabBuilder();
				_currentInjectedMenu = this;
				for (int l = 0; l < _tabDescs.Count; l++)
				{
					ConfigureTabPage(_tabMenu, l, tmpl, toggle, slider);
					_tabDescs[l].configure?.Invoke(obj2);
				}
				_currentInjectedMenu = null;
				BuildKeyboard(menu, tmpl);
				_tabMenu.SetActiveTab(0);
				_contentBuilt = true;
			}

			private GameObject BuildMainButton(Menu menu, Button tmpl)
			{
				//IL_006f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, ((Component)tmpl).transform.parent);
				((Object)val).name = "BBSMP_MainMenuButton";
				StripLocalizationComponents(val);
				val.transform.SetSiblingIndex(((Component)tmpl).transform.GetSiblingIndex() + 1);
				RectTransform component = val.GetComponent<RectTransform>();
				RectTransform component2 = ((Component)tmpl).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					component.anchorMin = component2.anchorMin;
					component.anchorMax = component2.anchorMax;
					component.pivot = component2.pivot;
					component.sizeDelta = component2.sizeDelta;
					((Transform)component).localScale = Vector3.one;
					float num = Mathf.Max(45f, Mathf.Abs(component2.sizeDelta.y) + 10f);
					component.anchoredPosition = component2.anchoredPosition + new Vector2(0f, num);
				}
				_mainButton = val.GetComponent<Button>();
				ClearButtonEvents(_mainButton);
				Button mainButton = _mainButton;
				if (mainButton != null)
				{
					((UnityEvent)mainButton.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						SetSubmenuVisible(isVisible: true);
					}));
				}
				SetButtonLabel(val, _mainButtonLabel);
				return val;
			}

			private GameObject BuildSubmenu(Menu menu, Button tmpl)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0042: 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_006e: 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_009a: 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_00e7: Expected O, but got Unknown
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: 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_018f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: 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_02a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("BBSMP_SubmenuCanvas");
				val.transform.SetParent(menu.mainMenuCanvas.transform, false);
				val.transform.SetAsLastSibling();
				RectTransform val2 = val.AddComponent<RectTransform>();
				val2.anchorMin = new Vector2(0f, 1f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 1f);
				val2.sizeDelta = new Vector2(860f, 650f);
				val2.anchoredPosition = new Vector2(10f, -10f);
				_submenuCG = val.AddComponent<CanvasGroup>();
				_submenuCG.alpha = 0f;
				_submenuCG.blocksRaycasts = false;
				_submenuCG.interactable = false;
				GameObject val3 = new GameObject("CustomSettingsContentRoot");
				val3.transform.SetParent(val.transform, false);
				RectTransform val4 = val3.AddComponent<RectTransform>();
				val4.anchorMin = new Vector2(0f, 1f);
				val4.anchorMax = new Vector2(0f, 1f);
				val4.pivot = new Vector2(0f, 1f);
				val4.sizeDelta = new Vector2(800f, 460f);
				val4.anchoredPosition = new Vector2(10f, -10f);
				RectTransform component = ((Component)tmpl).GetComponent<RectTransform>();
				float num = (((Object)(object)component != (Object)null) ? Mathf.Max(200f, component.sizeDelta.x) : 520f);
				float num2 = (((Object)(object)component != (Object)null) ? Mathf.Clamp(component.sizeDelta.y, 40f, 72f) : 52f);
				_fixedButtonInstances.Clear();
				for (int num3 = _fixedDescs.Count - 1; num3 >= 0; num3--)
				{
					(string label, UnityAction action) tuple = _fixedDescs[num3];
					string item = tuple.label;
					UnityAction item2 = tuple.action;
					GameObject val5 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, val.transform);
					((Object)val5).name = $"BBSMP_Fixed_{num3}";
					StripLocalizationComponents(val5);
					Button component2 = val5.GetComponent<Button>();
					ClearButtonEvents(component2);
					SetButtonLabel(val5, item);
					RectTransform component3 = val5.GetComponent<RectTransform>();
					component3.anchorMin = Vector2.zero;
					component3.anchorMax = Vector2.zero;
					component3.pivot = Vector2.zero;
					component3.sizeDelta = new Vector2(num, num2);
					int num4 = _fixedDescs.Count - 1 - num3;
					component3.anchoredPosition = new Vector2(10f, 10f + (float)num4 * (num2 + 10f));
					UnityAction capturedAction = item2;
					if (component2 != null)
					{
						((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							UnityAction obj = capturedAction;
							if (obj != null)
							{
								obj.Invoke();
							}
							SetSubmenuVisible(isVisible: false);
						}));
					}
					_fixedButtonInstances.Insert(0, component2);
				}
				_submenuItemList = val.AddComponent<MenuItemList>();
				_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[0]);
				_submenuRect = val2;
				ApplyMargin();
				return val;
			}

			private void BuildKeyboard(Menu menu, Button tmpl, bool useLowercaseFontForLetterKeys = true)
			{
				//IL_037c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0386: Expected O, but got Unknown
				//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_040e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0425: Unknown result type (might be due to invalid IL or missing references)
				//IL_0453: Unknown result type (might be due to invalid IL or missing references)
				//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0610: Unknown result type (might be due to invalid IL or missing references)
				//IL_0627: Unknown result type (might be due to invalid IL or missing references)
				//IL_063b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0659: Unknown result type (might be due to invalid IL or missing references)
				//IL_0879: Unknown result type (might be due to invalid IL or missing references)
				//IL_0890: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_08be: Unknown result type (might be due to invalid IL or missing references)
				//IL_08cf: Unknown result type (might be due to invalid IL or missing references)
				if (_kbBuilt || (Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null || (Object)(object)tmpl == (Object)null)
				{
					return;
				}
				_kbUseLowercaseFontForKeyLabels = useLowercaseFontForLetterKeys;
				_kbLowerRows = new string[4][]
				{
					new string[11]
					{
						"1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
						"."
					},
					new string[10] { "q", "w", "e", "r", "t", "y", "u", "i", "o", "p" },
					new string[9] { "a", "s", "d", "f", "g", "h", "j", "k", "l" },
					new string[7] { "z", "x", "c", "v", "b", "n", "m" }
				};
				_kbUpperRows = new string[4][]
				{
					new string[11]
					{
						"1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
						"."
					},
					new string[10] { "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P" },
					new string[9] { "A", "S", "D", "F", "G", "H", "J", "K", "L" },
					new string[7] { "Z", "X", "C", "V", "B", "N", "M" }
				};
				int num = _kbLowerRows.Length + 1;
				float num2 = 20f + (float)num * 44f + (float)(num - 1) * 4f - 15f;
				float num3 = 780f;
				int num4 = 0;
				for (int i = 0; i < _kbLowerRows.Length; i++)
				{
					if (_kbLowerRows[i].Length > num4)
					{
						num4 = _kbLowerRows[i].Length;
					}
				}
				float num5 = (num3 - (float)(num4 - 1) * 6f) / (float)num4;
				_kbRoot = new GameObject("BBSMP_Keyboard");
				_kbRoot.transform.SetParent(menu.mainMenuCanvas.transform, false);
				_kbRoot.transform.SetAsLastSibling();
				RectTransform val = _kbRoot.AddComponent<RectTransform>();
				val.anchorMin = new Vector2(0.5f, 0f);
				val.anchorMax = new Vector2(0.5f, 0f);
				val.pivot = new Vector2(0.5f, 0f);
				val.sizeDelta = new Vector2(800f, num2);
				val.anchoredPosition = new Vector2(0f, 100f);
				Image val2 = _kbRoot.AddComponent<Image>();
				((Graphic)val2).color = new Color(0.05f, 0.11f, 0.18f, 0.97f);
				_kbCG = _kbRoot.AddComponent<CanvasGroup>();
				_kbCG.alpha = 0f;
				_kbCG.interactable = false;
				_kbCG.blocksRaycasts = false;
				_kbCharRows = new Button[_kbLowerRows.Length][];
				float num6 = -10f;
				for (int j = 0; j < _kbLowerRows.Length; j++)
				{
					int num7 = _kbLowerRows[j].Length;
					float num8 = num5;
					float num9 = (float)num7 * num8 + (float)(num7 - 1) * 6f;
					float num10 = (0f - num9) * 0.5f;
					_kbCharRows[j] = (Button[])(object)new Button[num7];
					for (int k = 0; k < num7; k++)
					{
						int capturedRow = j;
						int capturedCol = k;
						GameObject val3 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, _kbRoot.transform);
						((Object)val3).name = "BBSMP_Key_" + _kbUpperRows[j][k];
						StripLocalizationComponents(val3);
						Button component = val3.GetComponent<Button>();
						ClearButtonEvents(component);
						if ((Object)(object)component != (Object)null)
						{
							((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
							{
								KbType(capturedRow, capturedCol);
							}));
						}
						SetButtonLabel(val3, _kbLowerRows[j][k], _kbUseLowercaseFontForKeyLabels);
						TMP_Text componentInChildren = val3.GetComponentInChildren<TMP_Text>(true);
						if ((Object)(object)componentInChildren != (Object)null)
						{
							componentInChildren.fontSize = 20f;
						}
						RectTransform component2 = val3.GetComponent<RectTransform>();
						component2.anchorMin = new Vector2(0.5f, 1f);
						component2.anchorMax = new Vector2(0.5f, 1f);
						component2.pivot = new Vector2(0f, 1f);
						component2.sizeDelta = new Vector2(num8, 44f);
						component2.anchoredPosition = new Vector2(num10 + (float)k * (num8 + 6f), num6);
						_kbCharRows[j][k] = component;
						_kbAllButtons.Add(val3);
					}
					num6 -= 48f;
				}
				float num11 = num3 - 216f - 18f;
				float[] obj = new float[4] { 72f, 0f, 72f, 72f };
				obj[1] = num11;
				float[] array = obj;
				string[] array2 = new string[4] { "Shift", "Space", "Back", "Done" };
				_kbSpecialRow = (Button[])(object)new Button[4];
				float num12 = (0f - num3) * 0.5f;
				for (int l = 0; l < 4; l++)
				{
					GameObject val4 = Object.Instantiate<GameObject>(((Component)tmpl).gameObject, _kbRoot.transform);
					((Object)val4).name = "BBSMP_Key_" + array2[l];
					StripLocalizationComponentsImmediate(val4);
					Button component3 = val4.GetComponent<Button>();
					ClearButtonEvents(component3);
					if ((Object)(object)component3 != (Object)null)
					{
						switch (l)
						{
						case 0:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbToggleShift));
							_kbShiftBtn = component3;
							break;
						case 1:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbSpace));
							break;
						case 2:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbBackspace));
							break;
						case 3:
							((UnityEvent)component3.onClick).AddListener(UnityAction.op_Implicit((Action)KbDone));
							break;
						}
					}
					SetButtonLabel(val4, array2[l]);
					TMP_Text componentInChildren2 = val4.GetComponentInChildren<TMP_Text>(true);
					if ((Object)(object)componentInChildren2 != (Object)null)
					{
						componentInChildren2.fontSize = 20f;
					}
					RectTransform component4 = val4.GetComponent<RectTransform>();
					component4.anchorMin = new Vector2(0.5f, 1f);
					component4.anchorMax = new Vector2(0.5f, 1f);
					component4.pivot = new Vector2(0f, 1f);
					component4.sizeDelta = new Vector2(array[l], 44f);
					component4.anchoredPosition = new Vector2(num12, num6);
					num12 += array[l] + 6f;
					_kbSpecialRow[l] = component3;
					_kbAllButtons.Add(val4);
				}
				WireKeyboardNavigation();
				ForceKeyboardFontSizes();
				MelonCoroutines.Start(EnforceKeyboardFontSizesCoroutine());
				_kbBuilt = true;
			}

			private void WireKeyboardNavigation()
			{
				//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_002c: Expected O, but got Unknown
				//IL_0171: 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_0180: Expected O, but got Unknown
				for (int i = 0; i < _kbCharRows.Length; i++)
				{
					int num = _kbCharRows[i].Length;
					for (int j = 0; j < num; j++)
					{
						Navigation val = new Navigation
						{
							mode = (Mode)0
						};
						val.selectOnLeft = (Selectable)(object)((j > 0) ? _kbCharRows[i][j - 1] : null);
						val.selectOnRight = (Selectable)(object)((j < num - 1) ? _kbCharRows[i][j + 1] : null);
						val.selectOnUp = (Selectable)(object)((i > 0) ? _kbCharRows[i - 1][Mathf.Min(j, _kbCharRows[i - 1].Length - 1)] : null);
						if (i < _kbCharRows.Length - 1)
						{
							val.selectOnDown = (Selectable)(object)_kbCharRows[i + 1][Mathf.Min(j, _kbCharRows[i + 1].Length - 1)];
						}
						else
						{
							int num2 = Mathf.Clamp(j * _kbSpecialRow.Length / _kbCharRows[i].Length, 0, _kbSpecialRow.Length - 1);
							val.selectOnDown = (Selectable)(object)_kbSpecialRow[num2];
						}
						((Selectable)_kbCharRows[i][j]).navigation = val;
					}
				}
				int num3 = _kbCharRows.Length - 1;
				int num4 = _kbCharRows[num3].Length;
				for (int k = 0; k < _kbSpecialRow.Length; k++)
				{
					Navigation val2 = new Navigation
					{
						mode = (Mode)0
					};
					val2.selectOnLeft = (Selectable)(object)((k > 0) ? _kbSpecialRow[k - 1] : null);
					val2.selectOnRight = (Selectable)(object)((k < _kbSpecialRow.Length - 1) ? _kbSpecialRow[k + 1] : null);
					val2.selectOnDown = null;
					int num5 = Mathf.Clamp(k * num4 / _kbSpecialRow.Length, 0, num4 - 1);
					val2.selectOnUp = (Selectable)(object)_kbCharRows[num3][num5];
					((Selectable)_kbSpecialRow[k]).navigation = val2;
				}
			}

			private void KbType(int row, int col)
			{
				if (_kbActiveField != null)
				{
					string[][] array = (_kbShift ? _kbUpperRows : _kbLowerRows);
					_kbActiveField.Value += array[row][col];
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
					if (_kbShift)
					{
						_kbShift = false;
						KbRefreshKeyLabels();
					}
				}
			}

			private void KbSpace()
			{
				if (_kbActiveField != null)
				{
					_kbActiveField.Value += " ";
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
				}
			}

			private void KbBackspace()
			{
				if (_kbActiveField != null && _kbActiveField.Value.Length != 0)
				{
					_kbActiveField.Value = _kbActiveField.Value.Substring(0, _kbActiveField.Value.Length - 1);
					_kbHasEdited = true;
					KbRefreshDisplay();
					_kbActiveField.OnChanged?.Invoke(_kbActiveField.Value);
				}
			}

			private void KbToggleShift()
			{
				_kbShift = !_kbShift;
				KbRefreshKeyLabels();
			}

			private void KbRefreshKeyLabels()
			{
				if (_kbCharRows == null)
				{
					return;
				}
				string[][] array = (_kbShift ? _kbUpperRows : _kbLowerRows);
				for (int i = 0; i < _kbCharRows.Length; i++)
				{
					for (int j = 0; j < _kbCharRows[i].Length; j++)
					{
						SetButtonLabel(((Component)_kbCharRows[i][j]).gameObject, array[i][j], _kbUseLowercaseFontForKeyLabels);
					}
				}
				if ((Object)(object)_kbShiftBtn != (Object)null)
				{
					SetButtonLabel(((Component)_kbShiftBtn).gameObject, _kbShift ? "SHIFT" : "Shift");
					ForceKeyboardFontSize(((Component)_kbShiftBtn).gameObject);
				}
			}

			private void ForceKeyboardFontSizes()
			{
				if (_kbAllButtons.Count != 0)
				{
					for (int i = 0; i < _kbAllButtons.Count; i++)
					{
						ForceKeyboardFontSize(_kbAllButtons[i]);
					}
				}
			}

			private static void ForceKeyboardFontSize(GameObject keyObj)
			{
				if (!((Object)(object)keyObj == (Object)null))
				{
					TMP_Text componentInChildren = keyObj.GetComponentInChildren<TMP_Text>(true);
					if (!((Object)(object)componentInChildren == (Object)null))
					{
						componentInChildren.fontSize = 20f;
						componentInChildren.ForceMeshUpdate(false, false);
					}
				}
			}

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

			private void KbRefreshDisplay()
			{
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: 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_00d8: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
				InputFieldInfo kbActiveField = _kbActiveField;
				if (kbActiveField != null && !((Object)(object)kbActiveField.DisplayText == (Object)null))
				{
					TMP_Text displayText = kbActiveField.DisplayText;
					_kbCursorVisible = true;
					_kbCursorTimer = 0f;
					ApplyCaretText(kbActiveField, _kbCursorVisible, _kbHasEdited);
					displayText.ForceMeshUpdate(false, false);
					float num = 0f;
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)kbActiveField.Viewport != (Object)null)
					{
						Rect rect = kbActiveField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
					if ((Object)(object)kbActiveField.CursorImage != (Object)null)
					{
						((Graphic)kbActiveField.CursorImage).color = Color.clear;
					}
				}
			}

			private void KbBlinkCursor()
			{
				//IL_0072: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				InputFieldInfo kbActiveField = _kbActiveField;
				if (!((Object)(object)kbActiveField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = kbActiveField.DisplayText;
					ApplyCaretText(kbActiveField, _kbCursorVisible, _kbHasEdited);
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)kbActiveField.Viewport != (Object)null)
					{
						Rect rect = kbActiveField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						float num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
				}
			}

			internal void OpenKeyboard(InputFieldInfo info, Button returnButton)
			{
				OpenKeyboard(info, returnButton, null, useOverlay: false);
			}

			internal void OpenKeyboard(InputFieldInfo info, Button returnButton, Action onDone)
			{
				OpenKeyboard(info, returnButton, onDone, useOverlay: false);
			}

			internal void OpenKeyboardForChat(InputFieldInfo info, Action onDone)
			{
				OpenKeyboard(info, null, onDone, useOverlay: true);
			}

			private void OpenKeyboard(InputFieldInfo info, Button returnButton, Action onDone, bool useOverlay)
			{
				if (_kbBuilt)
				{
					_kbActiveField = info;
					_kbReturnButton = returnButton;
					_kbOnDone = onDone;
					_kbUsingOverlay = useOverlay;
					_kbShift = false;
					_kbHasEdited = false;
					_kbCursorVisible = true;
					_kbCursorTimer = 0f;
					if (useOverlay && (Object)(object)_kbRoot != (Object)null)
					{
						RectTransform val = EnsureKeyboardOverlayRoot();
						_kbRoot.transform.SetParent((Transform)(object)val, false);
						_kbRoot.transform.SetAsLastSibling();
						ShowKeyboardOverlay();
					}
					KbRefreshKeyLabels();
					KbRefreshDisplay();
					SetKeyboardVisible(visible: true);
				}
			}

			internal void CloseKeyboardForChat()
			{
				CloseKeyboard();
			}

			internal void CloseKeyboardOverlay()
			{
				CloseKeyboardOverlay(dismissChatTab: false);
			}

			internal void CloseKeyboardOverlay(bool dismissChatTab)
			{
				CloseKeyboard();
				HideKeyboardOverlay();
				if (dismissChatTab)
				{
					Core.uiManager.showChatTab = false;
				}
			}

			private void CloseKeyboard()
			{
				//IL_0088: 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_00b9: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_kbActiveField?.DisplayText != (Object)null)
				{
					TMP_Text displayText = _kbActiveField.DisplayText;
					if (_kbActiveField.Value.Length > 0)
					{
						displayText.text = _kbActiveField.Value;
						((Graphic)displayText).color = _kbActiveField.ActiveColor;
					}
					else
					{
						displayText.text = _kbActiveField.Placeholder;
						((Graphic)displayText).color = _kbActiveField.PlaceholderColor;
					}
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null)
					{
						rectTransform.offsetMin = new Vector2(0f, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f, rectTransform.offsetMax.y);
					}
					if ((Object)(object)_kbActiveField.CursorImage != (Object)null)
					{
						((Graphic)_kbActiveField.CursorImage).color = Color.clear;
					}
				}
				SetKeyboardVisible(visible: false);
				_tabMenu?.SetActiveTab(_tabMenu.ActiveTab);
				Button kbReturnButton = _kbReturnButton;
				_kbActiveField = null;
				_kbReturnButton = null;
				_kbOnDone = null;
				if ((Object)(object)kbReturnButton != (Object)null)
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)kbReturnButton).gameObject);
					}
				}
			}

			private void KbDone()
			{
				_kbOnDone?.Invoke();
				CloseKeyboard();
			}

			internal void OnInputFieldButtonClick(InputFieldInfo info, Button btn)
			{
				if (!IsMouseTyping)
				{
					if (Input.GetMouseButtonUp(0))
					{
						OpenMouseTyping(info);
					}
					else
					{
						OpenKeyboard(info, btn);
					}
				}
			}

			internal void OpenMouseTyping(InputFieldInfo info)
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				_mouseTypingField = info;
				_mouseTypingActive = true;
				_mouseTypingNavFrame = -1;
				_mouseCursorBlinkFrame = -1;
				_mouseHasEdited = false;
				_mouseCursorTimer = 0f;
				_mouseCursorVisible = true;
				if ((Object)(object)info?.CursorImage != (Object)null)
				{
					((Graphic)info.CursorImage).color = Color.clear;
				}
				EventSystem current = EventSystem.current;
				if (current != null)
				{
					current.SetSelectedGameObject((GameObject)null);
				}
				RefreshMouseTypingDisplay();
			}

			private void CloseMouseTyping(bool restoreSelection = true)
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: 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_012e: Unknown result type (might be due to invalid IL or missing references)
				_mouseTypingActive = false;
				InputFieldInfo mouseTypingField = _mouseTypingField;
				_mouseTypingField = null;
				if (restoreSelection && (Object)(object)mouseTypingField?.OwnerButton != (Object)null)
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)mouseTypingField.OwnerButton).gameObject);
					}
				}
				if ((Object)(object)mouseTypingField.CursorImage != (Object)null)
				{
					((Graphic)mouseTypingField.CursorImage).color = Color.clear;
				}
				if (!((Object)(object)mouseTypingField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = mouseTypingField.DisplayText;
					if (mouseTypingField.Value.Length > 0)
					{
						displayText.text = mouseTypingField.Value;
						((Graphic)displayText).color = mouseTypingField.ActiveColor;
					}
					else
					{
						displayText.text = mouseTypingField.Placeholder;
						((Graphic)displayText).color = mouseTypingField.PlaceholderColor;
					}
					displayText.ForceMeshUpdate(false, false);
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null)
					{
						rectTransform.offsetMin = new Vector2(0f, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f, rectTransform.offsetMax.y);
					}
				}
			}

			private void RefreshMouseTypingDisplay()
			{
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: 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_00c6: 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_00df: Unknown result type (might be due to invalid IL or missing references)
				InputFieldInfo mouseTypingField = _mouseTypingField;
				if (!((Object)(object)mouseTypingField?.DisplayText == (Object)null))
				{
					TMP_Text displayText = mouseTypingField.DisplayText;
					ApplyCaretText(mouseTypingField, _mouseCursorVisible, _mouseHasEdited);
					displayText.ForceMeshUpdate(false, false);
					float num = 0f;
					RectTransform rectTransform = displayText.rectTransform;
					if ((Object)(object)rectTransform != (Object)null && (Object)(object)mouseTypingField.Viewport != (Object)null)
					{
						Rect rect = mouseTypingField.Viewport.rect;
						float width = ((Rect)(ref rect)).width;
						float displayWidthForRenderedText = GetDisplayWidthForRenderedText(displayText, displayText.text);
						num = ((width > 1f) ? Mathf.Max(0f, displayWidthForRenderedText - width) : 0f);
						rectTransform.offsetMin = new Vector2(0f - num, rectTransform.offsetMin.y);
						rectTransform.offsetMax = new Vector2(0f - num, rectTransform.offsetMax.y);
					}
					if ((Object)(object)mouseTypingField.CursorImage != (Object)null)
					{
						((Graphic)mouseTypingField.CursorImage).color = Color.clear;
					}
				}
			}

			private static void ApplyCaretText(InputFieldInfo field, bool showCaret, bool hasEdited)
			{
				//IL_003d: 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)
				if (!((Object)(object)field?.DisplayText == (Object)null))
				{
					bool flag = !string.IsNullOrEmpty(field.Value);
					((Graphic)field.DisplayText).color = (flag ? field.ActiveColor : field.PlaceholderColor);
					if (!flag)
					{
						field.DisplayText.text = (showCaret ? "|" : "<color=#FFFFFF00>|</color>");
					}
					else if (!hasEdited)
					{
						field.DisplayText.text = (showCaret ? (field.Value + "|") : (field.Value + "<color=#FFFFFF00>|</color>"));
					}
					else
					{
						field.DisplayText.text = (showCaret ? (field.Value + "|") : (field.Value + "<color=#FFFFFF00>|</color>"));
					}
				}
			}

			private static float GetDisplayWidthForRenderedText(TMP_Text text, string renderedText)
			{
				//IL_0034: 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)
				if ((Object)(object)text == (Object)null)
				{
					return 0f;
				}
				if (string.IsNullOrEmpty(renderedText))
				{
					return 0f;
				}
				float x = text.GetPreferredValues(renderedText + "M").x;
				float x2 = text.GetPreferredValues("M").x;
				return Mathf.Max(0f, x - x2);
			}

			private static bool IsPointerOverGameObject(GameObject target)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003e: Expected O, but got Unknown
				EventSystem current = EventSystem.current;
				if ((Object)(object)current == (Object)null || (Object)(object)target == (Object)null)
				{
					return false;
				}
				PointerEventData val = new PointerEventData(current)
				{
					position = Vector2.op_Implicit(Input.mousePosition)
				};
				List<RaycastResult> val2 = new List<RaycastResult>();
				current.RaycastAll(val, val2);
				for (int i = 0; i < val2.Count; i++)
				{
					GameObject gameObject = val2[i].gameObject;
					if (!((Object)(object)gameObject == (Object)null) && ((Object)(object)gameObject == (Object)(object)target || gameObject.transform.IsChildOf(target.transform)))
					{
						return true;
					}
				}
				return false;
			}

			private void SetKeyboardVisible(bool visible)
			{
				if ((Object)(object)_kbCG == (Object)null)
				{
					return;
				}
				_kbCG.alpha = (visible ? 1f : 0f);
				_kbCG.interactable = visible;
				_kbCG.blocksRaycasts = visible;
				if (visible && _kbCharRows != null && _kbCharRows.Length != 0)
				{
					Button val = _kbCharRows[0][0];
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						_submenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit((GameObject[])(object)new GameObject[1] { ((Component)val).gameObject });
					}
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject(((Component)val).gameObject);
					}
					MenuItemList.active = _submenuItemList;
				}
			}

			private void IntegrateIntoMainItemList()
			{
				if ((Object)(object)_mainMenuItemList == (Object)null || (Object)(object)_mainButtonObj == (Object)null)
				{
					return;
				}
				Il2CppReferenceArray<GameObject> items = _mainMenuItemList.items;
				if (items == null || ((Il2CppArrayBase<GameObject>)(object)items).Length == 0)
				{
					return;
				}
				for (int i = 0; i < ((Il2CppArrayBase<GameObject>)(object)items).Length; i++)
				{
					if ((Object)(object)((Il2CppArrayBase<GameObject>)(object)items)[i] == (Object)(object)_mainButtonObj)
					{
						return;
					}
				}
				Menu activeMenu = _activeMenu;
				Button val = ((activeMenu != null) ? activeMenu.ContinueGameButton : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				int num = -1;
				for (int j = 0; j < ((Il2CppArrayBase<GameObject>)(object)items).Length; j++)
				{
					if ((Object)(object)((Il2CppArrayBase<GameObject>)(object)items)[j] == (Object)(object)((Component)val).gameObject)
					{
						num = j;
						break;
					}
				}
				if (num < 0)
				{
					return;
				}
				GameObject[] array = (GameObject[])(object)new GameObject[((Il2CppArrayBase<GameObject>)(object)items).Length + 1];
				int k = 0;
				int num2 = 0;
				for (; k < array.Length; k++)
				{
					if (k == num + 1)
					{
						array[k] = _mainButtonObj;
					}
					else
					{
						array[k] = ((Il2CppArrayBase<GameObject>)(object)items)[num2++];
					}
				}
				_mainMenuItemList.items = Il2CppReferenceArray<GameObject>.op_Implicit(array);
			}

			private void UpdateVisibility(Menu menu)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				if ((Object)(object)menu == (Object)null)
				{
					return;
				}
				bool flag = (Object)(object)menu.mainMenuCanvas != (Object)null && menu.mainMenuCanvas.activeInHierarchy && (int)menu.currentMenuScreen == 0;
				if ((Object)(object)_mainButtonObj != (Object)null)
				{
					_mainButtonObj.SetActive(flag);
				}
				if (!flag)
				{
					if (GetSubmenuVisible())
					{
						SetSubmenuVisible(isVisible: false);
					}
					return;
				}
				bool submenuVisible = GetSubmenuVisible();
				if ((Object)(object)_mainMenuCG != (Object)null)
				{
					_mainMenuCG.alpha = (submenuVisible ? 0f : 1f);
					_mainMenuCG.blocksRaycasts = !submenuVisible;
					_mainMenuCG.interactable = !submenuVisible;
				}
				if ((Object)(object)menu.titleGroup != (Object)null)
				{
					menu.titleGroup.alpha = (submenuVisible ? 0f : 1f);
				}
			}

			private void SetSubmenuVisible(bool isVisible)
			{
				if ((Object)(object)_submenuCG == (Object)null)
				{
					return;
				}
				bool flag = _submenuCG.alpha > 0.5f;
				if (flag == isVisible)
				{
					return;
				}
				if (!isVisible && KbVisible)
				{
					SetKeyboardVisible(visible: false);
				}
				_submenuCG.alpha = (isVisible ? 1f : 0f);
				_submenuCG.blocksRaycasts = isVisible;
				_submenuCG.interactable = isVisible;
				for (int i = 0; i < _fixedButtonInstances.Count; i++)
				{
					if ((Object)(object)_fixedButtonInstances[i] != (Object)null)
					{
						((Selectable)_fixedButtonInstances[i]).interactable = isVisible;
					}
				}
				if ((Object)(object)_mainButton != (Object)null)
				{
					((Selectable)_mainButton).interactable = !isVisible;
				}
				if (isVisible)
				{
					ApplyMargin();
					_tabMenu?.OnShown();
					if ((Object)(object)_submenuItemList != (Object)null)
					{
						MenuItemList.active = _submenuItemList;
					}
				}
				else if ((Object)(object)_mainMenuItemList != (Object)null)
				{
					MenuItemList.active = _mainMenuItemList;
				}
				EventSystem current = EventSystem.current;
				if ((Object)(object)current != (Object)null)
				{
					if (isVisible && _fixedButtonInstances.Count > 0 && (Object)(object)_fixedButtonInstances[0] != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_fixedButtonInstances[0]).gameObject);
					}
					else if (!isVisible && (Object)(object)_mainButton != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_mainButton).gameObject);
					}
				}
				UpdateVisibility(_activeMenu);
			}

			private void EnsureSelection()
			{
				if (KbVisible || _mouseTypingActive)
				{
					return;
				}
				EventSystem current = EventSystem.current;
				if ((Object)(object)current == (Object)null)
				{
					return;
				}
				GameObject currentSelectedGameObject = current.currentSelectedGameObject;
				if (!((Object)(object)currentSelectedGameObject == (Object)null) && currentSelectedGameObject.activeInHierarchy)
				{
					Selectable component = currentSelectedGameObject.GetComponent<Selectable>();
					if (component == null || component.interactable)
					{
						return;
					}
				}
				if (GetSubmenuVisible())
				{
					if (_fixedButtonInstances.Count > 0 && (Object)(object)_fixedButtonInstances[0] != (Object)null)
					{
						current.SetSelectedGameObject(((Component)_fixedButtonInstances[0]).gameObject);
					}
					return;
				}
				Menu activeMenu = _activeMenu;
				if ((Object)(object)((activeMenu != null) ? activeMenu.ContinueGameButton : null) != (Object)null)
				{
					current.SetSelectedGameObject(((Component)_activeMenu.ContinueGameButton).gameObject);
				}
			}

			private void TryHandleCancel(Menu menu)
			{
				if (((menu != null) ? menu.rwPlayer : null) != null && !KbVisible && !_mouseTypingActive && (Input.GetKeyDown((KeyCode)27) || menu.rwPlayer.GetButtonDown(15)))
				{
					SetSubmenuVisible(isVisible: false);
				}
			}

			private void ApplyMargin()
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_submenuRect != (Object)null)
				{
					_submenuRect.anchoredPosition = new Vector2(10f + _sideMargin, -10f - _topMargin);
				}
			}

			private bool GetSubmenuVisible()
			{
				return (Object)(object)_submenuCG != (Object)null && _submenuCG.alpha > 0.5f;
			}

			private void ResolveExisting(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return;
				}
				Il2CppArrayBase<Transform> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Transform>(true);
				List<GameObject> list = new List<GameObject>();
				List<GameObject> list2 = new List<GameObject>();
				List<GameObject> list3 = new List<GameObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Transform val = componentsInChildren[i];
					if (!((Object)(object)val == (Object)null))
					{
						if (((Object)val).name == "BBSMP_MainMenuButton")
						{
							list.Add(((Component)val).gameObject);
						}
						else if (((Object)val).name == "BBSMP_SubmenuCanvas")
						{
							list2.Add(((Component)val).gameObject);
						}
						else if (((Object)val).name == "BBSMP_Keyboard")
						{
							list3.Add(((Component)val).gameObject);
						}
					}
				}
				if (list3.Count > 0)
				{
					if (_kbBuilt)
					{
						_kbRoot = list3[0];
						GameObject kbRoot = _kbRoot;
						_kbCG = ((kbRoot != null) ? kbRoot.GetComponent<CanvasGroup>() : null);
					}
					else
					{
						for (int j = 0; j < list3.Count; j++)
						{
							Object.Destroy((Object)(object)list3[j]);
						}
						_kbRoot = null;
						_kbCG = null;
					}
					for (int k = 1; k < list3.Count; k++)
					{
						Object.Destroy((Object)(object)list3[k]);
					}
				}
				if (list.Count > 0)
				{
					_mainButtonObj = list[0];
					_mainButton = _mainButtonObj.GetComponent<Button>();
					for (int l = 1; l < list.Count; l++)
					{
						Object.Destroy((Object)(object)list[l]);
					}
					_mainMenuRoot = _mainButtonObj.transform.parent;
					Transform mainMenuRoot = _mainMenuRoot;
					object obj = ((mainMenuRoot != null) ? ((Component)mainMenuRoot).GetComponent<CanvasGroup>() : null);
					if (obj == null)
					{
						Transform mainMenuRoot2 = _mainMenuRoot;
						obj = ((mainMenuRoot2 != null) ? ((Component)mainMenuRoot2).gameObject.AddComponent<CanvasGroup>() : null);
					}
					_mainMenuCG = (CanvasGroup)obj;
					Transform mainMenuRoot3 = _mainMenuRoot;
					_mainMenuItemList = ((mainMenuRoot3 != null) ? ((Component)mainMenuRoot3).GetComponent<MenuItemList>() : null);
				}
				if (list2.Count > 0)
				{
					_submenuObj = list2[0];
					_submenuCG = _submenuObj.GetComponent<CanvasGroup>();
					_submenuItemList = _submenuObj.GetComponent<MenuItemList>();
					for (int m = 1; m < list2.Count; m++)
					{
						Object.Destroy((Object)(object)list2[m]);
					}
					_fixedButtonInstances.Clear();
					for (int n = 0; n < _fixedDescs.Count; n++)
					{
						Transform val2 = _submenuObj.transform.Find($"BBSMP_Fixed_{n}");
						_fixedButtonInstances.Add((val2 != null) ? ((Component)val2).GetComponent<Button>() : null);
					}
				}
			}

			private void Reset()
			{
				if ((Object)(object)_mainButtonObj != (Object)null)
				{
					Object.Destroy((Object)(object)_mainButtonObj);
				}
				if ((Object)(object)_submenuObj != (Object)null)
				{
					Object.Destroy((Object)(object)_submenuObj);
				}
				if ((Object)(object)_kbRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_kbRoot);
				}
				_mainButtonObj = null;
				_mainButton = null;
				_submenuObj = null;
				_submenuCG = null;
				_submenuItemList = null;
				_submenuRect = null;
				_mainMenuRoot = null;
				_mainMenuCG = null;
				_mainMenuItemList = null;
				_tabMenu = null;
				_contentBuilt = false;
				_fixedButtonInstances.Clear();
				_kbRoot = null;
				_kbCG = null;
				_kbCharRows = null;
				_kbSpecialRow = null;
				_kbLowerRows = null;
				_kbUpperRows = null;
				_kbAllButtons.Clear();
				_kbActiveField = null;
				_kbReturnButton = null;
				_kbBuilt = false;
				_kbShift = false;
				_kbShiftBtn = null;
				_kbNavFrame = -1;
				_kbCursorTimer = 0f;
				_kbCursorVisible = true;
			}

			private static Button FindTemplateButton(Menu menu)
			{
				if ((Object)(object)menu.ContinueGameButton != (Object)null)
				{
					return menu.ContinueGameButton;
				}
				if ((Object)(object)menu.mainMenuCanvas == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Button> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Button>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					return null;
				}
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!((Object)(object)componentsInChildren[i] == (Object)null))
					{
						TMP_Text componentInChildren = ((Component)componentsInChildren[i]).GetComponentInChildren<TMP_Text>(true);
						string text = ((componentInChildren != null) ? componentInChildren.text : null) ?? "";
						if (text.Contains("continue", StringComparison.OrdinalIgnoreCase))
						{
							return componentsInChildren[i];
						}
					}
				}
				return componentsInChildren[0];
			}

			private static Toggle FindToggleTemplate(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Toggle> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Toggle>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					return null;
				}
				Toggle val = componentsInChildren[0];
				if ((Object)(object)val != (Object)null)
				{
					StripLocalizationComponentsImmediate(((Component)val).gameObject);
				}
				return val;
			}

			private static Slider FindSliderTemplate(Menu menu)
			{
				if ((Object)(object)((menu != null) ? menu.mainMenuCanvas : null) == (Object)null)
				{
					return null;
				}
				Il2CppArrayBase<Slider> componentsInChildren = menu.mainMenuCanvas.GetComponentsInChildren<Slider>(true);
				return (componentsInChildren != null && componentsInChildren.Length > 0) ? componentsInChildren[0] : null;
			}

			private static void DumpHierarchy(Menu menu, string reason)
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!((Object)(object)menu == (Object)null))
					{
						StringBuilder stringBuilder = new StringBuilder();
						stringBuilder.AppendLine("=== BBSMP Menu Hierarchy Dump ===");
						StringBuilder stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder3 = stringBuilder2;
						StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(8, 1, stringBuilder2);
						handler.AppendLiteral("Reason: ");
						handler.AppendFormatted(reason);
						stringBuilder3.AppendLine(ref handler);
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder4 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(6, 1, stringBuilder2);
						handler.AppendLiteral("Time: ");
						handler.AppendFormatted(DateTime.Now, "O");
						stringBuilder4.AppendLine(ref handler);
						stringBuilder2 = stringBuilder;
						StringBuilder stringBuilder5 = stringBuilder2;
						handler = new StringBuilder.AppendInterpolatedStringHandler(18, 2, stringBuilder2);
						handler.AppendLiteral("Screen: ");
						handler.AppendFormatted<MenuScreen>(menu.currentMenuScreen);
						handler.AppendLiteral("  Paused: ");
						handler.AppendFormatted(menu.paused);
						stringBuilder5.AppendLine(ref handler);
						if ((Object)(object)menu.mainMenuCanvas != (Object)null)
						{
							stringBuilder2 = stringBuilder;
							StringBuilder stringBuilder6 = stringBuilder2;
							handler = new StringBuilder.AppendInterpolatedStringHandler(9, 1, stringBuilder2);
							handler.AppendLiteral("CanvasW: ");
							handler.AppendFormatted(GetPath(menu.mainMenuCanvas.transform));
							stringBuilder6.AppendLine(ref handler);
							AppendTransform(stringBuilder, menu.mainMenuCanvas.transform, 0, 6);
						}
						string text = Path.Combine(Environment.CurrentDirectory, "UserData");
						Directory.CreateDirectory(text);
						File.WriteAllText(Path.Combine(text, "BBSMP_MenuHierarchyDump.txt"), stringBuilder.ToString());
					}
				}
				catch (Exception value)
				{
					Instance logger = Core.logger;
					if (logger != null)
					{
						logger.Error($"[MenuInject] Dump failed: {value}");
					}
				}
			}

			private static void AppendTransform(StringBuilder sb, Transform root, int depth, int maxDepth)
			{
				if ((Object)(object)root == (Object)null || depth > maxDepth)
				{
					return;
				}
				string value = new string(' ', depth * 2);
				Il2CppArrayBase<Component> components = ((Component)root).GetComponents<Component>();
				List<string> list = new List<string>();
				for (int i = 0; i < components.Length; i++)
				{
					if ((Object)(object)components[i] != (Object)null)
					{
						list.Add(((object)components[i]).GetType().Name);
					}
				}
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(5, 3, sb);
				handler.AppendFormatted(value);
				handler.AppendLiteral("- ");
				handler.AppendFormatted(((Object)root).name);
				handler.AppendLiteral(" [");
				handler.AppendFormatted(string.Join(", ", list));
				handler.AppendLiteral("]");
				sb.AppendLine(ref handler);
				for (int j = 0; j < root.childCount; j++)
				{
					AppendTransform(sb, root.GetChild(j), depth + 1, maxDepth);
				}
			}

			private static string GetPath(Transform t)
			{
				if ((Object)(object)t == (Object)null)
				{
					return "<null>";
				}
				Stack<string> stack = new Stack<string>();
				while ((Object)(object)t != (Object)null)
				{
					stack.Push(((Object)t).name);
					t = t.parent;
				}
				return string.Join("/", stack);
			}
		}

		internal static readonly List<InjectedMenu> _registeredMenus = new List<InjectedMenu>();

		private static RectTransform customRoot;

		private static Button buttonTemplate;

		private static Toggle toggleTemplate;

		private static Slider sliderTemplate;

		private const float SliderHandleSize = 112f;

		private static Sprite _inputFieldSprite;

		private static Sprite _sliderHandleSprite;

		private static Sprite _solidSprite;

		private static TMP_FontAsset _lowercaseTextFont;

		private const float KeyboardKeyFontSize = 20f;

		private static RectTransform _keyboardOverlayRoot;

		private static CanvasGroup _keyboardOverlayCanvasGroup;

		private static RuntimeTabMenu _currentTabMenu;

		private static int _currentTabPage = -1;

		private static InjectedMenu _currentInjectedMenu;

		private static float nextY;

		private const float Spacing = 10f;

		private const float DefaultHeight = 52f;

		internal static readonly Color TabUnselected = new Color(0.435f, 0.676f, 0.726f, 1f);

		internal static readonly Color TabSelected = new Color(1f, 1f, 1f, 0.78f);

		internal static readonly Color TabText = new Color(0f, 0.169f, 0.283f, 1f);

		internal static readonly Color TabHighlighted = new Color(0.519f, 0.804f, 0.865f, 1f);

		internal static InjectedMenu CurrentMenu => _currentInjectedMenu;

		internal static InjectedMenu GetKeyboardMenu()
		{
			if (_registeredMenus.Count > 0)
			{
				return _registeredMenus[0];
			}
			return null;
		}

		private static RectTransform EnsureKeyboardOverlayRoot()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_keyboardOverlayRoot != (Object)null)
			{
				return _keyboardOverlayRoot;
			}
			Il2CppReferenceArray<Type> val = new Il2CppReferenceArray<Type>(5L);
			((Il2CppArrayBase<Type>)(object)val)[0] = Il2CppType.Of<RectTransform>();
			((Il2CppArrayBase<Type>)(object)val)[1] = Il2CppType.Of<Canvas>();
			((Il2CppArrayBase<Type>)(object)val)[2] = Il2CppType.Of<CanvasScaler>();
			((Il2CppArrayBase<Type>)(object)val)[3] = Il2CppType.Of<GraphicRaycaster>();
			((Il2CppArrayBase<Type>)(object)val)[4] = Il2CppType.Of<CanvasGroup>();
			GameObject val2 = new GameObject("BBSMP_ChatKeyboardOverlay", val);
			Object.DontDestroyOnLoad((Object)(object)val2);
			Canvas component = val2.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.overrideSorting = true;
			component.sortingOrder = 5000;
			_keyboardOverlayCanvasGroup = val2.GetComponent<CanvasGroup>();
			_keyboardOverlayCanvasGroup.alpha = 1f;
			_keyboardOverlayCanvasGroup.blocksRaycasts = true;
			_keyboardOverlayCanvasGroup.interactable = true;
			_keyboardOverlayRoot = val2.GetComponent<RectTransform>();
			_keyboardOverlayRoot.anchorMin = Vector2.zero;
			_keyboardOverlayRoot.anchorMax = Vector2.one;
			_keyboardOverlayRoot.offsetMin = Vector2.zero;
			_keyboardOverlayRoot.offsetMax = Vector2.zero;
			return _keyboardOverlayRoot;
		}

		internal static void HideKeyboardOverlay()
		{
			if ((Object)(object)_keyboardOverlayCanvasGroup != (Object)null)
			{
				_keyboardOverlayCanvasGroup.alpha = 0f;
				_keyboardOverlayCanvasGroup.blocksRaycasts = false;
				_keyboardOverlayCanvasGroup.interactable = false;
			}
		}

		internal static void ShowKeyboardOverlay()
		{
			RectTransform val = EnsureKeyboardOverlayRoot();
			if ((Object)(object)val != (Object)null)
			{
				CanvasGroup keyboardOverlayCanvasGroup = _keyboardOverlayCanvasGroup;
				if ((Object)(object)keyboardOverlayCanvasGroup != (Object)null)
				{
					keyboardOverlayCanvasGroup.alpha = 1f;
					keyboardOverlayCanvasGroup.blocksRaycasts = true;
					keyboardOverlayCanvasGroup.interactable = true;
				}
			}
		}

		private static TMP_FontAsset GetOrCreateLowercaseTextFont()
		{
			if ((Object)(object)_lowercaseTextFont != (Object)null)
			{
				return _lowercaseTextFont;
			}
			StyleManager.Fonts.Prepare();
			if ((Object)(object)StyleManager.Fonts.Arial == (Object)null)
			{
				return null;
			}
			_lowercaseTextFont = TMP_FontAsset.CreateFontAsset(StyleManager.Fonts.Arial);
			return _lowercaseTextFont;
		}

		private static void ApplyLowercaseTextFont(TMP_Text text)
		{
			if (!((Object)(object)text == (Object)null))
			{
				TMP_FontAsset orCreateLowercaseTextFont = GetOrCreateLowercaseTextFont();
				if ((Object)(object)orCreateLowercaseTextFont != (Object)null)
				{
					text.font = orCreateLowercaseTextFont;
				}
			}
		}

		private static Sprite GetOrCreateSliderHandleSprite()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_sliderHandleSprite != (Object)null)
			{
				return _sliderHandleSprite;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			Color32[] array = (Color32[])(object)new Color32[4096];
			float num = 31.5f;
			float num2 = 31.5f;
			float num3 = 26f;
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num4 = (float)j - num;
					float num5 = (float)i - num2;
					float num6 = Mathf.Sqrt(num4 * num4 + num5 * num5);
					byte b = (byte)(Mathf.Clamp01(num3 + 0.5f - num6) * 255f);
					array[i * 64 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(array));
			val.Apply(false, false);
			_sliderHandleSprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0);
			return _sliderHandleSprite;
		}

		private static Sprite GetOrCreateInputFieldSprite()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0159: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inputFieldSprite != (Object)null)
			{
				return _inputFieldSprite;
			}
			Texture2D val = new Texture2D(128, 64, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			float num = 18f;
			float num2 = 109f;
			float num3 = 18f;
			float num4 = 45f;
			Color32[] array = (Color32[])(object)new Color32[8192];
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					float num5 = (((float)j < num) ? (num - (float)j) : (((float)j > num2) ? ((float)j - num2) : 0f));
					float num6 = (((float)i < num3) ? (num3 - (float)i) : (((float)i > num4) ? ((float)i - num4) : 0f));
					float num7 = Mathf.Sqrt(num5 * num5 + num6 * num6);
					byte b = (byte)(Mathf.Clamp01(18.5f - num7) * 255f);
					array[i * 128 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(array));
			val.Apply(false, false);
			_inputFieldSprite = Sprite.Create(val, new Rect(0f, 0f, 128f, 64f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(18f, 18f, 18f, 18f));
			return _inputFieldSprite;
		}

		private static Sprite GetOrCreateSolidSprite()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0042: 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_0075: 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)
			if ((Object)(object)_solidSprite != (Object)null)
			{
				return _solidSprite;
			}
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit((Color32[])(object)new Color32[1]
			{
				new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
			}));
			val.Apply(false, false);
			_solidSprite = Sprite.Create(val, new Rect(0f, 0f, 1f, 1f), new Vector2(0.5f, 0.5f));
			return _solidSprite;
		}

		public static MenuBuilder CreateMenu(string mainButtonLabel)
		{
			return new MenuBuilder(mainButtonLabel);
		}

		public static void Configure(RectTransform root, Button button, Toggle toggle = null, Slider slider = null)
		{
			customRoot = root;
			buttonTemplate = button;
			toggleTemplate = toggle;
			sliderTemplate = slider;
			_currentTabMenu = null;
			_currentTabPage = -1;
			ResetLayout();
		}

		public static void ConfigureTabPage(RuntimeTabMenu tabMenu, int pageIndex, Button button, Toggle toggle = null, Slider slider = null)
		{
			Configure(tabMenu?.GetPage(pageIndex), button, toggle, slider);
			_currentTabMenu = tabMenu;
			_currentTabPage = pageIndex;
		}

		public static RectTransform GetCustomRoot()
		{
			return customRoot;
		}

		public static void ClearCustomContent()
		{
			if ((Object)(object)customRoot == (Object)null)
			{
				return;
			}
			for (int num = ((Transform)customRoot).childCount - 1; num >= 0; num--)
			{
				Transform child = ((Transform)customRoot).GetChild(num);
				if ((Object)(object)child != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
			ResetLayout();
		}

		public static TMP_Text AddLabel(string text, RectTransform parent = null)
		{
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null || (Object)(object)buttonTemplate == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)buttonTemplate).gameObject, (Transform)(object)val);
			((Object)val2).name = "BBSMP_Label";
			StripLocalizationComponents(val2);
			Button component = val2.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Image component2 = val2.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = text;
				componentInChildren.alignment = (TextAlignmentOptions)4097;
				componentInChildren.ForceMeshUpdate(false, false);
			}
			PlaceInLayout(val2.GetComponent<RectTransform>(), val, 52f);
			return componentInChildren;
		}

		public static Image AddImage(Color color, float height = 52f, RectTransform parent = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = new GameObject("BBSMP_Image");
			val2.transform.SetParent((Transform)(object)val, false);
			RectTransform rect = val2.AddComponent<RectTransform>();
			Image val3 = val2.AddComponent<Image>();
			val3.sprite = GetOrCreateSolidSprite();
			val3.type = (Type)0;
			((Graphic)val3).color = color;
			PlaceInLayout(rect, val, height);
			return val3;
		}

		public static Button AddButton(string text, UnityAction onClick, RectTransform parent = null)
		{
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null || (Object)(object)buttonTemplate == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)buttonTemplate).gameObject, (Transform)(object)val);
			((Object)val2).name = "BBSMP_Button";
			StripLocalizationComponents(val2);
			Button component = val2.GetComponent<Button>();
			ClearButtonEvents(component);
			if ((Object)(object)component != (Object)null && (Delegate)(object)onClick != (Delegate)null)
			{
				((UnityEvent)component.onClick).AddListener(onClick);
			}
			SetButtonLabel(val2, text);
			PlaceInLayout(val2.GetComponent<RectTransform>(), val, 52f);
			_currentTabMenu?.RegisterPageSelectable(_currentTabPage, (Selectable)(object)component);
			return component;
		}

		public static Toggle AddToggle(string text, bool initialValue, UnityAction<bool> onValueChanged, RectTransform parent = null)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null || (Object)(object)toggleTemplate == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)toggleTemplate).gameObject, (Transform)(object)val);
			((Object)val2).name = "BBSMP_Toggle";
			Transform val3 = val2.transform.Find("Label");
			if ((Object)(object)val3 != (Object)null)
			{
				BBLocalize component = ((Component)val3).GetComponent<BBLocalize>();
				if ((Object)(object)component != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)component);
				}
				TMP_Text component2 = ((Component)val3).GetComponent<TMP_Text>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.text = text;
				}
			}
			Toggle component3 = val2.GetComponent<Toggle>();
			if ((Object)(object)component3 == (Object)null)
			{
				return null;
			}
			component3.onValueChanged = new ToggleEvent();
			component3.isOn = initialValue;
			if ((Delegate)(object)onValueChanged != (Delegate)null)
			{
				((UnityEvent<bool>)(object)component3.onValueChanged).AddListener(onValueChanged);
			}
			PlaceInLayout(val2.GetComponent<RectTransform>(), val, 52f);
			_currentTabMenu?.RegisterPageSelectable(_currentTabPage, (Selectable)(object)component3);
			return component3;
		}

		public static Slider AddSlider(string text, float min, float max, float value, UnityAction<float> onValueChanged, bool wholeNumbers = false, RectTransform parent = null)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null || (Object)(object)sliderTemplate == (Object)null)
			{
				return null;
			}
			Il2CppReferenceArray<Type> val2 = new Il2CppReferenceArray<Type>(2L);
			((Il2CppArrayBase<Type>)(object)val2)[0] = Il2CppType.Of<RectTransform>();
			((Il2CppArrayBase<Type>)(object)val2)[1] = Il2CppType.Of<HorizontalLayoutGroup>();
			GameObject val3 = new GameObject("BBSMP_SliderContainer", val2);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)val, false);
			HorizontalLayoutGroup component2 = val3.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 30f;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			if (!string.IsNullOrEmpty(text))
			{
				TMP_Text val4 = AddLabel(text, component);
				if ((Object)(object)val4 != (Object)null)
				{
					LayoutElement val5 = ((Component)val4).GetComponent<LayoutElement>() ?? ((Component)val4).gameObject.AddComponent<LayoutElement>();
					val5.flexibleWidth = 0f;
					val4.ForceMeshUpdate(false, false);
				}
			}
			GameObject val6 = InstantiateSliderTemplateSafely(((Component)sliderTemplate).gameObject, (Transform)(object)component);
			((Object)val6).name = "BBSMP_Slider";
			StripLocalizationComponents(val6);
			Slider component3 = val6.GetComponent<Slider>();
			if ((Object)(object)component3 == (Object)null)
			{
				return null;
			}
			component3.onValueChanged = new SliderEvent();
			component3.minValue = min;
			component3.maxValue = max;
			component3.wholeNumbers = wholeNumbers;
			component3.SetValueWithoutNotify(Mathf.Clamp(value, min, max));
			if ((Delegate)(object)onValueChanged != (Delegate)null)
			{
				((UnityEvent<float>)(object)component3.onValueChanged).AddListener(onValueChanged);
			}
			LayoutElement val7 = val6.GetComponent<LayoutElement>() ?? val6.AddComponent<LayoutElement>();
			val7.flexibleWidth = 1f;
			val7.minWidth = 100f;
			RectTransform val8 = component3.handleRect;
			if ((Object)(object)val8 == (Object)null)
			{
				Il2CppArrayBase<RectTransform> componentsInChildren = val6.GetComponentsInChildren<RectTransform>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					RectTransform val9 = componentsInChildren[i];
					if (!((Object)(object)val9 == (Object)null))
					{
						string name = ((Object)((Component)val9).gameObject).name;
						if (name.IndexOf("Handle", StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf("Area", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("Slide", StringComparison.OrdinalIgnoreCase) < 0)
						{
							val8 = val9;
							break;
						}
					}
				}
			}
			if ((Object)(object)val8 != (Object)null)
			{
				Image component4 = ((Component)val8).GetComponent<Image>();
				LayoutElement component5 = ((Component)val8).GetComponent<LayoutElement>();
				AspectRatioFitter component6 = ((Component)val8).GetComponent<AspectRatioFitter>();
				ContentSizeFitter component7 = ((Component)val8).GetComponent<ContentSizeFitter>();
				component3.handleRect = val8;
				val8.anchorMin = new Vector2(0.5f, 0.5f);
				val8.anchorMax = new Vector2(0.5f, 0.5f);
				val8.pivot = new Vector2(0.5f, 0.5f);
				((Transform)val8).localScale = Vector3.one;
				Vector2 sizeDelta = val8.sizeDelta;
				float num = Mathf.Abs(sizeDelta.x);
				float num2 = Mathf.Abs(sizeDelta.y);
				float num3 = 112f;
				if (num > 0.01f && num2 > 0.01f)
				{
					num3 = Mathf.Clamp(Mathf.Min(num, num2), 56f, 112f);
				}
				else if (num > 0.01f)
				{
					num3 = Mathf.Clamp(num * 0.72f, 56f, 112f);
				}
				else if (num2 > 0.01f)
				{
					num3 = Mathf.Clamp(num2 * 0.72f, 56f, 112f);
				}
				if ((Object)(object)component4 != (Object)null)
				{
					component4.sprite = GetOrCreateSliderHandleSprite();
					component4.type = (Type)0;
					component4.preserveAspect = true;
					((Graphic)component4).raycastTarget = true;
				}
				val8.SetSizeWithCurrentAnchors((Axis)0, num3);
				val8.SetSizeWithCurrentAnchors((Axis)1, num3);
				LayoutElement component8 = ((Component)val8).GetComponent<LayoutElement>();
				if ((Object)(object)component8 != (Object)null)
				{
					component8.minWidth = num3;
					component8.minHeight = num3;
					component8.preferredWidth = num3;
					component8.preferredHeight = num3;
					component8.flexibleWidth = 0f;
					component8.flexibleHeight = 0f;
				}
			}
			PlaceInLayout(component, val, 64f);
			_currentTabMenu?.RegisterPageSelectable(_currentTabPage, (Selectable)(object)component3);
			return component3;
		}

		private static GameObject InstantiateSliderTemplateSafely(GameObject template, Transform parent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			if ((Object)(object)template == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("BBSMP_SliderStaging");
			val.SetActive(false);
			GameObject val2 = Object.Instantiate<GameObject>(template, val.transform);
			StripNonUiComponents(val2);
			val2.transform.SetParent(parent, false);
			val.SetActive(true);
			Object.Destroy((Object)(object)val);
			return val2;
		}

		private static void StripNonUiComponents(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Component> componentsInChildren = root.GetComponentsInChildren<Component>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Component val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null) && !IsSafeSliderComponent(val))
				{
					Object.DestroyImmediate((Object)(object)val);
				}
			}
		}

		private static bool IsSafeSliderComponent(Component comp)
		{
			if (comp is Transform || comp is RectTransform || comp is CanvasRenderer)
			{
				return true;
			}
			string text = ((object)comp).GetType()?.Namespace ?? string.Empty;
			if (text.StartsWith("UnityEngine", StringComparison.Ordinal) || text.StartsWith("TMPro", StringComparison.Ordinal))
			{
				return true;
			}
			return false;
		}

		public static Button AddInputField(string placeholder = "", UnityAction<string> onChange = null, string initialValue = null, RectTransform parent = null)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: 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)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Expected O, but got Unknown
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = parent ?? customRoot;
			if ((Object)(object)val == (Object)null || (Object)(object)buttonTemplate == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)buttonTemplate).gameObject, (Transform)(object)val);
			((Object)val2).name = "BBSMP_InputField";
			StripLocalizationComponents(val2);
			Button component = val2.GetComponent<Button>();
			ClearButtonEvents(component);
			TMP_Text componentInChildren = val2.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = "";
				((Graphic)componentInChildren).raycastTarget = false;
			}
			Image component2 = val2.GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
				((Graphic)component2).raycastTarget = false;
			}
			GameObject val3 = new GameObject("BBSMP_InputPill");
			val3.transform.SetParent(val2.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(4f, 5f);
			val4.offsetMax = new Vector2(-4f, -5f);
			Image val5 = val3.AddComponent<Image>();
			val5.sprite = GetOrCreateInputFieldSprite();
			val5.type = (Type)1;
			Color color = default(Color);
			((Color)(ref color))..ctor(0.02f, 0.04f, 0.08f, 0.92f);
			Color val6 = Color.Lerp(color, Color.white, 2f);
			if ((Object)(object)sliderTemplate != (Object)null)
			{
				Il2CppArrayBase<Image> componentsInChildren = ((Component)sliderTemplate).GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Image val7 = componentsInChildren[i];
					if (!((Object)(object)val7 == (Object)null))
					{
						string name = ((Object)((Component)val7).gameObject).name;
						if (name.IndexOf("Background", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Track", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Base", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							color = ((Graphic)val7).color;
							break;
						}
					}
				}
			}
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).transition = (Transition)1;
				((Selectable)component).targetGraphic = (Graphic)(object)val5;
				ColorBlock colors = ((Selectable)component).colors;
				((ColorBlock)(ref colors)).normalColor = color;
				((ColorBlock)(ref colors)).highlightedColor = val6;
				((ColorBlock)(ref colors)).selectedColor = val6;
				((ColorBlock)(ref colors)).pressedColor = val6;
				((ColorBlock)(ref colors)).disabledColor = color;
				((ColorBlock)(ref colors)).colorMultiplier = 1f;
				((Selectable)component).colors = colors;
			}
			((Graphic)val5).color = color;
			GameObject val8 = new GameObject("BBSMP_InputViewport");
			val8.transform.SetParent(val3.transform, false);
			RectTransform val9 = val8.AddComponent<RectTransform>();
			val9.anchorMin = Vector2.zero;
			val9.anchorMax = Vector2.one;
			val9.offsetMin = new Vector2(10f, 3f);
			val9.offsetMax = new Vector2(-10f, -3f);
			val8.AddComponent<RectMask2D>();
			TMP_Text val10 = null;
			if ((Object)(object)componentInChildren != (Object)null)
			{
				GameObject val11 = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, val8.transform);
				((Object)val11).name = "BBSMP_InputValue";
				StripLocalizationComponentsImmediate(val11);
				Il2CppArrayBase<Image> componentsInChildren2 = val11.GetComponentsInChildren<Image>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					if ((Object)(object)componentsInChildren2[j] != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)componentsInChildren2[j]);
					}
				}
				val10 = val11.GetComponent<TMP_Text>();
				bool flag = !string.IsNullOrEmpty(initialValue);
				val10.text = (flag ? initialValue : (placeholder ?? ""));
				val10.alignment = (TextAlignmentOptions)4097;
				val10.enableWordWrapping = false;
				val10.overflowMode = (TextOverflowModes)0;
				val10.fontSize = 19f;
				val10.fontStyle = (FontStyles)0;
				val10.enableVertexGradient = false;
				ApplyLowercaseTextFont(val10);
				val10.ForceMeshUpdate(false, false);
				Color black = Color.black;
				Color val12 = default(Color);
				((Color)(ref val12))..ctor(0.45f, 0.45f, 0.45f, 1f);
				((Graphic)val10).color = (flag ? black : val12);
				((Graphic)val10).canvasRenderer.SetColor(Color.white);
				RectTransform component3 = val11.GetComponent<RectTransform>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.anchorMin = Vector2.zero;
					component3.anchorMax = Vector2.one;
					component3.offsetMin = Vector2.zero;
					component3.offsetMax = Vector2.zero;
				}
			}
			Image val13 = null;
			GameObject val14 = new GameObject("BBSMP_InputCursor");
			val14.transform.SetParent(((Component)val9).transform, false);
			RectTransform val15 = val14.AddComponent<RectTransform>();
			val15.anchorMin = new Vector2(0f, 0.5f);
			val15.anchorMax = new Vector2(0f, 0.5f);
			val15.pivot = new Vector2(0f, 0.5f);
			val15.sizeDelta = new Vector2(2f, 18f);
			val15.anchoredPosition = Vector2.zero;
			val13 = val14.AddComponent<Image>();
			((Graphic)val13).color = Color.clear;
			((Behaviour)val13).enabled = false;
			InputFieldInfo capturedInfo = new InputFieldInfo
			{
				Value = (initialValue ?? ""),
				DisplayText = val10,
				OnChanged = onChange,
				Placeholder = (placeholder ?? ""),
				Viewport = val9,
				ActiveColor = Color.black,
				PlaceholderColor = new Color(0.45f, 0.45f, 0.45f, 1f)
			};
			Button capturedBtn = component;
			InjectedMenu capturedMenu = _currentInjectedMenu;
			capturedInfo.OwnerButton = component;
			capturedInfo.CursorImage = val13;
			if (component != null)
			{
				((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
				{
					capturedMenu?.OnInputFieldButtonClick(capturedInfo, capturedBtn);
				}));
			}
			PlaceInLayout(val2.GetComponent<RectTransform>(), val, 52f);
			_currentTabMenu?.RegisterPageSelectable(_currentTabPage, (Selectable)(object)component);
			return component;
		}

		public static RuntimeTabMenu BuildNativeTabMenu(string[] tabNames, RectTransform contentRoot, Button nativeTabSource, Button fallbackTemplate)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0085: 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_00b1: 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_00d3: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Expected O, but got Unknown
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: 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_034d: Unknown result type (might be due to invalid IL or missing references)
			if (tabNames == null || tabNames.Length == 0 || (Object)(object)contentRoot == (Object)null)
			{
				return null;
			}
			RuntimeTabMenu menu = new RuntimeTabMenu(tabNames)
			{
				Root = contentRoot,
				Tabs = (Button[])(object)new Button[tabNames.Length],
				Pages = (RectTransform[])(object)new RectTransform[tabNames.Length]
			};
			GameObject val = new GameObject("BBSMP_TabHeader");
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent((Transform)(object)contentRoot, false);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.sizeDelta = new Vector2(0f, 56f);
			val2.anchoredPosition = Vector2.zero;
			menu.Header = val2;
			float num = ((contentRoot.sizeDelta.x > 0f) ? (contentRoot.sizeDelta.x / (float)tabNames.Length) : (520f / (float)tabNames.Length));
			GameObject val3 = (((Object)(object)nativeTabSource != (Object)null) ? ((Component)nativeTabSource).gameObject : ((Component)fallbackTemplate).gameObject);
			Button val4 = nativeTabSource ?? fallbackTemplate;
			if ((Object)(object)val4 != (Object)null)
			{
				RuntimeTabMenu runtimeTabMenu = menu;
				ColorBlock colors = ((Selectable)val4).colors;
				runtimeTabMenu.NativeHighlightedColor = ((ColorBlock)(ref colors)).highlightedColor;
			}
			for (int i = 0; i < tabNames.Length; i++)
			{
				int idx = i;
				GameObject val5 = Object.Instantiate<GameObject>(val3, (Transform)(object)val2);
				((Object)val5).name = $"BBSMP_Tab_{i}";
				StripLocalizationComponentsImmediate(val5);
				SetButtonLabel(val5, tabNames[i]);
				RectTransform component = val5.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchorMin = new Vector2(0f, 0f);
					component.anchorMax = new Vector2(0f, 1f);
					component.pivot = new Vector2(0f, 0.5f);
					component.sizeDelta = new Vector2(num - 4f, 0f);
					component.anchoredPosition = new Vector2((float)i * num, 0f);
				}
				Button component2 = val5.GetComponent<Button>();
				ClearButtonEvents(component2);
				if ((Object)(object)component2 != (Object)null)
				{
					((UnityEvent)component2.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						menu.SetActiveTab(idx);
					}));
				}
				menu.Tabs[i] = component2;
				GameObject val6 = new GameObject($"BBSMP_Page_{i}");
				RectTransform val7 = val6.AddComponent<RectTransform>();
				((Transform)val7).SetParent((Transform)(object)contentRoot, false);
				val7.anchorMin = Vector2.zero;
				val7.anchorMax = Vector2.one;
				val7.pivot = new Vector2(0.5f, 1f);
				val7.offsetMin = new Vector2(0f, 4f);
				val7.offsetMax = new Vector2(0f, -60f);
				CanvasGroup val8 = val6.AddComponent<CanvasGroup>();
				val8.alpha = 0f;
				val8.interactable = false;
				val8.blocksRaycasts = false;
				menu.Pages[i] = val7;
			}
			menu.SetActiveTab(0);
			return menu;
		}

		private static void ResetLayout()
		{
			nextY = 0f;
		}

		private static void PlaceInLayout(RectTransform rect, RectTransform parent, float height)
		{
			//IL_0028: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null) && !((Object)(object)parent == (Object)null))
			{
				rect.anchorMin = new Vector2(0f, 1f);
				rect.anchorMax = new Vector2(1f, 1f);
				rect.pivot = new Vector2(0.5f, 1f);
				rect.sizeDelta = new Vector2(0f, height);
				if ((Object)(object)parent == (Object)(object)customRoot)
				{
					rect.anchoredPosition = new Vector2(0f, 0f - nextY);
					nextY += height + 10f;
				}
			}
		}

		internal static void SetButtonLabel(GameObject obj, string label, bool useLowercaseFont = false)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return;
			}
			TMP_Text componentInChildren = obj.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Component> componentsInChildren = ((Component)componentInChildren).GetComponentsInChildren<Component>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Component val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null) && IsLocalizationComponent(val))
				{
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if (val2 != null)
					{
						val2.enabled = false;
					}
					Object.DestroyImmediate((Object)(object)val);
				}
			}
			componentInChildren.text = label;
			if ((Object)(object)toggleTemplate != (Object)null)
			{
				Transform obj2 = ((Component)toggleTemplate).transform.Find("Label");
				TMP_Text val3 = ((obj2 != null) ? ((Component)obj2).GetComponent<TMP_Text>() : null);
				if ((Object)(object)val3 != (Object)null)
				{
					componentInChildren.fontSize = val3.fontSize;
				}
			}
			if (useLowercaseFont)
			{
				componentInChildren.fontStyle = (FontStyles)0;
				ApplyLowercaseTextFont(componentInChildren);
			}
			componentInChildren.ForceMeshUpdate(false, false);
		}

		internal static void ClearButtonEvents(Button button)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if ((Object)(object)button != (Object)null)
			{
				button.onClick = new ButtonClickedEvent();
			}
		}

		internal static void StripLocalizationComponents(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Component> componentsInChildren = root.GetComponentsInChildren<Component>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Component val = componentsInChildren[i];
				if ((Object)(object)val != (Object)null && IsLocalizationComponent(val))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		internal static void StripLocalizationComponentsImmediate(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Component> componentsInChildren = root.GetComponentsInChildren<Component>(true);
			List<Component> list = new List<Component>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Component val = componentsInChildren[i];
				if ((Object)(object)val != (Object)null && IsLocalizationComponent(val))
				{
					list.Add(val);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Object.DestroyImmediate((Object)(object)list[j]);
			}
		}

		private static bool IsLocalizationComponent(Component comp)
		{
			return comp is BBLocalize;
		}
	}
	[HarmonyPatch]
	internal static class Patch_MenuHooks
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Menu), "Awake")]
		private static void Awake_Postfix(Menu __instance)
		{
			List<MenuInjectionLibrary.InjectedMenu> registeredMenus = MenuInjectionLibrary._registeredMenus;
			for (int i = 0; i < registeredMenus.Count; i++)
			{
				registeredMenus[i].OnMenuAwake(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Menu), "Update")]
		private static void Update_Prefix(Menu __instance)
		{
			List<MenuInjectionLibrary.InjectedMenu> registeredMenus = MenuInjectionLibrary._registeredMenus;
			for (int i = 0; i < registeredMenus.Count; i++)
			{
				registeredMenus[i].OnMenuPreUpdate(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Menu), "Update")]
		private static void Update_Postfix(Menu __instance)
		{
			List<MenuInjectionLibrary.InjectedMenu> registeredMenus = MenuInjectionLibrary._registeredMenus;
			for (int i = 0; i < registeredMenus.Count; i++)
			{
				registeredMenus[i].OnMenuUpdate(__instance);
			}
		}
	}
	public static class MultiplayerMenu
	{
		private enum KeybindCaptureTarget
		{
			None,
			PushToTalk,
			TabMenu,
			ChatMenu
		}

		private static MenuInjectionLibrary.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 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 ConnectFixedBtn => _menu?.GetFixedButton(0);

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

		public static void Initialize()
		{
			if (_menu == null)
			{
				ModSettings.Load();
				_menu = MenuInjectionLibrary.CreateMenu("Multiplayer").AddTab("Player", ConfigurePlayerTab).AddTab("Connection", ConfigureConnectionTab)
					.AddTab("General", ConfigureGeneralTab)
					.AddTab("Audio", ConfigureAudioTab)
					.AddFixedButton(GetConnectLabel(), UnityAction.op_Implicit((Action)OnConnectClicked))
					.AddFixedButton("Back")
					.WithMargin(136f, 125f)
					.Build();
				Core.OnConnectionStateChanged = (Action)Delegate.Combine(Core.OnConnectionStateChanged, new Action(RefreshConnectionState));
			}
		}

		public static void Update()
		{
			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(MenuInjectionLibrary.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_009b: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			Color value = ModSettings.player.SuitColor.Value;
			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();
			}));
			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();
			}));
			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();
			}));
			_colorPreviewImage = tab.AddImage(value, 40f);
		}

		private static void ConfigureConnectionTab(MenuInjectionLibrary.TabBuilder tab)
		{
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			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);
			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());
			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);
		}

		private static void ConfigureGeneralTab(MenuInjectionLibrary.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(MenuInjectionLibrary.TabBuilder tab)
		{
			tab.AddToggle(GetMicrophoneToggleLabel(), ModSettings.audio.MicrophoneEnabled.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnMicrophoneToggled));
			tab.AddToggle(GetDeafenToggleLabel(), ModSettings.audio.Deafened.Value, UnityAction<bool>.op_Implicit((Action<bool>)OnDeafenToggled));
			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;
			TMP_Text gainLabel = null;
			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);
				}
			}));
		}

		private static void OnConnectClicked()
		{
			if (Core.networkManager.client != null)
			{
				Core.networkManager.Disconnect();
				return;
			}
			ModSettings.Save();
			Core.networkManager.Connect(ModSettings.connection.Address.Value, ModSettings.connection.Port.Value, ModSettings.connection.Password.Value);
		}

		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 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.client == null)
			{
				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.client == null)
			{
				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.client == null)
			{
				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.client != null)
			{
				ModSettings.Save();
				Core.networkManager.mainThreadActions.Enqueue(delegate
				{
					Core.networkManager.SendPlayerInformation();
					LocalPlayer.Instance?.ApplySuitColor();
				});
				Core.uiManager.notificationsUI.AddMessage(LanguageManager.GetCurrentLanguage().AppearanceUpdated);
			}
		}

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

		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()
		{
			return (Core.networkManager?.client != null) ? LanguageManager.GetCurrentLanguage().Disconnect : LanguageManager.GetCurrentLanguage().Connect;
		}

		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()
		{
			return "Push to Talk Key: " + InputBindingHelper.GetDisplayName(ModSettings.audio.PushToTalkKey.Value);
		}

		private static string GetTabMenuKeyLabel()
		{
			return "Player List Key: " + InputBindingHelper.GetDisplayName(ModSettings.player.TabMenuKey.Value);
		}

		private static string GetChatMenuKeyLabel()
		{
			return "Chat Menu Key: " + InputBindingHelper.GetDisplayName(ModSettings.player.ChatMenuKey.Value);
		}

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

		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 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 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.client == null)
			{
				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_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_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)
			MenuInjectionLibrary.InjectedMenu keyboardMenu = MenuInjectionLibrary.GetKeyboardMenu();
			if (keyboardMenu == null || !Core.uiManager.ChatMenuUsesControllerBinding)
			{
				return false;
			}
			if (!keyboardMenu.IsKeyboardOpen)
			{
				MenuInjectionLibrary.InputFieldInfo info = new MenuInjectionLibrary.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(info, 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();
				MenuInjectionLibrary.GetKeyboardMenu()?.CloseKeyboardOverlay();
				Core.uiManager.showChatTab = false;
				current.Use();
			}
			else if ((int)current.keyCode == 27)
			{
				MenuInjectionLibrary.GetKeyboardMenu()?.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_0176: 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)
					{
						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 flag = Core.networkManager.client != null;
			string text = (flag ? currentLanguage.Disconnect : currentLanguage.Connect);
			if (GUILayout.Button(text, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()))
			{
				if (flag)
				{
					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("Tab Menu Key:", 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("Chat Menu Key:", 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.client != null;
			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.client != null;
			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.client != null;
			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_010a: 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_0110: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: 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_024b: 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_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			GUI.enabled = Core.networkManager.client != null;
			if (GUILayout.Button(currentLanguage.UpdateNameAndAppearance, StyleManager.Styles.Button, Array.Empty<GUILayoutOption>()) && Core.networkManager.client != null)
			{
				SaveConfig();
				Core.networkManager.mainThreadActions.Enqueue(delegate
				{
					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.client != null;
			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.server == null)
			{
				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.server == null || (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.server == null || (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;
			}
			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)
		{
			if (Core.networkManager != null)
			{
				Core.networkManager.Disconnect();
			}
			return true;
		}
	}
	[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
{
	internal class ClientListener : INetEventListener
	{
		public void OnPeerConnected(NetPeer peer)
		{
			Core.networkManager.server = peer;
			Core.networkManager.SendPlayerInformation();
			ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
			Core.uiManager.notificationsUI.AddMessage(currentLanguage.ConnectedToServer);
			Core.OnConnectionStateChanged?.Invoke();
		}

		public void OnPeerDisconnected(NetPeer peer, DisconnectInfo info)
		{
			Core.networkManager.server = null;
			Core.networkManager.Disconnect();
			Resources.UnloadUnusedAssets();
		}

		public void OnConnectionRequest(ConnectionRequest req)
		{
			req.AcceptIfKey("cuzzillobochfoddy");
		}

		public void OnNetworkError(IPEndPoint ep, SocketError error)
		{
			Core.logger.Error($"Network error: {error}");
		}

		public void OnNetworkReceiveUnconnected(IPEndPoint ep, NetPacketReader reader, UnconnectedMessageType type)
		{
			ReadPacket(reader);
		}

		public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod method)
		{
			ReadPacket(reader);
		}

		private void ReadPacket(NetPacketReader reader)
		{
			byte[] remainingBytes = ((NetDataReader)reader).GetRemainingBytes();
			reader.Recycle();
			if (remainingBytes.Length < 2)
			{
				Core.logger.Warning("Received packet too short to contain length header.");
				return;
			}
			ushort num = BitConverter.ToUInt16(remainingBytes, 0);
			if (num != remainingBytes.Length)
			{
				Core.logger.Warning($"Packet length mismatch: expected {num}, got {remainingBytes.Length}");
			}
			else
			{
				byte[] array = new byte[remainingBytes.Length - 2];
				Buffer.BlockCopy(remainingBytes, 2, array, 0, array.Length);
				Core.networkManager.HandleServerMessage(array);
			}
		}

		public void OnNetworkLatencyUpdate(NetPeer peer, int latency)
		{
		}
	}
	internal enum eOpCode : byte
	{
		BonePositionUpdate = 1,
		PlayerInformation = 2,
		ChatMessage = 8,
		AudioFrame = 9,
		GenericWorldEvent = 3,
		AddAccessory = 4,
		RemoveAccessory = 5,
		JiminyRibbon = 6,
		ToggleCollisions = 7,
		Ping = 10
	}
	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 NetworkManager
	{
		public NetPeer server;

		private ClientListener listener;

		private byte uuid;

		public ConcurrentQueue<Action> mainThreadActions = new ConcurrentQueue<Action>();

		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 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 const string EasterEggMarker = "\u2063";

		private IPAddress connectedServerAddress;

		public NetManager client { get; private set; }

		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);
		}

		public void Connect(string serverIP, int serverPort, string password)
		{
			//IL_006b: 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_0087: Expected O, but got Unknown
			if (client != null)
			{
				NetManager obj = client;
				if (obj != null)
				{
					obj.Stop();
				}
				client = null;
				server = null;
			}
			Core.uiManager.notificationsUI.AddMessage("Connecting to server...");
			listener = new ClientListener();
			client = new NetManager((INetEventListener)(object)listener, (PacketLayerBase)null)
			{
				AutoRecycle = true,
				DisconnectTimeout = 15000
			};
			client.Start();
			string text = "106" + (string.IsNullOrEmpty(password) ? "cuzzillobochfoddy" : password);
			client.Connect(serverIP, serverPort, text);
		}

		public void Disconnect()
		{
			if (client == null)
			{
				return;
			}
			NetManager obj = client;
			if (obj != null)
			{
				obj.Stop();
			}
			client = null;
			server = null;
			connectedServerAddress = null;
			IsEasterEggActive = false;
			localBoneSequenceNumber = 0;
			localAudioFrameSequenceNumber = 0;
			uuid = 0;
			numClones = 0;
			pendingPlayerJoins.Clear();
			pendingPlayerUpdates.Clear();
			mainThreadActions.Clear();
			lastSeenBoneSequences.Clear();
			lastSeenAudioFrameSequences.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();
			Core.uiManager.notificationsUI.AddMessage("Disconnected from server");
			Core.OnConnectionStateChanged?.Invoke();
		}

		public void Update()
		{
			if (client == null)
			{
				return;
			}
			if (Core.HasLoadedGame())
			{
				if (LocalPlayer.Instance == null)
				{
					LocalPlayer.Instance = new LocalPlayer();
					LocalPlayer.Instance.Initialize();
					return;
				}
				pendingPlayerJoins.Process(HandleServerMessage);
			}
			Action result;
			while (mainThreadActions.TryDequeue(out result))
			{
				try
				{
					result();
				}
				catch (Exception ex)
				{
					Core.logger.Error(ex.ToString());
				}
			}
			try
			{
				if (!client.UnsyncedEvents)
				{
					client.PollEvents(0);
				}
			}
			catch (Exception ex2)
			{
				Core.logger.Error(ex2.ToString());
			}
			WorldObjectSyncManager.Update();
		}

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

		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();
			}
		}

		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 static IPAddress ResolveServerAddress(string serverAddress)
		{
			if (string.IsNullOrWhiteSpace(serverAddress))
			{
				return null;
			}
			if (string.Equals(serverAddress, "localhost", StringComparison.OrdinalIgnoreCase))
			{
				return IPAddress.Loopback;
			}
			if (IPAddress.TryParse(serverAddress, out IPAddress address))
			{
				return address;
			}
			try
			{
				return Dns.GetHostAddresses(serverAddress).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;
					}
					IPInterfaceProperties iPProperties = networkInterface.GetIPProperties();
					foreach (UnicastIPAddressInformation unicastAddress in iPProperties.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 address, IPAddress subnetAddress, IPAddress subnetMask)
		{
			byte[] addressBytes = address.GetAddressBytes();
			byte[] addressBytes2 = subnetAddress.GetAddressBytes();
			byte[] addressBytes3 = subnetMask.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;
		}

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

		private string GetNicknameForSend()
		{
			UpdateEasterEggState();
			string text = StripEasterEggMarker(ModSettings.player.Nickname.Value ?? string.Empty);
			if (IsEasterEggActive)
			{
				text += "\u2063";
			}
			return text;
		}

		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[2] / 255f, (float)(int)data[3] / 255f, (float)(int)data[4] / 255f);
			bool flag = player.BaseSuitColor != val;
			player.UpdateBaseSuitColor(val);
			int num = data.Length - 5;
			if (num <= 0)
			{
				return;
			}
			string @string = Encoding.UTF8.GetString(data, 5, num);
			bool rainbowSuitActive = HasEasterEggMarker(@string);
			string text = StripEasterEggMarker(@string);
			player.SetRainbowSuitActive(rainbowSuitActive);
			if (!player.firstAppearanceApplication)
			{
				Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage.HasConnected, text));
				player.firstAppearanceApplication = true;
			}
			else
			{
				if (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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			byte b = data[2];
			int num = 3;
			switch (b)
			{
			case 0:
			{
				float num9 = BitConverter.ToSingle(data, num);
				num += 4;
				float num10 = BitConverter.ToSingle(data, num);
				num += 4;
				float num11 = BitConverter.ToSingle(data, num);
				num += 4;
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(num9, num10, num11);
				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;
				Quaternion val2 = default(Quaternion);
				((Quaternion)(ref val2))..ctor(num12, num13, num14, num15);
				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:
			{
				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;
				Vector3 localPosition = default(Vector3);
				((Vector3)(ref localPosition))..ctor(num2, num3, num4);
				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;
				Quaternion localRotation = default(Quaternion);
				((Quaternion)(ref localRotation))..ctor(num5, num6, num7, num8);
				string @string = Encoding.UTF8.GetString(data, num, data.Length - num);
				player.HoldItem(@string, handIndex, localPosition, localRotation);
				Core.uiManager.notificationsUI.AddMessage(player.displayName + " has picked up the " + @string);
				break;
			}
			default:
				Core.logger.Msg($"Unknown Accessory type: {b}");
				break;
			}
		}

		private void Send(List<byte> data, DeliveryMethod deliveryMethod)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Send(data.ToArray(), deliveryMethod);
		}

		private void Send(byte[] data, DeliveryMethod deliveryMethod)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			NetDataWriter val = new NetDataWriter();
			ushort num = (ushort)(data.Length + 2);
			val.Put(num);
			val.Put(data);
			NetPeer obj = server;
			if (obj != null)
			{
				obj.Send(val, deliveryMethod);
			}
		}

		public void SendCollisionToggle(bool state)
		{
			List<byte> data = new List<byte>(1024)
			{
				7,
				Convert.ToByte(state)
			};
			Send(data, (DeliveryMethod)2);
		}

		public void SendJiminyRibbonState(bool state)
		{
			List<byte> data = new List<byte>(1024)
			{
				6,
				Convert.ToByte(state)
			};
			Send(data, (DeliveryMethod)2);
		}

		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));
			Send(list, (DeliveryMethod)4);
		}

		private void SendAddAccessory(byte itemType, string itemName, Vector3 localPosition, Quaternion localRotation, int handIndex = 0)
		{
			//IL_002f: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			List<byte> list = new List<byte>(1024) { 4, itemType };
			if (itemType == 1)
			{
				list.Add((byte)handIndex);
			}
			list.AddRange(BitConverter.GetBytes(localPosition.x));
			list.AddRange(BitConverter.GetBytes(localPosition.y));
			list.AddRange(BitConverter.GetBytes(localPosition.z));
			list.AddRange(BitConverter.GetBytes(localRotation.x));
			list.AddRange(BitConverter.GetBytes(localRotation.y));
			list.AddRange(BitConverter.GetBytes(localRotation.z));
			list.AddRange(BitConverter.GetBytes(localRotation.w));
			list.AddRange(Encoding.UTF8.GetBytes(itemName));
			Send(list, (DeliveryMethod)2);
		}

		private void SendRemoveAccessory(byte itemType, int handIndex = 0)
		{
			List<byte> list = new List<byte>(1024) { 5, itemType };
			if (itemType == 1)
			{
				list.Add((byte)handIndex);
			}
			Send(list, (DeliveryMethod)2);
		}

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

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

		public void SendDonHat(Hat hat)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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 (LocalPlayer.Instance != null && !((Object)(object)LocalPlayer.Instance.headBone == (Object)null))
			{
				Vector3 localPosition = LocalPlayer.Instance.headBone.InverseTransformPoint(((Component)hat).transform.position);
				Quaternion localRotation = Quaternion.Inverse(LocalPlayer.Instance.headBone.rotation) * ((Component)hat).transform.rotation;
				string text = ((Object)hat).name;
				if (text.EndsWith("(Clone)"))
				{
					text = text.Substring(0, text.Length - "(Clone)".Length);
				}
				SendAddAccessory(0, text, localPosition, localRotation);
			}
		}

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

		public void SendChatMessage(string message)
		{
			List<byte> list = new List<byte>(1024) { 8 };
			list.AddRange(Encoding.UTF8.GetBytes(message));
			Send(list, (DeliveryMethod)2);
		}

		public void SendPlayerInformation()
		{
			//IL_001e: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			List<byte> list = new List<byte>(1024)
			{
				2,
				(byte)(ModSettings.player.SuitColor.Value.r * 255f),
				(byte)(ModSettings.player.SuitColor.Value.g * 255f),
				(byte)(ModSettings.player.SuitColor.Value.b * 255f)
			};
			list.AddRange(Encoding.UTF8.GetBytes(GetNicknameForSend()));
			Send(list, (DeliveryMethod)2);
		}

		public void SendAudioFrame(byte[] encodedData)
		{
			List<byte> list = new List<byte>(1024) { 9 };
			list.AddRange(BitConverter.GetBytes(localAudioFrameSequenceNumber++));
			list.AddRange(encodedData);
			Send(list, (DeliveryMethod)4);
		}

		public void HandleServerMessage(byte[] data)
		{
			try
			{
				if (data.Length < 1)
				{
					return;
				}
				byte b = data[0];
				switch (b)
				{
				case 1:
				{
					Core.DebugMsg("Personal UUID packet received");
					uuid = data[1];
					long serverUptimeMs2 = BitConverter.ToInt64(data, 2);
					WorldObjectSyncManager.OnServerTimeSample(serverUptimeMs2);
					Core.logger.Msg($"Received UUID: {uuid}");
					ILanguage currentLanguage = LanguageManager.GetCurrentLanguage();
					Core.uiManager.notificationsUI.AddMessage("Press the 'T' key to send a message");
					break;
				}
				case 2:
				{
					Core.DebugMsg("Player join packet received");
					byte key9 = data[1];
					if (players.ContainsKey(key9))
					{
						break;
					}
					if (!Core.HasLoadedGame() || LocalPlayer.Instance == null)
					{
						pendingPlayerJoins.Enqueue(key9, data);
						break;
					}
					RemotePlayer result = null;
					if (!RemotePlayer.GlobalPool.TryTake(out result))
					{
						result = new RemotePlayer();
						result.Initialize(numClones++);
					}
					result.SetActive(active: true);
					result.RemoveHat();
					result.ResetBonesToBind();
					result.InitializeAudioSource();
					players[key9] = result;
					pendingPlayerUpdates.Process(key9, HandleServerMessage);
					break;
				}
				case 3:
				{
					Core.DebugMsg("Player disconnect packet received");
					byte key11 = data[1];
					if (players.TryGetValue(key11, out var value13))
					{
						ILanguage currentLanguage2 = LanguageManager.GetCurrentLanguage();
						players.Remove(key11, out var _);
						lastSeenBoneSequences.Remove(key11, out var value15);
						lastSeenAudioFrameSequences.Remove(key11, out value15);
						Core.uiManager.notificationsUI.AddMessage(string.Format(currentLanguage2.HasDisconnected, value13.displayName));
						value13.Dispose();
					}
					pendingPlayerJoins.Clear(key11);
					pendingPlayerUpdates.Clear(key11);
					break;
				}
				case 4:
				{
					Core.DebugMsg("Player appearance packet received");
					byte key10 = data[1];
					if (players.TryGetValue(key10, out var value12))
					{
						ApplyAppearanceUpdate(value12, data);
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key10, data);
					}
					break;
				}
				case 5:
				{
					byte key3 = data[1];
					if (players.TryGetValue(key3, out var value4))
					{
						byte kickoffPoint = data[2];
						ushort num2 = BitConverter.ToUInt16(data, 3);
						byte[] array = data.Skip(5).ToArray();
						long serverUptimeMs = BitConverter.ToInt64(array, array.Length - 8);
						WorldObjectSyncManager.OnServerTimeSample(serverUptimeMs);
						array = array.Take(array.Length - 8).ToArray();
						if (!lastSeenBoneSequences.TryGetValue(key3, out var value5) || IsNewer(num2, value5))
						{
							lastSeenBoneSequences[key3] = num2;
							byte[] data2 = array;
							TransformNet[] bonesToUpdate = TransformNet.Deserialize(data2);
							value4.UpdateBones(bonesToUpdate, kickoffPoint);
						}
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key3, data);
					}
					break;
				}
				case 6:
				{
					Core.DebugMsg("GWE packet received");
					byte key4 = data[1];
					ushort current = BitConverter.ToUInt16(data, 2);
					byte[] array2 = data.Skip(4).ToArray();
					if (lastSeenBoneSequences.TryGetValue(key4, out var value6) && !IsNewer(current, value6))
					{
						break;
					}
					byte b2 = array2[0];
					switch (b2)
					{
					case 0:
						switch (array2[1])
						{
						case 0:
							if (LocalPlayer.Instance != null && (Object)(object)LocalPlayer.Instance.particleParty != (Object)null)
							{
								FootData val2 = FootDataHelpers.DeserializeFootData(array2.Skip(2).ToArray(), players[key4]);
								if (val2 != null)
								{
									isRunningNetParticle = true;
									LocalPlayer.Instance.particleParty.OnPlant(val2);
								}
							}
							break;
						case 1:
							if (LocalPlayer.Instance != null && (Object)(object)LocalPlayer.Instance.particleParty != (Object)null)
							{
								FootData val = FootDataHelpers.DeserializeFootData(array2.Skip(2).ToArray(), players[key4]);
								if (val != null)
								{
									isRunningNetParticle = true;
									LocalPlayer.Instance.particleParty.OnSlip(val);
								}
							}
							break;
						}
						break;
					case 1:
						break;
					default:
						Core.logger.Msg($"Unknown GWE eID: {b2}");
						break;
					}
					break;
				}
				case 7:
				{
					Core.DebugMsg("Accessory don packet received");
					byte key2 = data[1];
					if (players.TryGetValue(key2, out var value3))
					{
						ApplyAccessoryDon(value3, data);
						ApplyCollisionToggle(value3, value3.netCollisionsEnabled);
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key2, data);
					}
					break;
				}
				case 8:
				{
					Core.DebugMsg("Accessory doff packet received");
					byte key7 = data[1];
					if (players.TryGetValue(key7, out var value10))
					{
						byte b3 = data[2];
						switch (b3)
						{
						case 0:
							value10.RemoveHat();
							break;
						case 1:
							value10.DropItem(data[3]);
							break;
						default:
							Core.logger.Msg($"Unknown Accessory type: {b3}");
							break;
						}
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key7, data);
					}
					break;
				}
				case 9:
				{
					Core.DebugMsg("Jiminy Ribbon packet received");
					byte key5 = data[1];
					bool jiminyState = Convert.ToBoolean(data[2]);
					if (players.TryGetValue(key5, out var value7))
					{
						ApplyJiminyRibbonStateChange(value7, jiminyState);
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key5, data);
					}
					break;
				}
				case 10:
				{
					Core.DebugMsg("Collision toggle packet received");
					byte key8 = data[1];
					bool flag = Convert.ToBoolean(data[2]);
					if (players.TryGetValue(key8, out var value11))
					{
						ApplyCollisionToggle(value11, flag);
						Core.uiManager.notificationsUI.AddMessage(value11.displayName + " has " + (flag ? "enabled" : "disabled") + " collisions");
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key8, data);
					}
					break;
				}
				case 11:
				{
					Core.DebugMsg("Chat message received");
					byte key6 = data[1];
					string @string = Encoding.UTF8.GetString(data.Skip(2).ToArray());
					if (players.TryGetValue(key6, out var value8))
					{
						int num3 = @string.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
						float value9 = Mathf.Max(3f, 3f + (float)num3 - 5f) * 0.5f;
						Core.uiManager.notificationsUI.AddMessage(value8.displayName + ": " + @string, value9);
					}
					else
					{
						pendingPlayerUpdates.Enqueue(key6, data);
					}
					break;
				}
				case 12:
				{
					if (ModSettings.audio.Deafened.Value)
					{
						break;
					}
					byte key = data[1];
					if (players.TryGetValue(key, out var value))
					{
						ushort num = BitConverter.ToUInt16(data, 2);
						if (!lastSeenAudioFrameSequences.TryGetValue(key, out var value2) || IsNewer(num, value2))
						{
							lastSeenAudioFrameSequences[key] = num;
							byte[] subArray = data[4..];
							value.audioSource.QueueOpusPacket(subArray);
						}
					}
					break;
				}
				default:
					Core.logger.Msg($"Unknown opcode from server: {b}");
					break;
				}
			}
			catch (Exception ex)
			{
				Core.logger.Error((object)ex);
			}
		}
	}
	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_0078: 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 x = LocalPlayer.Instance.rootBone.position.x;
				float num8 = x - loopWidth * 0.5f;
				float num9 = num7 - num8;
				num9 = (num9 % loopWidth + loopWidth) % loopWidth;
				num7 = num9 + num8;
				float y = BitConverter.ToSingle(data, num3 + 3);
				float z = BitConverter.ToSingle(data, num3 + 7);
				short num10 = BitConverter.ToInt16(data, num3 + 11);
				short num11 = BitConverter.ToInt16(data, num3 + 13);
				short num12 = BitConverter.ToInt16(data, num3 + 15);
				float num13 = (float)num10 / 32767f;
				float num14 = (float)num11 / 32767f;
				float num15 = (float)num12 / 32767f;
				float num16 = 1f - (num13 * num13 + num14 * num14 + num15 * num15);
				float w = ((num16 > 0f) ? MathF.Sqrt(num16) : 0f);
				array[i] = new TransformNet(i, new Vector3(num7, y, z), new Quaternion(num13, num14, num15, 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.Localization
{
	public static class LanguageManager
	{
		private static Dictionary<string, ILanguage> _registeredLanguages;

		private static ILanguage _currentLanguage;

		public static string CurrentLanguage { get; private set; }

		static LanguageManager()
		{
			CurrentLanguage = "English";
			InitializeLanguages();
		}

		private static void InitializeLanguages()
		{
			_registeredLanguages = new Dictionary<string, ILanguage>
			{
				{
					"English",
					new EnglishLanguage()
				},
				{
					"Spanish",
					new SpanishLanguage()
				},
				{
					"German",
					new GermanLanguage()
				},
				{
					"French",
					new FrenchLanguage()
				},
				{
					"Japanese",
					new JapaneseLanguage()
				},
				{
					"Korean",
					new KoreanLanguage()
				},
				{
					"ChineseSimplified",
					new ChineseSimplifiedLanguage()
				},
				{
					"ChineseTraditional",
					new ChineseTraditionalLanguage()
				}
			};
			LoadLanguageFromConfig();
		}

		private static void LoadLanguageFromConfig()
		{
			try
			{
				string value = ModSettings.player.Language.Value;
				if (!string.IsNullOrEmpty(value) && _registeredLanguages.ContainsKey(value))
				{
					SetLanguage(value);
				}
				else
				{
					SetLanguage("English");
				}
			}
			catch
			{
				SetLanguage("English");
			}
		}

		public static void SetLanguage(string languageName)
		{
			if (_registeredLanguages.ContainsKey(languageName))
			{
				_currentLanguage = _registeredLanguages[languageName];
				CurrentLanguage = languageName;
				SaveLanguageToConfig(languageName);
				return;
			}
			Instance logger = Core.logger;
			if (logger != null)
			{
				logger.Warning("Language '" + languageName + "' not found. Using English.");
			}
			_currentLanguage = _registeredLanguages["English"];
			CurrentLanguage = "English";
			SaveLanguageToConfig("English");
		}

		private static void SaveLanguageToConfig(string languageName)
		{
			try
			{
				ModSettings.player.Language.Value = languageName;
				ModSettings.Save();
			}
			catch
			{
			}
		}

		public static ILanguage GetCurrentLanguage()
		{
			return _currentLanguage ?? new EnglishLanguage();
		}

		public static string[] GetAvailableLanguages()
		{
			return new List<string>(_registeredLanguages.Keys).ToArray();
		}

		public static void RegisterLanguage(string name, ILanguage language)
		{
			if (!_registeredLanguages.ContainsKey(name))
			{
				_registeredLanguages[name] = language;
			}
		}
	}
	public static class LanguageNativeNames
	{
		public static readonly Dictionary<string, string> NativeNames = new Dictionary<string, string>
		{
			{ "English", "English" },
			{ "Spanish", "Español" },
			{ "French", "Français" },
			{ "German", "Deutsch" },
			{ "Korean", "한국어" },
			{ "ChineseSimplified", "简体中文" },
			{ "ChineseTraditional", "繁體中文" },
			{ "Japanese", "日本語" }
		};

		public static string GetNativeName(string languageCode)
		{
			if (NativeNames.TryGetValue(languageCode, out var value))
			{
				return value;
			}
			return languageCode;
		}
	}
	public interface ILanguage
	{
		string Disconnect { get; }

		string Connect { get; }

		string ServerInformation { get; }

		string AudioSettings { get; }

		string MicrophoneDevices { get; }

		string GeneralSettings { get; }

		string PlayerCustomization { get; }

		string ServerIP { get; }

		string ServerPort { get; }

		string PasswordOptional { get; }

		string DisableMicrophone { get; }

		string EnableMicrophone { get; }

		string Deafen { get; }

		string Undeafen { get; }

		string EnablePushToTalk { get; }

		string DisablePushToTalk { get; }

		string PushToTalkKey { get; }

		string PressAnyKey { get; }

		string MicrophoneGain { get; }

		string Level { get; }

		string EnableCollisions { get; }

		string DisableCollisions { get; }

		string EnablePlayerCutsceneVisibility { get; }

		string DisablePlayerCutsceneVisibility { get; }

		string ConnectedPlayers { get; }

		string NoPlayersConnected { get; }

		string You { get; }

		string UpdateNameAndAppearance { get; }

		string Nickname { get; }

		string SuitTint { get; }

		string Red { get; }

		string Green { get; }

		string Blue { get; }

		string EnableNametags { get; }

		string DisableNametags { get; }

		string AppearanceUpdated { get; }

		string HasConnected { get; }

		string HasDisconnected { get; }

		string HasChangedNicknameTo { get; }

		string HasUpdatedTheirColor { get; }

		string ConnectedToServer { get; }

		string Language { get; }
	}
	public class EnglishLanguage : ILanguage
	{
		public string Disconnect => "Disconnect";

		public string Connect => "Connect";

		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 ServerIP => "Server IP:";

		public string ServerPort => "Server Port:";

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

		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 PressAnyKey => "Press any key...";

		public string MicrophoneGain => "Microphone Gain:";

		public string Level => "Level:";

		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 ConnectedPlayers => "Connected Players";

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

		public string You => "You";

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

		public string Nickname => "Nickname:";

		public string SuitTint => "Suit Tint:";

		public string Red => "Red:";

		public string Green => "Green:";

		public string Blue => "Blue:";

		public string EnableNametags => "Enable Nametag Visibility";

		public string DisableNametags => "Disable Nametag Visibility";

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

		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 ConnectedToServer => "Connected to server";

		public string Language => "Language:";
	}
	public class SpanishLanguage : ILanguage
	{
		public string Disconnect => "Desconectar";

		public string Connect => "Conectar";

		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 ServerIP => "IP del servidor:";

		public string ServerPort => "Puerto:";

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

		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 PressAnyKey => "Pulsa una tecla...";

		public string MicrophoneGain => "Ganancia:";

		public string Level => "Nivel:";

		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 ConnectedPlayers => "Jugadores conectados";

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

		public string You => "Tú";

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

		public string Nickname => "Apodo:";

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

		public string Red => "Rojo:";

		public string Green => "Verde:";

		public string Blue => "Azul:";

		public string EnableNametags => "Mostrar nombres";

		public string DisableNametags => "Ocultar nombres";

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

		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 ConnectedToServer => "Conectado al servidor";

		public string Language => "Idioma:";
	}
	public class FrenchLanguage : ILanguage
	{
		public string Disconnect => "Se déconnecter";

		public string Connect => "Se connecter";

		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 ServerIP => "IP du serveur :";

		public string ServerPort => "Port :";

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

		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 parler pour parler";

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

		public string PushToTalkKey => "Touche parler :";

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

		public string MicrophoneGain => "Gain micro :";

		public string Level => "Niveau :";

		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 ConnectedPlayers => "Joueurs connectés";

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

		public string You => "Vous";

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

		public string Nickname => "Pseudo :";

		public string SuitTint => "Couleur tenue :";

		public string Red => "Rouge :";

		public string Green => "Vert :";

		public string Blue => "Bleu :";

		public string EnableNametags => "Afficher noms";

		public string DisableNametags => "Masquer noms";

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

		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 ConnectedToServer => "Connecté au serveur";

		public string Language => "Langue :";
	}
	public class GermanLanguage : ILanguage
	{
		public string Disconnect => "Verbindung trennen";

		public string Connect => "Verbinden";

		public string ServerInformation => "Serverinformationen";

		public string AudioSettings => "Audioeinstellungen";

		public string MicrophoneDevices => "Mikrofone";

		public string GeneralSettings => "Allgemein";

		public string PlayerCustomization => "Anpassung";

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

		public string ServerPort => "Port:";

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

		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 PressAnyKey => "Beliebige Taste drücken...";

		public string MicrophoneGain => "Mikrofonpegel:";

		public string Level => "Pegel:";

		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 ConnectedPlayers => "Verbundene Spieler";

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

		public string You => "Du";

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

		public string Nickname => "Spitzname:";

		public string SuitTint => "Anzugfarbe:";

		public string Red => "Rot:";

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

		public string Blue => "Blau:";

		public string EnableNametags => "Namen anzeigen";

		public string DisableNametags => "Namen ausblenden";

		public string AppearanceUpdated => "Aussehen aktualisiert";

		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 ConnectedToServer => "Mit Server verbunden";

		public string Language => "Sprache:";
	}
	public class KoreanLanguage : ILanguage
	{
		public string Disconnect => "연결 끊기";

		public string Connect => "연결";

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

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

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

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

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

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

		public string ServerPort => "포트:";

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

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

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

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

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

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

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

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

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

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

		public string Level => "레벨:";

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

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

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

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

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

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

		public string You => "나";

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

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

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

		public string Red => "빨강:";

		public string Green => "초록:";

		public string Blue => "파랑:";

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

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

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

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

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

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

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

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

		public string Language => "언어:";
	}
	public class ChineseSimplifiedLanguage : ILanguage
	{
		public string Disconnect => "断开连接";

		public string Connect => "连接";

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

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

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

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

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

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

		public string ServerPort => "端口：";

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

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

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

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

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

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

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

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

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

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

		public string Level => "级别：";

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

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

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

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

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

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

		public string You => "你";

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

		public string Nickname => "昵称：";

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

		public string Red => "红：";

		public string Green => "绿：";

		public string Blue => "蓝：";

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

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

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

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

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

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

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

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

		public string Language => "语言：";
	}
	public class ChineseTraditionalLanguage : ILanguage
	{
		public string Disconnect => "中斷連線";

		public string Connect => "連線";

		public string ServerInformation => "伺服器資訊";

		public string AudioSettings => "音訊設定";

		public string MicrophoneDevices => "麥克風裝置";

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

		public string PlayerCustomization => "玩家自訂";

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

		public string ServerPort => "連接埠：";

		public string PasswordOptional => "密碼（選填）：";

		public string DisableMicrophone => "關閉麥克風";

		public string EnableMicrophone => "開啟麥克風";

		public string Deafen => "關閉聲音";

		public string Undeafen => "恢復聲音";

		public string EnablePushToTalk => "啟用按鍵說話";

		public string DisablePushToTalk => "停用按鍵說話";

		public string PushToTalkKey => "說話按鍵：";

		public string PressAnyKey => "按任意鍵...";

		public string MicrophoneGain => "麥克風音量：";

		public string Level => "等級：";

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

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

		public string EnablePlayerCutsceneVisibility => "過場動畫中顯示玩家";

		public string DisablePlayerCutsceneVisibility => "過場動畫中隱藏玩家";

		public string ConnectedPlayers => "已連線玩家";

		public string NoPlayersConnected => "沒有玩家連線。";

		public string You => "你";

		public string UpdateNameAndAppearance => "更新名稱與外觀";

		public string Nickname => "暱稱：";

		public string SuitTint => "服裝顏色：";

		public string Red => "紅：";

		public string Green => "綠：";

		public string Blue => "藍：";

		public string EnableNametags => "顯示名稱";

		public string DisableNametags => "隱藏名稱";

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

		public string HasConnected => "{0} 已連線";

		public string HasDisconnected => "{0} 已中斷連線";

		public string HasChangedNicknameTo => "{0} 將暱稱改為 {1}";

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

		public string ConnectedToServer => "已連線至伺服器";

		public string Language => "語言：";
	}
	public class JapaneseLanguage : ILanguage
	{
		public string Disconnect => "切断";

		public string Connect => "接続";

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

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

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

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

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

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

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

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

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

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

		public string Deafen => "ミュート（受信）";

		public string Undeafen => "ミュート解除（受信）";

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

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

		public string PushToTalkKey => "プッシュトゥトークキー：";

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

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

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

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

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

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

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

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

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

		public string You => "あなた";

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

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

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

		public string Red => "赤：";

		public string Green => "緑：";

		public string Blue => "青：";

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

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

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

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

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

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

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

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

		public string Language => "言語：";
	}
}
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;

		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);
		}
	}
	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;

		internal MelonPreferences_Entry<string> Language;

		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: true);
			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");
			Language = CreatePref("Language", "Language", "UI Language", "English");
		}
	}
}
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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Invalid comparison between Unknown and I4
			//IL_02c2: 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.DebugMsg($"Found {num2} recording device(s)");
				string value = default(string);
				Guid val = default(Guid);
				int value2 = default(int);
				SPEAKERMODE val2 = default(SPEAKERMODE);
				int num3 = default(int);
				DRIVER_STATE val3 = default(DRIVER_STATE);
				for (int i = 0; i < num2; i++)
				{
					((System)(ref fmodSystem)).getRecordDriverInfo(i, ref value, 256, ref val, ref value2, ref val2, ref num3, ref val3);
					Core.DebugMsg($"  Device {i}: {value} ({value2}Hz)");
				}
				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 val4 = default(CREATESOUNDEXINFO);
				val4.cbsize = Marshal.SizeOf(typeof(CREATESOUNDEXINFO));
				val4.length = 4800u;
				val4.numchannels = 1;
				val4.defaultfrequency = 24000;
				val4.format = (SOUND_FORMAT)2;
				recordNumDrivers = ((System)(ref fmodSystem)).createSound(string.Empty, (MODE)1026, ref val4, 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 value3)
			{
				MelonLogger.Error($"Error initializing BBSMicrophoneCapture: {value3}");
				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 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}");
			}
		}
	}
}