using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BaboonAPI.Hooks.Initializer;
using BaboonAPI.Hooks.Tracks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.FSharp.Core;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using TootTallyAccounts;
using TootTallyCore;
using TootTallyCore.APIServices;
using TootTallyCore.Graphics;
using TootTallyCore.Graphics.Animations;
using TootTallyCore.Utils.Assets;
using TootTallyCore.Utils.Helpers;
using TootTallyCore.Utils.SoundEffects;
using TootTallyCore.Utils.TootTallyGlobals;
using TootTallyCore.Utils.TootTallyModules;
using TootTallyCore.Utils.TootTallyNotifs;
using TootTallyGameModifiers;
using TootTallyLeaderboard;
using TootTallyLeaderboard.Replays;
using TootTallyMultiplayer.APIService;
using TootTallyMultiplayer.MultiplayerCore;
using TootTallyMultiplayer.MultiplayerCore.InputPrompts;
using TootTallyMultiplayer.MultiplayerCore.PointScore;
using TootTallyMultiplayer.MultiplayerPanels;
using TootTallySettings;
using TootTallySpectator;
using TootTallyWebsocketLibs;
using TrombLoader.CustomTracks;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Localization.Components;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;
using WebSocketSharp;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("TootTallyMultiplayer")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("TootTally Multiplayer Module")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+389087672cce6860a357e97563d00d5d43b3cc2d")]
[assembly: AssemblyProduct("TootTallyMultiplayer")]
[assembly: AssemblyTitle("TootTallyMultiplayer")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TootTallyMultiplayer
{
	public class MultiplayerCard : MonoBehaviour
	{
		public MultSerializableClasses.MultiplayerUserInfo user;

		public TMP_Text textName;

		public TMP_Text textState;

		public TMP_Text textRank;

		public TMP_Text textModifiers;

		public GameObject teamChanger;

		public Image image;

		public Image containerImage;

		public Transform container;

		private Button _teamChangerButton;

		private Text _teamChangerText;

		private Color _defaultColor;

		private Color _defaultContainerColor;

		private MultiplayerController _controller;

		public static readonly int TEAM_COUNT = Enum.GetNames(typeof(MultSerializableClasses.MultiplayerTeamState)).Length;

		public void Init(MultiplayerController controller)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0122: 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_0144: 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)
			_controller = controller;
			container = ((Component)this).transform.GetChild(1);
			textName = ((Component)container.Find("Name")).GetComponent<TMP_Text>();
			textState = ((Component)container.Find("State")).GetComponent<TMP_Text>();
			textRank = ((Component)container.Find("Rank")).GetComponent<TMP_Text>();
			textModifiers = ((Component)((Component)this).transform.GetChild(2).Find("Container/Modifiers")).GetComponent<TMP_Text>();
			textModifiers.enableAutoSizing = true;
			teamChanger = ((Component)((Component)this).transform.GetChild(0)).gameObject;
			_teamChangerText = teamChanger.gameObject.GetComponentInChildren<Text>();
			_teamChangerButton = teamChanger.GetComponent<Button>();
			((UnityEvent)_teamChangerButton.onClick).AddListener((UnityAction)delegate
			{
				controller.ChangeTeam(new object[2]
				{
					(user.team + 1) % TEAM_COUNT,
					user.id
				});
			});
			image = ((Component)this).gameObject.GetComponent<Image>();
			_defaultColor = ((Graphic)image).color;
			containerImage = ((Component)container).GetComponent<Image>();
			_defaultContainerColor = ((Graphic)containerImage).color;
		}

		public void UpdateTeamColor(int team)
		{
			//IL_0024: 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)
			user.team = team;
			switch (team)
			{
			case 0:
				UpdateTeamColor(new Color(1f, 0f, 0f), "R");
				break;
			case 1:
				UpdateTeamColor(new Color(0f, 0f, 1f), "B");
				break;
			}
		}

		private void UpdateTeamColor(Color mainColor, string text)
		{
			//IL_0008: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			Button teamChangerButton = _teamChangerButton;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = mainColor;
			((ColorBlock)(ref colors)).highlightedColor = new Color(mainColor.r + 0.3f, mainColor.g + 0.3f, mainColor.b + 0.3f);
			((ColorBlock)(ref colors)).pressedColor = mainColor;
			((ColorBlock)(ref colors)).disabledColor = mainColor;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)teamChangerButton).colors = colors;
			_teamChangerText.text = text;
		}

		public void UpdateUserCard(MultSerializableClasses.MultiplayerUserInfo user, string state)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			this.user = user;
			((Graphic)image).color = _defaultColor;
			((Graphic)containerImage).color = _defaultContainerColor;
			textName.text = user.username;
			textState.text = state ?? user.state;
			textRank.text = $"#{user.rank}";
			UpdateMods(user.mods);
			UpdateTeamColor(user.team);
		}

		public void UpdateMods(string mods)
		{
			user.mods = mods;
			textModifiers.text = mods;
		}
	}
	public class MultiplayerController
	{
		public enum MultiplayerState
		{
			None,
			Home,
			CreatingLobby,
			Lobby,
			Hosting,
			SelectSong,
			ExitScene,
			Playing,
			PointScene,
			Quitting
		}

		public enum MultiplayerUserState
		{
			Spectating = -1,
			NotReady,
			Ready,
			Loading,
			Playing
		}

		private static List<MultSerializableClasses.MultiplayerLobbyInfo> _lobbyInfoList;

		private static List<string> _newLobbyCodeList;

		private static MultSerializableClasses.MultiplayerLobbyInfo _currentLobby;

		private static MultiplayerSystem _multiConnection;

		private static MultiplayerLiveScoreController _multiLiveScoreController;

		private MultiplayerPanelBase _currentActivePanel;

		private MultiplayerPanelBase _lastPanel;

		public bool IsTransitioning;

		private bool _hasSong;

		private bool _songNeedUpdate;

		private MultSerializableClasses.UserState _currentUserState;

		private static string _savedDownloadLink;

		private static string _savedTrackRef;

		private string _searchFilter;

		private GameObject _muteButton;

		private Sprite _mutedBtnSprite;

		private Sprite _unmutedBtnSprite;

		private MultiplayerMainPanel _multMainPanel;

		private MultiplayerLobbyPanel _multLobbyPanel;

		private MultiplayerCreatePanel _multCreatePanel;

		private float _startGameTimer;

		private float _startGameTimerMaxTime;

		private float _nextStartTimerTick;

		public bool IsUpdating;

		public bool IsConnectionPending;

		public bool IsDownloadPending;

		public bool IsTimerStarted;

		public string LobbyCode;

		private TootTallyNotif _connectingNotif;

		private LoadingIcon _connectingLoadingIcon;

		public static MultSerializableClasses.MultiplayerSongInfo savedSongInfo;

		public static SingleTrackData savedTrackData;

		public PlaytestAnims GetInstance => CurrentInstance;

		public static PlaytestAnims CurrentInstance { get; private set; }

		public bool IsFreemod => _currentLobby.freemod;

		public bool IsConnected
		{
			get
			{
				if (_multiConnection != null)
				{
					return ((WebsocketManager)_multiConnection).IsConnected;
				}
				return false;
			}
		}

		public bool IsAnybodyLoading => _currentLobby.players.Where((MultSerializableClasses.MultiplayerUserInfo x) => x.id != TootTallyUser.userInfo.id).Any((MultSerializableClasses.MultiplayerUserInfo x) => x.state == "Loading");

		public bool IsRequestPending
		{
			get
			{
				if (!_multCreatePanel.IsRequestPending)
				{
					return IsConnectionPending;
				}
				return true;
			}
		}

		public bool IsDevMode
		{
			get
			{
				if (!TootTallyUser.userInfo.dev)
				{
					return TootTallyUser.userInfo.moderator;
				}
				return true;
			}
		}

		public bool IsSpectating => TootTallyGlobalVariables.isTournamentHosting;

		public MultiplayerController(PlaytestAnims __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00d5: 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_00d8: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
			CurrentInstance = __instance;
			((Component)CurrentInstance.factpanel).gameObject.SetActive(false);
			GameObject gameObject = GameObject.Find("Canvas-Window").gameObject;
			Transform val = gameObject.transform.Find("Panel");
			GameObject val2 = Object.Instantiate<GameObject>(AssetBundleManager.GetPrefab("multiplayercanvas"));
			_mutedBtnSprite = AssetManager.GetSprite("MuteBtnOff.png");
			_unmutedBtnSprite = AssetManager.GetSprite("MuteBtnOn.png");
			_muteButton = GameObjectFactory.CreateClickableImageHolder(val2.transform, Vector2.zero, Vector2.one * 64f, GetCurrentMuteSprite(), "MuteButton", (Action)OnToggleMuteButtonClick);
			RectTransform component = _muteButton.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.99f, 0f);
			component.pivot = val3;
			component.anchorMax = (component.anchorMin = val3);
			try
			{
				_multMainPanel = new MultiplayerMainPanel(val2, this);
			}
			catch (Exception ex)
			{
				Plugin.LogError(ex.Message);
				Plugin.LogError(ex.StackTrace);
			}
			try
			{
				_multLobbyPanel = new MultiplayerLobbyPanel(val2, this);
			}
			catch (Exception ex2)
			{
				Plugin.LogError(ex2.Message);
				Plugin.LogError(ex2.StackTrace);
			}
			try
			{
				_multCreatePanel = new MultiplayerCreatePanel(val2, this);
			}
			catch (Exception ex3)
			{
				Plugin.LogError(ex3.Message);
				Plugin.LogError(ex3.StackTrace);
			}
			if (_lobbyInfoList == null)
			{
				_lobbyInfoList = new List<MultSerializableClasses.MultiplayerLobbyInfo>();
			}
			_currentActivePanel = _multMainPanel;
			_searchFilter = "";
			if (IsConnected)
			{
				UpdateLobbySongDetails();
				_multiConnection.OnSocketOptionReceived = OnOptionInfoReceived;
				_multiConnection.OnSocketSongInfoReceived = OnSongInfoReceived;
				_multiConnection.OnSocketLobbyInfoReceived = OnLobbyInfoReceived;
				OnLobbyInfoReceived(_currentLobby);
			}
			TootTallyAnimationManager.AddNewScaleAnimation(_multMainPanel.panel, Vector3.one, 0.8f, GetSecondDegreeAnimation(1.5f), (Action<GameObject>)delegate
			{
				RefreshAllLobbyInfo();
				MultiplayerManager.AllowExit = true;
			});
		}

		public void OnToggleMuteButtonClick()
		{
			Plugin.Instance.MuteMusic.Value = !Plugin.Instance.MuteMusic.Value;
			if (Plugin.Instance.MuteMusic.Value)
			{
				MultiAudioController.PauseMusicHard();
			}
			else
			{
				MultiAudioController.PlayMusicHard();
			}
			_muteButton.GetComponent<Image>().sprite = GetCurrentMuteSprite();
		}

		public Sprite GetCurrentMuteSprite()
		{
			if (!Plugin.Instance.MuteMusic.Value)
			{
				return _unmutedBtnSprite;
			}
			return _mutedBtnSprite;
		}

		public void OnGameControllerStartSetup()
		{
			_multiLiveScoreController = GameObject.Find("GameplayCanvas/UIHolder").AddComponent<MultiplayerLiveScoreController>();
			MultiAudioController.PauseMusicSoft();
			MultiplayerPointScoreController.ClearSavedScores();
		}

		public void OnGameControllerStartSongSendReadyState()
		{
			if (!IsSpectating)
			{
				SendUserState(MultSerializableClasses.UserState.Playing);
			}
		}

		public void OnSongQuit()
		{
			if (!IsSpectating)
			{
				_multiConnection.SendUserState(MultSerializableClasses.UserState.NotReady);
			}
		}

		public void InitializePointScore(PointSceneController __instance)
		{
			GameObject.Find("Canvas/FullPanel").AddComponent<MultiplayerPointScoreController>().Initialize(__instance);
		}

		private IEnumerator<WaitForSeconds> DelayDisplayLobbyInfo(float delay, MultSerializableClasses.MultiplayerLobbyInfo lobby, Action<MultSerializableClasses.MultiplayerLobbyInfo> callback)
		{
			yield return new WaitForSeconds(delay);
			callback(lobby);
		}

		public void UpdateLobbyInfo()
		{
			List<MultSerializableClasses.MultiplayerLobbyInfo> list = _lobbyInfoList.Where((MultSerializableClasses.MultiplayerLobbyInfo x) => x.title.Contains(_searchFilter)).ToList();
			if (list.Count == 0)
			{
				_multMainPanel.ShowNoLobbyText();
				_multMainPanel.FinalizeLobbyDisplay();
				return;
			}
			_multMainPanel.SetupForLobbyDisplay();
			for (int num = 0; num < list.Count; num++)
			{
				if (_newLobbyCodeList.Contains(list[num].id))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)DelayDisplayLobbyInfo((float)num * 0.1f, list[num], _multMainPanel.DisplayLobby));
				}
				else
				{
					_multMainPanel.DisplayLobby(list[num], shouldAnimate: false);
				}
			}
			_multMainPanel.FinalizeLobbyDisplay();
			_newLobbyCodeList.Clear();
			_multMainPanel.UpdateScrolling(list.Count);
		}

		public void ConnectToLobby(string code, string password = "", bool forceEntry = false)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			RefreshAllLobbyInfo();
			if (_multiConnection != null && ((WebsocketManager)_multiConnection).ConnectionPending)
			{
				return;
			}
			TootTallyNotif connectingNotif = _connectingNotif;
			if (connectingNotif != null)
			{
				connectingNotif.Dispose();
			}
			LoadingIcon connectingLoadingIcon = _connectingLoadingIcon;
			if (connectingLoadingIcon != null)
			{
				connectingLoadingIcon.Dispose();
			}
			_multiConnection?.Disconnect();
			_connectingNotif = TootTallyNotifManager.ManualNotif("Connecting to " + code + "...", Theme.colors.notification.defaultText);
			_connectingLoadingIcon = GameObjectFactory.CreateLoadingIcon(((Component)_connectingNotif).gameObject.transform, new Vector2(0f, -42f), Vector2.one * 64f, AssetManager.GetSprite("icon.png"), true, "ConnectingLoadingSwirly");
			_connectingLoadingIcon.StartRecursiveAnimation();
			_connectingLoadingIcon.Show();
			Plugin.LogInfo("Connecting to " + code);
			IsConnectionPending = true;
			if (forceEntry)
			{
				code += "?ForceEntry=true";
			}
			else if (password != "")
			{
				code = code + "?Password=" + password;
			}
			_multiConnection = new MultiplayerSystem(code, isHost: false)
			{
				OnWebSocketOpenCallback = delegate
				{
					LoadingIcon connectingLoadingIcon2 = _connectingLoadingIcon;
					if (connectingLoadingIcon2 != null)
					{
						connectingLoadingIcon2.Dispose();
					}
					_connectingLoadingIcon = null;
					TootTallyNotif connectingNotif2 = _connectingNotif;
					if (connectingNotif2 != null)
					{
						connectingNotif2.Dispose();
					}
					_connectingNotif = null;
					_multMainPanel.OnLobbyConnectSuccess();
					_multiConnection.OnWebSocketCloseCallback = null;
					_multiConnection.OnSocketSongInfoReceived = OnSongInfoReceived;
					_multiConnection.OnSocketOptionReceived = OnOptionInfoReceived;
					_multiConnection.OnSocketLobbyInfoReceived = OnLobbyInfoReceived;
				},
				OnWebSocketCloseCallback = DisconnectFromLobby
			};
		}

		public void DisconnectFromLobby()
		{
			LoadingIcon connectingLoadingIcon = _connectingLoadingIcon;
			if (connectingLoadingIcon != null)
			{
				connectingLoadingIcon.Dispose();
			}
			_connectingLoadingIcon = null;
			TootTallyNotif connectingNotif = _connectingNotif;
			if (connectingNotif != null)
			{
				connectingNotif.Dispose();
			}
			_connectingNotif = null;
			if (((WebsocketManager)_multiConnection).IsConnected)
			{
				_multiConnection.Disconnect();
				if (MultiplayerManager.State == MultiplayerState.Lobby)
				{
					_multLobbyPanel.ResetData();
					savedSongInfo.trackRef = "";
					savedTrackData = null;
				}
			}
			else
			{
				_multMainPanel.OnLobbyDisconnectError();
			}
			_currentLobby.code = "";
			IsConnectionPending = false;
			if (MultiplayerManager.State == MultiplayerState.Lobby)
			{
				PlayDefaultSong();
				StopTimer();
				MultiplayerManager.UpdateMultiplayerStateIfChanged(MultiplayerState.Home);
				MoveToMain();
				RefreshAllLobbyInfo();
			}
		}

		public void OnPressEscape()
		{
			if (_multLobbyPanel.IsQuickChatOpened)
			{
				_multLobbyPanel.CloseQuickChat();
			}
			else
			{
				DisconnectFromLobby();
			}
		}

		public void Update()
		{
			if (!IsConnected || _multiConnection == null)
			{
				return;
			}
			if (IsConnectionPending)
			{
				UpdateConnection();
				return;
			}
			_multiConnection.UpdateStacks();
			if (IsTimerStarted)
			{
				UpdateTimer();
			}
		}

		public void UpdateConnection()
		{
			IsConnectionPending = false;
			string text = _multiConnection.GetServerID.Split(new char[1] { '?' })[0];
			TootTallyNotifManager.DisplayNotif("Connected to " + text, 6f);
			MultiplayerLogger.ClearLogs();
			MultiplayerLogger.ServerLog("Connected to " + text);
			MultiplayerManager.UpdateMultiplayerState(MultiplayerState.Lobby);
			OnLobbyConnectionSuccess();
		}

		public void OnLobbyConnectionSuccess()
		{
			MoveToLobby();
			if (TootTallyGlobalVariables.isTournamentHosting)
			{
				SendUserState(MultSerializableClasses.UserState.Spectating);
			}
		}

		public void MoveToCreate()
		{
			TransitionToPanel(_multCreatePanel);
		}

		public void MoveToLobby()
		{
			TransitionToPanel(_multLobbyPanel);
		}

		public void MoveToMain()
		{
			TransitionToPanel(_multMainPanel);
		}

		public void ReturnToLastPanel()
		{
			TransitionToPanel(_lastPanel);
		}

		public void HidePanel()
		{
			_currentActivePanel.panel.SetActive(false);
		}

		public void ShowPanel()
		{
			_currentActivePanel.panel.SetActive(true);
		}

		public void ShowMute()
		{
			GameObject muteButton = _muteButton;
			if (muteButton != null)
			{
				muteButton.SetActive(true);
			}
		}

		public void HideMute()
		{
			GameObject muteButton = _muteButton;
			if (muteButton != null)
			{
				muteButton.SetActive(false);
			}
		}

		public void RefreshAllLobbyInfo()
		{
			if (IsUpdating || (Object)(object)CurrentInstance == (Object)null)
			{
				return;
			}
			IsUpdating = true;
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.GetLobbyList(delegate(List<MultSerializableClasses.MultiplayerLobbyInfo> lobbyList)
			{
				if (lobbyList == null)
				{
					_multMainPanel.ShowServerDownText();
				}
				else
				{
					_multMainPanel.ClearAllLobby();
					IEnumerable<string> idList = _lobbyInfoList.Select((MultSerializableClasses.MultiplayerLobbyInfo x) => x.id);
					_newLobbyCodeList = (from x in lobbyList
						select x.id into x
						where !idList.Contains(x)
						select x).ToList();
					_lobbyInfoList = lobbyList;
					UpdateLobbyInfo();
				}
				IsUpdating = false;
				_multMainPanel.ShowRefreshLobbyButton();
			}));
		}

		public void RefreshCurrentLobbyInfo()
		{
			if (_currentLobby.code != "")
			{
				OnLobbyInfoReceived(_currentLobby);
			}
		}

		public void OnLobbyInfoReceived(MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo)
		{
			_currentLobby = lobbyInfo;
			if ((Object)(object)CurrentInstance != (Object)null)
			{
				_currentUserState = (MultSerializableClasses.UserState)Enum.Parse(typeof(MultSerializableClasses.UserState), _currentLobby.players.Find((MultSerializableClasses.MultiplayerUserInfo x) => x.id == TootTallyUser.userInfo.id).state);
				_multLobbyPanel.UpdateLobbyInfo(_currentLobby.players, lobbyInfo);
				OnSongInfoReceived(_currentLobby.songInfo);
			}
		}

		public void OnLobbyInfoReceived(MultiplayerSystem.SocketLobbyInfo socketLobbyInfo)
		{
			OnLobbyInfoReceived(socketLobbyInfo.lobbyInfo);
		}

		public void OnUserInfoReceived(MultSerializableClasses.MultiplayerUserInfo userInfo)
		{
			if (userInfo.id != 0)
			{
				int index = _currentLobby.players.FindIndex((MultSerializableClasses.MultiplayerUserInfo x) => x.id == userInfo.id);
				_currentLobby.players[index] = userInfo;
				if ((Object)(object)CurrentInstance != (Object)null)
				{
					_multLobbyPanel?.UpdateUserInfo(userInfo);
				}
			}
		}

		public void TransitionToPanel(MultiplayerPanelBase nextPanel)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			if (_currentActivePanel != nextPanel && !IsTransitioning)
			{
				IsTransitioning = true;
				_lastPanel = _currentActivePanel;
				Vector2 positionOut = -nextPanel.GetPanelPosition;
				TootTallyAnimationManager.AddNewPositionAnimation(_currentActivePanel.panel, Vector2.op_Implicit(positionOut), 0.9f, new SecondDegreeDynamicsAnimation(1.5f, 0.89f, 1.1f), (Action<GameObject>)delegate
				{
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					_lastPanel.panel.SetActive(false);
					_lastPanel.panel.GetComponent<RectTransform>().anchoredPosition = positionOut;
				});
				nextPanel.panel.SetActive(true);
				_currentActivePanel = nextPanel;
				TootTallyAnimationManager.AddNewPositionAnimation(nextPanel.panel, Vector2.op_Implicit(Vector2.zero), 0.9f, new SecondDegreeDynamicsAnimation(1.5f, 0.89f, 1.1f), (Action<GameObject>)delegate
				{
					IsTransitioning = false;
				});
			}
		}

		public void OnSongInfoReceived(MultiplayerSystem.SocketSongInfo socketSongInfo)
		{
			OnSongInfoReceived(socketSongInfo.songInfo);
		}

		public void OnSongInfoReceived(MultSerializableClasses.MultiplayerSongInfo songInfo)
		{
			//IL_02e5: 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_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Expected O, but got Unknown
			//IL_02b2: 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_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			if (songInfo.trackRef == "")
			{
				savedSongInfo = songInfo;
				_multLobbyPanel?.SetNullTrackDataDetails(isDownloadable: false);
				PlayDefaultSong();
				return;
			}
			if (songInfo.trackRef != savedSongInfo.trackRef || songInfo.gameSpeed != savedSongInfo.gameSpeed || (songInfo.modifiers != "FM" && songInfo.modifiers != savedSongInfo.modifiers))
			{
				MultSerializableClasses.MultiplayerUserInfo multiplayerUserInfo = _currentLobby.players.FirstOrDefault((MultSerializableClasses.MultiplayerUserInfo u) => u.isHost);
				if (multiplayerUserInfo.Equals(null))
				{
					multiplayerUserInfo.username = "System";
				}
				MultiplayerLogger.HostLog(multiplayerUserInfo.username, string.Format("Song \"{0} [{1:0.00}x]\"{2} was selected.", songInfo.songName, songInfo.gameSpeed, (songInfo.modifiers != "FM" && !songInfo.modifiers.Contains("None")) ? (" with [" + songInfo.modifiers + "]") : ""));
				TootTallyGlobalVariables.gameSpeedMultiplier = songInfo.gameSpeed;
				float num = (int)((songInfo.gameSpeed - 0.5f) / 0.25f);
				float difficulty;
				if (num != 6f)
				{
					float num2 = num * 0.25f + 0.5f;
					float num3 = (num + 1f) * 0.25f + 0.5f;
					float num4 = (songInfo.gameSpeed - num2) / (num3 - num2);
					difficulty = EasingHelper.Lerp(songInfo.speed_diffs[(int)num], songInfo.speed_diffs[(int)num + 1], num4);
				}
				else
				{
					difficulty = songInfo.speed_diffs[(int)num];
				}
				songInfo.difficulty = difficulty;
				if (songInfo.modifiers != "FM")
				{
					GameModifierManager.LoadModifiersFromString(songInfo.modifiers);
				}
				UpdateLobbySongInfo(songInfo.songName, songInfo.gameSpeed, songInfo.modifiers, difficulty, songInfo.isRated);
			}
			if (songInfo.trackRef == savedSongInfo.trackRef)
			{
				savedSongInfo = songInfo;
				UpdateLobbySongDetails();
				return;
			}
			FSharpOption<TromboneTrack> val = TrackLookup.tryLookup(songInfo.trackRef);
			_hasSong = songInfo.trackRef != "" && OptionModule.IsSome<TromboneTrack>(val);
			if (_hasSong)
			{
				SelectSongFromTrackref(val.Value.trackref);
				if (_currentUserState == MultSerializableClasses.UserState.NoSong)
				{
					SendUserState(IsSpectating ? MultSerializableClasses.UserState.Spectating : MultSerializableClasses.UserState.NotReady);
				}
				_songNeedUpdate = songInfo.fileHash != SongDataHelper.GetChoosenSongHash(songInfo.trackRef);
				_savedDownloadLink = (_songNeedUpdate ? FileHelper.GetDownloadLinkFromSongData(new SongDataFromDB
				{
					mirror = songInfo.mirror,
					download = songInfo.download
				}) : null);
				_savedTrackRef = "";
			}
			else
			{
				_savedDownloadLink = FileHelper.GetDownloadLinkFromSongData(new SongDataFromDB
				{
					mirror = songInfo.mirror,
					download = songInfo.download
				});
				_savedTrackRef = songInfo.trackRef;
				SendUserState(MultSerializableClasses.UserState.NoSong);
			}
			savedSongInfo = songInfo;
			_multLobbyPanel?.SetNullTrackDataDetails(_savedDownloadLink != null);
			UpdateLobbySongDetails();
		}

		public void DownloadSavedChart(ProgressBar bar)
		{
			if (_savedDownloadLink == null || IsDownloadPending)
			{
				return;
			}
			IsDownloadPending = true;
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)TootTallyAPIService.DownloadZipFromServer(_savedDownloadLink, bar, (Action<byte[]>)delegate(byte[] data)
			{
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				IsDownloadPending = false;
				if (data != null)
				{
					try
					{
						string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), "Downloads/");
						string text2 = _savedDownloadLink.Split(new char[1] { '/' }).Last() ?? "";
						if (!Directory.Exists(text))
						{
							Directory.CreateDirectory(text);
						}
						FileHelper.WriteBytesToFile(text, text2, data);
						string text3 = Path.Combine(text, text2);
						string text4 = Path.Combine(Paths.BepInExRootPath, "CustomSongs/");
						FileHelper.ExtractZipToDirectory(text3, text4);
						FileHelper.DeleteFile(text, text2);
						Plugin.Instance.reloadManager.ReloadAll((IProgressCallbacks)new ProgressCallbacks
						{
							onComplete = delegate
							{
								SelectSongFromTrackref(_savedTrackRef);
								SendUserState(IsSpectating ? MultSerializableClasses.UserState.Spectating : MultSerializableClasses.UserState.NotReady);
							},
							onError = delegate(Exception error)
							{
								Plugin.LogError(error.StackTrace);
								TootTallyNotifManager.DisplayNotif("Download failed. Unexpected error occured.", 6f);
							}
						});
						return;
					}
					catch (Exception)
					{
						_multLobbyPanel.OnUserStateChange(_currentUserState);
						TootTallyNotifManager.DisplayNotif("Download failed. Unexpected error occured.", 6f);
						return;
					}
				}
				_multLobbyPanel.OnUserStateChange(_currentUserState);
				TootTallyNotifManager.DisplayNotif("Download failed.", 6f);
			}));
		}

		public void SelectSongFromTrackref(string trackref)
		{
			FSharpOption<TromboneTrack> val = TrackLookup.tryLookup(trackref);
			if (val != null)
			{
				TromboneTrack value = val.Value;
				CustomTrack val2 = (CustomTrack)(object)((value is CustomTrack) ? value : null);
				if (val2 != null && File.Exists(Path.Combine(val2.folderPath, "song.ogg")))
				{
					PlayClipPlaybackFromTrack(val2);
					goto IL_003f;
				}
			}
			PlayDefaultSong();
			goto IL_003f;
			IL_003f:
			savedTrackData = TrackLookup.toTrackData(val.Value);
			GlobalVariables.levelselect_index = savedTrackData.trackindex;
			GlobalVariables.chosen_track = savedTrackData.trackref;
			GlobalVariables.chosen_track_data = savedTrackData;
			_hasSong = true;
			_savedDownloadLink = null;
			_savedTrackRef = null;
			UpdateLobbySongDetails();
			Plugin.LogInfo("Selected: " + savedTrackData.trackref);
		}

		public void PlayClipPlaybackFromTrack(CustomTrack ct)
		{
			MultiAudioController.PauseMusicSoft(0.3f, delegate
			{
				MultiAudioController.LoadClip(Path.Combine(ct.folderPath, "song.ogg"), delegate
				{
					MultiAudioController.PlayMusicSoft();
				});
			});
		}

		public void PlayDefaultSong()
		{
			if (!MultiAudioController.IsPlayingDefault)
			{
				MultiAudioController.PauseMusicSoft(0.3f, delegate
				{
					MultiAudioController.SetSongToDefault();
					MultiAudioController.PlayMusicSoft();
				});
			}
		}

		public void UpdateLobbySongInfo(string songName, float gamespeed, string modifiers, float difficulty, bool isRated)
		{
			_multLobbyPanel?.OnSongInfoChanged(songName, gamespeed, modifiers, difficulty, isRated);
		}

		public void UpdateLobbySongDetails()
		{
			if (!((Object)(object)CurrentInstance == (Object)null))
			{
				if (savedTrackData != null)
				{
					_multLobbyPanel?.SetTrackDataDetails(savedTrackData, _savedDownloadLink != null);
				}
				if (savedSongInfo.trackRef != "")
				{
					_multLobbyPanel?.OnSongInfoChanged(savedSongInfo);
				}
			}
		}

		public void StartLobbyGame()
		{
			if (IsTimerStarted)
			{
				_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.AbortTimer);
				return;
			}
			if (_multLobbyPanel.IsGameRunning)
			{
				_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.AbortGame);
				return;
			}
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.StartTimer, new object[1] { 5 });
		}

		public void SendStartGame()
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.StartGame);
		}

		public void StartGame()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			FSharpOption<TromboneTrack> val = TrackLookup.tryLookup(savedSongInfo.trackRef);
			_hasSong = savedSongInfo.trackRef != "" && OptionModule.IsSome<TromboneTrack>(val);
			if (_hasSong && (Object)(object)CurrentInstance != (Object)null && !IsTransitioning)
			{
				TootTallyGlobalVariables.isPracticing = false;
				MultiplayerManager.UpdateMultiplayerState(MultiplayerState.Playing);
				Plugin.LogInfo("Starting Multiplayer for " + GlobalVariables.chosen_track_data.trackname_short + " - " + GlobalVariables.chosen_track_data.trackref);
				MultiplayerLogger.ServerLog("Song starting now.");
				IsTransitioning = true;
				CurrentInstance.sfx_ok.Play();
				((Component)CurrentInstance.fadepanel).gameObject.SetActive(true);
				MultiAudioController.PauseMusicSoft();
				TootTallyAnimationManager.AddNewAlphaAnimation(((Component)CurrentInstance.fadepanel).gameObject, 1f, 0.65f, new SecondDegreeDynamicsAnimation(1f, 1f, 1f), (Action<GameObject>)delegate
				{
					LoadLoaderScene();
				});
			}
			else
			{
				TootTallyNotifManager.DisplayNotif("Cannot start the game. " + ((!_hasSong) ? "Chart not owned." : ""), 6f);
			}
		}

		public void AbortTimer()
		{
			StopTimer();
			MultiplayerLogger.ServerLog("Start timer aborted.");
		}

		public void AbortGame()
		{
			MultiplayerManager.AbortGame();
			MultiplayerLogger.ServerLog("Song has been aborted.");
		}

		public void StopTimer()
		{
			IsTimerStarted = false;
			_startGameTimer = (_startGameTimerMaxTime = _nextStartTimerTick);
			_multLobbyPanel.OnTimerAbort();
		}

		public void StartTimer(float time)
		{
			_startGameTimer = (_startGameTimerMaxTime = (_startGameTimer = (_nextStartTimerTick = time)));
			_multLobbyPanel.OnTimerStart();
			IsTimerStarted = true;
		}

		public void UpdateTimer()
		{
			_startGameTimer -= Time.deltaTime;
			if (_startGameTimer <= 0f)
			{
				StopTimer();
				if (_multLobbyPanel.IsHost)
				{
					SendStartGame();
				}
			}
			else if (_startGameTimer < _nextStartTimerTick)
			{
				MultiplayerLogger.ServerLog($"Song starting in {Mathf.RoundToInt(_startGameTimer)}s");
				_nextStartTimerTick -= 1f;
				CurrentInstance.sfx_hover.Play();
			}
		}

		public void UpdateSearchFilter(string filter)
		{
			_searchFilter = filter;
			RefreshAllLobbyInfo();
		}

		public void KickUserFromLobby(int userID)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.KickFromLobby, new object[1] { userID });
		}

		public void BanUserFromLobby(int userID)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.BanFromLobby, new object[1] { userID });
		}

		public void GiveHostUser(int userID)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.GiveHost, new object[1] { userID });
			_currentUserState = MultSerializableClasses.UserState.NoSong;
		}

		public void SendQuickChat(MultiplayerSystem.QuickChat chat)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.QuickChat, new object[1] { (int)chat });
		}

		public void SendQuickChat(int chatId)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.QuickChat, new object[1] { chatId });
		}

		public void ChangeTeam(dynamic[] values)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.ChangeTeam, values);
		}

		public void SetModifiers(string values)
		{
			_multiConnection.SendOptionInfo(MultiplayerSystem.OptionInfoType.SetModifiers, new object[1] { values });
		}

		public void OnQuickChatReceived(int userID, MultiplayerSystem.QuickChat chat)
		{
			_multLobbyPanel?.OnQuickChatReceived(userID, chat);
		}

		public void SendSetLobbySettings(MultiplayerSystem.SocketSetLobbyInfo lobbyInfo)
		{
			_multiConnection.SendSetLobbyInfo(lobbyInfo);
		}

		public void OpenSongLink()
		{
			if (!(savedSongInfo.trackRef == "") && savedSongInfo.songID != 0)
			{
				Application.OpenURL($"https://toottally.com/song/{savedSongInfo.songID}/");
			}
		}

		public void LoadLoaderScene()
		{
			CurrentInstance = null;
			_multLobbyPanel = null;
			IsTransitioning = false;
			SceneManager.LoadScene("loader");
		}

		public void TransitionToSongSelection()
		{
			HideMute();
			MultiplayerManager.UpdateMultiplayerState(MultiplayerState.SelectSong);
		}

		public void OnOptionInfoReceived(MultiplayerSystem.SocketOptionInfo optionInfo)
		{
			object obj = Enum.Parse(typeof(MultiplayerSystem.OptionInfoType), optionInfo.optionType);
			if (!(obj is MultiplayerSystem.OptionInfoType))
			{
				return;
			}
			switch ((MultiplayerSystem.OptionInfoType)obj)
			{
			case MultiplayerSystem.OptionInfoType.StartGame:
				StartGame();
				break;
			case MultiplayerSystem.OptionInfoType.StartTimer:
				StartTimer((float)optionInfo.values[0]);
				break;
			case MultiplayerSystem.OptionInfoType.AbortGame:
				AbortGame();
				break;
			case MultiplayerSystem.OptionInfoType.AbortTimer:
				AbortTimer();
				break;
			case MultiplayerSystem.OptionInfoType.KickFromLobby:
				if (TootTallyUser.userInfo.id == (int)optionInfo.values[0])
				{
					DisconnectFromLobby();
				}
				break;
			case MultiplayerSystem.OptionInfoType.QuickChat:
				OnQuickChatReceived((int)optionInfo.values[0], (MultiplayerSystem.QuickChat)optionInfo.values[1]);
				break;
			case MultiplayerSystem.OptionInfoType.Refresh:
			case MultiplayerSystem.OptionInfoType.UpdateUserState:
			case MultiplayerSystem.OptionInfoType.GiveHost:
				RefreshAllLobbyInfo();
				break;
			case MultiplayerSystem.OptionInfoType.UpdateUserInfo:
				OnUserInfoReceived(optionInfo.values[0].ToObject<MultSerializableClasses.MultiplayerUserInfo>());
				break;
			case MultiplayerSystem.OptionInfoType.UpdateScore:
				_multiLiveScoreController?.UpdateLiveScore((int)optionInfo.values[0], (int)optionInfo.values[1], (int)optionInfo.values[2], (int)optionInfo.values[3], (optionInfo.values.Length >= 5) ? ((int)optionInfo.values[4]) : 0, (optionInfo.values.Length >= 6) ? ((float)optionInfo.values[5]) : 0f);
				break;
			case MultiplayerSystem.OptionInfoType.FinalScore:
				MultiplayerPointScoreController.AddScore((int)optionInfo.values[0], (int)optionInfo.values[1], (float)optionInfo.values[2], (int)optionInfo.values[3], optionInfo.values[4].ToObject<int[]>(), (optionInfo.values.Length >= 6) ? ((string)optionInfo.values[5]) : "-", (optionInfo.values.Length >= 7) ? ((string)optionInfo.values[6]) : null);
				break;
			case MultiplayerSystem.OptionInfoType.Quit:
				_multiLiveScoreController?.OnUserQuit((int)optionInfo.values[0]);
				break;
			case MultiplayerSystem.OptionInfoType.ChangeTeam:
				_multLobbyPanel.UpdateTeam((int)optionInfo.values[1], (int)optionInfo.values[0]);
				break;
			case MultiplayerSystem.OptionInfoType.SetModifiers:
				_multLobbyPanel.UpdateMods((int)optionInfo.values[0], optionInfo.values[1]);
				break;
			case MultiplayerSystem.OptionInfoType.SongFinished:
			case MultiplayerSystem.OptionInfoType.BanFromLobby:
				break;
			}
		}

		public static MultSerializableClasses.MultiplayerUserInfo GetUserFromLobby(int id)
		{
			return _currentLobby.players.Find((MultSerializableClasses.MultiplayerUserInfo x) => x.id == id);
		}

		public void SendSongFinishedToLobby()
		{
			_multiConnection?.SendOptionInfo(MultiplayerSystem.OptionInfoType.SongFinished);
		}

		public void SendQuitFlag()
		{
			_multiConnection?.SendOptionInfo(MultiplayerSystem.OptionInfoType.Quit);
		}

		public void SendSongHashToLobby(string songHash, float gamespeed, string modifiers)
		{
			modifiers = (_currentLobby.freemod ? "FM" : modifiers);
			_multiConnection?.SendSongHash(songHash, gamespeed, modifiers);
		}

		public void SendScoreDataToLobby(int score, int combo, int health, int tally, float accuracy)
		{
			_multiConnection?.SendUpdateScore(score, combo, health, tally, accuracy);
			_multiLiveScoreController?.UpdateLiveScore(TootTallyUser.userInfo.id, score, combo, health, tally, accuracy);
		}

		public void SendUserState(MultSerializableClasses.UserState state)
		{
			if (_currentUserState != state)
			{
				_currentUserState = state;
				_multLobbyPanel?.OnUserStateChange(state);
				_multiConnection?.SendUserState(state);
			}
		}

		public static SecondDegreeDynamicsAnimation GetSecondDegreeAnimation(float speedMult = 1f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new SecondDegreeDynamicsAnimation(speedMult, 0.75f, 1.15f);
		}

		public static SecondDegreeDynamicsAnimation GetSecondDegreeAnimationNoBounce(float speedMult = 1f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new SecondDegreeDynamicsAnimation(speedMult, 1f, 1f);
		}

		public void Dispose()
		{
			CurrentInstance = null;
			_lobbyInfoList?.Clear();
			_multiConnection?.Disconnect();
		}

		public void DebugFakeLobby()
		{
			_multMainPanel?.DisplayLobbyDebug();
		}

		public void DebugFakeUser()
		{
			_multLobbyPanel?.DisplayUserInfoDebug();
		}
	}
	public static class MultiplayerGameObjectFactory
	{
		private static TMP_InputField _inputFieldPrefab;

		private static GameObject _userCardPrefab;

		private static GameObject _liveScorePrefab;

		private static GameObject _pointScorePrefab;

		private static Toggle _togglePrefab;

		private static bool _isInitialized;

		private const int ROW_COUNT = 3;

		private const int COLUMN_COUNT = 3;

		private const int GROUP_COUNT = 4;

		public static void Initialize()
		{
			if (!_isInitialized)
			{
				SetUserCardPrefab();
				SetInputFieldPrefab();
				SetLiveScorePrefab();
				SetPointScorePrefab();
				_isInitialized = true;
			}
		}

		private static void SetUserCardPrefab()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			_userCardPrefab = Object.Instantiate<GameObject>(GameModifierFactory.GetBorderedHorizontalBox(new Vector2(800f, 72f), 3, (Transform)null));
			CustomButton val = GameObjectFactory.CreateCustomButton(_userCardPrefab.transform, Vector2.zero, new Vector2(25f, 65f), "R", "TeamChanger", (Action)null);
			GameObject gameObject = ((Component)_userCardPrefab.transform.GetChild(0)).gameObject;
			HorizontalLayoutGroup component = gameObject.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = false;
			bool childForceExpandHeight = (((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false);
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = childForceExpandHeight;
			TMP_Text val2 = GameObjectFactory.CreateSingleText(gameObject.transform, "Name", "", Vector2.one / 2f, new Vector2(240f, 75f), Theme.colors.leaderboard.text, (TextFont)0);
			val2.alignment = (TextAlignmentOptions)513;
			TMP_Text val3 = GameObjectFactory.CreateSingleText(gameObject.transform, "State", "", Vector2.one / 2f, new Vector2(240f, 75f), Theme.colors.leaderboard.text, (TextFont)0);
			val3.alignment = (TextAlignmentOptions)516;
			TMP_Text val4 = GameObjectFactory.CreateSingleText(gameObject.transform, "Rank", "", Vector2.one / 2f, new Vector2(100f, 75f), Theme.colors.leaderboard.text, (TextFont)0);
			val4.alignment = (TextAlignmentOptions)516;
			GameObject borderedHorizontalBox = GameModifierFactory.GetBorderedHorizontalBox(new Vector2(70f, 72f), 0, _userCardPrefab.transform);
			GameObject gameObject2 = ((Component)borderedHorizontalBox.transform.GetChild(0)).gameObject;
			TMP_Text val5 = GameObjectFactory.CreateSingleText(gameObject2.transform, "Modifiers", "", Vector2.one / 2f, new Vector2(70f, 75f), Theme.colors.leaderboard.text, (TextFont)0);
			val5.alignment = (TextAlignmentOptions)514;
			((Component)val).transform.SetAsFirstSibling();
			Object.DontDestroyOnLoad((Object)(object)_userCardPrefab);
		}

		private static void SetLiveScorePrefab()
		{
			//IL_000a: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			_liveScorePrefab = GameModifierFactory.GetBorderedHorizontalBox(new Vector2(160f, 28f), 2, (Transform)null);
			CanvasGroup val = _liveScorePrefab.AddComponent<CanvasGroup>();
			val.alpha = 0.75f;
			GameObject gameObject = ((Component)_liveScorePrefab.transform.GetChild(0)).gameObject;
			HorizontalLayoutGroup component = gameObject.GetComponent<HorizontalLayoutGroup>();
			bool childControlWidth = (((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false);
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = childControlWidth;
			RectTransform component2 = _liveScorePrefab.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(1f, 0f);
			component2.anchorMin = val2;
			Vector2 pivot = (component2.anchorMax = val2);
			component2.pivot = pivot;
			GameObject val4 = Object.Instantiate<GameObject>(gameObject, gameObject.transform);
			((Object)val4).name = "Mask";
			val4.AddComponent<LayoutElement>().ignoreLayout = true;
			val4.AddComponent<Mask>().showMaskGraphic = false;
			_liveScorePrefab.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_liveScorePrefab);
		}

		private static void SetPointScorePrefab()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			_pointScorePrefab = GameModifierFactory.GetBorderedHorizontalBox(new Vector2(200f, 28f), 2, (Transform)null);
			GameObject gameObject = ((Component)_pointScorePrefab.transform.GetChild(0)).gameObject;
			HorizontalLayoutGroup component = gameObject.GetComponent<HorizontalLayoutGroup>();
			bool childControlWidth = (((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false);
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = childControlWidth;
			RectTransform component2 = _pointScorePrefab.GetComponent<RectTransform>();
			component2.pivot = new Vector2(0f, 1f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.04f, 0.926f);
			component2.anchorMin = val;
			component2.anchorMax = val;
			_pointScorePrefab.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_pointScorePrefab);
		}

		private static void SetInputFieldPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0013: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_00a1: 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_00a7: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_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_0101: 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_010a: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_012f: 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_0181: 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)
			GameObject val = new GameObject("InputFieldHolder");
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = new Vector2(350f, 50f);
			GameObject val3 = Object.Instantiate<GameObject>(val, val.transform);
			GameObject val4 = Object.Instantiate<GameObject>(val3, val.transform);
			((Object)val3).name = "Image";
			((Object)val4).name = "Text";
			_inputFieldPrefab = val.AddComponent<TMP_InputField>();
			Vector2 anchorMax = (val2.anchorMin = Vector2.zero);
			val2.anchorMax = anchorMax;
			((Selectable)_inputFieldPrefab).image = val3.AddComponent<Image>();
			RectTransform component = val3.GetComponent<RectTransform>();
			Vector2 val5 = (component.pivot = Vector2.zero);
			anchorMax = (component.anchorMax = val5);
			component.anchorMin = anchorMax;
			component.anchoredPosition = new Vector2(0f, 4f);
			component.sizeDelta = new Vector2(350f, 2f);
			RectTransform component2 = val4.GetComponent<RectTransform>();
			Vector2 val7 = (component2.pivot = Vector2.zero);
			val5 = (component2.anchorMax = val7);
			anchorMax = (component2.anchorMin = val5);
			component2.anchoredPosition = anchorMax;
			component2.sizeDelta = new Vector2(350f, 50f);
			_inputFieldPrefab.textComponent = GameObjectFactory.CreateSingleText(val4.transform, "TextLabel", "", Theme.colors.leaderboard.text, (TextFont)0);
			_inputFieldPrefab.textComponent.rectTransform.pivot = new Vector2(0f, 0.5f);
			_inputFieldPrefab.textComponent.alignment = (TextAlignmentOptions)513;
			_inputFieldPrefab.textComponent.margin = new Vector4(5f, 0f, 0f, 0f);
			_inputFieldPrefab.textComponent.enableWordWrapping = true;
			_inputFieldPrefab.textViewport = _inputFieldPrefab.textComponent.rectTransform;
			Object.DontDestroyOnLoad((Object)(object)_inputFieldPrefab);
		}

		public static void SetTogglePrefab(HomeController __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			_togglePrefab = Object.Instantiate<Toggle>(__instance.set_tog_accessb_jumpscare);
			((Object)_togglePrefab).name = "MultiplayerTogglePrefab";
			_togglePrefab.onValueChanged = new ToggleEvent();
			Object.DontDestroyOnLoad((Object)(object)_togglePrefab);
		}

		public static TMP_InputField CreateInputField(Transform canvasTransform, string name, Vector2 size, float fontSize, string text, bool isPassword)
		{
			//IL_0019: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			TMP_InputField val = Object.Instantiate<TMP_InputField>(_inputFieldPrefab, canvasTransform);
			((Object)val).name = name;
			((Component)val).GetComponent<RectTransform>().sizeDelta = size;
			((Component)((Component)val).transform.Find("Image")).GetComponent<RectTransform>().sizeDelta = new Vector2(size.x, 2f);
			((Component)((Component)val).transform.Find("Text")).GetComponent<RectTransform>().sizeDelta = size;
			((Component)val.textComponent).GetComponent<RectTransform>().sizeDelta = size;
			val.textComponent.fontSize = fontSize;
			val.textComponent.overflowMode = (TextOverflowModes)1;
			val.text = text;
			val.inputType = (InputType)(isPassword ? 2 : 0);
			return val;
		}

		public static GameObject CreateLiveScoreCard(Transform canvasTransform, Vector2 position, string name)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_liveScorePrefab, canvasTransform);
			val.SetActive(true);
			val.GetComponent<RectTransform>().anchoredPosition = position;
			((Object)val).name = name;
			return val;
		}

		public static GameObject CreatePointScoreCard(Transform canvasTransform, Vector2 position, string name)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(_pointScorePrefab, canvasTransform);
			val.SetActive(true);
			val.GetComponent<RectTransform>().anchoredPosition = position;
			((Object)val).name = name;
			return val;
		}

		public static MultiplayerCard CreateUserCard(Transform canvasTransform, MultiplayerController controller)
		{
			MultiplayerCard multiplayerCard = Object.Instantiate<GameObject>(_userCardPrefab, canvasTransform).AddComponent<MultiplayerCard>();
			multiplayerCard.Init(controller);
			return multiplayerCard;
		}

		public static GameObject CreatePasswordInputPrompt(Transform canvasTransform, string titleText, Action<string> OnConfirm, Action OnCancel)
		{
			//IL_0017: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0095: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			GameObject borderedVerticalBox = GameModifierFactory.GetBorderedVerticalBox(new Vector2(520f, 235f), 4, canvasTransform);
			RectTransform component = borderedVerticalBox.GetComponent<RectTransform>();
			Vector2 val = (component.pivot = Vector2.one / 2f);
			Vector2 anchorMin = (component.anchorMax = val);
			component.anchorMin = anchorMin;
			GameObject gameObject = ((Component)borderedVerticalBox.transform.GetChild(0)).gameObject;
			VerticalLayoutGroup component2 = gameObject.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component2).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 21f;
			((LayoutGroup)component2).padding = new RectOffset(5, 5, 35, 5);
			TMP_Text val4 = GameObjectFactory.CreateSingleText(gameObject.transform, "TitleText", titleText, (TextFont)0);
			val4.fontSize = 26f;
			val4.fontStyle = (FontStyles)1;
			val4.rectTransform.sizeDelta = new Vector2(0f, 32f);
			GameObject horizontalBox = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 30f), gameObject.transform);
			HorizontalLayoutGroup component3 = horizontalBox.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 8f;
			((LayoutGroup)component3).padding = new RectOffset(0, 0, 3, 0);
			TMP_Text val5 = GameObjectFactory.CreateSingleText(horizontalBox.transform, "InputFieldLabel", "Password:", (TextFont)0);
			val5.rectTransform.sizeDelta = new Vector2(115f, 30f);
			val5.alignment = (TextAlignmentOptions)1028;
			TMP_InputField inputField = CreateInputField(horizontalBox.transform, "InputField", new Vector2(275f, 30f), 24f, "", isPassword: true);
			GameObject val6 = GameObjectFactory.CreateClickableImageHolder(((Component)inputField).transform, new Vector2(300f, 0f), Vector2.one * 64f, AssetManager.GetSprite("HD.png"), "ShowPasswordButton", (Action)delegate
			{
			});
			GameObject horizontalBox2 = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 66f), gameObject.transform);
			HorizontalLayoutGroup component4 = horizontalBox2.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 100f;
			bool childControlHeight = (((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false);
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = childControlHeight;
			CustomButton val7 = GameObjectFactory.CreateCustomButton(horizontalBox2.transform, Vector2.zero, new Vector2(170f, 65f), "Confirm", "ConfirmButton", (Action)delegate
			{
				OnConfirm?.Invoke(inputField.text);
			});
			CustomButton val8 = GameObjectFactory.CreateCustomButton(horizontalBox2.transform, Vector2.zero, new Vector2(170f, 65f), "Cancel", "CancelButton", OnCancel);
			return borderedVerticalBox;
		}

		public static LobbySettingsInputPrompt CreateLobbySettingsInputPrompt(Transform canvasTransform, MultiplayerController controller)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			LobbySettingsInputPrompt lobbySettingsInputPrompt = new LobbySettingsInputPrompt(canvasTransform, controller);
			lobbySettingsInputPrompt.gameObject.transform.localScale = new Vector3(0f, 0f, 1f);
			return lobbySettingsInputPrompt;
		}

		public static CustomPopup CreateQuickChatPopup(Transform buttonTransform, Transform popupTransform, Action<MultiplayerSystem.QuickChat> OnBtnClickCallback)
		{
			//IL_0013: 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_003c: 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_0058: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: 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)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: 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_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: 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_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: 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_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			CustomPopup val = new CustomPopup("Quick Chat", buttonTransform, Vector2.zero, new Vector2(64f, 64f), AssetManager.GetSprite("Bubble.png"), popupTransform, new Vector2(720f, 700f), 38, new Vector2(32f, 32f));
			GameObject gameObject = ((Component)val.popupBox.transform.GetChild(0)).gameObject;
			VerticalLayoutGroup component = gameObject.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 0f;
			((LayoutGroup)component).childAlignment = (TextAnchor)4;
			Color normalColor = default(Color);
			((Color)(ref normalColor))..ctor(0.5f, 0.5f, 0.5f, 0.35f);
			Color highlightedColor = default(Color);
			((Color)(ref highlightedColor))..ctor(0.6f, 0.6f, 0.6f, 0.5f);
			for (int i = 0; i < 3; i++)
			{
				GameObject horizontalBox = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 205f), gameObject.transform);
				((HorizontalOrVerticalLayoutGroup)horizontalBox.GetComponent<HorizontalLayoutGroup>()).spacing = 20f;
				for (int j = 0; j < 3; j++)
				{
					GameObject verticalBox = GameModifierFactory.GetVerticalBox(new Vector2(190f, 0f), horizontalBox.transform);
					VerticalLayoutGroup component2 = verticalBox.GetComponent<VerticalLayoutGroup>();
					((HorizontalOrVerticalLayoutGroup)component2).spacing = 2f;
					for (int k = 0; k < 4; k++)
					{
						int index = i * 4 * 3 + j * 4 + k;
						KeyValuePair<MultiplayerSystem.QuickChat, string> keyValuePair = MultiplayerSystem.QuickChatToTextDic.ElementAt(index);
						MultiplayerSystem.QuickChat quickChatKey = keyValuePair.Key;
						string text = string.Concat(from x in quickChatKey.ToString()
							select (!char.IsUpper(x)) ? x.ToString() : (" " + x)).TrimStart(new char[1] { ' ' });
						CustomButton val2 = GameObjectFactory.CreateCustomButton(verticalBox.transform, Vector2.zero, new Vector2(0f, 36f), text, $"QCButton{quickChatKey}", (Action)delegate
						{
							OnBtnClickCallback(quickChatKey);
						});
						val2.textHolder.fontSize = 16;
						ColorBlock colors = ((Selectable)val2.button).colors;
						((ColorBlock)(ref colors)).normalColor = normalColor;
						((ColorBlock)(ref colors)).highlightedColor = highlightedColor;
						((Selectable)val2.button).colors = colors;
						BubblePopupHandler val3 = ((Component)val2).gameObject.AddComponent<BubblePopupHandler>();
						val3.Initialize(val.popupBox.transform, GameObjectFactory.CreateBubble(Vector2.zero, ((Object)val2).name + "Bubble", keyValuePair.Value ?? "", Vector2.zero, 6, true, 22), false);
					}
				}
			}
			CustomButton val4 = GameObjectFactory.CreateCustomButton(gameObject.transform, Vector2.zero, Vector2.one * 5f, "", "QCButtonH", (Action)delegate
			{
				OnBtnClickCallback(MultiplayerSystem.QuickChat.LetsBone);
			});
			((Component)val4).gameObject.AddComponent<LayoutElement>().ignoreLayout = true;
			CustomButton val5 = GameObjectFactory.CreateCustomButton(gameObject.transform, Vector2.zero, Vector2.one * 5f, "", "QCButtonH2", (Action)delegate
			{
				OnBtnClickCallback(MultiplayerSystem.QuickChat.TiltControl);
			});
			((Component)val5).gameObject.AddComponent<LayoutElement>().ignoreLayout = true;
			ColorBlock colors2 = ((Selectable)val4.button).colors;
			((ColorBlock)(ref colors2)).normalColor = new Color(0f, 0f, 0f, 0f);
			((ColorBlock)(ref colors2)).highlightedColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			Button button = val4.button;
			ColorBlock colors3 = (((Selectable)val5.button).colors = colors2);
			((Selectable)button).colors = colors3;
			RectTransform component3 = ((Component)val4).GetComponent<RectTransform>();
			RectTransform component4 = ((Component)val5).GetComponent<RectTransform>();
			Vector2 val7 = (component3.pivot = (component4.pivot = Vector2.one * 0.5f));
			((Vector2)(ref val7))..ctor(0.2f, 0.95f);
			component3.anchorMax = val7;
			component3.anchorMin = val7;
			((Vector2)(ref val7))..ctor(0.8f, 0.95f);
			component4.anchorMax = val7;
			component4.anchorMin = val7;
			return val;
		}

		public static Toggle CreateToggle(Transform canvasTransform, string name, Vector2 size, string text)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_009f: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			Toggle val = Object.Instantiate<Toggle>(_togglePrefab, canvasTransform);
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			component.pivot = Vector2.op_Implicit(Vector3.zero);
			component.anchoredPosition = Vector2.op_Implicit(Vector3.zero);
			component.sizeDelta = size;
			TMP_Text val2 = GameObjectFactory.CreateSingleText(((Component)val).transform, name + "Label", text, Vector2.zero, new Vector2(250f, 0f), Theme.colors.leaderboard.text, (TextFont)1);
			val2.alignment = (TextAlignmentOptions)513;
			val2.fontStyle = (FontStyles)4;
			val2.enableWordWrapping = false;
			val2.rectTransform.anchoredPosition = new Vector2(20f, 0f);
			RectTransform rectTransform = val2.rectTransform;
			RectTransform rectTransform2 = val2.rectTransform;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(1f, 0.5f);
			rectTransform2.anchorMin = val3;
			rectTransform.anchorMax = val3;
			val2.fontSize = 28f;
			val2.text = text;
			((Object)val).name = name;
			val.isOn = false;
			return val;
		}
	}
	public static class MultiplayerManager
	{
		public enum HomeScreenButtonIndexes
		{
			Play,
			Collect,
			Quit,
			Improv,
			Baboon,
			Credit,
			Settings,
			Advanced
		}

		public static readonly WaitForSeconds WAIT_TIME = new WaitForSeconds(5f);

		public static bool AllowExit;

		public const string PLAYTEST_SCENE_NAME = "zzz_playtest";

		public const string LEVELSELECT_SCENE_NAME = "levelselect";

		private static readonly string[] LETTER_GRADES = new string[7] { "F", "D", "C", "B", "A", "S", "SS" };

		private static PlaytestAnims _currentInstance;

		private static PointSceneController _currentPointSceneInstance;

		private static RectTransform _multiButtonOutlineRectTransform;

		private static TootTallyAnimation _multiBtnAnimation;

		private static TootTallyAnimation _multiTextAnimation;

		private static MultiplayerController _multiController;

		private static bool _isSceneActive;

		private static bool _multiButtonLoaded;

		private static bool _isLevelSelectInit;

		private static bool _attemptedInitLevelSelect;

		private static bool _isRecursiveRefreshRunning;

		private static bool _isForceExit;

		private static bool _wasAutotootUsed;

		private static bool _isSyncing = true;

		private static float _syncTimeoutTimer;

		public static MultiplayerController.MultiplayerState State { get; private set; }

		public static MultiplayerController.MultiplayerState PreviousState { get; private set; }

		public static MultiplayerController GetMultiplayerController => _multiController;

		public static bool IsConnectedToMultiplayer
		{
			get
			{
				if (_multiController != null)
				{
					return _multiController.IsConnected;
				}
				return false;
			}
		}

		public static bool IsPlayingMultiplayer
		{
			get
			{
				if (_multiController != null)
				{
					return State == MultiplayerController.MultiplayerState.Playing;
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(PlaytestAnims), "Start")]
		[HarmonyPrefix]
		public static bool OnStartPrefixLoadLevelSelectIfNotInit(PlaytestAnims __instance)
		{
			TootTallyGlobalVariables.isPlayingMultiplayer = true;
			GlobalVariables.scene_destination = "levelselect";
			if (SpectatingManager.IsSpectating)
			{
				SpectatingManager.StopAllSpectator();
			}
			_currentInstance = __instance;
			if (!_isLevelSelectInit)
			{
				_attemptedInitLevelSelect = true;
				__instance.fadepanel.alpha = 1f;
				((Component)__instance.fadepanel).gameObject.SetActive(true);
				SceneManager.LoadScene("levelselect", (LoadSceneMode)1);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlaytestAnims), "Start")]
		[HarmonyPostfix]
		public static void ChangePlayTestToMultiplayerScreen(PlaytestAnims __instance)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!_isLevelSelectInit)
			{
				return;
			}
			((Component)Camera.main).transform.localPosition = Vector3.zero;
			((Component)__instance.logo_trect).gameObject.SetActive(false);
			((Component)__instance.logo_crect).gameObject.SetActive(false);
			MultiplayerGameObjectFactory.Initialize();
			MultiAudioController.InitMusic();
			if (!MultiAudioController.IsMusicLoaded)
			{
				MultiAudioController.LoadCurrentIndexMusic(delegate
				{
					MultiAudioController.PlayMusicSoft();
				});
			}
			else if (MultiAudioController.IsPaused)
			{
				MultiAudioController.ResumeMusicSoft();
			}
			else
			{
				MultiAudioController.PlayMusicSoft();
			}
			_multiController = new MultiplayerController(__instance);
			_isSceneActive = true;
			AllowExit = false;
			if (_multiController.IsConnected && (State == MultiplayerController.MultiplayerState.SelectSong || State == MultiplayerController.MultiplayerState.PointScene || State == MultiplayerController.MultiplayerState.Quitting))
			{
				UpdateMultiplayerState(MultiplayerController.MultiplayerState.Lobby);
				_multiController.UpdateLobbySongDetails();
				return;
			}
			GameModifierManager.ClearAllModifiers();
			PreviousState = MultiplayerController.MultiplayerState.None;
			UpdateMultiplayerState(MultiplayerController.MultiplayerState.Home);
			StartRecursiveRefresh();
		}

		[HarmonyPatch(typeof(Plugin), "Update")]
		[HarmonyPostfix]
		public static void Update()
		{
			if (!_isSceneActive)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27) && CanPressEscape())
			{
				if (State == MultiplayerController.MultiplayerState.Home)
				{
					ExitMultiplayer();
				}
				else if (State == MultiplayerController.MultiplayerState.Lobby)
				{
					_multiController.OnPressEscape();
				}
				else
				{
					_multiController.ReturnToLastPanel();
					RollbackMultiplayerState();
				}
			}
			else if (Input.GetKeyDown((KeyCode)45) && State != MultiplayerController.MultiplayerState.Playing)
			{
				MultiAudioController.ChangeVolume(-0.01f);
			}
			else if (Input.GetKeyDown((KeyCode)61) && State != MultiplayerController.MultiplayerState.Playing)
			{
				MultiAudioController.ChangeVolume(0.01f);
			}
			else if (Input.GetKeyDown((KeyCode)275) && MultiAudioController.IsPlayingDefault)
			{
				MultiAudioController.NextSong(delegate
				{
					MultiAudioController.PlayMusicSoft();
				});
			}
			else if (Input.GetKeyDown((KeyCode)276) && MultiAudioController.IsPlayingDefault)
			{
				MultiAudioController.PreviousSong(delegate
				{
					MultiAudioController.PlayMusicSoft();
				});
			}
			_multiController?.Update();
		}

		private static bool CanPressEscape()
		{
			if (!_multiController.IsTransitioning && !_multiController.IsRequestPending && State != MultiplayerController.MultiplayerState.ExitScene && State != MultiplayerController.MultiplayerState.SelectSong && State != MultiplayerController.MultiplayerState.Playing && State != MultiplayerController.MultiplayerState.PointScene)
			{
				return State != MultiplayerController.MultiplayerState.Quitting;
			}
			return false;
		}

		[HarmonyPatch(typeof(PlaytestAnims), "nextScene")]
		[HarmonyPrefix]
		public static bool OverwriteNextScene()
		{
			Plugin.LogInfo("exiting multi");
			_isSceneActive = false;
			SceneManager.LoadScene("saveslot");
			return false;
		}

		[HarmonyPatch(typeof(HomeController), "Start")]
		[HarmonyPostfix]
		public static void OnHomeControllerStartPostFixAddMultiplayerButton(HomeController __instance)
		{
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: 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_01fa: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_0218: 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_024a: Expected O, but got Unknown
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: 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_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
			TootTallyGlobalVariables.isPlayingMultiplayer = false;
			GameObject gameObject = GameObject.Find("MainCanvas").gameObject;
			GameObject gameObject2 = ((Component)gameObject.transform.Find("MainMenu")).gameObject;
			MultiplayerGameObjectFactory.SetTogglePrefab(__instance);
			GameObject multiplayerButton = Object.Instantiate<GameObject>(__instance.btncontainers[1], gameObject2.transform);
			GameObject val = Object.Instantiate<GameObject>(((Component)gameObject2.transform.Find("Button1Collect")).gameObject, gameObject2.transform);
			GameObject multiplayerText = Object.Instantiate<GameObject>(__instance.paneltxts[1], gameObject2.transform);
			((Object)multiplayerButton).name = "MULTIContainer";
			((Object)val).name = "MULTIButton";
			((Object)multiplayerText).name = "MULTIText";
			Object.DestroyImmediate((Object)(object)((Component)multiplayerText.transform.GetChild(1)).GetComponent<LocalizeStringEvent>());
			Text component = ((Component)multiplayerText.transform.GetChild(1)).GetComponent<Text>();
			string text = (((Component)multiplayerText.transform.GetChild(1).GetChild(0)).GetComponent<Text>().text = "<i>MULTI</i>");
			component.text = text;
			ThemeManager.OverwriteGameObjectSpriteAndColor(((Component)multiplayerButton.transform.Find("FG")).gameObject, "MultiplayerButtonV2.png", Color.white);
			multiplayerButton.transform.SetSiblingIndex(0);
			multiplayerText.transform.SetSiblingIndex(21);
			val.transform.SetSiblingIndex(22);
			RectTransform component2 = multiplayerText.GetComponent<RectTransform>();
			component2.anchoredPosition = new Vector2(100f, 100f);
			component2.sizeDelta = new Vector2(334f, 87f);
			_multiButtonOutlineRectTransform = ((Component)multiplayerButton.transform.Find("outline")).GetComponent<RectTransform>();
			((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Expected O, but got Unknown
				if (__instance.waitforclick == 0f)
				{
					__instance.addWaitForClick(0.4f);
					if (TootTallyUser.userInfo == null || TootTallyUser.userInfo.id == 0)
					{
						TootTallyNotifManager.DisplayError("Please login on TootTally to play online.", 6f);
					}
					else
					{
						__instance.playSfx(3);
						Plugin.LogInfo("Entering Multiplayer...");
						__instance.musobj.Stop();
						__instance.quickFlash(2);
						TootTallyAnimationManager.AddNewTransformScaleAnimation(__instance.fullcanvas, Vector2.zero, 0.5f, new SecondDegreeDynamicsAnimation(2.5f, 0.95f, -0.35f), (Action<GameObject>)null);
						__instance.screenfade.alpha = 0f;
						LeanTween.alphaCanvas(__instance.screenfade, 1f, 0.45f).setDelay(0.25f).setOnComplete((Action)LoadPlayTestScene);
					}
				}
			});
			EventTrigger component3 = val.GetComponent<EventTrigger>();
			component3.triggers.Clear();
			Entry val2 = new Entry();
			val2.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				//IL_0034: 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_0058: Expected O, but got Unknown
				//IL_0067: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_00ca: 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_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)
				TootTallyAnimation multiBtnAnimation = _multiBtnAnimation;
				if (multiBtnAnimation != null)
				{
					multiBtnAnimation.Dispose();
				}
				_multiBtnAnimation = TootTallyAnimationManager.AddNewScaleAnimation(((Component)multiplayerButton.transform.Find("outline")).gameObject, new Vector2(1.01f, 1.01f), 0.5f, new SecondDegreeDynamicsAnimation(3.75f, 0.8f, 1.05f), (Action<GameObject>)null);
				_multiBtnAnimation.SetStartVector(((Transform)_multiButtonOutlineRectTransform).localScale);
				TootTallyAnimation multiTextAnimation = _multiTextAnimation;
				if (multiTextAnimation != null)
				{
					multiTextAnimation.Dispose();
				}
				_multiTextAnimation = TootTallyAnimationManager.AddNewScaleAnimation(multiplayerText, new Vector2(1f, 1f), 0.5f, new SecondDegreeDynamicsAnimation(3.5f, 0.65f, 1.15f), (Action<GameObject>)null);
				_multiTextAnimation.SetStartVector(((Transform)multiplayerText.GetComponent<RectTransform>()).localScale);
				__instance.playSfx(2);
				RectTransform component10 = multiplayerButton.GetComponent<RectTransform>();
				component10.anchoredPosition += new Vector2(-2f, 0f);
			});
			component3.triggers.Add(val2);
			Entry val3 = new Entry();
			val3.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				//IL_0034: 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_0058: Expected O, but got Unknown
				//IL_0067: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_00ca: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				TootTallyAnimation multiBtnAnimation = _multiBtnAnimation;
				if (multiBtnAnimation != null)
				{
					multiBtnAnimation.Dispose();
				}
				_multiBtnAnimation = TootTallyAnimationManager.AddNewScaleAnimation(((Component)multiplayerButton.transform.Find("outline")).gameObject, new Vector2(0.4f, 0.4f), 0.5f, new SecondDegreeDynamicsAnimation(1.5f, 0.8f, 1f), (Action<GameObject>)null);
				_multiBtnAnimation.SetStartVector(((Transform)_multiButtonOutlineRectTransform).localScale);
				TootTallyAnimation multiTextAnimation = _multiTextAnimation;
				if (multiTextAnimation != null)
				{
					multiTextAnimation.Dispose();
				}
				_multiTextAnimation = TootTallyAnimationManager.AddNewScaleAnimation(multiplayerText, new Vector2(0.8f, 0.8f), 0.5f, new SecondDegreeDynamicsAnimation(3.5f, 0.65f, 1.15f), (Action<GameObject>)null);
				_multiTextAnimation.SetStartVector(((Transform)multiplayerText.GetComponent<RectTransform>()).localScale);
				RectTransform component10 = multiplayerButton.GetComponent<RectTransform>();
				component10.anchoredPosition += new Vector2(2f, 0f);
			});
			component3.triggers.Add(val3);
			_multiButtonLoaded = true;
			GameObject val4 = __instance.btncontainers[1];
			ThemeManager.OverwriteGameObjectSpriteAndColor(((Component)val4.transform.Find("FG")).gameObject, "CollectButtonV2.png", Color.white);
			GameObject gameObject3 = ((Component)val4.transform.Find("FG")).gameObject;
			RectTransform component4 = gameObject3.GetComponent<RectTransform>();
			val4.GetComponent<RectTransform>().anchoredPosition = new Vector2(900f, 475.2f);
			val4.GetComponent<RectTransform>().sizeDelta = new Vector2(320f, 190f);
			component4.sizeDelta = new Vector2(320f, 190f);
			GameObject val5 = __instance.allbtnoutlines[1];
			ThemeManager.OverwriteGameObjectSpriteAndColor(val5, "CollectButtonOutline.png", Color.white);
			RectTransform component5 = val5.GetComponent<RectTransform>();
			component5.sizeDelta = new Vector2(351f, 217.2f);
			GameObject val6 = __instance.paneltxts[1];
			val6.transform.GetChild(1).localScale = Vector3.one * 0.6f;
			val6.GetComponent<RectTransform>().anchoredPosition = new Vector2(790f, 430f);
			val6.GetComponent<RectTransform>().sizeDelta = new Vector2(285f, 48f);
			val6.GetComponent<RectTransform>().pivot = Vector2.one / 2f;
			GameObject val7 = __instance.btncontainers[3];
			GameObject gameObject4 = ((Component)val7.transform.Find("FG")).gameObject;
			ThemeManager.OverwriteGameObjectSpriteAndColor(gameObject4, "ImprovButtonV2.png", Color.white);
			RectTransform component6 = gameObject4.GetComponent<RectTransform>();
			val7.GetComponent<RectTransform>().anchoredPosition = new Vector2(-150f, 156f);
			component6.sizeDelta = new Vector2(450f, 190f);
			GameObject val8 = __instance.allbtnoutlines[3];
			ThemeManager.OverwriteGameObjectSpriteAndColor(val8, "ImprovButtonOutline.png", Color.white);
			RectTransform component7 = val8.GetComponent<RectTransform>();
			component7.sizeDelta = new Vector2(480f, 220f);
			GameObject val9 = __instance.paneltxts[3];
			Transform child = val9.transform.GetChild(0);
			Transform child2 = val9.transform.GetChild(1);
			Vector3 localScale = (child2.localScale = Vector3.one * 0.6f);
			child.localScale = localScale;
			child.localPosition = Vector2.op_Implicit(new Vector2(-196f, 0f));
			child2.localPosition = Vector2.op_Implicit(new Vector2(42f, 25f));
			val9.GetComponent<RectTransform>().anchoredPosition = new Vector2(305f, 385f);
			val9.GetComponent<RectTransform>().sizeDelta = new Vector2(426f, 54f);
			GameObject gameObject5 = ((Component)gameObject2.transform.Find("Button1Collect")).gameObject;
			RectTransform component8 = gameObject5.GetComponent<RectTransform>();
			component8.anchoredPosition = new Vector2(739f, 380f);
			component8.sizeDelta = new Vector2(320f, 190f);
			((Transform)component8).Rotate(0f, 0f, 15f);
			GameObject gameObject6 = ((Component)gameObject2.transform.Find("Button3FreeImprov")).gameObject;
			RectTransform component9 = gameObject6.GetComponent<RectTransform>();
			component9.anchoredPosition = new Vector2(310f, 383f);
			component9.sizeDelta = new Vector2(450f, 195f);
		}

		private static void LoadPlayTestScene()
		{
			SceneManager.LoadScene("zzz_playtest");
		}

		[HarmonyPatch(typeof(HomeController), "Update")]
		[HarmonyPostfix]
		public static void AnimateMultiButton(HomeController __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (_multiButtonLoaded)
			{
				((Component)((Component)((Component)_multiButtonOutlineRectTransform).transform.parent).transform.Find("FG/texholder")).GetComponent<CanvasGroup>().alpha = (((Transform)_multiButtonOutlineRectTransform).localScale.y - 0.4f) / 1.5f;
			}
		}

		[HarmonyPatch(typeof(GlobalLeaderboardManager), "OnLevelSelectControllerStartPostfix")]
		[HarmonyPrefix]
		public static bool PreventGlobalLeaderboardFromLoadingWhenInitMulti()
		{
			if (_attemptedInitLevelSelect)
			{
				_attemptedInitLevelSelect = false;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(GameObjectFactory), "OnLevelSelectControllerInitialize")]
		[HarmonyPostfix]
		public static void ArtificiallyInitLevelSelectOnFirstMultiplayerEnter(LevelSelectController levelSelectController)
		{
			if (!_isLevelSelectInit)
			{
				Plugin.LogInfo("levelselect init success");
				_isLevelSelectInit = true;
				if ((Object)(object)_currentInstance != (Object)null)
				{
					LeanTween.cancelAll();
					SceneManager.UnloadSceneAsync("levelselect");
					_currentInstance.Start();
				}
			}
		}

		[HarmonyPatch(typeof(ReplaySystemManager), "ResolveLoadReplay")]
		[HarmonyPrefix]
		public static bool SkipResolveReplayIfInMulti()
		{
			if (State != MultiplayerController.MultiplayerState.SelectSong)
			{
				return true;
			}
			TootTallyNotifManager.DisplayNotif("Cannot watch replays in multiplayer.", 6f);
			return false;
		}

		[HarmonyPatch(typeof(LevelSelectController), "Start")]
		[HarmonyPostfix]
		public static void HideBackButton(LevelSelectController __instance)
		{
			if (IsConnectedToMultiplayer)
			{
				_currentInstance.hidefade();
				_multiController.SendUserState(MultSerializableClasses.UserState.SelectingSong);
			}
		}

		[HarmonyPatch(typeof(LevelSelectController), "clickBack")]
		[HarmonyPrefix]
		public static bool ClickBackButtonMultiplayerSelectSong(LevelSelectController __instance)
		{
			if (!IsConnectedToMultiplayer)
			{
				return true;
			}
			OnMultiplayerSelectSongExit(__instance);
			return false;
		}

		[HarmonyPatch(typeof(LevelSelectController), "clickPlay")]
		[HarmonyPrefix]
		public static bool ClickPlayButtonMultiplayerSelectSong(LevelSelectController __instance)
		{
			if (__instance.back_clicked)
			{
				return false;
			}
			if (!IsConnectedToMultiplayer)
			{
				return true;
			}
			SingleTrackData val = (MultiplayerController.savedTrackData = __instance.alltrackslist[__instance.songindex]);
			string trackref = val.trackref;
			TromboneTrack val2 = TrackLookup.lookup(trackref);
			string songHash = SongDataHelper.GetSongHash(val2);
			GlobalVariables.levelselect_index = val.trackindex;
			GlobalVariables.chosen_track = val.trackref;
			GlobalVariables.chosen_track_data = val;
			_multiController.SendSongHashToLobby(songHash, TootTallyGlobalVariables.gameSpeedMultiplier, GameModifierManager.GetModifiersString());
			OnMultiplayerSelectSongExit(__instance);
			return false;
		}

		private static void OnMultiplayerSelectSongExit(LevelSelectController __instance)
		{
			//IL_006a: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			_multiController.SendUserState(MultSerializableClasses.UserState.Ready);
			UpdateMultiplayerState(MultiplayerController.MultiplayerState.Lobby);
			__instance.clipPlayer.cancelCrossfades();
			__instance.back_clicked = true;
			__instance.bgmus.Stop();
			__instance.doSfx(__instance.sfx_click, 1f, 1f);
			__instance.fader.SetActive(true);
			__instance.fader.transform.localScale = new Vector3(9.9f, 0.001f, 1f);
			LeanTween.cancelAll();
			TootTallyAnimationManager.AddNewTransformScaleAnimation(__instance.fader, new Vector2(9.9f, 9.75f), 0.25f, new SecondDegreeDynamicsAnimation(2.5f, 1f, 0.5f), (Action<GameObject>)delegate
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				_multiController.ShowPanel();
				_multiController.ShowMute();
				SceneManager.UnloadSceneAsync("levelselect");
				MultiAudioController.ResumeMusicSoft();
				_currentInstance.startBGAnims();
				_currentInstance.fadepanel.alpha = 1f;
				((Component)_currentInstance.fadepanel).gameObject.SetActive(true);
				TootTallyAnimationManager.AddNewAlphaAnimation(((Component)_currentInstance.fadepanel).gameObject, 0f, 1f, new SecondDegreeDynamicsAnimation(1f, 1f, 1f), (Action<GameObject>)delegate
				{
					_currentInstance.hidefade();
				});
				_currentInstance.factpanel.anchoredPosition3D = new Vector3(0f, -600f, 0f);
			});
		}

		[HarmonyPatch(typeof(LevelSelectController), "hoverPlay")]
		[HarmonyPrefix]
		public static bool PreventHoverPlayLeanTweenWhenTransitioning(LevelSelectController __instance)
		{
			if (IsConnectedToMultiplayer)
			{
				return !__instance.back_clicked;
			}
			return false;
		}

		[HarmonyPatch(typeof(LevelSelectController), "unHoverPlay")]
		[HarmonyPrefix]
		public static bool PreventUnhoverPlayLeanTweenWhenTransitioning(LevelSelectController __instance)
		{
			if (IsConnectedToMultiplayer)
			{
				return !__instance.back_clicked;
			}
			return false;
		}

		[HarmonyPatch(typeof(LoadController), "Start")]
		[HarmonyPostfix]
		public static void StopMusicForWhateverFuckingReasons()
		{
			if (IsConnectedToMultiplayer)
			{
				MultiAudioController.StopMusicHard();
			}
		}

		[HarmonyPatch(typeof(PointSceneController), "Start")]
		[HarmonyPostfix]
		private static void OnPointSceneControllerStart(PointSceneController __instance)
		{
			if (State == MultiplayerController.MultiplayerState.Playing)
			{
				_currentPointSceneInstance = __instance;
				if (TootTallyGlobalVariables.isTournamentHosting)
				{
					_multiController.SendQuitFlag();
				}
				else
				{
					_multiController.SendSongFinishedToLobby();
				}
				_multiController.InitializePointScore(__instance);
				UpdateMultiplayerState(MultiplayerController.MultiplayerState.PointScene);
				__instance.btn_retry_obj.SetActive(false);
				__instance.btn_nav_cards.SetActive(false);
				__instance.btn_nav_baboon.SetActive(false);
				__instance.btn_leaderboard.SetActive(false);
			}
		}

		public static void OnMultiplayerPointScoreClick(int score, float percent, int maxCombo, int[] noteTally)
		{
			if (!((Object)(object)_currentPointSceneInstance == (Object)null))
			{
				_currentPointSceneInstance.txt_score.text = $"{score}:n0 {percent:0.00}%";
				_currentPointSceneInstance.txt_perfectos.text = noteTally[4].ToString("n0");
				_currentPointSceneInstance.txt_nices.text = noteTally[3].ToString("n0");
				_currentPointSceneInstance.txt_okays.text = noteTally[2].ToString("n0");
				_currentPointSceneInstance.txt_mehs.text = noteTally[1].ToString("n0");
				_currentPointSceneInstance.txt_nasties.text = noteTally[0].ToString("n0");
				_currentPointSceneInstance.scorepercentage = Mathf.Max((float)(score / GlobalVariables.gameplay_absolute_max_score), 0.01f);
				_currentPointSceneInstance.scoreindex = (int)Mathf.Clamp(_currentPointSceneInstance.scorepercentage / 0.2f - 1f, -1f, 5f);
				_currentPointSceneInstance.letterscore = LETTER_GRADES[_currentPointSceneInstance.scoreindex + 1];
				_currentPointSceneInstance.popScoreAnim(_currentPointSceneInstance.scoreindex + 1);
			}
		}

		[HarmonyPatch(typeof(PointSceneController), "clickCont")]
		[HarmonyPostfix]
		private static void OnClickContReturnToMulti(PointSceneController __instance)
		{
			if (State == MultiplayerController.MultiplayerState.PointScene)
			{
				__instance.scenetarget = "zzz_playtest";
			}
		}

		[HarmonyPatch(typeof(PointSceneController), "clickRetry")]
		[HarmonyPrefix]
		private static bool OnRetryClickPreventRetry()
		{
			if (State == MultiplayerController.MultiplayerState.PointScene)
			{
				TootTallyNotifManager.DisplayNotif("Can't retry in multiplayer.", 6f);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(GameController), "pauseRetryLevel")]
		[HarmonyPrefix]
		private static bool PreventRetryInMultiplayer()
		{
			if (_multiController != null && State == MultiplayerController.MultiplayerState.Quitting)
			{
				TootTallyNotifManager.DisplayNotif("Can't quick retry in multiplayer.", 6f);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(GameController), "pauseQuitLevel")]
		[HarmonyPrefix]
		private static bool PreventQuickQuittingInMultiplayer()
		{
			if (_multiController != null && State == MultiplayerController.MultiplayerState.Quitting)
			{
				TootTallyNotifManager.DisplayNotif("Can't fast quit in multiplayer.", 6f);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(GameController), "doScoreText")]
		[HarmonyPostfix]
		private static void OnDoScoreTextSendScoreToLobby(int whichtext, GameController __instance)
		{
			if (IsPlayingMultiplayer && IsConnectedToMultiplayer && !_wasAutotootUsed)
			{
				if (!_wasAutotootUsed && __instance.controllermode)
				{
					_wasAutotootUsed = true;
					_multiController.SendQuitFlag();
				}
				else
				{
					_multiController.SendScoreDataToLobby(__instance.totalscore, __instance.highestcombocounter, (int)__instance.currenthealth, whichtext, __instance.notescoreaverage);
				}
			}
		}

		[HarmonyPatch(typeof(GameController), "Start")]
		[HarmonyPostfix]
		private static void OnMultiplayerGameStart(GameController __instance)
		{
			_wasAutotootUsed = false;
			if (IsPlayingMultiplayer)
			{
				_multiController.OnGameControllerStartSetup();
			}
		}

		[HarmonyPatch(typeof(GameController), "Update")]
		[HarmonyPostfix]
		private static void OnMultiplayerUpdateWaitForSync(GameController __instance)
		{
			if (__instance.freeplay)
			{
				return;
			}
			if (_isSyncing)
			{
				if (IsPlayingMultiplayer && (!_multiController.IsAnybodyLoading || _syncTimeoutTimer > 10f))
				{
					__instance.startSong(true);
				}
				else
				{
					_syncTimeoutTimer += Time.deltaTime;
				}
			}
			else if (IsPlayingMultiplayer && _isForceExit && !__instance.quitting)
			{
				OnExitBaseGame(__instance);
			}
			if (IsPlayingMultiplayer)
			{
				__instance.restarttimer = 0.01f;
			}
		}

		private static void OnExitBaseGame(GameController __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if ((int)Cursor.lockState == 1)
			{
				Cursor.lockState = (CursorLockMode)2;
			}
			__instance.notebuttonpressed = false;
			if ((int)__instance.musictrack_status != 2)
			{
				__instance.musictrack.Pause();
			}
			VideoPlayer custombg_video = __instance.custombg_video;
			if (custombg_video != null)
			{
				custombg_video.Pause();
			}
			__instance.sfxrefs.backfromfreeplay.Play();
			__instance.puppet_humanc.shaking = false;
			__instance.puppet_humanc.stopParticleEffects();
			__instance.puppet_humanc.playCameraRotationTween(false);
			__instance.paused = true;
			__instance.quitting = true;
			__instance.pausecanvas.SetActive(true);
			__instance.pausecontroller.showPausePanel();
			Cursor.visible = true;
		}

		[HarmonyPatch(typeof(GameController), "startSong")]
		[HarmonyPrefix]
		private static bool OnMultiplayerWaitForSync()
		{
			if (!IsPlayingMultiplayer)
			{
				return true;
			}
			_multiController.OnGameControllerStartSongSendReadyState();
			if (_multiController.IsAnybodyLoading && _syncTimeoutTimer < 10f)
			{
				_isSyncing = true;
				_syncTimeoutTimer = 0f;
				TootTallyNotifManager.DisplayNotif("Waiting for all players to load...", 6f);
				return false;
			}
			_syncTimeoutTimer = 0f;
			_isSyncing = false;
			return true;
		}

		[HarmonyPatch(typeof(PauseCanvasController), "showPausePanel")]
		[HarmonyPrefix]
		public static bool OnGamePause(PauseCanvasController __instance)
		{
			if (!IsPlayingMultiplayer)
			{
				return true;
			}
			_isForceExit = false;
			UpdateMultiplayerState(MultiplayerController.MultiplayerState.Quitting);
			GameController gc = __instance.gc;
			gc.paused = true;
			gc.quitting = true;
			gc.sfxrefs.backfromfreeplay.Play();
			gc.pausecanvas.SetActive(false);
			gc.curtainc.closeCurtain(false);
			LeanTween.alphaCanvas(__instance.curtaincontroller.fullfadeblack, 1f, 0.5f).setDelay(0.6f).setEaseInOutQuint()
				.setOnComplete((Action)delegate
				{
					__instance.curtaincontroller.unloadAssets();
					SceneManager.LoadScene("zzz_playtest");
				});
			return false;
		}

		[HarmonyPatch(typeof(SpectatingManager), "OnSpectateButtonPress")]
		[HarmonyPrefix]
		public static bool PreventSpectatingWhileInMultiplayer()
		{
			if (IsPlayingMultiplayer || IsConnectedToMultiplayer || _isSceneActive)
			{
				TootTallyNotifManager.DisplayNotif("Cannot spectate someone while in multiplayer.", 6f);
				return false;
			}
			return true;
		}

		public static void ExitMultiplayer()
		{
			if (AllowExit)
			{
				UpdateMultiplayerState(MultiplayerController.MultiplayerState.ExitScene);
			}
		}

		public static void AbortGame()
		{
			if (IsConnectedToMultiplayer && IsPlayingMultiplayer && State == MultiplayerController.MultiplayerState.Playing)
			{
				_isForceExit = true;
			}
		}

		public static void UpdateMultiplayerStateIfChanged(MultiplayerController.MultiplayerState newState)
		{
			if (State != newState)
			{
				PreviousState = State;
				State = newState;
				ResolveMultiplayerState();
			}
		}

		public static void UpdateMultiplayerState(MultiplayerController.MultiplayerState newState)
		{
			PreviousState = State;
			State = newState;
			ResolveMultiplayerState();
		}

		private static void ResolveMultiplayerState()
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			Plugin.LogInfo($"Multiplayer state changed from {PreviousState} to {State}");
			switch (State)
			{
			case MultiplayerController.MultiplayerState.Lobby:
				_multiController.OnLobbyConnectionSuccess();
				break;
			case MultiplayerController.MultiplayerState.SelectSong:
				_currentInstance.fadepanel.alpha = 0f;
				((Component)_currentInstance.fadepanel).gameObject.SetActive(true);
				MultiAudioController.PauseMusicSoft();
				TootTallyAnimationManager.AddNewAlphaAnimation(((Component)_currentInstance.fadepanel).gameObject, 1f, 0.25f, new SecondDegreeDynamicsAnimation(1f, 1f, 1f), (Action<GameObject>)delegate
				{
					SceneManager.LoadScene("levelselect", (LoadSceneMode)1);
					_multiController.HidePanel();
				});
				_currentInstance.factpanel.anchoredPosition3D = new Vector3(0f, -600f, 0f);
				break;
			case MultiplayerController.MultiplayerState.ExitScene:
				MultiAudioController.StopMusicSoft();
				StopRecursiveRefresh();
				_multiController.Dispose();
				LeaveScene();
				break;
			case MultiplayerController.MultiplayerState.Playing:
				StopRecursiveRefresh();
				break;
			case MultiplayerController.MultiplayerState.Quitting:
				if (!_wasAutotootUsed)
				{
					_multiController.SendQuitFlag();
				}
				_multiController.OnSongQuit();
				break;
			case MultiplayerController.MultiplayerState.Home:
			case MultiplayerController.MultiplayerState.CreatingLobby:
			case MultiplayerController.MultiplayerState.Hosting:
			case MultiplayerController.MultiplayerState.PointScene:
				break;
			}
		}

		private static void LeaveScene()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if (TootTallyUser.userInfo.id == 8)
			{
				_currentInstance.nextScene();
				return;
			}
			_currentInstance.sfx_ok.Play();
			((Component)_currentInstance.fadepanel).gameObject.SetActive(true);
			TootTallyAnimationManager.AddNewAlphaAnimation(((Component)_currentInstance.fadepanel).gameObject, 1f, 0.4f, new SecondDegreeDynamicsAnimation(1f, 1f, 1f), (Action<GameObject>)delegate
			{
				_currentInstance.nextScene();
			});
		}

		public static void RollbackMultiplayerState()
		{
			MultiplayerController.MultiplayerState state = State;
			State = PreviousState;
			PreviousState = state;
			ResolveMultiplayerState();
		}

		public static void StartRecursiveRefresh()
		{
			_isRecursiveRefreshRunning = true;
			((MonoBehaviour)_currentInstance).StartCoroutine((IEnumerator)RecursiveLobbyRefresh());
		}

		public static void StopRecursiveRefresh()
		{
			_isRecursiveRefreshRunning = false;
			((MonoBehaviour)_currentInstance).StopCoroutine((IEnumerator)RecursiveLobbyRefresh());
		}

		private static IEnumerator<WaitForSeconds> RecursiveLobbyRefresh()
		{
			yield return WAIT_TIME;
			if ((Object)(object)_currentInstance != (Object)null && _isRecursiveRefreshRunning)
			{
				_multiController.RefreshAllLobbyInfo();
				((MonoBehaviour)_currentInstance).StartCoroutine((IEnumerator)RecursiveLobbyRefresh());
			}
		}

		public static void DebugFakeLobby()
		{
			_multiController?.DebugFakeLobby();
		}

		public static void DebugFakeUser()
		{
			_multiController?.DebugFakeUser();
		}
	}
	[BepInPlugin("TootTallyMultiplayer", "TootTallyMultiplayer", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("Tooter")]
	public class Plugin : BaseUnityPlugin, ITootTallyModule
	{
		public static Plugin Instance;

		private Harmony _harmony;

		public static TootTallySettingPage settingPage;

		public bool IsConfigInitialized { get; set; }

		public string Name
		{
			get
			{
				return "TootTallyMultiplayer";
			}
			set
			{
				Name = value;
			}
		}

		public ConfigEntry<bool> ModuleConfigEnabled { get; set; }

		public ConfigEntry<bool> MuteMusic { get; set; }

		public ConfigEntry<bool> ShowLiveScore { get; set; }

		public ConfigEntry<string> SavedLobbyTitle { get; set; }

		public ConfigEntry<string> SavedLobbyDesc { get; set; }

		public ConfigEntry<int> SavedLobbyMaxPlayer { get; set; }

		public ConfigEntry<MultiAudioController.MusicStyle> SavedMusicStyle { get; set; }

		public static void LogInfo(string msg)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)msg);
		}

		public static void LogError(string msg)
		{
			((BaseUnityPlugin)Instance).Logger.LogError((object)msg);
		}

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				_harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				GameInitializationEvent.Register(((BaseUnityPlugin)this).Info, (Action)TryInitialize);
			}
		}

		public void Update()
		{
		}

		private void TryInitialize()
		{
			ModuleConfigEnabled = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Modules", "Multiplayer", true, "Enable TootTally's Multiplayer module");
			TootTallyModuleManager.AddModule((ITootTallyModule)(object)this);
			Plugin.Instance.AddModuleToSettingPage((ITootTallyModule)(object)this);
		}

		public void LoadModule()
		{
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
			ShowLiveScore = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "ShowLiveScore", true, "Show the live score while playing in multiplayer.");
			MuteMusic = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "MuteMusic", false, "Mute the multiplayer menu music and song preview");
			SavedLobbyTitle = ((BaseUnityPlugin)this).Config.Bind<string>("General", "SavedLobbyTitle", "", "Last lobby creation name used.");
			SavedLobbyDesc = ((BaseUnityPlugin)this).Config.Bind<string>("General", "SavedLobbyDesc", "Welcome to my lobby!", "Last lobby creation description used.");
			SavedLobbyMaxPlayer = ((BaseUnityPlugin)this).Config.Bind<int>("General", "SavedLobbyMaxPlayer", 16, "Last lobby creation lobby max player used.");
			SavedMusicStyle = ((BaseUnityPlugin)this).Config.Bind<MultiAudioController.MusicStyle>("Music", "SavedMusicStyle", MultiAudioController.MusicStyle.Default, "Last selected multiplayer music style.");
			AssetManager.LoadAssets(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Instance).Info.Location), "Assets"));
			_harmony.PatchAll(typeof(MultiplayerManager));
			LogInfo("Module loaded!");
		}

		public void UnloadModule()
		{
			_harmony.UnpatchSelf();
			LogInfo("Module unloaded!");
		}
	}
	public class MultiplayerSystem : WebsocketManager
	{
		public enum DataType
		{
			SongInfo,
			LobbyInfo,
			OptionInfo,
			SetSong,
			SetLobbyInfo
		}

		public enum QuickChat
		{
			Hello = 0,
			Welcome = 1,
			Thanks = 2,
			Sorry = 3,
			Bye = 4,
			Leave = 5,
			BeRightBack = 6,
			StartWithoutMe = 7,
			Wait = 8,
			ImReady = 9,
			ReadyUp = 10,
			GoodLuck = 11,
			GoodChart = 12,
			ChangeSong = 13,
			Downloading = 14,
			NotWorking = 15,
			Yes = 16,
			No = 17,
			Maybe = 18,
			Sure = 19,
			SpeedUp = 20,
			SlowDown = 21,
			TooHard = 22,
			TooEasy = 23,
			NicePlay = 24,
			GoodGame = 25,
			CloseOne = 26,
			Rematch = 27,
			Laugh = 28,
			Enjoy = 29,
			WhoHost = 30,
			MeHost = 31,
			FreeMod = 32,
			NoMod = 33,
			LastSong = 34,
			Scared = 35,
			PlaceHolder3 = 36,
			PlaceHolder4 = 37,
			PlaceHolder5 = 38,
			PlaceHolder6 = 39,
			LetsBone = 999,
			TiltControl = 1000
		}

		public enum OptionInfoType
		{
			Refresh,
			UpdateUserInfo,
			UpdateUserState,
			UpdateScore,
			SongFinished,
			FinalScore,
			QuickChat,
			Quit,
			ChangeTeam,
			SetModifiers,
			GiveHost,
			KickFromLobby,
			BanFromLobby,
			StartTimer,
			StartGame,
			AbortTimer,
			AbortGame,
			LobbyInfoChanged
		}

		public interface ISocketMessage
		{
			string dataType { get; }
		}

		public struct SocketSetSongByHash : ISocketMessage
		{
			public string filehash { get; set; }

			public float gamespeed { get; set; }

			public string modifiers { get; set; }

			public string dataType => DataType.SetSong.ToString();
		}

		public struct SocketSetLobbyInfo : ISocketMessage
		{
			public string name;

			public string description;

			public string password;

			public int maxPlayer;

			public bool autorotate;

			public bool teams;

			public bool freemod;

			public string dataType => DataType.SetLobbyInfo.ToString();
		}

		public struct SocketOptionInfo : ISocketMessage
		{
			public string optionType { get; set; }

			public dynamic[] values { get; set; }

			public string dataType => DataType.OptionInfo.ToString();
		}

		public struct SocketLobbyInfo : ISocketMessage
		{
			public MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo { get; set; }

			public string dataType => DataType.LobbyInfo.ToString();
		}

		public struct SocketSongInfo : ISocketMessage
		{
			public MultSerializableClasses.MultiplayerSongInfo songInfo { get; set; }

			public string dataType => DataType.SongInfo.ToString();
		}

		public class SocketDataConverter : JsonConverter
		{
			public override bool CanWrite => false;

			public override bool CanConvert(Type objectType)
			{
				return objectType == typeof(ISocketMessage);
			}

			public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
			{
				JObject val = JObject.Load(reader);
				object obj = Enum.Parse(typeof(DataType), Extensions.Value<string>((IEnumerable<JToken>)val["dataType"]));
				if (obj is DataType)
				{
					switch ((DataType)obj)
					{
					case DataType.SongInfo:
						return ((JToken)val).ToObject<SocketSongInfo>(serializer);
					case DataType.LobbyInfo:
						return ((JToken)val).ToObject<SocketLobbyInfo>(serializer);
					case DataType.OptionInfo:
						return ((JToken)val).ToObject<SocketOptionInfo>(serializer);
					}
				}
				return null;
			}

			public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
			{
				throw new NotImplementedException();
			}
		}

		public Action OnWebSocketOpenCallback;

		public Action OnWebSocketCloseCallback;

		public static JsonConverter[] _dataConverter = (JsonConverter[])(object)new JsonConverter[1]
		{
			new SocketDataConverter()
		};

		public ConcurrentQueue<SocketSongInfo> _receivedSongInfo;

		public ConcurrentQueue<SocketLobbyInfo> _receivedLobbyInfo;

		public ConcurrentQueue<SocketOptionInfo> _receivedSocketOptionInfo;

		public Action<SocketSongInfo> OnSocketSongInfoReceived;

		public Action<SocketLobbyInfo> OnSocketLobbyInfoReceived;

		public Action<SocketOptionInfo> OnSocketOptionReceived;

		public static readonly Dictionary<QuickChat, string> QuickChatToTextDic = new Dictionary<QuickChat, string>
		{
			{
				QuickChat.Hello,
				"Hello!"
			},
			{
				QuickChat.Welcome,
				"Welcome!"
			},
			{
				QuickChat.Thanks,
				"Thanks!"
			},
			{
				QuickChat.Sorry,
				"Sorry..."
			},
			{
				QuickChat.Bye,
				"Bye bye!"
			},
			{
				QuickChat.Leave,
				"I have to leave."
			},
			{
				QuickChat.BeRightBack,
				"I will be right back."
			},
			{
				QuickChat.StartWithoutMe,
				"You can start without me."
			},
			{
				QuickChat.Wait,
				"Wait for me."
			},
			{
				QuickChat.ImReady,
				"I'm ready!"
			},
			{
				QuickChat.ReadyUp,
				"Ready up!"
			},
			{
				QuickChat.GoodLuck,
				"Good luck!"
			},
			{
				QuickChat.GoodChart,
				"I like this chart."
			},
			{
				QuickChat.ChangeSong,
				"Can we change the song?"
			},
			{
				QuickChat.Downloading,
				"I'm downloading the song."
			},
			{
				QuickChat.NotWorking,
				"The download is not working."
			},
			{
				QuickChat.Yes,
				"Yes."
			},
			{
				QuickChat.No,
				"No."
			},
			{
				QuickChat.Maybe,
				"Maybe."
			},
			{
				QuickChat.Sure,
				"Sure!"
			},
			{
				QuickChat.SpeedUp,
				"We should increase the game speed."
			},
			{
				QuickChat.SlowDown,
				"We should lower the game speed."
			},
			{
				QuickChat.TooHard,
				"I think the song is too hard."
			},
			{
				QuickChat.TooEasy,
				"I think the song is too easy."
			},
			{
				QuickChat.NicePlay,
				"Nice play!"
			},
			{
				QuickChat.GoodGame,
				"Good game."
			},
			{
				QuickChat.CloseOne,
				"That was a close match!"
			},
			{
				QuickChat.Rematch,
				"Rematch!"
			},
			{
				QuickChat.Laugh,
				"Ahah!"
			},
			{
				QuickChat.Enjoy,
				"Im enjoying this lobby!"
			},
			{
				QuickChat.MeHost,
				"I want to be host."
			},
			{
				QuickChat.WhoHost,
				"Who wants to be host?"
			},
			{
				QuickChat.FreeMod,
				"I want to use modifiers."
			},
			{
				QuickChat.NoMod,
				"I don't want to use modifiers."
			},
			{
				QuickChat.LastSong,
				"This is my last song."
			},
			{
				QuickChat.Scared,
				"I'm scared..."
			},
			{
				QuickChat.LetsBone,
				"Let's bone again!"
			},
			{
				QuickChat.TiltControl,
				"I'm using tilt controls."
			}
		};

		public string GetServerID => ((WebsocketManager)this)._id;

		public MultiplayerSystem(string serverID, bool isHost)
			: base(serverID, "wss://spec.toottally.com/mp/join/", "1.1.0")
		{
			((WebsocketManager)this).ConnectionPending = true;
			_receivedSongInfo = new ConcurrentQueue<SocketSongInfo>();
			_receivedLobbyInfo = new ConcurrentQueue<SocketLobbyInfo>();
			_receivedSocketOptionInfo = new ConcurrentQueue<SocketOptionInfo>();
			((WebsocketManager)this).ConnectToWebSocketServer(((WebsocketManager)this)._url + serverID, Plugin.GetAPIKey, isHost);
		}

		public void SendSongHash(string filehash, float gamespeed, string modifiers)
		{
			SocketSetSongByHash socketSetSongByHash = new SocketSetSongByHash
			{
				filehash = filehash,
				gamespeed = gamespeed,
				modifiers = modifiers
			};
			SendSongHash(socketSetSongByHash);
		}

		public void SendSetLobbyInfo(SocketSetLobbyInfo lobbyInfo)
		{
			string text = JsonConvert.SerializeObject((object)lobbyInfo);
			((WebsocketManager)this).SendToSocket(text);
		}

		public void SendSongHash(SocketSetSongByHash socketSetSongByHash)
		{
			string text = JsonConvert.SerializeObject((object)socketSetSongByHash);
			((WebsocketManager)this).SendToSocket(text);
		}

		public void SendOptionInfo(OptionInfoType optionType, dynamic[] values = null)
		{
			SocketOptionInfo socketOptionInfo = new SocketOptionInfo
			{
				optionType = optionType.ToString(),
				values = values
			};
			string text = JsonConvert.SerializeObject((object)socketOptionInfo);
			((WebsocketManager)this).SendToSocket(text);
		}

		public void SendUserState(MultSerializableClasses.UserState state)
		{
			SendOptionInfo(OptionInfoType.UpdateUserState, new object[1] { state.ToString() });
		}

		public void SendUpdateScore(int score, int combo, int health, int tally, float accuracy)
		{
			SendOptionInfo(OptionInfoType.UpdateScore, new object[5] { score, combo, health, tally, accuracy });
		}

		public void UpdateStacks()
		{
			if (OnSocketSongInfoReceived != null && _receivedSongInfo.TryDequeue(out var result))
			{
				OnSocketSongInfoReceived(result);
			}
			if (OnSocketLobbyInfoReceived != null && _receivedLobbyInfo.TryDequeue(out var result2))
			{
				OnSocketLobbyInfoReceived(result2);
			}
			if (OnSocketOptionReceived != null && _receivedSocketOptionInfo.TryDequeue(out var result3))
			{
				OnSocketOptionReceived(result3);
			}
		}

		protected override void OnDataReceived(object sender, MessageEventArgs e)
		{
			if (e.IsText)
			{
				ISocketMessage socketMessage;
				try
				{
					socketMessage = JsonConvert.DeserializeObject<ISocketMessage>(e.Data, _dataConverter);
				}
				catch (Exception)
				{
					return;
				}
				if (socketMessage is SocketSongInfo item && !((WebsocketManager)this).IsHost)
				{
					_receivedSongInfo.Enqueue(item);
				}
				else if (socketMessage is SocketOptionInfo item2)
				{
					_receivedSocketOptionInfo.Enqueue(item2);
				}
				else if (socketMessage is SocketLobbyInfo item3)
				{
					_receivedLobbyInfo.Enqueue(item3);
				}
			}
		}

		protected override void OnWebSocketError(object sender, ErrorEventArgs e)
		{
			((WebsocketManager)this).OnWebSocketError(sender, e);
		}

		protected override void OnWebSocketOpen(object sender, EventArgs e)
		{
			OnWebSocketOpenCallback?.Invoke();
			((WebsocketManager)this).OnWebSocketOpen(sender, e);
		}

		protected override void OnWebSocketClose(object sender, CloseEventArgs e)
		{
			OnWebSocketCloseCallback?.Invoke();
			((WebsocketManager)this).OnWebSocketClose(sender, e);
		}

		public void Disconnect()
		{
			if (((WebsocketManager)this).IsConnected)
			{
				TootTallyNotifManager.DisplayNotif("Disconnected from multiplayer server.", 6f);
				((WebsocketManager)this).CloseWebsocket();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "TootTallyMultiplayer";

		public const string PLUGIN_NAME = "TootTallyMultiplayer";

		public const string PLUGIN_VERSION = "1.1.0";
	}
}
namespace TootTallyMultiplayer.MultiplayerPanels
{
	public class MultiplayerCreatePanel : MultiplayerPanelBase
	{
		private GameObject _centerContainer;

		private TMP_InputField _lobbyName;

		private TMP_InputField _lobbyDescription;

		private TMP_InputField _lobbyPassword;

		private TMP_InputField _lobbyMaxPlayer;

		private Toggle _autoRotateToggle;

		private Toggle _teamsToggle;

		private Toggle _freemodToggle;

		private Toggle _autoStartOnReady;

		public bool IsRequestPending;

		public MultiplayerCreatePanel(GameObject canvas, MultiplayerController controller)
			: base(canvas, controller, "CreateLayout")
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: 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_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			panel.transform.localPosition = Vector2.op_Implicit(new Vector2(0f, 2000f));
			_centerContainer = GameModifierFactory.GetVerticalBox(new Vector2(500f, 0f), center.transform);
			VerticalLayoutGroup component = _centerContainer.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 40f;
			((LayoutGroup)component).childAlignment = (TextAnchor)1;
			TMP_Text val = GameObjectFactory.CreateSingleText(headerCenter.transform, "TitleText", "Create Lobby", (TextFont)0);
			val.enableAutoSizing = true;
			string text = ((Plugin.Instance.SavedLobbyTitle.Value == "") ? (TootTallyUser.userInfo.username + "'s Lobby") : Plugin.Instance.SavedLobbyTitle.Value);
			GameObject horizontalBox = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 55f), _centerContainer.transform);
			HorizontalLayoutGroup component2 = horizontalBox.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 8f;
			((LayoutGroup)component2).childAlignment = (TextAnchor)3;
			GameObject val2 = Object.Instantiate<GameObject>(horizontalBox, _centerContainer.transform);
			GameObject val3 = Object.Instantiate<GameObject>(horizontalBox, _centerContainer.transform);
			GameObject val4 = Object.Instantiate<GameObject>(horizontalBox, _centerContainer.transform);
			TMP_Text val5 = GameObjectFactory.CreateSingleText(horizontalBox.transform, "NameLabel", "Name:", (TextFont)0);
			val5.rectTransform.sizeDelta = new Vector2(140f, 55f);
			val5.alignment = (TextAlignmentOptions)1025;
			_lobbyName = MultiplayerGameObjectFactory.CreateInputField(horizontalBox.transform, "LobbyNameInputField", new Vector2(300f, 30f), 24f, text, isPassword: false);
			TMP_Text val6 = Object.Instantiate<TMP_Text>(val5, val2.transform);
			((Object)val6).name = "DescLabel";
			val6.text = "Description:";
			_lobbyDescription = MultiplayerGameObjectFactory.CreateInputField(val2.transform, "LobbyDescriptionInputField", new Vector2(300f, 30f), 24f, Plugin.Instance.SavedLobbyDesc.Value, isPassword: false);
			TMP_Text val7 = Object.Instantiate<TMP_Text>(val5, val3.transform);
			((Object)val7).name = "PasswordLabel";
			val7.text = "Password:";
			_lobbyPassword = MultiplayerGameObjectFactory.CreateInputField(val3.transform, "LobbyPasswordInputField", new Vector2(300f, 30f), 24f, "", isPassword: true);
			TMP_Text val8 = Object.Instantiate<TMP_Text>(val5, val4.transform);
			((Object)val8).name = "MaxPlayerLabel";
			val8.text = "Max Player:";
			_lobbyMaxPlayer = MultiplayerGameObjectFactory.CreateInputField(val4.transform, "LobbyMaxPlayerInputField", new Vector2(300f, 30f), 24f, Plugin.Instance.SavedLobbyMaxPlayer.Value.ToString(), isPassword: false);
			GameObject verticalBox = GameModifierFactory.GetVerticalBox(new Vector2(245f, 0f), _centerContainer.transform);
			VerticalLayoutGroup component3 = verticalBox.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component3).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = (((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = false);
			_autoRotateToggle = MultiplayerGameObjectFactory.CreateToggle(verticalBox.transform, "AutorotateToggle", new Vector2(60f, 60f), "autorotate");
			_autoStartOnReady = MultiplayerGameObjectFactory.CreateToggle(verticalBox.transform, "AutoStartWhenReady", new Vector2(60f, 60f), "autostart");
			_teamsToggle = MultiplayerGameObjectFactory.CreateToggle(verticalBox.transform, "TeamsToggle", new Vector2(60f, 60f), "teams");
			_freemodToggle = MultiplayerGameObjectFactory.CreateToggle(verticalBox.transform, "FreemodToggle", new Vector2(60f, 60f), "freemod");
			GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Back", "CreateBackButton", (Action)OnBackButtonClick);
			GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Create", "CreateLobbyButton", (Action)OnCreateButtonClick);
		}

		private void OnBackButtonClick()
		{
			if (!controller.IsRequestPending)
			{
				controller.MoveToMain();
				MultiplayerManager.UpdateMultiplayerState(MultiplayerController.MultiplayerState.Home);
			}
		}

		public static bool ValidateInput(string name, string desc, string pass, string maxPlayer)
		{
			bool flag = true;
			if (!int.TryParse(maxPlayer, out var result))
			{
				flag = false;
				TootTallyNotifManager.DisplayNotif("MaxPlayer must be a number.", 6f);
			}
			else if (result < 2 || result > 32)
			{
				flag = false;
				TootTallyNotifManager.DisplayNotif("MaxPlayer must be between 2 and 32.", 6f);
			}
			if (name.Length > 32)
			{
				flag = false;
				TootTallyNotifManager.DisplayNotif("Lobby name has to be\n32 characters or shorter", 6f);
			}
			if (desc.Length > 100)
			{
				flag = false;
				TootTallyNotifManager.DisplayNotif("Description has to be\n100 characters or shorter", 6f);
			}
			if (pass.Length > 100)
			{
				flag = false;
				TootTallyNotifManager.DisplayNotif("Password has to be\n100 characters or shorter", 6f);
			}
			if (flag)
			{
				Plugin.Instance.SavedLobbyTitle.Value = name;
				Plugin.Instance.SavedLobbyDesc.Value = desc;
				Plugin.Instance.SavedLobbyMaxPlayer.Value = result;
			}
			return flag;
		}

		private void OnCreateButtonClick()
		{
			//IL_007a: 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_00a9: 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 (IsRequestPending || !ValidateInput(_lobbyName.text, _lobbyDescription.text, _lobbyPassword.text, _lobbyMaxPlayer.text) || controller.IsConnected || controller.IsConnectionPending)
			{
				return;
			}
			IsRequestPending = true;
			TootTallyNotif notif = TootTallyNotifManager.ManualNotif("Creating lobby...", Theme.colors.notification.defaultText);
			LoadingIcon swirly = GameObjectFactory.CreateLoadingIcon(((Component)notif).gameObject.transform, new Vector2(0f, -42f), Vector2.one * 64f, AssetManager.GetSprite("icon.png"), true, "LobbyCreateLoadingSwirly");
			swirly.StartRecursiveAnimation();
			swirly.Show();
			MultSerializableClasses.APICreateSubmission apiSubmission = new MultSerializableClasses.APICreateSubmission
			{
				name = _lobbyName.text,
				description = _lobbyDescription.text,
				password = _lobbyPassword.text,
				maxPlayer = int.Parse(_lobbyMaxPlayer.text),
				autorotate = _autoRotateToggle.isOn,
				autostart = _autoStartOnReady.isOn,
				teams = _teamsToggle.isOn,
				freemod = _freemodToggle.isOn,
				version = "1.1.0"
			};
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.CreateMultiplayerServerRequest(apiSubmission, delegate(string serverCode)
			{
				if (serverCode != null)
				{
					TootTallyNotifManager.DisplayNotif("Lobby #" + serverCode + " created.", 6f);
					Plugin.LogInfo(serverCode);
					controller.ConnectToLobby(serverCode, _lobbyPassword.text);
				}
				else
				{
					TootTallyNotifManager.DisplayNotif("Lobby creation failed.", 6f);
				}
				swirly.Dispose();
				notif.Dispose();
				IsRequestPending = false;
			}));
		}
	}
	public class MultiplayerLobbyPanel : MultiplayerPanelBase
	{
		public GameObject lobbyUserContainer;

		public GameObject rightPanel;

		public GameObject rightPanelContainer;

		public GameObject middlePanel;

		public GameObject titleContainer;

		public GameObject songDescContainer;

		public GameObject buttonContainer;

		public GameObject songInfoContainer;

		public GameObject songInfoTop;

		public GameObject songInfoBottom;

		private CustomPopup _quickChatPopup;

		private CustomPopup _modifiersPopup;

		private Dictionary<Metadata, ModifierButton> _modifierButtonDict = new Dictionary<Metadata, ModifierButton>();

		private Dictionary<int, MultiplayerCard> _userCardsDict;

		private CustomButton _selectSongButton;

		private CustomButton _startGameButton;

		private CustomButton _readyUpButton;

		private CustomButton _downloadButton;

		private CustomButton _profileButton;

		private CustomButton _giveHostButton;

		private CustomButton _kickButton;

		private CustomButton _banButton;

		private GameObject _lobbySettingButton;

		private TMP_Text _titleText;

		private TMP_Text _maxPlayerText;

		private TMP_Text _songNameText;

		private TMP_Text _songArtistText;

		private TMP_Text _timeText;

		private TMP_Text _songDescText;

		private TMP_Text _bpmText;

		private TMP_Text _gameSpeedText;

		private TMP_Text _modifiersText;

		private TMP_Text _ratingText;

		private TMP_Text _lobbyLogText;

		private Image _ratedIcon;

		private ProgressBar _downloadProgressBar;

		private Slider _hiddenUserCardSlider;

		private Slider _scrollSpeedSlider;

		private ScrollableSliderHandler _scrollingHandler;

		private GameObject _dropdownMenu;

		private GameObject _dropdownMenuContainer;

		private MultSerializableClasses.MultiplayerUserInfo _dropdownUserInfo;

		private TootTallyAnimation _dropdownAnimation;

		private LobbySettingsInputPrompt _lobbySettingsInputPrompt;

		public bool IsHost;

		private int _maxPlayerCount;

		private int _readyCount;

		private bool _isFreeMod;

		private bool _isAutoStartOnReady;

		private float _previousUserCount;

		private float _savedGameSpeed;

		private float _lastLobbyContainerPosY;

		private Vector3 _lobbyContainerScrollingDistance;

		private bool _canPressButton;

		private bool _canDoQuickChat = true;

		private MultSerializableClasses.UserState _userState;

		private MultSerializableClasses.MultiplayerUserInfo _hostInfo;

		private List<MultSerializableClasses.MultiplayerUserInfo> _lastUsers;

		private float _posYJumpValue = 83f;

		private float _posYOffset = -340f;

		private bool _isDownloadable;

		public bool IsGameRunning
		{
			get
			{
				if (_userCardsDict != null)
				{
					return _userCardsDict.Values.Any((MultiplayerCard x) => x.user.state == "Playing");
				}
				return false;
			}
		}

		public bool IsQuickChatOpened => _quickChatPopup.isPopupEnabled;

		public MultiplayerLobbyPanel(GameObject canvas, MultiplayerController controller)
			: base(canvas, controller, "LobbyLayout")
		{
			//IL_0050: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: 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_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: 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_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: 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_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Expected O, but got Unknown
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06af: Expected O, but got Unknown
			//IL_06c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Expected O, but got Unknown
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0769: Expected O, but got Unknown
			//IL_076c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0836: Unknown result type (might be due to invalid IL or missing references)
			//IL_083d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0856: Unknown result type (might be due to invalid IL or missing references)
			//IL_085d: Unknown result type (might be due to invalid IL or missing references)
			//IL_087e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0888: Expected O, but got Unknown
			//IL_0893: Unknown result type (might be due to invalid IL or missing references)
			//IL_0898: Unknown result type (might be due to invalid IL or missing references)
			//IL_089f: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0938: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0944: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09be: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a17: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aaa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b70: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cde: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d1e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df3: Unknown result type (might be due to invalid IL or missing references)
			panel.transform.localPosition = Vector2.op_Implicit(new Vector2(2000f, 0f));
			lobbyUserContainer = ((Component)center.transform.Find("Left/UserContainer")).gameObject;
			rightPanel = ((Component)center.transform.Find("Right")).gameObject;
			rightPanelContainer = ((Component)rightPanel.transform.Find("InfoContainer")).gameObject;
			middlePanel = ((Component)center.transform.Find("Middle")).gameObject;
			titleContainer = ((Component)rightPanelContainer.transform.GetChild(0)).gameObject;
			songInfoContainer = ((Component)rightPanelContainer.transform.GetChild(1)).gameObject;
			songInfoTop = ((Component)songInfoContainer.transform.GetChild(0)).gameObject;
			songInfoBottom = ((Component)songInfoContainer.transform.GetChild(1)).gameObject;
			songDescContainer = ((Component)rightPanelContainer.transform.GetChild(2)).gameObject;
			buttonContainer = ((Component)rightPanelContainer.transform.GetChild(3)).gameObject;
			_quickChatPopup = MultiplayerGameObjectFactory.CreateQuickChatPopup(buttonContainer.transform, canvas.transform, OnSendQuickChatButtonClick);
			_modifiersPopup = GameModifierFactory.CreateModifiersPopup(buttonContainer.transform, Vector2.zero, new Vector2(64f, 64f), canvas.transform, new Vector2(350f, 250f), 38, new Vector2(32f, 32f));
			GameObject val = GameModifierFactory.CreatePopupContainer(_modifiersPopup, new Vector2(0f, 130f));
			((LayoutGroup)((Component)val.transform.parent).GetComponent<VerticalLayoutGroup>()).childAlignment = (TextAnchor)4;
			val.GetComponent<GridLayoutGroup>().cellSize = Vector2.one * 64f;
			AddModifierButton(val.transform, GameModifiers.HIDDEN);
			AddModifierButton(val.transform, GameModifiers.FLASHLIGHT);
			AddModifierButton(val.transform, GameModifiers.EASY_MODE);
			AddModifierButton(val.transform, GameModifiers.STRICT_MODE);
			AddModifierButton(val.transform, GameModifiers.HIDDEN_CURSOR);
			AddModifierButton(val.transform, GameModifiers.MIRROR_MODE);
			AddModifierButton(val.transform, GameModifiers.NO_BREATHING);
			_hiddenUserCardSlider = new GameObject("ContainerSlider", new Type[1] { typeof(Slider) }).GetComponent<Slider>();
			((Component)_hiddenUserCardSlider).gameObject.SetActive(true);
			((UnityEvent<float>)(object)_hiddenUserCardSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float value)
			{
				OnSliderValueChangeScrollContainer(lobbyUserContainer, value);
			});
			_scrollingHandler = ((Component)_hiddenUserCardSlider).gameObject.AddComponent<ScrollableSliderHandler>();
			((Behaviour)_scrollingHandler).enabled = false;
			_userCardsDict = new Dictionary<int, MultiplayerCard>();
			_lobbySettingsInputPrompt = MultiplayerGameObjectFactory.CreateLobbySettingsInputPrompt(canvas.transform, controller);
			_lobbySettingsInputPrompt.gameObject.SetActive(false);
			_lobbySettingButton = GameObjectFactory.CreateClickableImageHolder(headerRight.transform, Vector2.zero, new Vector2(72f, 72f), AssetManager.GetSprite("motherfuckinglobbysettingsicon256.png"), "LobbySettingButton", (Action)_lobbySettingsInputPrompt.Show).gameObject;
			_lobbySettingButton.gameObject.SetActive(false);
			GameObjectFactory.CreateClickableImageHolder(headerLeft.transform, Vector2.zero, new Vector2(72f, 72f), AssetManager.GetSprite("gtfo.png"), "LobbyBackButton", (Action)OnBackButtonClick);
			_dropdownMenu = GameModifierFactory.GetBorderedVerticalBox(new Vector2(300f, 180f), 5, panel.transform);
			((Behaviour)_dropdownMenu.GetComponent<Image>()).enabled = false;
			_dropdownMenu.SetActive(false);
			_lobbyContainerScrollingDistance = Vector3.zero;
			EventTrigger val2 = _dropdownMenu.AddComponent<EventTrigger>();
			Entry val3 = new Entry();
			val3.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				HideDropdown();
			});
			val2.triggers.Add(val3);
			_dropdownMenu.AddComponent<LayoutElement>().ignoreLayout = true;
			RectTransform component = _dropdownMenu.GetComponent<RectTransform>();
			component.pivot = new Vector2(0f, 1f);
			_dropdownMenuContainer = ((Component)_dropdownMenu.transform.GetChild(0)).gameObject;
			_profileButton = GameObjectFactory.CreateCustomButton(_dropdownMenuContainer.transform, Vector2.zero, new Vector2(295f, 60f), "Profile", "DropdownProfile", (Action)OnProfileButtonClick);
			_giveHostButton = GameObjectFactory.CreateCustomButton(_dropdownMenuContainer.transform, Vector2.zero, new Vector2(295f, 60f), "Give Host", "DropdownGiveHost", (Action)OnGiveHostButtonClick);
			_kickButton = GameObjectFactory.CreateCustomButton(_dropdownMenuContainer.transform, Vector2.zero, new Vector2(295f, 60f), "Kick", "DropdownKick", (Action)OnKickUserButtonClick);
			_banButton = GameObjectFactory.CreateCustomButton(_dropdownMenuContainer.transform, Vector2.zero, new Vector2(295f, 60f), "Ban", "DropdownBan", (Action)OnBanButtonClick);
			_titleText = GameObjectFactory.CreateSingleText(headerCenter.transform, "TitleText", "-", (TextFont)0);
			_titleText.enableAutoSizing = true;
			_titleText.alignment = (TextAlignmentOptions)513;
			_titleText.fontStyle = (FontStyles)1;
			_titleText.fontSizeMax = 60f;
			_maxPlayerText = GameObjectFactory.CreateSingleText(headerCenter.transform, "MaxPlayer", "-/-", (TextFont)0);
			_maxPlayerText.alignment = (TextAlignmentOptions)516;
			_titleText.fontStyle = (FontStyles)1;
			_maxPlayerText.fontSize = 32f;
			_maxPlayerText.enableWordWrapping = false;
			((LayoutGroup)titleContainer.GetComponent<VerticalLayoutGroup>()).padding = new RectOffset(15, 15, 15, 15);
			((LayoutGroup)songInfoContainer.GetComponent<VerticalLayoutGroup>()).padding = new RectOffset(15, 15, 15, 15);
			_songNameText = GameObjectFactory.CreateSingleText(titleContainer.transform, "SongNameText", "-", (TextFont)0);
			_songNameText.rectTransform.sizeDelta = new Vector2(0f, 60f);
			_songNameText.enableAutoSizing = true;
			_songNameText.fontSizeMax = 48f;
			_songNameText.fontSizeMin = 32f;
			_songNameText.overflowMode = (TextOverflowModes)1;
			_songNameText.fontStyle = (FontStyles)1;
			EventTrigger val4 = ((Component)_songNameText).gameObject.AddComponent<EventTrigger>();
			Entry val5 = new Entry();
			val5.eventID = (EventTriggerType)4;
			((UnityEvent<BaseEventData>)(object)val5.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				OnTitleTextClickOpenSongLink();
			});
			val4.triggers.Add(val5);
			_songArtistText = GameObjectFactory.CreateSingleText(titleContainer.transform, "SongArtistText", "-", (TextFont)0);
			_songArtistText.rectTransform.sizeDelta = new Vector2(0f, 75f);
			_songArtistText.fontSizeMax = 30f;
			_songDescText = GameObjectFactory.CreateSingleText(songDescContainer.transform, "SongDescText", "-", (TextFont)0);
			_songDescText.alignment = (TextAlignmentOptions)257;
			_songDescText.fontSizeMax = 22f;
			TMP_Text songArtistText = _songArtistText;
			TMP_Text songDescText = _songDescText;
			TextOverflowModes overflowMode = (TextOverflowModes)0;
			songDescText.overflowMode = (TextOverflowModes)0;
			songArtistText.overflowMode = overflowMode;
			TMP_Text songNameText = _songNameText;
			TMP_Text songArtistText2 = _songArtistText;
			TextAlignmentOptions alignment = (TextAlignmentOptions)513;
			songArtistText2.alignment = (TextAlignmentOptions)513;
			songNameText.alignment = alignment;
			float num = 32f;
			((LayoutGroup)songDescContainer.GetComponent<VerticalLayoutGroup>()).padding = new RectOffset(15, 15, 15, 15);
			GameObjectFactory.CreateImageHolder(songInfoTop.transform, Vector2.zero, Vector2.one * num, AssetManager.GetSprite("gamespeed64.png"), "GameSpeedIcon");
			_gameSpeedText = GameObjectFactory.CreateSingleText(songInfoTop.transform, "GameSpeedText", " -", (TextFont)0);
			GameObjectFactory.CreateImageHolder(songInfoTop.transform, Vector2.zero, Vector2.one * num, AssetManager.GetSprite("stardiff64.png"), "RatingIcon");
			_ratingText = GameObjectFactory.CreateSingleText(songInfoTop.transform, "RatingText", " -", (TextFont)0);
			_ratedIcon = GameObjectFactory.CreateImageHolder(songInfoTop.transform, Vector2.zero, Vector2.one * num, AssetManager.GetSprite("rated64.png"), "RatedIcon").GetComponent<Image>();
			((Behaviour)_ratedIcon).enabled = false;
			_modifiersText = GameObjectFactory.CreateSingleText(songInfoTop.transform, "ModsText", "M ", (TextFont)0);
			_modifiersText.margin = new Vector4(45f, 0f);
			GameObjectFactory.CreateImageHolder(songInfoBottom.transform, Vector2.zero, Vector2.one * num, AssetManager.GetSprite("time64.png"), "TimeIcon");
			_timeText = GameObjectFactory.CreateSingleText(songInfoBottom.transform, "TimeText", " -", (TextFont)0);
			GameObjectFactory.CreateImageHolder(songInfoBottom.transform, Vector2.zero, Vector2.one * num, AssetManager.GetSprite("bpm64.png"), "BPMIcon");
			_bpmText = GameObjectFactory.CreateSingleText(songInfoBottom.transform, "BPMText", " -", (TextFont)0);
			RectTransform rectTransform = _timeText.rectTransform;
			RectTransform rectTransform2 = _gameSpeedText.rectTransform;
			RectTransform rectTransform3 = _modifiersText.rectTransform;
			RectTransform rectTransform4 = _bpmText.rectTransform;
			Vector2 val6 = default(Vector2);
			((Vector2)(ref val6))..ctor(200f, 0f);
			rectTransform4.sizeDelta = val6;
			rectTransform.sizeDelta = (rectTransform2.sizeDelta = (rectTransform3.sizeDelta = val6));
			_ratingText.rectTransform.sizeDelta = new Vector2(70f, 0f);
			BetterScrollSpeedSliderPatcher.SetSliderOption();
			_scrollSpeedSlider = GameObjectFactory.CreateSliderFromPrefab(songInfoBottom.transform, "ScrollSpeedSlider");
			_scrollSpeedSlider.minValue = (float)BetterScrollSpeedSliderPatcher.options.Min.Value / 100f;
			_scrollSpeedSlider.maxValue = (float)BetterScrollSpeedSliderPatcher.options.Max.Value / 100f;
			_scrollSpeedSlider.value = BetterScrollSpeedSliderPatcher.options.LastValue.Value / 100f;
			((Component)_scrollSpeedSlider).gameObject.SetActive(true);
			((Component)_scrollSpeedSlider).transform.localScale = Vector3.one * 1.75f;
			TMP_Text sliderText = GameObjectFactory.CreateSingleText((Transform)(object)_scrollSpeedSlider.handleRect, "ScrollSpeedSliderText", BetterScrollSpeedSliderPatcher.SliderValueToText(_scrollSpeedSlider.value), (TextFont)0);
			sliderText.enableWordWrapping = false;
			sliderText.fontSize = 12f;
			((UnityEvent<float>)(object)_scrollSpeedSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float value)
			{
				BetterScrollSpeedSliderPatcher.options.LastValue.Value = value * 100f;
				sliderText.text = BetterScrollSpeedSliderPatcher.SliderValueToText(value);
				GlobalVariables.gamescrollspeed = value;
			});
			SetTextsParameters(_timeText, _bpmText, _gameSpeedText, _modifiersText, _ratingText);
			_selectSongButton = GameObjectFactory.CreateCustomButton(buttonContainer.transform, Vector2.zero, new Vector2(170f, 65f), "SelectSong", "SelectSongButton", (Action)OnSelectSongButtonClick);
			((Component)_selectSongButton).gameObject.SetActive(false);
			_startGameButton = GameObjectFactory.CreateCustomButton(buttonContainer.transform, Vector2.zero, new Vector2(170f, 65f), "Start Game", "StartGameButton", (Action)OnStartGameButtonClick);
			((Component)_startGameButton).gameObject.SetActive(false);
			_readyUpButton = GameObjectFactory.CreateCustomButton(buttonContainer.transform, Vector2.zero, new Vector2(220f, 100f), "Ready Up", "ReadyUpButton", (Action)OnReadyButtonClick);
			_downloadButton = GameObjectFactory.CreateCustomButton(buttonContainer.transform, Vector2.zero, new Vector2(220f, 100f), "Download", "DownloadButton", (Action)OnDownloadButtonClick);
			((Component)_downloadButton).gameObject.SetActive(false);
			_downloadProgressBar = GameObjectFactory.CreateProgressBar(buttonContainer.transform, Vector2.zero, new Vector2(550f, 35f), false, "DownloadProgressBar");
			ResetData();
			footer.AddComponent<Mask>();
			_lobbyLogText = GameObjectFactory.CreateSingleText(footer.transform, "LogText", MultiplayerLogger.GetFormattedLogs(), (TextFont)0);
			_lobbyLogText.alignment = (TextAlignmentOptions)1025;
			_lobbyLogText.overflowMode = (TextOverflowModes)2;
			_lobbyLogText.lineSpacing = 22f;
			_lobbyLogText.margin = Vector4.one * 2f;
			MultiplayerLogger.OnLogReceivedUpdate = UpdateLogText;
		}

		private void AddModifierButton(Transform transform, Metadata modifier)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			ModifierButton value = new ModifierButton(transform, modifier, false, new Vector2(64f, 64f), 6, 16, false, (Action)delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				ToggleModifier(modifier);
			});
			_modifierButtonDict.Add(modifier, value);
		}

		private void ToggleModifier(Metadata modifier)
		{
			//IL_0006: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			ModifierButton val = _modifierButtonDict[modifier];
			if (!val.onCooldown)
			{
				val.onCooldown = true;
				MultiplayerCard multiplayerCard = _userCardsDict[TootTallyUser.userInfo.id];
				List<Metadata> modifierSet = GameModifierManager.GetModifierSet(multiplayerCard.user.mods);
				if (modifierSet.Contains(modifier))
				{
					modifierSet.Remove(modifier);
				}
				else
				{
					modifierSet.Add(modifier);
				}
				controller.SetModifiers(string.Join(",", modifierSet.Select((Metadata i) => ((Metadata)(ref i)).Name)));
			}
		}

		public void ResetData()
		{
			_userState = MultSerializableClasses.UserState.None;
			DisableButton(0.8f);
			_lobbySettingsInputPrompt.Hide(animate: false);
			_quickChatPopup.popupBox.SetActive(false);
			_modifiersPopup.popupBox.SetActive(false);
			SetNullTrackDataDetails(isDownloadable: false);
		}

		private void SetTextsParameters(params TMP_Text[] texts)
		{
			foreach (TMP_Text val in texts)
			{
				val.fontSize = 22f;
				val.alignment = (TextAlignmentOptions)513;
				val.enableWordWrapping = false;
			}
		}

		public void UpdateLobbyInfo(List<MultSerializableClasses.MultiplayerUserInfo> users, MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo)
		{
			if (_lastUsers != null)
			{
				users.FindAll((MultSerializableClasses.MultiplayerUserInfo x) => !_lastUsers.Any((MultSerializableClasses.MultiplayerUserInfo l) => x.id == l.id)).ToList().ForEach(delegate(MultSerializableClasses.MultiplayerUserInfo u)
				{
					MultiAudioController.PlayJoinSound();
					MultiplayerLogger.ServerLog(u.username + " joined the lobby.");
				});
				_lastUsers.FindAll((MultSerializableClasses.MultiplayerUserInfo l) => !users.Any((MultSerializableClasses.MultiplayerUserInfo x) => l.id == x.id)).ToList().ForEach(delegate(MultSerializableClasses.MultiplayerUserInfo u)
				{
					MultiAudioController.PlayLeaveSound();
					MultiplayerLogger.ServerLog(u.username + " left the lobby.");
				});
			}
			_isFreeMod = lobbyInfo.freemod;
			_isAutoStartOnReady = lobbyInfo.autostart;
			ClearAllUserRows();
			MultSerializableClasses.MultiplayerUserInfo hostInfo = users.Find((MultSerializableClasses.MultiplayerUserInfo x) => x.isHost);
			if (_hostInfo.id == 0 || _hostInfo.id != hostInfo.id)
			{
				if (_hostInfo.id != 0 && _hostInfo.username != "")
				{
					MultiplayerLogger.ServerLog("Host was given to " + hostInfo.username + ".");
				}
				_hostInfo = hostInfo;
			}
			IsHost = _hostInfo.id == TootTallyUser.userInfo.id;
			_lobbySettingButton.SetActive(IsHost);
			((Component)_startGameButton).gameObject.SetActive(IsHost);
			((Component)_selectSongButton).gameObject.SetActive(IsHost);
			((Component)_readyUpButton).gameObject.SetActive(!IsHost);
			_maxPlayerCount = lobbyInfo.maxPlayerCount;
			_maxPlayerText.text = $"{users.Count}/{_maxPlayerCount}";
			users.ForEach(DisplayUserInfo);
			UpdateScrolling(_userCardsDict.Count);
			_lastUsers = users;
			_titleText.text = lobbyInfo.title;
			_userCardsDict.Values.ToList().ForEach(delegate(MultiplayerCard item)
			{
				item.teamChanger.SetActive(lobbyInfo.teams);
			});
			_lobbySettingsInputPrompt.UpdateLobbyValues(lobbyInfo);
			((Component)_modifiersPopup.openPopupButton.button).gameObject.SetActive(lobbyInfo.freemod);
		}

		public void UpdateScrolling(int userCount)
		{
			bool flag = userCount > 6;
			if (!flag && ((Behaviour)_scrollingHandler).enabled)
			{
				_scrollingHandler.ResetAcceleration();
				_hiddenUserCardSlider.value = 0f;
			}
			((Behaviour)_scrollingHandler).enabled = flag;
			_scrollingHandler.accelerationMult = (flag ? (20f / (float)userCount) : 1f);
			((Behaviour)((Component)center.transform.Find("Left")).GetComponent<HorizontalLayoutGroup>()).enabled = !flag;
			if (_previousUserCount != 0f && _hiddenUserCardSlider.value != 0f && flag)
			{
				Slider hiddenUserCardSlider = _hiddenUserCardSlider;
				hiddenUserCardSlider.value *= _previousUserCount / (float)userCount;
			}
			_previousUserCount = userCount;
		}

		public void DisplayUserInfoDebug()
		{
			DisplayUserInfo(new MultSerializableClasses.MultiplayerUserInfo
			{
				id = TootTallyUser.userInfo.id + _userCardsDict.Count,
				rank = 69,
				username = "TestUser",
				state = "Ready"
			});
			UpdateScrolling(_userCardsDict.Count);
		}

		public void DisplayUserInfo(MultSerializableClasses.MultiplayerUserInfo user)
		{
			//IL_00a0: 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_00f3: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<MultSerializableClasses.UserState>(user.state, ignoreCase: false, out var result))
			{
				result = MultSerializableClasses.UserState.Unknown;
			}
			MultSerializableClasses.UserState userState = ((user.id == _hostInfo.id) ? MultSerializableClasses.UserState.Host : result);
			if (_userState == MultSerializableClasses.UserState.None && IsSelf(user.id))
			{
				OnUserStateChange(result);
			}
			MultiplayerCard multiplayerCard = MultiplayerGameObjectFactory.CreateUserCard(lobbyUserContainer.transform, controller);
			_userCardsDict.Add(user.id, multiplayerCard);
			GameObject imageHolder = GameObjectFactory.CreateClickableImageHolder(multiplayerCard.container, Vector2.zero, new Vector2(100f, 64f), AssetManager.GetSprite("icon.png"), "PFP", (Action)delegate
			{
				OnUserPFPClick(user);
			});
			imageHolder.transform.localPosition = new Vector3(-305f, 0f, 0f);
			imageHolder.transform.localScale = Vector2.op_Implicit(Vector2.one * 0.9f);
			imageHolder.transform.SetAsFirstSibling();
			AssetManager.GetProfilePictureByID(user.id, (Action<Sprite>)delegate(Sprite sprite)
			{
				imageHolder.GetComponent<Image>().sprite = sprite;
			});
			UpdateUserInfo(user);
		}

		public void UpdateUserInfo(MultSerializableClasses.MultiplayerUserInfo user)
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			if (_userCardsDict.ContainsKey(user.id))
			{
				MultiplayerCard multiplayerCard = _userCardsDict[user.id];
				MultSerializableClasses.UserState userState = ((multiplayerCard.user.id != 0) ? ((MultSerializableClasses.UserState)Enum.Parse(typeof(MultSerializableClasses.UserState), multiplayerCard.user.state)) : MultSerializableClasses.UserState.None);
				MultSerializableClasses.UserState userState2 = (MultSerializableClasses.UserState)Enum.Parse(typeof(MultSerializableClasses.UserState), user.state);
				MultSerializableClasses.UserState userState3 = ((user.id == _hostInfo.id) ? MultSerializableClasses.UserState.Host : userState2);
				string state = ((userState3 == MultSerializableClasses.UserState.Host && (user.state == "Ready" || user.state == "NotReady")) ? "Host" : user.state);
				if (_userState == MultSerializableClasses.UserState.None && IsSelf(user.id))
				{
					OnUserStateChange(userState2);
				}
				multiplayerCard.UpdateUserCard(user, state);
				((Selectable)multiplayerCard.teamChanger.gameObject.GetComponent<Button>()).interactable = IsSelf(user.id) || IsHost;
				_readyCount = _userCardsDict.Values.Where((MultiplayerCard x) => (x.user.state == "Ready" || x.user.state == "Spectating") && !IsSelf(x.user.id)).Count() + 1;
				Color val = UserStateToColor(userState3);
				GameObjectFactory.TintImage(((Component)multiplayerCard.container).GetComponent<Image>(), val, 0.2f);
				((Graphic)multiplayerCard.image).color = val;
				if (IsHost && !controller.IsTimerStarted)
				{
					SetHostButtonText();
				}
				UpdateScrolling(_userCardsDict.Count);
				if (IsSelf(user.id) && _isFreeMod)
				{
					SetOwnMods(user.mods);
				}
			}
		}

		public void UpdateMods(int id, string mods)
		{
			if (_userCardsDict.ContainsKey(id))
			{
				MultiplayerCard multiplayerCard = _userCardsDict[id];
				multiplayerCard.UpdateMods(mods);
				if (IsSelf(id) && _isFreeMod)
				{
					SetOwnMods(mods);
				}
			}
		}

		public void UpdateTeam(int id, int team)
		{
			if (_userCardsDict.ContainsKey(id))
			{
				MultiplayerCard multiplayerCard = _userCardsDict[id];
				multiplayerCard.UpdateTeamColor(team);
				((Selectable)multiplayerCard.teamChanger.gameObject.GetComponent<Button>()).interactable = IsSelf(id) || IsHost;
			}
		}

		private void SetOwnMods(string mods)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			GameModifierManager.LoadModifiersFromString(mods);
			List<Metadata> modifierSet = GameModifierManager.GetModifierSet(mods);
			foreach (Metadata key in _modifierButtonDict.Keys)
			{
				if (modifierSet.Contains(key))
				{
					_modifierButtonDict[key].ToggleOn();
				}
				else
				{
					_modifierButtonDict[key].ToggleOff();
				}
			}
		}

		public void OnQuickChatReceived(int userID, MultiplayerSystem.QuickChat chat)
		{
			if (_userCardsDict.ContainsKey(userID) && MultiplayerSystem.QuickChatToTextDic.ContainsKey(chat))
			{
				if (_hostInfo.id == userID)
				{
					MultiplayerLogger.HostLog(_userCardsDict[userID].user.username, MultiplayerSystem.QuickChatToTextDic[chat]);
				}
				else
				{
					MultiplayerLogger.UserLog(_userCardsDict[userID].user.username, MultiplayerSystem.QuickChatToTextDic[chat]);
				}
			}
		}

		public void OnSendQuickChatButtonClick(MultiplayerSystem.QuickChat chat)
		{
			if (IsQuickChatOpened && _canDoQuickChat)
			{
				DisableQuickChat(0.5f);
				controller.SendQuickChat(chat);
			}
		}

		public void OnSliderValueChangeScrollContainer(GameObject container, float value)
		{
			//IL_0009: 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_004c: 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_006e: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = container.GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(component.anchoredPosition.x, value * ((float)_userCardsDict.Count - 7f) * _posYJumpValue + _posYOffset);
			_lobbyContainerScrollingDistance.y = _lastLobbyContainerPosY - component.anchoredPosition.y;
			Transform transform = _dropdownMenu.transform;
			transform.localPosition -= _lobbyContainerScrollingDistance;
			_lastLobbyContainerPosY = component.anchoredPosition.y;
		}

		public void RemoveUserCard(int id)
		{
			_userCardsDict.Remove(id);
		}

		private Color UserStateToColor(MultSerializableClasses.UserState userState)
		{
			//IL_007c: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_0098: 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_00b4: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(userState switch
			{
				MultSerializableClasses.UserState.NoSong => new Color(0.95f, 0.2f, 0.2f, 1f), 
				MultSerializableClasses.UserState.NotReady => new Color(0.95f, 0.95f, 0.2f, 1f), 
				MultSerializableClasses.UserState.Ready => new Color(0.2f, 0.95f, 0.2f, 1f), 
				MultSerializableClasses.UserState.Host => new Color(0.95f, 0.2f, 0.95f, 1f), 
				MultSerializableClasses.UserState.Spectating => new Color(0f, 0f, 0.95f, 1f), 
				_ => new Color(0.95f, 0.95f, 0.95f, 1f), 
			});
		}

		private void OnUserPFPClick(MultSerializableClasses.MultiplayerUserInfo user)
		{
			//IL_0013: 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_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_004a: 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_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_0097: Unknown result type (might be due to invalid IL or missing references)
			_dropdownUserInfo = user;
			UpdateDropdown(user.id);
			Vector3 mousePosition = Input.mousePosition;
			mousePosition.z = 0f;
			_dropdownMenu.transform.position = mousePosition - new Vector3(1f, 1f, 0f) * 4f;
			_dropdownMenu.transform.localScale = Vector2.op_Implicit(Vector2.zero);
			_dropdownMenu.SetActive(true);
			TootTallyAnimation dropdownAnimation = _dropdownAnimation;
			if (dropdownAnimation != null)
			{
				dropdownAnimation.Dispose();
			}
			_dropdownAnimation = TootTallyAnimationManager.AddNewScaleAnimation(_dropdownMenu, Vector2.one, 0.6f, MultiplayerController.GetSecondDegreeAnimation(2.8f), (Action<GameObject>)null);
		}

		private void HideDropdown()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			TootTallyAnimation dropdownAnimation = _dropdownAnimation;
			if (dropdownAnimation != null)
			{
				dropdownAnimation.Dispose();
			}
			_dropdownAnimation = TootTallyAnimationManager.AddNewScaleAnimation(_dropdownMenu, Vector2.zero, 0.4f, MultiplayerController.GetSecondDegreeAnimationNoBounce(5f), (Action<GameObject>)delegate
			{
				_dropdownMenu.SetActive(false);
			});
		}

		private void UpdateDropdown(int userID)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			bool flag = IsSelf(userID);
			bool flag2 = (IsHost && !flag) || controller.IsDevMode;
			((Component)_kickButton).gameObject.SetActive(flag2);
			((Component)_giveHostButton).gameObject.SetActive(flag2);
			((Component)_banButton).gameObject.SetActive(flag2);
			_dropdownMenu.GetComponent<RectTransform>().sizeDelta = new Vector2(300f, (float)(flag2 ? 240 : 60));
		}

		private bool IsSelf(int userID)
		{
			return TootTallyUser.userInfo.id == userID;
		}

		public void ClearAllUserRows()
		{
			CollectionExtensions.Do<MultiplayerCard>((IEnumerable<MultiplayerCard>)_userCardsDict.Values, (Action<MultiplayerCard>)delegate(MultiplayerCard x)
			{
				Object.DestroyImmediate((Object)(object)((Component)x).gameObject);
			});
			_userCardsDict.Clear();
		}

		public void OnReadyButtonClick()
		{
			if (_canPressButton)
			{
				if (_userState == MultSerializableClasses.UserState.Playing)
				{
					_userState = MultSerializableClasses.UserState.NotReady;
					OnUserStateChange(_userState);
				}
				switch (_userState)
				{
				case MultSerializableClasses.UserState.NotReady:
					controller.SendUserState(MultSerializableClasses.UserState.Ready);
					DisableButton(0.8f);
					break;
				case MultSerializableClasses.UserState.Ready:
					controller.SendUserState(MultSerializableClasses.UserState.NotReady);
					DisableButton(0.8f);
					break;
				default:
					TootTallyNotifManager.DisplayNotif($"Cannot ready up when userstate is {_userState}", 6f);
					break;
				}
			}
		}

		public void OnDownloadButtonClick()
		{
			if (_canPressButton && _isDownloadable && !controller.IsDownloadPending)
			{
				((Component)_downloadButton).gameObject.SetActive(false);
				controller.DownloadSavedChart(_downloadProgressBar);
			}
		}

		public void SetHostButtonText()
		{
			int num = (from x in _userCardsDict.Values
				select x.user into x
				where x.state != "Spectating"
				select x).Count();
			if (IsHost)
			{
				if (IsGameRunning)
				{
					_startGameButton.textHolder.text = "Abort Game";
				}
				else if (_readyCount >= num)
				{
					_startGameButton.textHolder.text = "Start Game";
				}
				else
				{
					_startGameButton.textHolder.text = $"{_readyCount}/{num} Force Start";
				}
			}
		}

		public void OnBackButtonClick()
		{
			if (!controller.IsTransitioning)
			{
				ClearAllUserRows();
				controller.DisconnectFromLobby();
				_userState = MultSerializableClasses.UserState.None;
			}
		}

		public void OnSelectSongButtonClick()
		{
			if (_canPressButton)
			{
				_quickChatPopup.OnCloseAnimation();
				_modifiersPopup.OnCloseAnimation();
				_lobbySettingsInputPrompt.Hide(animate: false);
				controller.TransitionToSongSelection();
			}
		}

		public void OnStartGameButtonClick()
		{
			DisableButton(0.5f);
			controller.StartLobbyGame();
		}

		public void OnKickUserButtonClick()
		{
			HideDropdown();
			Plugin.LogInfo($"Attempting to kick {_dropdownUserInfo.username} (ID:{_dropdownUserInfo.id})");
			controller.KickUserFromLobby(_dropdownUserInfo.id);
			controller.RefreshCurrentLobbyInfo();
		}

		public void OnTitleTextClickOpenSongLink()
		{
			controller.OpenSongLink();
		}

		public void OnBanButtonClick()
		{
			HideDropdown();
			Plugin.LogInfo($"Attempting to ban {_dropdownUserInfo.username} (ID:{_dropdownUserInfo.id})");
			controller.BanUserFromLobby(_dropdownUserInfo.id);
			controller.RefreshCurrentLobbyInfo();
		}

		public void OnProfileButtonClick()
		{
			HideDropdown();
			Application.OpenURL($"https://toottally.com/profile/{_dropdownUserInfo.id}");
		}

		public void OnTimerStart()
		{
			DisableButton();
			if (IsHost)
			{
				_startGameButton.textHolder.text = "Abort Timer";
			}
		}

		public void OnTimerAbort()
		{
			EnableButton();
			if (IsHost)
			{
				SetHostButtonText();
			}
		}

		public void OnGiveHostButtonClick()
		{
			HideDropdown();
			if (_canPressButton)
			{
				_userState = MultSerializableClasses.UserState.None;
				controller.GiveHostUser(_dropdownUserInfo.id);
				controller.RefreshCurrentLobbyInfo();
			}
		}

		public void OnSongInfoChanged(string songName, float gamespeed, string modifiers, float difficulty, bool isRated)
		{
			_savedGameSpeed = gamespeed;
			_songNameText.text = songName;
			_gameSpeedText.text = $" <b>{gamespeed:0.00}x</b>";
			_modifiersText.text = "M <b>" + modifiers + "</b>";
			_ratingText.text = $" <b>{difficulty:0.00}</b>";
			((Behaviour)_ratedIcon).enabled = isRated;
			((Component)_startGameButton).gameObject.SetActive(IsHost && !controller.IsDownloadPending);
			((Component)_downloadButton).gameObject.SetActive(!controller.IsDownloadPending && _isDownloadable);
			((Component)_readyUpButton).gameObject.SetActive(!IsHost);
		}

		public void OnSongInfoChanged(MultSerializableClasses.MultiplayerSongInfo songInfo)
		{
			OnSongInfoChanged(songInfo.songName, songInfo.gameSpeed, songInfo.modifiers, songInfo.difficulty, songInfo.isRated);
		}

		public void SetTrackDataDetails(SingleTrackData trackData, bool isDownloadable = false)
		{
			_isDownloadable = isDownloadable;
			_songArtistText.text = trackData.artist ?? "";
			_songDescText.text = trackData.desc ?? "";
			if (_savedGameSpeed == 0f)
			{
				_savedGameSpeed = 1f;
			}
			_bpmText.text = $" <b>{(float)trackData.tempo * _savedGameSpeed}</b>";
			TimeSpan timeSpan = TimeSpan.FromSeconds((float)trackData.length / _savedGameSpeed);
			string text = string.Format("{0}{1}:{2:00}", (timeSpan.Hours != 0) ? (timeSpan.Hours + ":") : "", (timeSpan.Minutes != 0) ? ((object)timeSpan.Minutes) : "0", (timeSpan.Seconds != 0) ? ((object)timeSpan.Seconds) : "00");
			_timeText.text = " <b>" + text + "</b>";
			((Component)_downloadButton).gameObject.SetActive(!controller.IsDownloadPending && _isDownloadable);
			((Component)_readyUpButton).gameObject.SetActive(!IsHost);
		}

		public void SetNullTrackDataDetails(bool isDownloadable)
		{
			_isDownloadable = isDownloadable;
			((Component)_readyUpButton).gameObject.SetActive(isDownloadable);
			((Component)_startGameButton).gameObject.SetActive(false);
			((Behaviour)_ratedIcon).enabled = false;
			_ratingText.text = "-";
			_songNameText.text = "-";
			_songArtistText.text = "-";
			_songDescText.text = "-";
			_bpmText.text = " -";
			_timeText.text = " -";
		}

		public void OnUserStateChange(MultSerializableClasses.UserState state)
		{
			_userState = state;
			switch (state)
			{
			case MultSerializableClasses.UserState.NoSong:
				((Component)_readyUpButton).gameObject.SetActive(false);
				((Component)_downloadButton).gameObject.SetActive(!controller.IsDownloadPending && _isDownloadable);
				_downloadButton.textHolder.text = "Download Chart";
				break;
			case MultSerializableClasses.UserState.NotReady:
				((Component)_readyUpButton).gameObject.SetActive(!IsHost);
				_readyUpButton.textHolder.text = "Ready Up";
				_downloadButton.textHolder.text = "Update Chart";
				break;
			case MultSerializableClasses.UserState.Ready:
				((Component)_readyUpButton).gameObject.SetActive(!IsHost);
				_readyUpButton.textHolder.text = "Not Ready";
				_downloadButton.textHolder.text = "Update Chart";
				break;
			case MultSerializableClasses.UserState.Spectating:
				((Component)_readyUpButton).gameObject.SetActive(false);
				((Component)_downloadButton).gameObject.SetActive(!controller.IsDownloadPending && _isDownloadable);
				_downloadButton.textHolder.text = "Download Chart";
				break;
			}
		}

		public void CloseQuickChat()
		{
			_quickChatPopup.OnCloseAnimation();
		}

		private void DisableButton(float delay)
		{
			_canPressButton = false;
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)DelayAllowButtonClick(delay));
		}

		private void DisableQuickChat(float delay)
		{
			_canDoQuickChat = false;
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)DelayAllowQuickChat(delay));
		}

		public void DisableButton()
		{
			_canPressButton = false;
		}

		public void EnableButton()
		{
			_canPressButton = true;
		}

		private IEnumerator<WaitForSeconds> DelayAllowButtonClick(float delay)
		{
			yield return new WaitForSeconds(delay);
			AllowButtonClick();
		}

		private IEnumerator<WaitForSeconds> DelayAllowQuickChat(float delay)
		{
			yield return new WaitForSeconds(delay);
			AllowQuickChat();
		}

		public void AllowQuickChat()
		{
			_canDoQuickChat = true;
		}

		private static string ColorText(string text, Color color)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorUtility.ToHtmlStringRGBA(color) + ">" + text + "</color>";
		}

		private void UpdateLogText(string text)
		{
			_lobbyLogText.text = text;
		}

		private void AllowButtonClick()
		{
			_canPressButton = true;
		}
	}
	public class MultiplayerMainPanel : MultiplayerPanelBase
	{
		public GameObject lobbyListContainer;

		public GameObject lobbyInfoContainer;

		public GameObject searchPanel;

		public GameObject searchLeft;

		public GameObject searchCenter;

		public GameObject searchRight;

		private GameObject _currentInputPrompt;

		private List<GameObject> _lobbyInfoRowsList;

		private ConcurrentDictionary<string, int> _savedCodeToPing;

		private string _lastSelectedLobbyID;

		private Slider _slider;

		private ScrollableSliderHandler _scrollingHandler;

		private static Entry _pointerExitLobbyContainerEvent;

		private TMP_Text _lobbyPlayerListText;

		private TMP_Text _noLobbyText;

		private TMP_InputField _searchInputField;

		private static CustomButton _connectButton;

		private static CustomButton _createLobbyButton;

		private static CustomButton _refreshLobbyButton;

		private static CustomButton _shutdownButton;

		private static CustomButton _forceConnectButton;

		private static TootTallyAnimation _connectButtonScaleAnimation;

		private static MultSerializableClasses.MultiplayerLobbyInfo _selectedLobby;

		private static GameObject _hoveredLobbyContainer;

		private static GameObject _selectedLobbyContainer;

		private static float _previousLobbyCount;

		private bool debugPassword;

		private float _posYJumpValue = 125f;

		private float _posYOffset;

		private string _hoverLobbyID;

		public MultiplayerMainPanel(GameObject canvas, MultiplayerController controller)
			: base(canvas, controller, "MainLayout")
		{
			//IL_00ed: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Expected O, but got Unknown
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			searchPanel = ((Component)panel.transform.Find("Search")).gameObject;
			searchLeft = ((Component)searchPanel.transform.GetChild(0)).gameObject;
			searchCenter = ((Component)searchPanel.transform.GetChild(1)).gameObject;
			searchRight = ((Component)searchPanel.transform.GetChild(2)).gameObject;
			lobbyListContainer = ((Component)center.transform.Find("Left/LobbyContainer")).gameObject;
			lobbyInfoContainer = ((Component)center.transform.Find("Right/InfoContainer")).gameObject;
			_lobbyInfoRowsList = new List<GameObject>();
			_savedCodeToPing = new ConcurrentDictionary<string, int>();
			GameObjectFactory.CreateClickableImageHolder(headerLeft.transform, Vector2.zero, new Vector2(72f, 72f), AssetManager.GetSprite("gtfo.png"), "LobbyBackButton", (Action)MultiplayerManager.ExitMultiplayer);
			TMP_Text val = GameObjectFactory.CreateSingleText(headerCenter.transform, "TitleText", "TootTally Multiplayer", (TextFont)0);
			val.enableAutoSizing = true;
			TMP_Text val2 = GameObjectFactory.CreateSingleText(headerRight.transform, "ServerText", "Server: Toronto", (TextFont)0);
			val2.fontSize = 40f;
			HorizontalLayoutGroup component = searchLeft.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)component).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = (((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false);
			((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			((LayoutGroup)component).padding = new RectOffset(-12, 0, 0, 0);
			TMP_Text val3 = GameObjectFactory.CreateSingleText(searchLeft.transform, "SearchText", "Search:", (TextFont)0);
			val3.alignment = (TextAlignmentOptions)4100;
			val3.rectTransform.sizeDelta = new Vector2(90f, 30f);
			_searchInputField = MultiplayerGameObjectFactory.CreateInputField(searchLeft.transform, "SearchInput", new Vector2(350f, 36f), 24f, "", isPassword: false);
			((UnityEvent<string>)(object)_searchInputField.onValueChanged).AddListener((UnityAction<string>)controller.UpdateSearchFilter);
			_slider = new GameObject("ContainerSlider", new Type[1] { typeof(Slider) }).GetComponent<Slider>();
			((Component)_slider).gameObject.SetActive(true);
			((UnityEvent<float>)(object)_slider.onValueChanged).AddListener((UnityAction<float>)OnSliderValueChangeScrollContainer);
			_scrollingHandler = ((Component)_slider).gameObject.AddComponent<ScrollableSliderHandler>();
			((Behaviour)_scrollingHandler).enabled = false;
			_lobbyPlayerListText = GameObjectFactory.CreateSingleText(lobbyInfoContainer.transform, "LobbyDetailInfoText", "", (TextFont)0);
			_lobbyPlayerListText.rectTransform.sizeDelta = new Vector2(0f, 620f);
			_lobbyPlayerListText.enableAutoSizing = true;
			_lobbyPlayerListText.fontSizeMax = 32f;
			_lobbyPlayerListText.alignment = (TextAlignmentOptions)257;
			_pointerExitLobbyContainerEvent = new Entry();
			_pointerExitLobbyContainerEvent.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)_pointerExitLobbyContainerEvent.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				OnMouseExitClearLobbyDetails();
			});
			_noLobbyText = GameObjectFactory.CreateSingleText(lobbyListContainer.transform, "NoLobbyText", "No lobby found.\nTry creating your own lobby!", (TextFont)0);
			_noLobbyText.rectTransform.sizeDelta = Vector2.one * 200f;
			_noLobbyText.fontSize = 32f;
			((Graphic)_noLobbyText).color = new Color(1f, 1f, 1f, 0.5f);
			_createLobbyButton = GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Create", "LobbyCreateButton", (Action)OnCreateLobbyButtonClick);
			_refreshLobbyButton = GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Refresh", "RefreshLobbyButton", (Action)OnRefreshLobbyButtonClick);
			_connectButton = GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Connect", "LobbyConnectButton", (Action)OnConnectButtonClick);
			((Component)_connectButton).gameObject.SetActive(false);
			if (controller.IsDevMode)
			{
				EnableDevMode();
			}
		}

		private void EnableDevMode()
		{
			//IL_000b: 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_004a: 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)
			_forceConnectButton = GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Force Connect", "FCButton", (Action)OnForceConnectButtonClick);
			_shutdownButton = GameObjectFactory.CreateCustomButton(footer.transform, Vector2.zero, new Vector2(150f, 75f), "Shutdown", "SDButton", (Action)OnShutdownButtonClick);
			ToggleEnableDevButtons(isEnabled: false);
		}

		private void ToggleEnableDevButtons(bool isEnabled)
		{
			if (controller.IsDevMode)
			{
				((Behaviour)_forceConnectButton.button).enabled = isEnabled;
				((Behaviour)_shutdownButton.button).enabled = isEnabled;
			}
		}

		public void DisplayLobbyDebug()
		{
			MultiplayerManager.StopRecursiveRefresh();
			DisplayLobby(new MultSerializableClasses.MultiplayerLobbyInfo
			{
				id = "AAAAA",
				maxPlayerCount = 16,
				players = new List<MultSerializableClasses.MultiplayerUserInfo>(),
				songInfo = default(MultSerializableClasses.MultiplayerSongInfo),
				state = "SelectingSong",
				title = $"TEST LOBBY{Random.Range(1, 200)}",
				hasPassword = debugPassword
			}, shouldAnimate: true);
			debugPassword = !debugPassword;
			UpdateScrolling(_lobbyInfoRowsList.Count);
			((Component)_noLobbyText).gameObject.SetActive(false);
		}

		public void ShowServerDownText()
		{
			((Component)_noLobbyText).gameObject.SetActive(true);
			_noLobbyText.text = "Server is currently under maintenance.\nTry again later.";
			ClearLobbyDetailsText();
		}

		public void ShowNoLobbyText()
		{
			((Component)_noLobbyText).gameObject.SetActive(true);
			_noLobbyText.text = "No lobby found.\nTry creating your own lobby!";
			ClearLobbyDetailsText();
		}

		public void SetupForLobbyDisplay()
		{
			_selectedLobby.code = "";
			((Component)_noLobbyText).gameObject.SetActive(false);
		}

		public void FinalizeLobbyDisplay()
		{
			if (_selectedLobby.code == "" && (Object)(object)_currentInputPrompt != (Object)null)
			{
				DestroyInputPrompt();
			}
		}

		public void DisplayLobby(MultSerializableClasses.MultiplayerLobbyInfo lobbyinfo)
		{
			DisplayLobby(lobbyinfo, shouldAnimate: true);
		}

		public void DisplayLobby(MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo, bool shouldAnimate)
		{
			//IL_001f: 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_006d: Expected O, but got Unknown
			//IL_006f: 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_009d: Expected O, but got Unknown
			//IL_009f: 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_01dc: 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_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Expected O, but got Unknown
			GameObject lobbyContainer = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 120f), lobbyListContainer.transform);
			((Behaviour)lobbyContainer.GetComponent<Image>()).enabled = true;
			_lobbyInfoRowsList.Add(lobbyContainer);
			EventTrigger val = lobbyContainer.AddComponent<EventTrigger>();
			Entry val2 = new Entry();
			val2.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				OnMouseEnterDisplayLobbyDetails(lobbyInfo, lobbyContainer);
			});
			val.triggers.Add(val2);
			Entry val3 = new Entry();
			val3.eventID = (EventTriggerType)4;
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				OnMouseClickSelectLobby(lobbyInfo, lobbyContainer, animateConnect: true);
			});
			val.triggers.Add(val3);
			val.triggers.Add(_pointerExitLobbyContainerEvent);
			GameObject verticalBox = GameModifierFactory.GetVerticalBox(new Vector2((float)(lobbyInfo.hasPassword ? 1020 : 1084), 0f), lobbyContainer.transform);
			VerticalLayoutGroup component = verticalBox.GetComponent<VerticalLayoutGroup>();
			bool childForceExpandHeight = (((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true);
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = childForceExpandHeight;
			TMP_Text val4 = GameObjectFactory.CreateSingleText(verticalBox.transform, "LobbyName", lobbyInfo.title, (TextFont)0);
			val4.fontStyle = (FontStyles)1;
			val4.fontSize = 28f;
			TMP_Text val5 = GameObjectFactory.CreateSingleText(verticalBox.transform, "LobbyState", lobbyInfo.state, (TextFont)0);
			if (lobbyInfo.state == "Playing")
			{
				val5.text = val5.text + ": " + lobbyInfo.songInfo.songShortName;
			}
			val5.fontSizeMax = 36f;
			val5.fontSizeMin = 18f;
			TextAlignmentOptions alignment = (TextAlignmentOptions)513;
			val5.alignment = (TextAlignmentOptions)513;
			val4.alignment = alignment;
			GameObject val6 = GameObjectFactory.CreateImageHolder(lobbyContainer.transform, Vector2.zero, Vector2.one * 64f, AssetManager.GetSprite("lock.png"), "LockedLobbyIcon");
			val6.SetActive(lobbyInfo.hasPassword);
			GameObject verticalBox2 = GameModifierFactory.GetVerticalBox(new Vector2(90f, 0f), lobbyContainer.transform);
			VerticalLayoutGroup component2 = verticalBox2.GetComponent<VerticalLayoutGroup>();
			childForceExpandHeight = (((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true);
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = childForceExpandHeight;
			TMP_Text val7 = GameObjectFactory.CreateSingleText(verticalBox2.transform, "LobbyCount", $"{lobbyInfo.players.Count}/{lobbyInfo.maxPlayerCount}", (TextFont)0);
			val7.fontSize = 32f;
			val7.fontStyle = (FontStyles)1;
			TMP_Text t4 = GameObjectFactory.CreateSingleText(verticalBox2.transform, "LobbyPing", "-ms", (TextFont)0);
			TMP_Text obj = t4;
			alignment = (TextAlignmentOptions)516;
			obj.alignment = (TextAlignmentOptions)516;
			val7.alignment = alignment;
			if (shouldAnimate)
			{
				lobbyContainer.transform.eulerAngles = new Vector3(270f, 0f, 0f);
				TootTallyAnimationManager.AddNewEulerAngleAnimation(lobbyContainer, Vector3.zero, 2f, new SecondDegreeDynamicsAnimation(1.25f, 1f, 1f), (Action<GameObject>)null);
			}
			if (_lastSelectedLobbyID == lobbyInfo.id)
			{
				OnMouseClickSelectLobby(lobbyInfo, lobbyContainer, animateConnect: false);
			}
			if (_savedCodeToPing.ContainsKey(lobbyInfo.id))
			{
				t4.text = $"{_savedCodeToPing[lobbyInfo.id]}ms";
				return;
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)SendPing("68.183.206.69", delegate(int ping)
			{
				if (!_savedCodeToPing.TryAdd(lobbyInfo.id, ping))
				{
					Plugin.LogInfo("Server ID " + lobbyInfo.id + " was already pinged.");
				}
				t4.text = $"{ping}ms";
			}));
		}

		private static IEnumerator<WaitForSeconds> SendPing(string address, Action<int> callback)
		{
			WaitForSeconds waitTime = new WaitForSeconds(0.01f);
			Ping pingSender = new Ping(address);
			while (!pingSender.isDone)
			{
				yield return waitTime;
			}
			callback(pingSender.time);
		}

		public void OnSliderValueChangeScrollContainer(float value)
		{
			//IL_000e: 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)
			RectTransform component = lobbyListContainer.GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(component.anchoredPosition.x, value * ((float)_lobbyInfoRowsList.Count - 5f) * _posYJumpValue + _posYOffset);
		}

		public void UpdateScrolling(int lobbyCount)
		{
			bool flag = lobbyCount > 4;
			if (!flag && ((Behaviour)_scrollingHandler).enabled)
			{
				_scrollingHandler.ResetAcceleration();
				_slider.value = 0f;
			}
			((Behaviour)_scrollingHandler).enabled = flag;
			((Behaviour)((Component)center.transform.Find("Left")).GetComponent<HorizontalLayoutGroup>()).enabled = !flag;
			_scrollingHandler.accelerationMult = (flag ? (16f / (float)lobbyCount) : 1f);
			if (_previousLobbyCount != 0f && _slider.value != 0f && flag)
			{
				Slider slider = _slider;
				slider.value *= _previousLobbyCount / (float)lobbyCount;
			}
			_previousLobbyCount = lobbyCount;
		}

		public void OnMouseEnterDisplayLobbyDetails(MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo, GameObject lobbyContainer)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			_lobbyPlayerListText.text = "<u>Player List</u>\n";
			lobbyInfo.players.ForEach(delegate(MultSerializableClasses.MultiplayerUserInfo u)
			{
				TMP_Text lobbyPlayerListText = _lobbyPlayerListText;
				lobbyPlayerListText.text = lobbyPlayerListText.text + u.username + "\n";
			});
			if (((Object)(object)_selectedLobbyContainer == (Object)null || (Object)(object)_hoveredLobbyContainer != (Object)(object)lobbyContainer) && (Object)(object)lobbyContainer != (Object)(object)_selectedLobbyContainer)
			{
				if (_hoverLobbyID != lobbyInfo.id && (_selectedLobby.code == "" || _hoverLobbyID != _selectedLobby.id))
				{
					controller.GetInstance.sfx_hover.Play();
				}
				_hoveredLobbyContainer = lobbyContainer;
				_hoverLobbyID = lobbyInfo.id;
				((Graphic)_hoveredLobbyContainer.GetComponent<Image>()).color = new Color(0.15f, 0.15f, 0.15f, 0.58f);
			}
		}

		public void OnMouseExitClearLobbyDetails()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (_selectedLobby.code != "")
			{
				OnMouseEnterDisplayLobbyDetails(_selectedLobby, _selectedLobbyContainer);
			}
			else
			{
				ClearLobbyDetailsText();
			}
			if ((Object)(object)_hoveredLobbyContainer != (Object)null)
			{
				((Graphic)_hoveredLobbyContainer.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.58f);
			}
			_hoverLobbyID = "";
			_hoveredLobbyContainer = null;
		}

		public void ClearLobbyDetailsText()
		{
			_lobbyPlayerListText.text = "-";
		}

		public void OnMouseClickSelectLobby(MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo, GameObject lobbyContainer, bool animateConnect)
		{
			//IL_0083: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			if (_selectedLobby.code == lobbyInfo.code)
			{
				return;
			}
			if ((Object)(object)_selectedLobbyContainer != (Object)null)
			{
				((Graphic)_selectedLobbyContainer.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.58f);
			}
			_selectedLobby = lobbyInfo;
			_lastSelectedLobbyID = lobbyInfo.id;
			_selectedLobbyContainer = lobbyContainer;
			((Graphic)_selectedLobbyContainer.GetComponent<Image>()).color = new Color(0f, 0.35f, 0f, 0.58f);
			_hoveredLobbyContainer = null;
			TootTallyAnimation connectButtonScaleAnimation = _connectButtonScaleAnimation;
			if (connectButtonScaleAnimation != null)
			{
				connectButtonScaleAnimation.Dispose();
			}
			ToggleEnableDevButtons(isEnabled: true);
			if (lobbyInfo.players.Count < lobbyInfo.maxPlayerCount)
			{
				((Component)_connectButton).gameObject.SetActive(true);
				((Component)_connectButton).gameObject.GetComponent<RectTransform>().pivot = Vector2.one / 2f;
				if (animateConnect)
				{
					((Component)_connectButton).transform.localScale = Vector2.op_Implicit(Vector2.zero);
					_connectButtonScaleAnimation = TootTallyAnimationManager.AddNewScaleAnimation(((Component)_connectButton).gameObject, Vector3.one, 1f, new SecondDegreeDynamicsAnimation(2.5f, 0.98f, 1.1f), (Action<GameObject>)null);
					controller.GetInstance.sfx_hover.Play();
				}
				else
				{
					((Component)_connectButton).transform.localScale = Vector3.one;
				}
			}
		}

		public void OnShutdownButtonClick()
		{
			if (!(_selectedLobby.code == "") && controller.IsDevMode)
			{
				Plugin.LogInfo("Shutting down lobby " + _selectedLobby.code);
				TootTallyNotifManager.DisplayNotif("Shutting down lobby " + _selectedLobby.code, 6f);
				((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.ShutdownMultiplayerServer(_selectedLobby.code, controller.RefreshAllLobbyInfo));
			}
		}

		public void ClearAllLobby()
		{
			_selectedLobby.code = "";
			_selectedLobbyContainer = null;
			_hoveredLobbyContainer = null;
			((Component)_connectButton).gameObject.SetActive(false);
			ToggleEnableDevButtons(isEnabled: false);
			_lobbyInfoRowsList.ForEach((Action<GameObject>)Object.DestroyImmediate);
			_lobbyInfoRowsList.Clear();
		}

		public void OnCreateLobbyButtonClick()
		{
			((Behaviour)_scrollingHandler).enabled = false;
			MultiplayerManager.UpdateMultiplayerState(MultiplayerController.MultiplayerState.CreatingLobby);
			controller.MoveToCreate();
		}

		public void OnConnectButtonClick()
		{
			if (!(_selectedLobby.code == ""))
			{
				if (_selectedLobby.hasPassword)
				{
					ShowPasswordInputPrompt();
				}
				else
				{
					controller.ConnectToLobby(_selectedLobby.code);
				}
			}
		}

		public void OnForceConnectButtonClick()
		{
			if (!(_selectedLobby.code == "") && controller.IsDevMode)
			{
				controller.ConnectToLobby(_selectedLobby.code, "", forceEntry: true);
			}
		}

		public void ShowPasswordInputPrompt()
		{
			_currentInputPrompt = MultiplayerGameObjectFactory.CreatePasswordInputPrompt(canvas.transform, "Enter lobby password", OnConfirmPasswordInputPrompt, OnCancelInputPrompt);
		}

		public void OnConfirmPasswordInputPrompt(string password)
		{
			controller.ConnectToLobby(_selectedLobby.code, password);
		}

		public void OnCancelInputPrompt()
		{
			if (!controller.IsConnectionPending)
			{
				DestroyInputPrompt();
			}
		}

		public void DestroyInputPrompt()
		{
			Object.DestroyImmediate((Object)(object)_currentInputPrompt);
			_currentInputPrompt = null;
		}

		public void OnLobbyConnectSuccess()
		{
			if ((Object)(object)_currentInputPrompt != (Object)null)
			{
				DestroyInputPrompt();
			}
			_lastSelectedLobbyID = null;
			_selectedLobby.code = "";
		}

		public void OnLobbyDisconnectError()
		{
			if ((Object)(object)_currentInputPrompt != (Object)null)
			{
				TootTallyNotifManager.DisplayNotif("Password is incorrect.", 6f);
				DestroyInputPrompt();
			}
			else
			{
				TootTallyNotifManager.DisplayNotif("Unexpected error occured.", 6f);
			}
		}

		public void OnRefreshLobbyButtonClick()
		{
			((Behaviour)_refreshLobbyButton.button).enabled = false;
			controller.RefreshAllLobbyInfo();
		}

		public void ShowRefreshLobbyButton()
		{
			((Behaviour)_refreshLobbyButton.button).enabled = true;
		}
	}
	public abstract class MultiplayerPanelBase
	{
		public MultiplayerController controller;

		public GameObject canvas;

		public GameObject panel;

		public GameObject header;

		public GameObject center;

		public GameObject footer;

		public GameObject headerLeft;

		public GameObject headerCenter;

		public GameObject headerRight;

		public Vector2 GetPanelPosition => panel.GetComponent<RectTransform>().anchoredPosition;

		public MultiplayerPanelBase(GameObject canvas, MultiplayerController controller, string name)
		{
			this.canvas = canvas;
			this.controller = controller;
			panel = ((Component)canvas.transform.Find(name ?? "")).gameObject;
			header = ((Component)panel.transform.Find("Header")).gameObject;
			headerLeft = ((Component)header.transform.GetChild(0)).gameObject;
			headerCenter = ((Component)header.transform.GetChild(1)).gameObject;
			headerRight = ((Component)header.transform.GetChild(2)).gameObject;
			center = ((Component)panel.transform.Find("Center")).gameObject;
			footer = ((Component)panel.transform.Find("Footer")).gameObject;
		}
	}
}
namespace TootTallyMultiplayer.MultiplayerCore
{
	public class MultiplayerLiveScore : MonoBehaviour
	{
		private MultiplayerLiveScoreController _controller;

		private TMP_Text _positionText;

		private TMP_Text _nameText;

		private TMP_Text _scoreText;

		private TMP_Text _comboText;

		private TootTallyAnimation _positionAnimation;

		private GameObject _rainbowMask;

		private Image _rainbow1;

		private Image _rainbow2;

		private Image _outlineImage;

		private RectTransform _rainbowMaskRect;

		private CanvasGroup _canvasGroup;

		private int _lastTween;

		private int _id;

		private string _name;

		private int _score;

		private int _health;

		private int _combo;

		private int _position;

		private int _count;

		private bool _hasQuit;

		private int _previousHealth;

		private bool _IsSelf => _id == TootTallyUser.userInfo.id;

		public int GetScore => _score;

		public void Initialize(int id, string name, MultiplayerLiveScoreController controller)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			_hasQuit = false;
			_id = id;
			if (_IsSelf)
			{
				((Graphic)_outlineImage).color = new Color(0.95f, 0.2f, 0.95f, 0.5f);
			}
			_name = name;
			_controller = controller;
		}

		public void Awake()
		{
			//IL_005e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00e6: 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_00ee: 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_0152: 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_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			_lastTween = 0;
			Transform child = ((Component)this).transform.GetChild(0);
			_rainbowMask = ((Component)child.Find("Mask")).gameObject;
			_rainbowMaskRect = _rainbowMask.GetComponent<RectTransform>();
			RectTransform rainbowMaskRect = _rainbowMaskRect;
			RectTransform rainbowMaskRect2 = _rainbowMaskRect;
			RectTransform rainbowMaskRect3 = _rainbowMaskRect;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			rainbowMaskRect3.pivot = val;
			Vector2 anchorMin = (rainbowMaskRect2.anchorMax = val);
			rainbowMaskRect.anchorMin = anchorMin;
			_canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
			_outlineImage = ((Component)this).GetComponent<Image>();
			GameObject val3 = GameObjectFactory.CreateImageHolder(_rainbowMask.transform, Vector2.zero, new Vector2(180f, 60f), AssetManager.GetSprite("rainbow.png"), "Rainbow1");
			RectTransform component = val3.GetComponent<RectTransform>();
			((Vector2)(ref val))..ctor(0f, 1f);
			component.pivot = val;
			anchorMin = (component.anchorMax = val);
			component.anchorMin = anchorMin;
			val3.transform.localPosition = new Vector3(-180f, 0f, 10f);
			val3.AddComponent<LayoutElement>().ignoreLayout = true;
			_rainbow1 = val3.GetComponent<Image>();
			_rainbow1.preserveAspect = false;
			((Graphic)_rainbow1).color = new Color(1f, 1f, 1f, 0.25f);
			GameObject val5 = Object.Instantiate<GameObject>(val3, _rainbowMask.transform);
			((Object)val5).name = "Rainbow2";
			val5.transform.localPosition = new Vector3(0f, 0f, 10f);
			_rainbow2 = val5.GetComponent<Image>();
			LeanTween.moveLocalX(val3, 0f, 2f).setLoopClamp();
			LeanTween.moveLocalX(val5, 180f, 2f).setLoopClamp();
			_positionText = GameObjectFactory.CreateSingleText(child, "Position", "#-", (TextFont)0);
			_positionText.rectTransform.sizeDelta = new Vector2(18f, 0f);
			_nameText = GameObjectFactory.CreateSingleText(child, "Name", "Unknown", (TextFont)0);
			_nameText.rectTransform.sizeDelta = new Vector2(66f, 0f);
			GameObject verticalBox = GameModifierFactory.GetVerticalBox(new Vector2(60f, 0f), child);
			((Behaviour)verticalBox.GetComponent<Image>()).enabled = false;
			VerticalLayoutGroup component2 = verticalBox.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			_scoreText = GameObjectFactory.CreateSingleText(verticalBox.transform, "Score", "-", (TextFont)0);
			_scoreText.rectTransform.sizeDelta = new Vector2(0f, 12f);
			_comboText = GameObjectFactory.CreateSingleText(verticalBox.transform, "Combo", "-", (TextFont)0);
			_comboText.rectTransform.sizeDelta = new Vector2(0f, 4f);
			SetTextProperties(_positionText, _nameText, _scoreText, _comboText);
			TMP_Text positionText = _positionText;
			TMP_Text nameText = _nameText;
			TextAlignmentOptions alignment = (TextAlignmentOptions)513;
			nameText.alignment = (TextAlignmentOptions)513;
			positionText.alignment = alignment;
			TMP_Text positionText2 = _positionText;
			bool enableAutoSizing = (_comboText.enableAutoSizing = false);
			positionText2.enableAutoSizing = enableAutoSizing;
			_positionText.fontSize = 14f;
			_comboText.fontSize = 8f;
		}

		public void UpdateScore(int score, int combo, int health)
		{
			//IL_002e: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			_score = score;
			_combo = combo;
			_health = health;
			_rainbowMaskRect.sizeDelta = new Vector2(160f * ((float)health / 100f), 28f);
			if (_previousHealth != _health && (_previousHealth == 100 || _health == 100))
			{
				Image rainbow = _rainbow1;
				Image rainbow2 = _rainbow2;
				Color color = default(Color);
				((Color)(ref color))..ctor(1f, 1f, 1f, (health == 100) ? 0.85f : 0.25f);
				((Graphic)rainbow2).color = color;
				((Graphic)rainbow).color = color;
			}
			_previousHealth = health;
			_nameText.text = _name;
			_scoreText.text = _score.ToString();
			_comboText.text = $"{_combo}x";
		}

		public void SetPosition(int position, int count)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (_position != position || _count != count)
			{
				TootTallyAnimation positionAnimation = _positionAnimation;
				if (positionAnimation != null)
				{
					positionAnimation.Dispose();
				}
				_positionAnimation = TootTallyAnimationManager.AddNewPositionAnimation(((Component)this).gameObject, new Vector3(0f, (float)(32 * (count - position))), 1f, GetSecondDegreeAnimation(1.5f), (Action<GameObject>)null);
				_positionText.text = $"#{position}";
				_count = count;
				_position = position;
			}
		}

		public void SetQuitUI()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!_hasQuit)
			{
				_hasQuit = true;
				((Graphic)((Component)this).gameObject.GetComponent<Image>()).color = new Color(1f, 0f, 0f, 0.35f);
				((Component)_rainbow1).gameObject.SetActive(false);
				((Component)_rainbow2).gameObject.SetActive(false);
				_comboText.text = "(Quit)";
			}
		}

		public void SetIsVisible(bool visible, bool animate = true)
		{
			if (!animate)
			{
				_canvasGroup.alpha = (visible ? 0.8f : 0f);
				return;
			}
			if (_lastTween != 0)
			{
				LeanTween.cancel(_lastTween);
			}
			_lastTween = LeanTween.alphaCanvas(_canvasGroup, visible ? 0.8f : 0f, 0.14f).setOnComplete((Action)delegate
			{
				_lastTween = 0;
			}).id;
		}

		private static void SetTextProperties(params TMP_Text[] texts)
		{
			foreach (TMP_Text val in texts)
			{
				val.enableWordWrapping = false;
				val.overflowMode = (TextOverflowModes)0;
				val.alignment = (TextAlignmentOptions)516;
				val.enableAutoSizing = true;
				val.fontSizeMin = 8f;
				val.fontSizeMax = 12f;
			}
		}

		public void Dispose()
		{
			LeanTween.cancel(((Component)_rainbow1).gameObject);
			LeanTween.cancel(((Component)_rainbow2).gameObject);
			Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
			_controller.Remove(_id);
		}

		private static SecondDegreeDynamicsAnimation GetSecondDegreeAnimation(float speed)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new SecondDegreeDynamicsAnimation(speed, 1f, 1f);
		}
	}
	public class MultiplayerLiveScoreController : MonoBehaviour
	{
		private Dictionary<int, MultiplayerLiveScore> _idToLiveScoreDict;

		public static Dictionary<int, List<float[]>> idToSavedNoteDataDict;

		private bool _isInitialized;

		private float _timer;

		public void Awake()
		{
			_idToLiveScoreDict = new Dictionary<int, MultiplayerLiveScore>();
			if (idToSavedNoteDataDict == null)
			{
				idToSavedNoteDataDict = new Dictionary<int, List<float[]>>();
			}
			idToSavedNoteDataDict.Clear();
			_isInitialized = true;
		}

		public void Update()
		{
			if (!_isInitialized)
			{
				return;
			}
			_timer += Time.deltaTime;
			if (_timer > 1f)
			{
				_timer = 0f;
				IOrderedEnumerable<KeyValuePair<int, MultiplayerLiveScore>> source = _idToLiveScoreDict.OrderByDescending((KeyValuePair<int, MultiplayerLiveScore> x) => x.Value.GetScore);
				for (int num = 0; num < source.Count(); num++)
				{
					source.ElementAt(num).Value.SetPosition(num + 1, _idToLiveScoreDict.Count);
				}
			}
			if (!Input.GetKeyDown((KeyCode)9))
			{
				return;
			}
			Plugin.Instance.ShowLiveScore.Value = !Plugin.Instance.ShowLiveScore.Value;
			foreach (MultiplayerLiveScore value in _idToLiveScoreDict.Values)
			{
				value.SetIsVisible(Plugin.Instance.ShowLiveScore.Value);
			}
		}

		public void UpdateLiveScore(int id, int score, int combo, int health, int judgement, float accuracy)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!_isInitialized)
			{
				return;
			}
			if (!_idToLiveScoreDict.ContainsKey(id))
			{
				MultSerializableClasses.MultiplayerUserInfo userFromLobby = MultiplayerController.GetUserFromLobby(id);
				if (userFromLobby.id == 0)
				{
					return;
				}
				MultiplayerLiveScore multiplayerLiveScore = MultiplayerGameObjectFactory.CreateLiveScoreCard(((Component)this).gameObject.transform, new Vector2(200f, (float)(32 * _idToLiveScoreDict.Count)), $"{id}LiveScore").AddComponent<MultiplayerLiveScore>();
				multiplayerLiveScore.Initialize(id, userFromLobby.username, this);
				multiplayerLiveScore.SetIsVisible(Plugin.Instance.ShowLiveScore.Value, animate: false);
				_idToLiveScoreDict.Add(id, multiplayerLiveScore);
				idToSavedNoteDataDict.Add(id, new List<float[]>());
			}
			_idToLiveScoreDict[id].UpdateScore(score, combo, health);
			idToSavedNoteDataDict[id].Add(new float[2] { accuracy, combo });
		}

		public void OnUserQuit(int id)
		{
			if (_idToLiveScoreDict.ContainsKey(id))
			{
				_idToLiveScoreDict[id].SetQuitUI();
			}
		}

		public void OnDestroy()
		{
			_idToLiveScoreDict.Clear();
			_isInitialized = false;
		}

		public void Remove(int id)
		{
			_idToLiveScoreDict.Remove(id);
		}
	}
	public static class MultiAudioController
	{
		public enum MusicStyle
		{
			Default,
			Alternative
		}

		private static AudioSource _audioSource;

		private static AudioSource _soundSource;

		private static AudioClip _defaultAudio;

		private static AudioClip _joinSound;

		private static AudioClip _leaveSound;

		private static bool _isInitialized;

		private static float _volume;

		public static bool IsPaused;

		public static bool IsMusicLoaded;

		public static bool IsTransitioning;

		private static string[] _musicFileNames = new string[2] { "MultiplayerMusic.mp3", "MultiplayerMusic2.mp3" };

		private static int _currentMusicIndex;

		private static float GetMaxVolume => 0.2f * GlobalVariables.localsettings.maxvolume_music;

		public static bool IsPlaying => _audioSource.isPlaying;

		public static bool IsPlayingDefault
		{
			get
			{
				if (IsMusicLoaded && _audioSource.isPlaying)
				{
					return (Object)(object)_audioSource.clip == (Object)(object)_defaultAudio;
				}
				return false;
			}
		}

		public static bool IsMuted => Plugin.Instance.MuteMusic.Value;

		public static void InitMusic()
		{
			if (!_isInitialized)
			{
				_soundSource = ((Component)Plugin.Instance).gameObject.AddComponent<AudioSource>();
				_soundSource.loop = false;
				_soundSource.volume = GetMaxVolume;
				_audioSource = ((Component)Plugin.Instance).gameObject.AddComponent<AudioSource>();
				_audioSource.loop = true;
				_volume = GetMaxVolume;
				_currentMusicIndex = Mathf.Clamp((int)Plugin.Instance.SavedMusicStyle.Value, 0, _musicFileNames.Length - 1);
				_isInitialized = true;
				IsPaused = false;
				IsMusicLoaded = false;
				IsTransitioning = false;
				LoadSound("MultiplayerJoin.wav", delegate(AudioClip c)
				{
					_joinSound = c;
				});
				LoadSound("MultiplayerLeave.wav", delegate(AudioClip c)
				{
					_leaveSound = c;
				});
			}
		}

		public static void NextSong(Action OnLoadedCallback = null)
		{
			if (IsMuted || IsTransitioning)
			{
				return;
			}
			IsTransitioning = true;
			_currentMusicIndex = ++_currentMusicIndex % Enum.GetNames(typeof(MusicStyle)).Length;
			if (IsPlayingDefault)
			{
				StopMusicSoft(0.3f, delegate
				{
					LoadMusic(_currentMusicIndex, OnLoadedCallback);
				});
			}
			else
			{
				LoadMusic(_currentMusicIndex, OnLoadedCallback);
			}
		}

		public static void PreviousSong(Action OnLoadedCallback = null)
		{
			if (IsMuted || IsTransitioning)
			{
				return;
			}
			IsTransitioning = true;
			_currentMusicIndex = --_currentMusicIndex % Enum.GetNames(typeof(MusicStyle)).Length;
			if (IsPlayingDefault)
			{
				StopMusicSoft(0.3f, delegate
				{
					LoadMusic(_currentMusicIndex, OnLoadedCallback);
				});
			}
			else
			{
				LoadMusic(_currentMusicIndex, OnLoadedCallback);
			}
		}

		public static void LoadCurrentIndexMusic(Action onLoadedCallback = null)
		{
			LoadMusic(_currentMusicIndex, onLoadedCallback);
		}

		public static void LoadMusic(int musicIndex, Action OnLoadedCallback = null)
		{
			if (musicIndex < 0 || musicIndex > _musicFileNames.Length - 1)
			{
				Plugin.LogError($"Music Index inexpected value was {musicIndex}");
				return;
			}
			IsMusicLoaded = false;
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.TryLoadingAudioClipLocal(_musicFileNames[musicIndex], delegate(AudioClip clip)
			{
				IsTransitioning = false;
				if ((Object)(object)clip == (Object)null)
				{
					IsMusicLoaded = false;
					Plugin.LogError("Music " + _musicFileNames[musicIndex] + " couldn't be loaded.");
				}
				else
				{
					Plugin.Instance.SavedMusicStyle.Value = (MusicStyle)musicIndex;
					IsMusicLoaded = true;
					_audioSource.clip = clip;
					_defaultAudio = clip;
					_audioSource.volume = 0f;
					OnLoadedCallback?.Invoke();
				}
			}));
		}

		public static void LoadClip(string path, Action OnLoadedCallback = null)
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.TryLoadingSongAudio(path, delegate(AudioClip clip)
			{
				if ((Object)(object)clip == (Object)null)
				{
					Plugin.LogError("Clip " + path + " couldn't be loaded.");
				}
				else
				{
					_audioSource.clip = clip;
					_audioSource.volume = 0f;
					OnLoadedCallback?.Invoke();
				}
			}));
		}

		public static void LoadSound(string path, Action<AudioClip> OnLoadedCallback)
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine((IEnumerator)MultiplayerAPIService.TryLoadingSound(path, delegate(AudioClip clip)
			{
				if ((Object)(object)clip == (Object)null)
				{
					Plugin.LogError("Sound " + path + " couldn't be loaded.");
				}
				else
				{
					OnLoadedCallback?.Invoke(clip);
				}
			}));
		}

		public static void PlayMusicSoft(float time = 0.3f)
		{
			if (!IsMuted && !((Object)(object)_audioSource.clip == (Object)null))
			{
				_audioSource.Play();
				LeanTween.value(0f, _volume, time).setOnUpdate((Action<float>)delegate(float v)
				{
					_audioSource.volume = v;
				});
			}
		}

		public static void ResumeMusicSoft(float time = 0.3f)
		{
			if (!IsMuted && !((Object)(object)_audioSource.clip == (Object)null))
			{
				IsPaused = false;
				_audioSource.UnPause();
				LeanTween.value(0f, _volume, time).setOnUpdate((Action<float>)delegate(float v)
				{
					_audioSource.volume = v;
				});
			}
		}

		public static void StopMusicHard()
		{
			AudioSource audioSource = _audioSource;
			if (audioSource != null)
			{
				audioSource.Stop();
			}
		}

		public static void PauseMusicHard()
		{
			AudioSource audioSource = _audioSource;
			if (audioSource != null)
			{
				audioSource.Pause();
			}
		}

		public static void PlayMusicHard()
		{
			if (!IsMuted && !((Object)(object)_audioSource.clip == (Object)null))
			{
				_audioSource.volume = _volume;
				AudioSource audioSource = _audioSource;
				if (audioSource != null)
				{
					audioSource.Play();
				}
			}
		}

		public static void StopMusicSoft(float time = 0.3f, Action OnComplete = null)
		{
			float volume = _audioSource.volume;
			LeanTween.value(volume, 0f, time).setOnComplete((Action)delegate
			{
				_audioSource.Stop();
				OnComplete?.Invoke();
			}).setOnUpdate((Action<float>)delegate(float v)
			{
				_audioSource.volume = v;
			});
		}

		public static void PauseMusicSoft(float time = 0.3f)
		{
			IsPaused = true;
			float volume = _audioSource.volume;
			LeanTween.value(volume, 0f, time).setOnComplete((Action)_audioSource.Pause).setOnUpdate((Action<float>)delegate(float v)
			{
				_audioSource.volume = v;
			});
		}

		public static void PauseMusicSoft(float time, Action OnComplete)
		{
			IsPaused = true;
			float volume = _audioSource.volume;
			LeanTween.value(volume, 0f, time).setOnComplete((Action)delegate
			{
				_audioSource.Pause();
				OnComplete?.Invoke();
			}).setOnUpdate((Action<float>)delegate(float v)
			{
				_audioSource.volume = v;
			});
		}

		public static void ChangeVolume(float increment)
		{
			_volume = Mathf.Clamp(_volume + increment, 0f, 1f);
			_audioSource.volume = _volume;
		}

		public static void SetSongToDefault()
		{
			if ((Object)(object)_audioSource.clip != (Object)(object)_defaultAudio && (Object)(object)_defaultAudio != (Object)null)
			{
				_audioSource.clip = _defaultAudio;
			}
		}

		public static void PlayJoinSound()
		{
			if (!((Object)(object)_joinSound == (Object)null) && !((Object)(object)_soundSource == (Object)null))
			{
				_soundSource.PlayOneShot(_joinSound);
			}
		}

		public static void PlayLeaveSound()
		{
			if (!((Object)(object)_leaveSound == (Object)null) && !((Object)(object)_soundSource == (Object)null))
			{
				_soundSource.PlayOneShot(_leaveSound);
			}
		}
	}
	public static class MultiplayerLogger
	{
		public static Queue<string> logList = new Queue<string>();

		public static Action<string> OnLogReceivedUpdate;

		public static void LogInfo(string message)
		{
			logList.Enqueue(message);
			OnLogReceivedUpdate?.Invoke(GetFormattedLogs());
			if (logList.Count > 69)
			{
				logList.Dequeue();
			}
		}

		public static void UserLog(string user, string message)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			LogInfo("[" + ColorText("User", Color.yellow) + "] " + user + ": " + message);
		}

		public static void HostLog(string name, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			LogInfo("[" + ColorText("Host", new Color(0.95f, 0.2f, 0.95f)) + "] " + name + ": " + message);
		}

		public static void ServerLog(string message)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			LogInfo("[" + ColorText("Server", Color.green) + "]: " + message);
		}

		public static string GetFormattedLogs()
		{
			if (logList.Count <= 0)
			{
				return "-";
			}
			return string.Join("\n", logList);
		}

		public static void ClearLogs()
		{
			logList.Clear();
		}

		public static string ColorText(string text, Color color)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorUtility.ToHtmlStringRGB(color) + ">" + text + "</color>";
		}
	}
}
namespace TootTallyMultiplayer.MultiplayerCore.PointScore
{
	public class MultiplayerPointScore : MonoBehaviour
	{
		private TMP_Text _positionText;

		private TMP_Text _nameText;

		private TMP_Text _percentText;

		private TMP_Text _scoreText;

		private TMP_Text _maxComboText;

		private Image _outlineImage;

		private Color _outlineColor;

		private Color _outlineHoverColor;

		private string _name;

		private string _grade;

		private string _modifiers;

		private int _id;

		private int _score;

		private int _maxCombo;

		private int _position;

		private int _count;

		private float _percent;

		private int[] _noteTally;

		private TootTallyAnimation _animation;

		private bool _IsSelf => _id == TootTallyUser.userInfo.id;

		public int GetScore => _score;

		public void Initialize(int id, string name, int score, float percent, int maxCombo, string grade, int[] noteTally, string modifiers = null, Action<int, string, int, float, string, int[], string> onClick = null)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0186: 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_004d: 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_0069: 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)
			_id = id;
			if (_IsSelf)
			{
				Image outlineImage = _outlineImage;
				Color val = default(Color);
				((Color)(ref val))..ctor(0.95f, 0.2f, 0.95f, 0.5f);
				((Graphic)outlineImage).color = val;
				_outlineColor = val;
				_outlineHoverColor = new Color(0.95f, 0.45f, 0.95f, 0.65f);
			}
			_name = name;
			_score = score;
			_percent = percent;
			_maxCombo = maxCombo;
			_grade = grade;
			_noteTally = noteTally;
			_modifiers = modifiers;
			_nameText.text = _name;
			_scoreText.text = _score.ToString();
			_percentText.text = $"{_percent:0.00}%";
			_maxComboText.text = $"{_maxCombo}x";
			EventTrigger val2 = ((Component)this).gameObject.AddComponent<EventTrigger>();
			Entry val3 = new Entry();
			val3.eventID = (EventTriggerType)4;
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				onClick?.Invoke(_id, _name, _score, _percent, _grade, _noteTally, _modifiers);
			});
			val2.triggers.Add(val3);
			Entry val4 = new Entry();
			val4.eventID = (EventTriggerType)0;
			((UnityEvent<BaseEventData>)(object)val4.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_outlineImage).color = _outlineHoverColor;
				SoundEffectsManager.PlayerBtnHover();
			});
			val2.triggers.Add(val4);
			Entry val5 = new Entry();
			val5.eventID = (EventTriggerType)1;
			((UnityEvent<BaseEventData>)(object)val5.callback).AddListener((UnityAction<BaseEventData>)delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_outlineImage).color = _outlineColor;
			});
			val2.triggers.Add(val5);
		}

		public void Awake()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0075: 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_00e1: 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_0153: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			Transform child = ((Component)this).transform.GetChild(0);
			_outlineImage = ((Component)this).GetComponent<Image>();
			_outlineColor = ((Graphic)_outlineImage).color;
			_outlineHoverColor = new Color(0.65f, 0.65f, 0.65f, 0.75f);
			_positionText = GameObjectFactory.CreateSingleText(child, "Position", "#-", (TextFont)0);
			_positionText.rectTransform.sizeDelta = new Vector2(18f, 0f);
			_nameText = GameObjectFactory.CreateSingleText(child, "Name", "Unknown", (TextFont)0);
			_nameText.rectTransform.sizeDelta = new Vector2(66f, 0f);
			_percentText = GameObjectFactory.CreateSingleText(child, "Percent", "-%", (TextFont)0);
			_percentText.rectTransform.sizeDelta = new Vector2(30f, 0f);
			GameObject verticalBox = GameModifierFactory.GetVerticalBox(new Vector2(60f, 0f), child);
			((Behaviour)verticalBox.GetComponent<Image>()).enabled = false;
			VerticalLayoutGroup component = verticalBox.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			_scoreText = GameObjectFactory.CreateSingleText(verticalBox.transform, "Score", "-", (TextFont)0);
			_scoreText.rectTransform.sizeDelta = new Vector2(0f, 12f);
			_maxComboText = GameObjectFactory.CreateSingleText(verticalBox.transform, "MaxCombo", "-", (TextFont)0);
			_maxComboText.rectTransform.sizeDelta = new Vector2(0f, 4f);
			SetTextProperties(_positionText, _nameText, _scoreText, _percentText, _maxComboText);
			TMP_Text positionText = _positionText;
			TMP_Text nameText = _nameText;
			TextAlignmentOptions alignment = (TextAlignmentOptions)513;
			nameText.alignment = (TextAlignmentOptions)513;
			positionText.alignment = alignment;
			TMP_Text positionText2 = _positionText;
			bool enableAutoSizing = (_maxComboText.enableAutoSizing = false);
			positionText2.enableAutoSizing = enableAutoSizing;
			_positionText.fontSize = 14f;
			_maxComboText.fontSize = 8f;
		}

		public void SetPosition(int position, int count)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (_position != position || _count != count)
			{
				TootTallyAnimation animation = _animation;
				if (animation != null)
				{
					animation.Dispose();
				}
				_animation = TootTallyAnimationManager.AddNewPositionAnimation(((Component)this).gameObject, new Vector3(0f, (float)(-32 * (position - 1))), 1f, GetSecondDegreeAnimation(1.5f), (Action<GameObject>)null);
				_positionText.text = $"#{position}";
				_count = count;
				_position = position;
			}
		}

		private static void SetTextProperties(params TMP_Text[] texts)
		{
			foreach (TMP_Text val in texts)
			{
				val.enableWordWrapping = false;
				val.overflowMode = (TextOverflowModes)0;
				val.alignment = (TextAlignmentOptions)516;
				val.enableAutoSizing = true;
				val.fontSizeMin = 8f;
				val.fontSizeMax = 12f;
			}
		}

		private static SecondDegreeDynamicsAnimation GetSecondDegreeAnimation(float speed)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new SecondDegreeDynamicsAnimation(speed, 1f, 1f);
		}
	}
	public class MultiplayerPointScoreController : MonoBehaviour
	{
		public class SavedPointScore
		{
			public int id;

			public int score;

			public int maxCombo;

			public int[] noteTally;

			public float percent;

			public string grade;

			public string modifiers;

			public SavedPointScore(int id, int score, float percent, int maxCombo, string grade, int[] noteTally, string modifiers = null)
			{
				this.id = id;
				this.score = score;
				this.percent = percent;
				this.maxCombo = maxCombo;
				this.grade = grade;
				this.noteTally = noteTally;
				this.modifiers = modifiers;
			}
		}

		private static Dictionary<int, MultiplayerPointScore> _idToPointScoreDict;

		private static List<SavedPointScore> _savedPointScoreList;

		private static GameObject _gameObject;

		private static bool _isInitialized;

		private static PointSceneController _pointSceneController;

		private static ScoreGraph _scoreGraph;

		public void Awake()
		{
			_gameObject = ((Component)this).gameObject;
			_idToPointScoreDict = new Dictionary<int, MultiplayerPointScore>();
			if (_savedPointScoreList != null)
			{
				_savedPointScoreList.ForEach(InitPointScore);
				_savedPointScoreList.Clear();
			}
			_isInitialized = true;
		}

		public void Initialize(PointSceneController __instance)
		{
			_pointSceneController = __instance;
			try
			{
				_scoreGraph = _pointSceneController.scorepopupcamera.GetComponent<ScoreGraph>();
				((Graphic)((Component)((Component)_pointSceneController.btn_cont_canvas).transform.parent).GetComponent<Image>()).raycastTarget = false;
			}
			catch (Exception ex)
			{
				Plugin.LogError("Couldn't find ScoreGraph Component in scorepopupcamera object: " + ex.Message);
				Plugin.LogError("Trace: " + ex.StackTrace);
			}
		}

		public static void AddScoreDebug()
		{
			AddScore(MultiplayerController.GetUserFromLobby(TootTallyUser.userInfo.id).id, Random.Range(1, 1000000), Random.value, Random.Range(0, 1000), new int[5] { 0, 1, 2, 3, 4 }, "S", "EZ,HD");
		}

		public static void AddScore(int id, int score, float percent, int maxCombo, int[] noteTally, string grade, string modifiers = null)
		{
			if (_isInitialized)
			{
				InitPointScore(id, score, percent, maxCombo, grade, noteTally, modifiers);
				return;
			}
			if (_savedPointScoreList == null)
			{
				_savedPointScoreList = new List<SavedPointScore>();
			}
			_savedPointScoreList.Add(new SavedPointScore(id, score, percent, maxCombo, grade, noteTally, modifiers));
		}

		private static void InitPointScore(SavedPointScore pointScore)
		{
			InitPointScore(pointScore.id, pointScore.score, pointScore.percent, pointScore.maxCombo, pointScore.grade, pointScore.noteTally, pointScore.modifiers);
		}

		private static void InitPointScore(int id, int score, float percent, int maxCombo, string grade, int[] noteTally, string modifiers = null)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (_idToPointScoreDict.ContainsKey(id))
			{
				return;
			}
			MultSerializableClasses.MultiplayerUserInfo userFromLobby = MultiplayerController.GetUserFromLobby(id);
			if (userFromLobby.id != 0)
			{
				MultiplayerPointScore multiplayerPointScore = MultiplayerGameObjectFactory.CreatePointScoreCard(_gameObject.transform, new Vector2(-250f, (float)(32 * _idToPointScoreDict.Count)), $"{id}PointScore").AddComponent<MultiplayerPointScore>();
				multiplayerPointScore.Initialize(id, userFromLobby.username, score, percent, maxCombo, grade, noteTally, modifiers, OnPointScoreClick);
				_idToPointScoreDict.Add(id, multiplayerPointScore);
				MultiplayerPointScore[] array = (from x in _idToPointScoreDict
					select x.Value into x
					orderby x.GetScore descending
					select x).ToArray();
				for (int num = 0; num < array.Length; num++)
				{
					array[num].SetPosition(num + 1, _idToPointScoreDict.Count);
				}
			}
		}

		public static void OnPointScoreClick(int id, string name, int score, float percent, string grade, int[] noteTally, string modifiers = null)
		{
			if (_isInitialized && !((Object)(object)_pointSceneController == (Object)null))
			{
				UpdatePointSceneData(name, score, percent, grade, noteTally, modifiers);
				UpdatePointSceneGraph(id);
			}
		}

		public static void UpdatePointSceneData(string name, int score, float percent, string grade, int[] noteTally, string modifiers = null)
		{
			if ((Object)(object)_pointSceneController.track_dotimages[0] == (Object)null)
			{
				InitTrackArrays();
			}
			_pointSceneController.popScoreAnim(Enumerable.Contains(grade, 'S') ? 5 : 4);
			if (Plugin.Instance.option.ShowCoolS.Value && noteTally[0] == 0 && noteTally[1] == 0 && noteTally[2] == 0)
			{
				Text giantscoretext = _pointSceneController.giantscoretext;
				string text = (_pointSceneController.giantscoretextshad.text = "You Suck");
				giantscoretext.text = text;
				Text giantscoretext2 = _pointSceneController.giantscoretext;
				int fontSize = (_pointSceneController.giantscoretextshad.fontSize = 12);
				giantscoretext2.fontSize = fontSize;
				if (noteTally[3] == 0)
				{
					((Component)_pointSceneController.giantscorediamond.transform.Find("cool-s")).GetComponent<Image>().sprite = AssetManager.GetSprite("Cool-sss.png");
				}
				((Component)_pointSceneController.giantscorediamond.transform.Find("cool-s")).gameObject.SetActive(true);
			}
			else
			{
				Text giantscoretext3 = _pointSceneController.giantscoretext;
				string text = (_pointSceneController.giantscoretextshad.text = grade);
				giantscoretext3.text = text;
				Text giantscoretext4 = _pointSceneController.giantscoretext;
				int fontSize = (_pointSceneController.giantscoretextshad.fontSize = 110);
				giantscoretext4.fontSize = fontSize;
				((Component)_pointSceneController.giantscorediamond.transform.Find("cool-s")).gameObject.SetActive(false);
			}
			_pointSceneController.txt_prevhigh.text = name;
			GameObject val = GameObject.Find("Canvas/FullPanel/LeftLabels/PREV. HI SCORE");
			Text[] componentsInChildren = val.GetComponentsInChildren<Text>();
			Text[] array = componentsInChildren;
			foreach (Text val2 in array)
			{
				val2.text = "Player";
			}
			_pointSceneController.txt_score.text = $"{score:n0} {percent:0.00}%";
			_pointSceneController.txt_nasties.text = noteTally[0].ToString("n0");
			_pointSceneController.txt_mehs.text = noteTally[1].ToString("n0");
			_pointSceneController.txt_okays.text = noteTally[2].ToString("n0");
			_pointSceneController.txt_nices.text = noteTally[3].ToString("n0");
			_pointSceneController.txt_perfectos.text = noteTally[4].ToString("n0");
			if (!string.IsNullOrEmpty(modifiers) && !modifiers.ToLower().Contains("none"))
			{
				Text txt_trackname = _pointSceneController.txt_trackname;
				txt_trackname.text = txt_trackname.text + " [" + modifiers + "]";
			}
		}

		private static void InitTrackArrays()
		{
			for (int i = 0; i < 4; i++)
			{
				_pointSceneController.track_arrows_rects[i] = ((Component)_pointSceneController.track_arrows_objs[i].transform).GetComponent<RectTransform>();
			}
			_pointSceneController.track_barempty = ((Component)_pointSceneController.trackobj.transform.GetChild(0)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_barfill = ((Component)_pointSceneController.trackobj.transform.GetChild(1)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_arrow = ((Component)_pointSceneController.trackobj.transform.GetChild(2)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot0 = ((Component)_pointSceneController.trackobj.transform.GetChild(3)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot1 = ((Component)_pointSceneController.trackobj.transform.GetChild(4)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot2 = ((Component)_pointSceneController.trackobj.transform.GetChild(5)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot3 = ((Component)_pointSceneController.trackobj.transform.GetChild(6)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot4 = ((Component)_pointSceneController.trackobj.transform.GetChild(7)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot5 = ((Component)_pointSceneController.trackobj.transform.GetChild(8)).gameObject.GetComponent<RectTransform>();
			_pointSceneController.track_dot0img = ((Component)_pointSceneController.trackobj.transform.GetChild(3)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dot1img = ((Component)_pointSceneController.trackobj.transform.GetChild(4)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dot2img = ((Component)_pointSceneController.trackobj.transform.GetChild(5)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dot3img = ((Component)_pointSceneController.trackobj.transform.GetChild(6)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dot4img = ((Component)_pointSceneController.trackobj.transform.GetChild(7)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dot5img = ((Component)_pointSceneController.trackobj.transform.GetChild(8)).gameObject.GetComponent<Image>();
			_pointSceneController.track_dotimages[0] = _pointSceneController.track_dot0img;
			_pointSceneController.track_dotimages[1] = _pointSceneController.track_dot1img;
			_pointSceneController.track_dotimages[2] = _pointSceneController.track_dot2img;
			_pointSceneController.track_dotimages[3] = _pointSceneController.track_dot3img;
			_pointSceneController.track_dotimages[4] = _pointSceneController.track_dot4img;
			_pointSceneController.track_dotimages[5] = _pointSceneController.track_dot5img;
			_pointSceneController.track_dot0txt = ((Component)((Component)_pointSceneController.track_dot0).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dot1txt = ((Component)((Component)_pointSceneController.track_dot1).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dot2txt = ((Component)((Component)_pointSceneController.track_dot2).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dot3txt = ((Component)((Component)_pointSceneController.track_dot3).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dot4txt = ((Component)((Component)_pointSceneController.track_dot4).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dot5txt = ((Component)((Component)_pointSceneController.track_dot5).transform.GetChild(0)).gameObject.GetComponent<Text>();
			_pointSceneController.track_dottxts[0] = _pointSceneController.track_dot0txt;
			_pointSceneController.track_dottxts[1] = _pointSceneController.track_dot1txt;
			_pointSceneController.track_dottxts[2] = _pointSceneController.track_dot2txt;
			_pointSceneController.track_dottxts[3] = _pointSceneController.track_dot3txt;
			_pointSceneController.track_dottxts[4] = _pointSceneController.track_dot4txt;
			_pointSceneController.track_dottxts[5] = _pointSceneController.track_dot5txt;
			_pointSceneController.track_p0 = ((Component)((Component)_pointSceneController.track_dot0).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_p1 = ((Component)((Component)_pointSceneController.track_dot1).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_p2 = ((Component)((Component)_pointSceneController.track_dot2).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_p3 = ((Component)((Component)_pointSceneController.track_dot3).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_p4 = ((Component)((Component)_pointSceneController.track_dot4).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_p5 = ((Component)((Component)_pointSceneController.track_dot5).transform.GetChild(1)).gameObject.GetComponent<ParticleSystem>();
			_pointSceneController.track_ps[0] = _pointSceneController.track_p0;
			_pointSceneController.track_ps[1] = _pointSceneController.track_p1;
			_pointSceneController.track_ps[2] = _pointSceneController.track_p2;
			_pointSceneController.track_ps[3] = _pointSceneController.track_p3;
			_pointSceneController.track_ps[4] = _pointSceneController.track_p4;
			_pointSceneController.track_ps[5] = _pointSceneController.track_p5;
		}

		public static void UpdatePointSceneGraph(int id)
		{
			if (MultiplayerLiveScoreController.idToSavedNoteDataDict != null && MultiplayerLiveScoreController.idToSavedNoteDataDict.ContainsKey(id))
			{
				for (int i = 0; i < MultiplayerLiveScoreController.idToSavedNoteDataDict[id].Count && i < GlobalVariables.gameplay_allnotescores.Count; i++)
				{
					UpdatePointSceneGraphNode(MultiplayerLiveScoreController.idToSavedNoteDataDict[id][i][0], MultiplayerLiveScoreController.idToSavedNoteDataDict[id][i][1], GlobalVariables.gameplay_allnotescores[i][2], i);
				}
			}
		}

		public static void UpdatePointSceneGraphNode(float score, float mult, float timestamp, int index)
		{
			//IL_0091: 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)
			if (_scoreGraph.graphpanel.transform.childCount >= index + 4)
			{
				RectTransform component = ((Component)_scoreGraph.graphpanel.transform.GetChild(index + 4)).GetComponent<RectTransform>();
				if (((Object)component).name.Contains("node"))
				{
					float num = timestamp / _scoreGraph.lasttimestamp;
					component.anchoredPosition3D = new Vector3(num * (float)_scoreGraph.panelwidth, (Mathf.Clamp(score, 50f, 100f) - 50f) * (_scoreGraph.nodevspacing * 2f), 0f);
					_scoreGraph.multline.SetPosition(index, new Vector3(num * (float)_scoreGraph.panelwidth, Mathf.Min(mult, 10f) / 10f * (float)_scoreGraph.panelheight, 0f));
				}
			}
		}

		public static void ClearSavedScores()
		{
			_savedPointScoreList?.Clear();
		}

		public void OnDestroy()
		{
			_idToPointScoreDict = null;
			_pointSceneController = null;
			_isInitialized = false;
		}
	}
}
namespace TootTallyMultiplayer.MultiplayerCore.InputPrompts
{
	public class LobbySettingsInputPrompt
	{
		private MultiplayerController controller;

		public GameObject gameObject;

		private GameObject _container;

		private GameObject _topContainer;

		private GameObject _bottomContainer;

		private GameObject _lobbySettingsContainer;

		private GameObject _otherSettingsContainer;

		private TMP_InputField _nameInput;

		private TMP_InputField _descInput;

		private TMP_InputField _passwordInput;

		private TMP_InputField _maxPlayerInput;

		private Toggle _autorotateButton;

		private Toggle _autostartToggle;

		private Toggle _freemodButton;

		private Toggle _teamsButton;

		private TootTallyAnimation _lobbySettingsAnimation;

		public LobbySettingsInputPrompt(Transform canvasTransform, MultiplayerController controller)
		{
			//IL_0018: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00a4: 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)
			//IL_00b4: 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_00bd: 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_00c5: 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_00fc: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_0596: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			this.controller = controller;
			gameObject = GameModifierFactory.GetBorderedVerticalBox(new Vector2(890f, 490f), 5, canvasTransform);
			_container = ((Component)gameObject.transform.GetChild(0)).gameObject;
			((Graphic)_container.GetComponent<Image>()).color = new Color(0.1f, 0.1f, 0.1f, 0.85f);
			VerticalLayoutGroup component = _container.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 10f;
			((LayoutGroup)component).padding = new RectOffset(5, 5, 25, 5);
			RectTransform component2 = gameObject.GetComponent<RectTransform>();
			component2.anchorMin = (component2.anchorMax = (component2.pivot = Vector2.one / 2f));
			_topContainer = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 360f), _container.transform);
			_lobbySettingsContainer = GameModifierFactory.GetVerticalBox(new Vector2(545f, 0f), _topContainer.transform);
			VerticalLayoutGroup component3 = _lobbySettingsContainer.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component3).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 10f;
			TMP_Text val3 = GameObjectFactory.CreateSingleText(_lobbySettingsContainer.transform, "LobbySettingsText", "Lobby Settings", (TextFont)0);
			val3.fontSize = 42f;
			val3.margin = new Vector4(5f, 0f);
			val3.rectTransform.sizeDelta = new Vector2(545f, 70f);
			val3.alignment = (TextAlignmentOptions)4097;
			GameObject horizontalBox = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 55f), _lobbySettingsContainer.transform);
			HorizontalLayoutGroup component4 = horizontalBox.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 8f;
			((LayoutGroup)component4).childAlignment = (TextAnchor)3;
			GameObject val4 = Object.Instantiate<GameObject>(horizontalBox, _lobbySettingsContainer.transform);
			GameObject val5 = Object.Instantiate<GameObject>(horizontalBox, _lobbySettingsContainer.transform);
			GameObject val6 = Object.Instantiate<GameObject>(horizontalBox, _lobbySettingsContainer.transform);
			TMP_Text val7 = GameObjectFactory.CreateSingleText(horizontalBox.transform, "NameLabel", "Name:", (TextFont)0);
			val7.rectTransform.sizeDelta = new Vector2(140f, 55f);
			val7.alignment = (TextAlignmentOptions)1025;
			_nameInput = MultiplayerGameObjectFactory.CreateInputField(horizontalBox.transform, "NameInputField", new Vector2(350f, 30f), 24f, Plugin.Instance.SavedLobbyTitle.Value, isPassword: false);
			TMP_Text val8 = Object.Instantiate<TMP_Text>(val7, val4.transform);
			((Object)val8).name = "DescLabel";
			val8.text = "Description:";
			_descInput = MultiplayerGameObjectFactory.CreateInputField(val4.transform, "DescInputField", new Vector2(350f, 30f), 24f, Plugin.Instance.SavedLobbyDesc.Value, isPassword: false);
			TMP_Text val9 = Object.Instantiate<TMP_Text>(val7, val5.transform);
			((Object)val9).name = "PasswordLabel";
			val9.text = "Password:";
			_passwordInput = MultiplayerGameObjectFactory.CreateInputField(val5.transform, "PassInputField", new Vector2(350f, 30f), 24f, "", isPassword: true);
			TMP_Text val10 = Object.Instantiate<TMP_Text>(val7, val6.transform);
			((Object)val10).name = "MaxPlayerLabel";
			val10.text = "Max Player:";
			_maxPlayerInput = MultiplayerGameObjectFactory.CreateInputField(val6.transform, "MaxPlayerInputField", new Vector2(350f, 30f), 24f, Plugin.Instance.SavedLobbyMaxPlayer.Value.ToString(), isPassword: false);
			_otherSettingsContainer = GameModifierFactory.GetVerticalBox(new Vector2(245f, 0f), _topContainer.transform);
			VerticalLayoutGroup component5 = _otherSettingsContainer.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component5).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)component5).childForceExpandWidth = (((HorizontalOrVerticalLayoutGroup)component5).childControlWidth = false);
			TMP_Text val11 = GameObjectFactory.CreateSingleText(_otherSettingsContainer.transform, "OtherSettingsText", "Other", (TextFont)0);
			val11.fontSize = 42f;
			val11.rectTransform.sizeDelta = new Vector2(245f, 55f);
			val11.alignment = (TextAlignmentOptions)4098;
			VerticalLayoutGroup component6 = _otherSettingsContainer.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component6).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)component6).childControlHeight = (((HorizontalOrVerticalLayoutGroup)component6).childForceExpandHeight = false);
			_autorotateButton = MultiplayerGameObjectFactory.CreateToggle(_otherSettingsContainer.transform, "AutorotateToggle", new Vector2(60f, 60f), "autorotate");
			_autostartToggle = MultiplayerGameObjectFactory.CreateToggle(_otherSettingsContainer.transform, "AutostartToggle", new Vector2(60f, 60f), "autostart");
			_teamsButton = MultiplayerGameObjectFactory.CreateToggle(_otherSettingsContainer.transform, "TeamsToggle", new Vector2(60f, 60f), "teams");
			_freemodButton = MultiplayerGameObjectFactory.CreateToggle(_otherSettingsContainer.transform, "FreemodToggle", new Vector2(60f, 60f), "freemod");
			_bottomContainer = GameModifierFactory.GetHorizontalBox(new Vector2(0f, 90f), _container.transform);
			HorizontalLayoutGroup component7 = _bottomContainer.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component7).spacing = 40f;
			((HorizontalOrVerticalLayoutGroup)component7).childControlHeight = (((HorizontalOrVerticalLayoutGroup)component7).childForceExpandHeight = false);
			CustomButton val12 = GameObjectFactory.CreateCustomButton(_bottomContainer.transform, Vector2.zero, new Vector2(170f, 65f), "Confirm", "ConfirmButton", (Action)OnSettingsPromptConfirm);
			CustomButton val13 = GameObjectFactory.CreateCustomButton(_bottomContainer.transform, Vector2.zero, new Vector2(170f, 65f), "Cancel", "CancelButton", (Action)Hide);
		}

		public void OnSettingsPromptConfirm()
		{
			if (MultiplayerCreatePanel.ValidateInput(_nameInput.text, _descInput.text, _passwordInput.text, _maxPlayerInput.text))
			{
				TootTallyNotifManager.DisplayNotif("Sending new lobby info...", 6f);
				MultiplayerSystem.SocketSetLobbyInfo lobbyInfo = new MultiplayerSystem.SocketSetLobbyInfo
				{
					name = _nameInput.text,
					description = _descInput.text,
					password = _passwordInput.text,
					maxPlayer = int.Parse(_maxPlayerInput.text),
					autorotate = _autorotateButton.isOn,
					teams = _teamsButton.isOn,
					freemod = _freemodButton.isOn
				};
				controller.SendSetLobbySettings(lobbyInfo);
				Hide();
			}
		}

		public void Show()
		{
			//IL_0024: 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_0053: Expected O, but got Unknown
			TootTallyAnimation lobbySettingsAnimation = _lobbySettingsAnimation;
			if (lobbySettingsAnimation != null)
			{
				lobbySettingsAnimation.Dispose();
			}
			gameObject.SetActive(true);
			_lobbySettingsAnimation = TootTallyAnimationManager.AddNewScaleAnimation(gameObject, Vector3.one, 0.8f, new SecondDegreeDynamicsAnimation(1.8f, 0.95f, 1f), (Action<GameObject>)delegate
			{
				_lobbySettingsAnimation = null;
			});
		}

		public void Hide()
		{
			Hide(animate: true);
		}

		public void Hide(bool animate = true)
		{
			//IL_001b: 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_004a: Expected O, but got Unknown
			TootTallyAnimation lobbySettingsAnimation = _lobbySettingsAnimation;
			if (lobbySettingsAnimation != null)
			{
				lobbySettingsAnimation.Dispose();
			}
			if (animate)
			{
				_lobbySettingsAnimation = TootTallyAnimationManager.AddNewScaleAnimation(gameObject, Vector2.zero, 0.8f, new SecondDegreeDynamicsAnimation(2.2f, 1f, 1f), (Action<GameObject>)delegate
				{
					_lobbySettingsAnimation = null;
					gameObject.SetActive(false);
				});
			}
			else
			{
				gameObject.SetActive(false);
			}
		}

		public void UpdateLobbyValues(MultSerializableClasses.MultiplayerLobbyInfo lobbyInfo)
		{
			_nameInput.text = lobbyInfo.title;
			_descInput.text = lobbyInfo.description;
			_maxPlayerInput.text = lobbyInfo.maxPlayerCount.ToString() ?? "";
			_autorotateButton.isOn = lobbyInfo.autorotate;
			_teamsButton.isOn = lobbyInfo.teams;
			_freemodButton.isOn = lobbyInfo.freemod;
		}
	}
}
namespace TootTallyMultiplayer.APIService
{
	public static class MultiplayerAPIService
	{
		public const string MULTURL = "https://spec.toottally.com/mp";

		public static IEnumerator<UnityWebRequestAsyncOperation> GetLobbyList(Action<List<MultSerializableClasses.MultiplayerLobbyInfo>> callback)
		{
			string query = "https://spec.toottally.com/mp/list";
			UnityWebRequest webRequest = UnityWebRequest.Get(query);
			yield return webRequest.SendWebRequest();
			if (!HasError(webRequest, query))
			{
				List<MultSerializableClasses.MultiplayerLobbyInfo> lobbies = JsonConvert.DeserializeObject<MultSerializableClasses.APIMultiplayerInfo>(webRequest.downloadHandler.text).lobbies;
				callback(lobbies);
			}
			else
			{
				callback(null);
			}
		}

		public static IEnumerator<UnityWebRequestAsyncOperation> ShutdownMultiplayerServer(string code, Action callback)
		{
			string query = "https://spec.toottally.com/mp/delete";
			MultSerializableClasses.APIShutdownSubmission aPIShutdownSubmission = new MultSerializableClasses.APIShutdownSubmission
			{
				lobby_code = code
			};
			byte[] bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject((object)aPIShutdownSubmission));
			UnityWebRequest val = PostUploadRequestWithHeader(query, bytes, new List<string[]> { new string[2]
			{
				"Authorization",
				"APIKey " + Plugin.GetAPIKey
			} });
			yield return val.SendWebRequest();
			callback();
		}

		public static IEnumerator<UnityWebRequestAsyncOperation> CreateMultiplayerServerRequest(MultSerializableClasses.APICreateSubmission apiSubmission, Action<string> callback)
		{
			string query = "https://spec.toottally.com/mp/create";
			byte[] bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject((object)apiSubmission));
			UnityWebRequest webRequest = PostUploadRequestWithHeader(query, bytes, new List<string[]> { new string[2]
			{
				"Authorization",
				"APIKey " + Plugin.GetAPIKey
			} });
			yield return webRequest.SendWebRequest();
			if (!HasError(webRequest, query))
			{
				callback(webRequest.downloadHandler.text);
			}
			else
			{
				callback(null);
			}
		}

		public static IEnumerator<UnityWebRequestAsyncOperation> TryLoadingAudioClipLocal(string fileName, Action<AudioClip> callback)
		{
			string assetDir = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), "Music");
			assetDir = Path.Combine(assetDir, fileName);
			UnityWebRequest webRequest = UnityWebRequestMultimedia.GetAudioClip("file://" + assetDir, (AudioType)13);
			yield return webRequest.SendWebRequest();
			if (!HasError(webRequest, assetDir))
			{
				callback(DownloadHandlerAudioClip.GetContent(webRequest));
			}
		}

		public static IEnumerator<UnityWebRequestAsyncOperation> TryLoadingSongAudio(string fileName, Action<AudioClip> callback)
		{
			UnityWebRequest webRequest = UnityWebRequestMultimedia.GetAudioClip("file://" + fileName, (AudioType)14);
			yield return webRequest.SendWebRequest();
			if (!HasError(webRequest, fileName))
			{
				callback(DownloadHandlerAudioClip.GetContent(webRequest));
			}
		}

		public static IEnumerator<UnityWebRequestAsyncOperation> TryLoadingSound(string fileName, Action<AudioClip> callback)
		{
			string assetDir = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location), "Music");
			assetDir = Path.Combine(assetDir, fileName);
			UnityWebRequest webRequest = UnityWebRequestMultimedia.GetAudioClip("file://" + assetDir, (AudioType)20);
			yield return webRequest.SendWebRequest();
			if (!HasError(webRequest, assetDir))
			{
				callback(DownloadHandlerAudioClip.GetContent(webRequest));
			}
		}

		private static UnityWebRequest PostUploadRequest(string query, byte[] data, string contentType = "application/json")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			DownloadHandler val = (DownloadHandler)new DownloadHandlerBuffer();
			UploadHandler val2 = (UploadHandler)new UploadHandlerRaw(data);
			val2.contentType = contentType;
			return new UnityWebRequest(query, "POST", val, val2);
		}

		private static UnityWebRequest PostUploadRequestWithHeader(string query, byte[] data, List<string[]> headers, string contentType = "application/json")
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			DownloadHandler val = (DownloadHandler)new DownloadHandlerBuffer();
			UploadHandler val2 = (UploadHandler)new UploadHandlerRaw(data);
			val2.contentType = contentType;
			UnityWebRequest val3 = new UnityWebRequest(query, "POST", val, val2);
			foreach (string[] header in headers)
			{
				val3.SetRequestHeader(header[0], header[1]);
			}
			return val3;
		}

		private static bool HasError(UnityWebRequest webRequest)
		{
			if (!webRequest.isNetworkError)
			{
				return webRequest.isHttpError;
			}
			return true;
		}

		private static bool HasError(UnityWebRequest webRequest, string query)
		{
			if (webRequest.isNetworkError || webRequest.isHttpError)
			{
				Plugin.LogError("QUERY ERROR: " + query);
			}
			if (webRequest.isNetworkError)
			{
				Plugin.LogError("NETWORK ERROR: " + webRequest.error);
			}
			if (webRequest.isHttpError)
			{
				Plugin.LogError("HTTP ERROR " + webRequest.error);
			}
			if (!webRequest.isNetworkError)
			{
				return webRequest.isHttpError;
			}
			return true;
		}
	}
	public static class MultSerializableClasses
	{
		[Serializable]
		public struct APIShutdownSubmission
		{
			public string lobby_code;
		}

		[Serializable]
		public struct APICreateSubmission
		{
			public string name;

			public string description;

			public string password;

			public int maxPlayer;

			public string version;

			public bool autorotate;

			public bool autostart;

			public bool teams;

			public bool freemod;
		}

		[Serializable]
		public struct APIMultiplayerInfo
		{
			public int count { get; set; }

			public List<MultiplayerLobbyInfo> lobbies { get; set; }
		}

		[Serializable]
		public struct MultiplayerLobbyInfo
		{
			public bool autorotate;

			public string code;

			public string description;

			public string id;

			public int maxPlayerCount;

			public string title;

			public bool hasPassword;

			public string state;

			public bool teams;

			public bool freemod;

			public bool autostart;

			public LobbyType lobbytype;

			public List<MultiplayerUserInfo> players;

			public MultiplayerSongInfo songInfo;
		}

		[Serializable]
		public struct MultiplayerSongInfo
		{
			public float difficulty;

			public string charter;

			public string download;

			public string mirror;

			public string fileHash;

			public float gameSpeed;

			public string modifiers;

			public int songID;

			public string songName;

			public string songShortName;

			public string trackRef;

			public bool isRated;

			public float[] speed_diffs;
		}

		[Serializable]
		public struct MultiplayerUserInfo
		{
			public string country;

			public int id;

			public int rank;

			public int team;

			public string username;

			public string state;

			public string mods;

			public bool isHost;
		}

		public enum MultiplayerTeamState
		{
			Red,
			Blue
		}

		public enum UserState
		{
			None,
			Ready,
			NotReady,
			NoSong,
			SelectingSong,
			Loading,
			Playing,
			Host,
			Spectating,
			Unknown
		}

		public enum LobbyType
		{
			Individual,
			Team,
			Rated,
			BattleRoyal,
			Casual
		}
	}
}