using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UKSRR.Game;
using UKSRR.Integrity;
using UKSRR.Match;
using UKSRR.Network;
using UKSRR.Timing;
using UKSRR.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("pink404")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("UKSRR")]
[assembly: AssemblyTitle("UKSRR")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 UKSRR
{
	[BepInPlugin("com.uksrr.client", "UKSR Ranked", "1.0.21")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.uksrr.client";

		public const string Name = "UKSR Ranked";

		public const string Version = "1.0.21";

		private Harmony _harmony;

		internal static Plugin Instance { get; private set; }

		internal MatchManager Matches { get; private set; }

		internal RankedNotificationManager Notifications { get; private set; }

		internal SteamRankedBridge Network { get; private set; }

		private void Awake()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			RankedSettings.Initialize(((BaseUnityPlugin)this).Config);
			ThumbnailCatalog.Initialize(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), ((BaseUnityPlugin)this).Logger);
			Matches = new MatchManager(((BaseUnityPlugin)this).Logger);
			RankedFinalRankHook.Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			Notifications = ((Component)this).gameObject.AddComponent<RankedNotificationManager>();
			Notifications.Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			Matches.InitializeNotifications(Notifications);
			Network = ((Component)this).gameObject.AddComponent<SteamRankedBridge>();
			Network.Initialize(Matches, Notifications, ((BaseUnityPlugin)this).Logger);
			_harmony = new Harmony("com.uksrr.client");
			_harmony.PatchAll();
			((Component)this).gameObject.AddComponent<SceneWatcher>().Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			((Component)this).gameObject.AddComponent<GameplayProbe>().Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			((Component)this).gameObject.AddComponent<RankedResultWatcher>().Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			RankedSpectatorOverlay rankedSpectatorOverlay = ((Component)this).gameObject.AddComponent<RankedSpectatorOverlay>();
			MainMenuInjector mainMenuInjector = ((Component)this).gameObject.AddComponent<MainMenuInjector>();
			rankedSpectatorOverlay.Initialize(Matches, Network, ((BaseUnityPlugin)this).Logger, null);
			mainMenuInjector.Initialize(Matches, Network, rankedSpectatorOverlay, ((BaseUnityPlugin)this).Logger);
			((Component)this).gameObject.AddComponent<PauseMenuRewriter>().Initialize(Matches, ((BaseUnityPlugin)this).Logger);
			((Component)this).gameObject.AddComponent<RankedHud>().Initialize(Matches, Network, Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "icon.png"));
			IntegrityScanner.LogLoadedPlugins(((BaseUnityPlugin)this).Logger);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"UKSR Ranked v1.0.21 loaded. authoritative vanilla-timer IGT, one-step hybrid joins, Steam friend invites, in-level spectating, responsive UI, and shared results.");
		}

		private void Update()
		{
			Matches.Tick();
		}

		private void OnDestroy()
		{
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
			}
		}
	}
}
namespace UKSRR.UI
{
	public sealed class MainMenuInjector : MonoBehaviour
	{
		private enum SelectionContext
		{
			None,
			PrivateLobby,
			PublicMatch
		}

		private MatchManager _matches;

		private SteamRankedBridge _network;

		private RankedSpectatorOverlay _spectator;

		private ManualLogSource _log;

		private GameObject _rankedButton;

		private RankedPanel _panel;

		private Button _styleTemplate;

		private Button _vanillaPlay;

		private VanillaMenuBridge _vanillaMenus;

		private float _nextScan;

		private int _scanAttemptsRemaining;

		private SelectionContext _selectionContext;

		private int _publicBrowserPage;

		private int _lastLobbyUiRevision = -1;

		private float _nextUiAutoRefresh;

		private bool _spectatorResultsActive;

		private bool _pendingLevelPRank;

		private string _browseLayer = "OVERTURE";

		public void Initialize(MatchManager matches, SteamRankedBridge network, RankedSpectatorOverlay spectator, ManualLogSource log)
		{
			_matches = matches;
			_network = network;
			_spectator = spectator;
			_log = log;
			_vanillaMenus = new VanillaMenuBridge((MonoBehaviour)(object)this, _matches, _log, GetVanillaPlay, OpenRankedHome, OnLevelSelected);
			_scanAttemptsRemaining = 120;
			SceneManager.activeSceneChanged += OnActiveSceneChanged;
			_log.LogInfo((object)"UKSR Ranked injector initialized. Exact 0.3.1 discovery + scene-aware reinjection.");
		}

		private void OnDestroy()
		{
			SceneManager.activeSceneChanged -= OnActiveSceneChanged;
			if (_vanillaMenus != null)
			{
				_vanillaMenus.RestoreDifficultyButtonsPublic();
				_vanillaMenus.RestoreLevelButtons();
			}
		}

		private void OnActiveSceneChanged(Scene previous, Scene next)
		{
			_rankedButton = null;
			_vanillaPlay = null;
			_scanAttemptsRemaining = 8;
			_nextScan = Time.unscaledTime + 0.35f;
		}

		private void Update()
		{
			if ((Object)(object)_network != (Object)null && Time.unscaledTime >= _nextUiAutoRefresh)
			{
				_nextUiAutoRefresh = Time.unscaledTime + 0.2f;
				if (_network.LobbyUiRevision != _lastLobbyUiRevision)
				{
					_lastLobbyUiRevision = _network.LobbyUiRevision;
					if (_panel != null && _network.InLobby)
					{
						OpenNetworkPrivateLobby();
					}
				}
			}
			if (_panel != null && !_panel.Alive)
			{
				_panel = null;
			}
			if ((Object)(object)_network != (Object)null && _network.AlternativeOfferPending && _network.IsSearching)
			{
				OpenAlternativeQueueOffer();
				return;
			}
			if (_matches.ReturnToLobbyOnMenuRequested)
			{
				Button val = FindButton("PLAY");
				if ((Object)(object)val != (Object)null)
				{
					_vanillaPlay = val;
					Button val2 = FindButton("OPTIONS");
					_styleTemplate = (((Object)(object)val2 != (Object)null) ? val2 : val);
					bool num = _matches.State == MatchState.Finished;
					_matches.ConsumeReturnToLobbyRequest();
					if (num)
					{
						OpenMatchResults();
					}
					else if ((Object)(object)_network != (Object)null && !string.IsNullOrEmpty(_network.LobbyId))
					{
						if (_network.CurrentLobbyIsPrivate)
						{
							OpenNetworkPrivateLobby();
						}
						else
						{
							OpenPublicQueue();
						}
					}
					else
					{
						OpenRankedHome();
					}
					return;
				}
			}
			if (!((Object)(object)_rankedButton != (Object)null) && _scanAttemptsRemaining > 0 && !(Time.unscaledTime < _nextScan))
			{
				_scanAttemptsRemaining--;
				_nextScan = Time.unscaledTime + ((_scanAttemptsRemaining > 8) ? 0.1f : 0.5f);
				TryInjectMainMenuButton();
			}
		}

		private void TryInjectMainMenuButton()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			Button val = FindButton("PLAY");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			_vanillaPlay = val;
			if (!((Object)(object)GameObject.Find("UKSRR_RankedPlay") != (Object)null))
			{
				Button val2 = FindButton("OPTIONS");
				_styleTemplate = (((Object)(object)val2 != (Object)null) ? val2 : val);
				Button val3 = Object.Instantiate<Button>(_styleTemplate, ((Component)val).transform.parent);
				((Component)val3).gameObject.SetActive(false);
				((Object)((Component)val3).gameObject).name = "UKSRR_RankedPlay";
				((Component)val3).transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex() + 1);
				PlaceUnderPlay(val, val3);
				UiText.Set(((Component)val3).gameObject, "RANKED PLAY");
				val3.onClick = new ButtonClickedEvent();
				((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
				{
					OpenRankedDifficultySelect();
				});
				((Component)val3).gameObject.SetActive(true);
				_rankedButton = ((Component)val3).gameObject;
				_log.LogInfo((object)"Injected RANKED PLAY under PLAY. Exact 0.3.1 discovery succeeded.");
			}
		}

		private Button GetVanillaPlay()
		{
			if ((Object)(object)_vanillaPlay != (Object)null && (Object)(object)((Component)_vanillaPlay).gameObject != (Object)null)
			{
				return _vanillaPlay;
			}
			_vanillaPlay = FindButton("PLAY");
			return _vanillaPlay;
		}

		private static Button FindButton(string text)
		{
			return ((IEnumerable<Button>)Resources.FindObjectsOfTypeAll<Button>()).FirstOrDefault((Func<Button, bool>)delegate(Button b)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)b != (Object)null)
				{
					Scene scene = ((Component)b).gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && ((Component)b).gameObject.activeInHierarchy)
					{
						return string.Equals(UiText.Get(((Component)b).gameObject).Trim(), text, StringComparison.OrdinalIgnoreCase);
					}
				}
				return false;
			});
		}

		private static void PlaceUnderPlay(Button play, Button ranked)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00c0: 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_00da: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Component)play).transform.parent;
			if ((Object)(object)((Component)parent).GetComponent<VerticalLayoutGroup>() != (Object)null || (Object)(object)((Component)parent).GetComponent<GridLayoutGroup>() != (Object)null)
			{
				return;
			}
			RectTransform component = ((Component)play).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)ranked).GetComponent<RectTransform>();
			Rect rect = component.rect;
			float num = Mathf.Max(55f, Mathf.Abs(((Rect)(ref rect)).height) + 8f);
			component2.anchoredPosition = component.anchoredPosition + Vector2.down * num;
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (!((Object)(object)val == (Object)(object)((Component)play).transform) && !((Object)(object)val == (Object)(object)((Component)ranked).transform))
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (!((Object)(object)val2 == (Object)null) && val2.anchoredPosition.y < component.anchoredPosition.y)
					{
						val2.anchoredPosition += Vector2.down * num;
					}
				}
			}
		}

		public void OpenRankedHome()
		{
			ClosePanel();
			Button vanillaPlay = GetVanillaPlay();
			if ((Object)(object)vanillaPlay == (Object)null)
			{
				_log.LogWarning((object)"UKSRR cannot open ranked menu because vanilla PLAY is unavailable.");
				return;
			}
			Button val = FindButton("OPTIONS");
			_styleTemplate = (((Object)(object)val != (Object)null) ? val : vanillaPlay);
			if ((Object)(object)_network == (Object)null || !_network.SteamProfileReady)
			{
				OpenSteamConnectionError();
				return;
			}
			_matches.EnterLobby();
			_panel = new RankedPanel(_styleTemplate, "UKSR RANKED");
			_panel.AddButton("PUBLIC MATCH", OpenPublicMatch);
			_panel.AddButton("PRIVATE LOBBY", OpenPrivateLobby);
			_panel.AddButton("PROFILE", OpenProfile);
			_panel.AddButton("SETTINGS", OpenSettings);
			_panel.AddButton("DIFFICULTY: " + _matches.DifficultyName, OpenRankedDifficultySelect);
			_panel.AddButton("BACK", ClosePanel);
		}

		private void OpenSteamConnectionError()
		{
			ClosePanel();
			Button vanillaPlay = GetVanillaPlay();
			if ((Object)(object)vanillaPlay != (Object)null)
			{
				Button val = FindButton("OPTIONS");
				_styleTemplate = (((Object)(object)val != (Object)null) ? val : vanillaPlay);
			}
			_panel = new RankedPanel(_styleTemplate, "STEAM CONNECTION ERROR");
			_panel.AddLabel("UKSR COULD NOT FIND A VALID STEAM PROFILE.");
			_panel.AddLabel(((Object)(object)_network == (Object)null) ? "NETWORK BRIDGE UNAVAILABLE" : _network.SteamConnectionError);
			_panel.AddLabel("STEAM MUST BE RUNNING AND ULTRAKILL MUST BE CONNECTED TO YOUR STEAM PROFILE.");
			_panel.AddButton("RETRY STEAM CONNECTION", delegate
			{
				if ((Object)(object)_network != (Object)null && _network.RefreshSteamIdentity())
				{
					OpenRankedHome();
				}
				else
				{
					OpenSteamConnectionError();
				}
			});
			_panel.AddButton("BACK", ClosePanel);
		}

		private void OpenRankedDifficultySelect()
		{
			ClosePanel();
			Button vanillaPlay = GetVanillaPlay();
			if ((Object)(object)vanillaPlay != (Object)null)
			{
				Button val = FindButton("OPTIONS");
				_styleTemplate = (((Object)(object)val != (Object)null) ? val : vanillaPlay);
			}
			_panel = new RankedPanel(_styleTemplate, "SELECT DIFFICULTY");
			List<RankedPanel.GridItem> items = new List<RankedPanel.GridItem>();
			AddDifficultyItem(items, 0, "HARMLESS");
			AddDifficultyItem(items, 1, "LENIENT");
			AddDifficultyItem(items, 2, "STANDARD");
			AddDifficultyItem(items, 3, "VIOLENT");
			AddDifficultyItem(items, 4, "BRUTAL");
			_panel.AddGrid(items, 2, 480f, 60f);
			((Selectable)_panel.AddButton("ULTRAKILL MUST DIE // DISABLED", null)).interactable = false;
			_panel.AddButton("BACK", OpenRankedHome);
		}

		private void AddDifficultyItem(List<RankedPanel.GridItem> items, int value, string name)
		{
			string label = ((_matches.Difficulty == value) ? ("> " + name + " <") : name);
			items.Add(new RankedPanel.GridItem(label, delegate
			{
				_matches.SetDifficulty(value, name);
				OpenRankedHome();
			}));
		}

		private void OpenPublicMatch()
		{
			_selectionContext = SelectionContext.PublicMatch;
			_publicBrowserPage = 0;
			OpenPublicCategorySelect();
		}

		private void OpenPublicCategorySelect()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "PUBLIC MATCH // CATEGORY");
			List<RankedPanel.GridItem> list = new List<RankedPanel.GridItem>();
			list.Add(new RankedPanel.GridItem("FULL GAME ANY%", delegate
			{
				_matches.SetCategory(CategoryDefinition.FullGameAny());
				StartPublicSearch();
			}));
			list.Add(new RankedPanel.GridItem("FULL GAME P-RANK", delegate
			{
				_matches.SetCategory(CategoryDefinition.FullGamePRank());
				StartPublicSearch();
			}));
			list.Add(new RankedPanel.GridItem("ACT ANY%", delegate
			{
				OpenPublicActSelect(pRank: false);
			}));
			list.Add(new RankedPanel.GridItem("ACT P-RANK", delegate
			{
				OpenPublicActSelect(pRank: true);
			}));
			list.Add(new RankedPanel.GridItem("LAYER ANY%", delegate
			{
				OpenPublicLayerSelect(pRank: false);
			}));
			list.Add(new RankedPanel.GridItem("LAYER P-RANK", delegate
			{
				OpenPublicLayerSelect(pRank: true);
			}));
			list.Add(new RankedPanel.GridItem("LEVEL ANY%", delegate
			{
				OpenLevelSelectForContext(pRank: false, SelectionContext.PublicMatch);
			}));
			list.Add(new RankedPanel.GridItem("LEVEL P-RANK", delegate
			{
				OpenLevelSelectForContext(pRank: true, SelectionContext.PublicMatch);
			}));
			_panel.AddPagedGrid(list, _publicBrowserPage, 3, delegate(int nextPage)
			{
				_publicBrowserPage = nextPage;
				OpenPublicCategorySelect();
			});
			_panel.AddBottomLeftAction("BACK", OpenRankedHome, 0);
		}

		private void OpenPublicActSelect(bool pRank)
		{
			OpenActSelectForContext(pRank, SelectionContext.PublicMatch);
		}

		private void OpenPublicLayerSelect(bool pRank)
		{
			OpenLayerSelectForContext(pRank, SelectionContext.PublicMatch);
		}

		private void StartPublicSearch()
		{
			if ((Object)(object)_network != (Object)null)
			{
				string level = ((_matches.Category == null) ? "" : _matches.Category.Scope);
				_network.BeginRankedSearchFor(level, _matches.DifficultyName);
			}
			OpenPublicQueue();
		}

		private void OpenPublicQueue()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "PUBLIC MATCH // MATCHMAKING");
			_panel.AddLabel("CATEGORY: " + ((_matches.Category == null) ? "NOT SELECTED" : _matches.Category.DisplayName));
			_panel.AddLabel("DIFFICULTY: " + _matches.DifficultyName);
			_panel.AddLabel("ELO: " + RankedSettings.Rating + " // SOFT MATCH ONLY");
			_panel.AddLabel("STATUS: " + (((Object)(object)_network == (Object)null) ? "NETWORK UNAVAILABLE" : _network.Status));
			if ((Object)(object)_network != (Object)null && _network.AlternativeQueueAvailable)
			{
				_panel.AddLabel("OTHER QUEUE: " + _network.AlternativeQueueLabel);
				_panel.AddButton("JOIN OTHER QUEUE", delegate
				{
					_network.AcceptAlternativeQueue();
					OpenPublicQueue();
				});
			}
			if ((Object)(object)_network != (Object)null && !string.IsNullOrEmpty(_network.LobbyId))
			{
				_panel.AddLabel("MATCH ID: " + _network.LobbyId);
			}
			_panel.AddButton(((Object)(object)_network != (Object)null && _network.IsSearching) ? "CANCEL MATCHMAKING" : "SEARCH AGAIN", delegate
			{
				if ((Object)(object)_network != (Object)null)
				{
					if (_network.IsSearching)
					{
						_network.CancelRankedSearch();
					}
					else
					{
						StartPublicSearch();
					}
				}
				OpenPublicQueue();
			});
			_panel.AddButton("CHANGE CATEGORY", OpenPublicCategorySelect);
			_panel.AddButton("BACK", OpenRankedHome);
		}

		private void OpenAlternativeQueueOffer()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "MATCHMAKING OPTION");
			_panel.AddLabel("NO ONE IS QUEUEING YOUR EXACT CATEGORY.");
			_panel.AddLabel("SOMEONE IS QUEUEING:");
			_panel.AddLabel(((Object)(object)_network == (Object)null) ? "UNKNOWN" : _network.AlternativeQueueLabel);
			_panel.AddLabel("WANT TO RUN THAT INSTEAD?");
			_panel.AddButton("YES // JOIN THAT QUEUE", delegate
			{
				if ((Object)(object)_network != (Object)null)
				{
					_network.AcceptAlternativeQueue();
				}
				OpenPublicQueue();
			});
			_panel.AddButton("NO // KEEP SEARCHING", delegate
			{
				if ((Object)(object)_network != (Object)null)
				{
					_network.DismissAlternativeQueue();
				}
				OpenPublicQueue();
			});
		}

		private void OpenMatchResults()
		{
			ClosePanel();
			Button vanillaPlay = GetVanillaPlay();
			if ((Object)(object)vanillaPlay != (Object)null)
			{
				Button val = FindButton("OPTIONS");
				_styleTemplate = (((Object)(object)val != (Object)null) ? val : vanillaPlay);
			}
			if ((Object)(object)_styleTemplate == (Object)null)
			{
				_log.LogWarning((object)"UKSR cannot open results because no menu button template is available.");
				OpenRankedHome();
				return;
			}
			List<RankedStanding> list = (((Object)(object)_network == (Object)null) ? new List<RankedStanding>() : _network.GetStandings());
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (!list[i].Finished && !list[i].Forfeit)
				{
					num++;
				}
			}
			if ((Object)(object)_network != (Object)null)
			{
				for (int j = 0; j < _network.LivePeers.Count; j++)
				{
					RankedLivePeer rankedLivePeer = _network.LivePeers[j];
					if (rankedLivePeer == null || rankedLivePeer.State == "finished" || rankedLivePeer.State == "forfeit")
					{
						continue;
					}
					bool flag = false;
					for (int k = 0; k < list.Count; k++)
					{
						if (list[k].SteamId == rankedLivePeer.SteamId)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						num++;
					}
				}
			}
			_spectatorResultsActive = _matches != null && _matches.State == MatchState.Finished && num > 0;
			_panel = new RankedPanel(_styleTemplate, _spectatorResultsActive ? "SPECTATING REMAINING RUNNERS" : "MATCH RESULTS");
			if (_spectatorResultsActive)
			{
				_panel.AddLabel("YOUR RUN IS LOCKED IN // WAITING FOR " + num + " PLAYER" + ((num == 1) ? "" : "S"));
				_panel.AddLabel(" ");
				for (int l = 0; l < list.Count; l++)
				{
					RankedStanding rankedStanding = list[l];
					if (rankedStanding.IsSelf)
					{
						_panel.AddLabel("YOU // FINISHED // " + RankedNotificationManager.FormatTime(rankedStanding.Igt));
						continue;
					}
					if (rankedStanding.Finished)
					{
						_panel.AddLabel(rankedStanding.Name + " // FINISHED // " + RankedNotificationManager.FormatTime(rankedStanding.Igt));
						continue;
					}
					if (rankedStanding.Forfeit)
					{
						_panel.AddLabel(rankedStanding.Name + " // DNF");
						continue;
					}
					RankedLivePeer rankedLivePeer2 = null;
					if ((Object)(object)_network != (Object)null)
					{
						for (int m = 0; m < _network.LivePeers.Count; m++)
						{
							if (_network.LivePeers[m].SteamId == rankedStanding.SteamId)
							{
								rankedLivePeer2 = _network.LivePeers[m];
								break;
							}
						}
					}
					string text = rankedStanding.Name + " // RUNNING";
					if (rankedLivePeer2 != null)
					{
						text = text + " // IGT " + RankedNotificationManager.FormatTime(rankedLivePeer2.Igt);
						if (!string.IsNullOrEmpty(rankedLivePeer2.Level))
						{
							text = text + " // " + rankedLivePeer2.Level;
						}
					}
					_panel.AddLabel(text);
				}
				_panel.AddLabel(" ");
				_panel.AddLabel("RUNNING PLAYERS // SPECTATE FROM THE RIGHT");
				int num2 = 0;
				if ((Object)(object)_network != (Object)null)
				{
					for (int n = 0; n < _network.LivePeers.Count; n++)
					{
						RankedLivePeer rankedLivePeer3 = _network.LivePeers[n];
						if (rankedLivePeer3 == null || rankedLivePeer3.State != "running")
						{
							continue;
						}
						string label = rankedLivePeer3.Name + " // " + (string.IsNullOrEmpty(rankedLivePeer3.Level) ? "RUNNING" : rankedLivePeer3.Level) + " // IGT " + RankedNotificationManager.FormatTime(rankedLivePeer3.Igt);
						string steamId = rankedLivePeer3.SteamId;
						_panel.AddRightColumnButton(label, delegate
						{
							if ((Object)(object)_spectator != (Object)null)
							{
								_spectator.SpectateSteamId(steamId);
							}
						}, num2);
						num2++;
					}
				}
				_panel.AddBottomLeftAction("REFRESH RESULTS", OpenMatchResults, 0);
				((MonoBehaviour)this).StartCoroutine(RefreshResultsVisualNextFrames());
				return;
			}
			RankedStanding rankedStanding2 = null;
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				if (list[num3].Finished)
				{
					rankedStanding2 = list[num3];
					break;
				}
			}
			if (rankedStanding2 != null)
			{
				_panel.AddLabel("WINNER // " + rankedStanding2.Name);
				_panel.AddLabel("BEST IGT // " + RankedNotificationManager.FormatTime(rankedStanding2.Igt));
			}
			else
			{
				_panel.AddLabel("NO FINISHER");
			}
			_panel.AddLabel(" ");
			int num4 = 1;
			for (int num5 = 0; num5 < list.Count; num5++)
			{
				RankedStanding rankedStanding3 = list[num5];
				string text2;
				if (!rankedStanding3.Finished)
				{
					text2 = ((!rankedStanding3.Forfeit) ? ("... " + rankedStanding3.Name + " // UNRESOLVED") : ("DNF // " + rankedStanding3.Name));
				}
				else
				{
					text2 = num4 + ". " + rankedStanding3.Name + "   IGT " + RankedNotificationManager.FormatTime(rankedStanding3.Igt) + "   RTA " + RankedNotificationManager.FormatTime(rankedStanding3.Rta);
					num4++;
				}
				if (rankedStanding3.IsSelf)
				{
					text2 += " // YOU";
				}
				_panel.AddLabel(text2);
			}
			if (list.Count == 0)
			{
				_panel.AddLabel("NO RESULT DATA");
			}
			_panel.AddButton("REFRESH RESULTS", OpenMatchResults);
			_panel.AddButton("RETURN TO LOBBY", delegate
			{
				_spectatorResultsActive = false;
				if ((Object)(object)_network != (Object)null && !string.IsNullOrEmpty(_network.LobbyId))
				{
					if (_network.CurrentLobbyIsPrivate)
					{
						OpenNetworkPrivateLobby();
					}
					else
					{
						OpenPublicQueue();
					}
				}
				else
				{
					OpenRankedHome();
				}
			});
			((MonoBehaviour)this).StartCoroutine(RefreshResultsVisualNextFrames());
			_panel.ForceRefresh();
		}

		private IEnumerator RefreshResultsVisualNextFrames()
		{
			yield return null;
			if (_panel != null && _panel.Alive)
			{
				_panel.ForceRefresh();
			}
			yield return (object)new WaitForSecondsRealtime(0.08f);
			if (_panel != null && _panel.Alive)
			{
				_panel.ForceRefresh();
			}
		}

		private void OpenNetworkPrivateLobby()
		{
			ClosePanel();
			_selectionContext = SelectionContext.PrivateLobby;
			_panel = new RankedPanel(_styleTemplate, "PRIVATE LOBBY");
			_panel.AddLabel("PLAYER: " + (((Object)(object)_network == (Object)null) ? "UNAVAILABLE" : (_network.SteamProfileReady ? _network.SteamName : "STEAM NOT CONNECTED")));
			if ((Object)(object)_network == (Object)null || string.IsNullOrEmpty(_network.LobbyId))
			{
				_panel.AddButton("CREATE ROOM", delegate
				{
					if ((Object)(object)_network != (Object)null)
					{
						_network.CreateRoom();
					}
					OpenNetworkPrivateLobby();
				});
				_panel.AddButton("JOIN ROOM FROM CLIPBOARD", delegate
				{
					if ((Object)(object)_network != (Object)null)
					{
						_network.JoinRoomFromClipboard();
					}
					OpenNetworkPrivateLobby();
				});
				_panel.AddLabel("COPY A UKSR ROOM CODE, THEN PRESS JOIN ROOM.");
				_panel.AddLabel("STATUS: " + (((Object)(object)_network == (Object)null) ? "NETWORK UNAVAILABLE" : _network.Status));
				_panel.AddButton("BACK", OpenRankedHome);
				return;
			}
			_panel.AddLabel("ROOM CODE: " + _network.LobbyCode);
			_panel.AddButton("COPY ROOM CODE", delegate
			{
				GUIUtility.systemCopyBuffer = _network.LobbyCode;
				OpenNetworkPrivateLobby();
			});
			_panel.AddRightColumnLabel("PLAYERS // " + _network.LobbyPlayers.Count + "/8", 0);
			for (int num = 0; num < _network.LobbyPlayers.Count && num < 8; num++)
			{
				_panel.AddRightColumnLabel(num + 1 + ". " + _network.LobbyPlayers[num], num + 1);
			}
			if (_network.IsLobbyOwner)
			{
				_panel.AddButton("CHANGE CATEGORY / MAP", OpenPrivateCategorySelect);
			}
			else
			{
				_panel.AddLabel("CATEGORY / LEVEL CONTROLLED BY HOST");
			}
			_panel.AddLabel("CATEGORY: " + ((_matches.Category == null) ? "WAITING FOR HOST" : _matches.Category.DisplayName));
			if (_matches.Category != null && _matches.Category.IsLevelSpecific)
			{
				_panel.AddLabel("LEVEL: " + (string.IsNullOrEmpty(_matches.SelectedLevel) ? "NOT SELECTED" : _matches.SelectedLevel));
			}
			_panel.AddBottomRightButton(_network.IsReady ? "READY: YES" : "READY UP", delegate
			{
				_network.SetRoomReady();
				OpenNetworkPrivateLobby();
			}, 1);
			if (_network.IsLobbyOwner && _network.AllPlayersReady)
			{
				_panel.AddBottomRightButton("START GAME", delegate
				{
					StartPrivateRankedRun();
				}, 0);
			}
			else if (_network.IsLobbyOwner)
			{
				((Selectable)_panel.AddBottomRightButton("WAITING FOR READY", null, 0)).interactable = false;
			}
			_panel.AddBottomLeftAction("LEAVE ROOM", delegate
			{
				_network.LeaveRoom();
				OpenRankedHome();
			}, 0);
			_panel.ForceRefresh();
		}

		private void StartPrivateRankedRun()
		{
			if (!((Object)(object)_network == (Object)null))
			{
				_network.StartRoom();
				if (_matches.State != MatchState.WaitingForFirstInput)
				{
					OpenNetworkPrivateLobby();
				}
				else
				{
					ClosePanel();
				}
			}
		}

		private void OpenPrivateCategorySelect()
		{
			if ((Object)(object)_network != (Object)null && !_network.IsLobbyOwner)
			{
				OpenNetworkPrivateLobby();
				return;
			}
			_selectionContext = SelectionContext.PrivateLobby;
			OpenCategorySelect();
		}

		private void OpenNetworkProfile()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "UKSR // PROFILE");
			_panel.AddLabel("PLAYER: " + (((Object)(object)_network == (Object)null) ? "UNKNOWN" : _network.SteamName));
			_panel.AddLabel("UKSR CLIENT: " + (((Object)(object)_network == (Object)null) ? "UNKNOWN" : _network.ClientId));
			_panel.AddLabel("STEAM: " + (((Object)(object)_network == (Object)null) ? "UNAVAILABLE" : (_network.SteamProfileReady ? _network.SteamId : "NOT CONNECTED")));
			_panel.AddLabel("CATEGORY: " + ((_matches.Category == null) ? "NOT SELECTED" : _matches.Category.DisplayName));
			_panel.AddLabel("DIFFICULTY: " + _matches.DifficultyName);
			_panel.AddLabel("ELO: " + RankedSettings.Rating);
			_panel.AddLabel("RECORD: " + RankedSettings.Record);
			_panel.AddButton("BACK", OpenRankedHome);
		}

		private void OpenSettings()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "UKSR // SETTINGS");
			_panel.AddButton("TIMER: " + (RankedSettings.TimerEnabled ? "ON" : "OFF"), delegate
			{
				RankedSettings.TimerEnabled = !RankedSettings.TimerEnabled;
				OpenSettings();
			});
			_panel.AddLabel("TIMER POSITION");
			List<RankedPanel.GridItem> list = new List<RankedPanel.GridItem>();
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.TopLeft, "TOP LEFT"), delegate
			{
				SetTimerPosition(TimerPosition.TopLeft);
			}));
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.TopCenter, "TOP CENTER"), delegate
			{
				SetTimerPosition(TimerPosition.TopCenter);
			}));
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.TopRight, "TOP RIGHT"), delegate
			{
				SetTimerPosition(TimerPosition.TopRight);
			}));
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.BottomLeft, "BOTTOM LEFT"), delegate
			{
				SetTimerPosition(TimerPosition.BottomLeft);
			}));
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.BottomCenter, "BOTTOM CENTER"), delegate
			{
				SetTimerPosition(TimerPosition.BottomCenter);
			}));
			list.Add(new RankedPanel.GridItem(TimerPositionLabel(TimerPosition.BottomRight, "BOTTOM RIGHT"), delegate
			{
				SetTimerPosition(TimerPosition.BottomRight);
			}));
			_panel.AddGrid(list, 3, 300f, 56f);
			_panel.AddLabel("TIMER PREVIEW");
			_panel.AddLabel(RankedSettings.TimerEnabled ? TimerPreviewText() : "[ TIMER DISABLED ]");
			_panel.AddButton("PROGRESS NOTIFICATIONS: " + (RankedSettings.ProgressNotifications ? "ON" : "OFF"), delegate
			{
				RankedSettings.ProgressNotifications = !RankedSettings.ProgressNotifications;
				OpenSettings();
			});
			_panel.AddButton("BACK", OpenRankedHome);
		}

		private void SetTimerPosition(TimerPosition position)
		{
			RankedSettings.TimerPosition = position;
			OpenSettings();
		}

		private static string TimerPositionLabel(TimerPosition position, string label)
		{
			if (RankedSettings.TimerPosition != position)
			{
				return label;
			}
			return "> " + label + " <";
		}

		private static string TimerPreviewText()
		{
			return "[" + RankedSettings.TimerPosition.ToString().ToUpperInvariant() + "]  RTA 00:01:23.456   IGT 00:01:19.882";
		}

		private void OpenCategorySelect()
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, (_selectionContext == SelectionContext.PrivateLobby) ? "PRIVATE LOBBY // CATEGORY" : "SELECT CATEGORY");
			List<RankedPanel.GridItem> list = new List<RankedPanel.GridItem>();
			list.Add(new RankedPanel.GridItem("FULL GAME ANY%", delegate
			{
				PickForContext(CategoryDefinition.FullGameAny());
			}));
			list.Add(new RankedPanel.GridItem("FULL GAME P-RANK", delegate
			{
				PickForContext(CategoryDefinition.FullGamePRank());
			}));
			list.Add(new RankedPanel.GridItem("ACT ANY%", delegate
			{
				OpenActSelectForContext(pRank: false, _selectionContext);
			}));
			list.Add(new RankedPanel.GridItem("ACT P-RANK", delegate
			{
				OpenActSelectForContext(pRank: true, _selectionContext);
			}));
			list.Add(new RankedPanel.GridItem("LAYER ANY%", delegate
			{
				OpenLayerSelectForContext(pRank: false, _selectionContext);
			}));
			list.Add(new RankedPanel.GridItem("LAYER P-RANK", delegate
			{
				OpenLayerSelectForContext(pRank: true, _selectionContext);
			}));
			list.Add(new RankedPanel.GridItem("LEVEL ANY%", delegate
			{
				_matches.SetCategory(CategoryDefinition.IndividualAny(""));
				_matches.SetSelectedLevel("");
				if (_selectionContext == SelectionContext.PrivateLobby)
				{
					OpenLevelSelectForContext(pRank: false, SelectionContext.PrivateLobby);
				}
				else
				{
					ReturnAfterCategoryChoice();
				}
			}));
			list.Add(new RankedPanel.GridItem("LEVEL P-RANK", delegate
			{
				_matches.SetCategory(CategoryDefinition.IndividualPRank(""));
				_matches.SetSelectedLevel("");
				if (_selectionContext == SelectionContext.PrivateLobby)
				{
					OpenLevelSelectForContext(pRank: true, SelectionContext.PrivateLobby);
				}
				else
				{
					ReturnAfterCategoryChoice();
				}
			}));
			_panel.AddGrid(list, 2, 480f, 60f);
			_panel.AddButton("BACK", (_selectionContext == SelectionContext.PrivateLobby) ? new Action(OpenNetworkPrivateLobby) : new Action(OpenRankedHome));
		}

		private void OpenActSelectForContext(bool pRank, SelectionContext context)
		{
			_selectionContext = context;
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, pRank ? "SELECT ACT // P-RANK" : "SELECT ACT // ANY%");
			string[] obj = new string[4] { "PRELUDE", "ACT I", "ACT II", "ACT III" };
			List<RankedPanel.GridItem> list = new List<RankedPanel.GridItem>();
			string[] array = obj;
			foreach (string text in array)
			{
				string captured = text;
				list.Add(new RankedPanel.GridItem(captured, delegate
				{
					CategoryDefinition category = (pRank ? CategoryDefinition.ActPRank(captured) : CategoryDefinition.ActAny(captured));
					_matches.SetCategory(category);
					if (_selectionContext == SelectionContext.PublicMatch)
					{
						StartPublicSearch();
					}
					else
					{
						OpenNetworkPrivateLobby();
					}
				}));
			}
			_panel.AddGrid(list, 2, 480f, 60f);
			_panel.AddButton("BACK", (_selectionContext == SelectionContext.PublicMatch) ? new Action(OpenPublicCategorySelect) : new Action(OpenCategorySelect));
		}

		private void OpenLayerSelectForContext(bool pRank, SelectionContext context)
		{
			_selectionContext = context;
			ClosePanel();
			if (string.IsNullOrEmpty(_browseLayer))
			{
				_browseLayer = "OVERTURE";
			}
			_panel = new RankedPanel(_styleTemplate, pRank ? "SELECT LAYER // P-RANK" : "SELECT LAYER // ANY%");
			List<RankedPanel.BrowserItem> list = new List<RankedPanel.BrowserItem>();
			LevelCatalog.LayerInfo[] layers = LevelCatalog.Layers;
			foreach (LevelCatalog.LayerInfo layerInfo in layers)
			{
				string captured = layerInfo.Name;
				list.Add(new RankedPanel.BrowserItem(captured, delegate
				{
					_browseLayer = captured;
					OpenLayerSelectForContext(pRank, context);
				}));
			}
			List<RankedPanel.PreviewItem> list2 = new List<RankedPanel.PreviewItem>();
			string[] levelsForLayer = LevelCatalog.GetLevelsForLayer(_browseLayer);
			foreach (string text in levelsForLayer)
			{
				list2.Add(new RankedPanel.PreviewItem(text, ThumbnailCatalog.GetTitle(text), text, null));
			}
			_panel.AddTwoPaneBrowser(list, list2, _browseLayer, delegate
			{
				CategoryDefinition category = (pRank ? CategoryDefinition.LayerPRank(_browseLayer) : CategoryDefinition.LayerAny(_browseLayer));
				_matches.SetCategory(category);
				if (_selectionContext == SelectionContext.PublicMatch)
				{
					StartPublicSearch();
				}
				else
				{
					OpenNetworkPrivateLobby();
				}
			});
			_panel.AddButton("BACK", (_selectionContext == SelectionContext.PublicMatch) ? new Action(OpenPublicCategorySelect) : new Action(OpenCategorySelect));
		}

		private void OpenLevelSelectForContext(bool pRank, SelectionContext context)
		{
			_selectionContext = context;
			ClosePanel();
			if (string.IsNullOrEmpty(_browseLayer))
			{
				_browseLayer = "OVERTURE";
			}
			_panel = new RankedPanel(_styleTemplate, pRank ? "SELECT LEVEL // P-RANK" : "SELECT LEVEL // ANY%");
			List<RankedPanel.BrowserItem> list = new List<RankedPanel.BrowserItem>();
			LevelCatalog.LayerInfo[] layers = LevelCatalog.Layers;
			foreach (LevelCatalog.LayerInfo layerInfo in layers)
			{
				string capturedLayer = layerInfo.Name;
				list.Add(new RankedPanel.BrowserItem(capturedLayer, delegate
				{
					_browseLayer = capturedLayer;
					OpenLevelSelectForContext(pRank, context);
				}));
			}
			List<RankedPanel.PreviewItem> list2 = new List<RankedPanel.PreviewItem>();
			string[] levelsForLayer = LevelCatalog.GetLevelsForLayer(_browseLayer);
			foreach (string text in levelsForLayer)
			{
				string capturedLevel = text;
				list2.Add(new RankedPanel.PreviewItem(capturedLevel, ThumbnailCatalog.GetTitle(capturedLevel), capturedLevel, delegate
				{
					_matches.SetSelectedLevel(capturedLevel);
					_matches.SetCategory(pRank ? CategoryDefinition.IndividualPRank(capturedLevel) : CategoryDefinition.IndividualAny(capturedLevel));
					OnLevelSelected();
				}));
			}
			_panel.AddTwoPaneBrowser(list, list2, _browseLayer, null);
			_panel.AddButton("BACK", (context == SelectionContext.PublicMatch) ? new Action(OpenPublicCategorySelect) : new Action(OpenNetworkPrivateLobby));
		}

		private void PickForContext(CategoryDefinition category)
		{
			_matches.SetCategory(category);
			ReturnAfterCategoryChoice();
		}

		private void ReturnAfterCategoryChoice()
		{
			if (_selectionContext == SelectionContext.PrivateLobby)
			{
				OpenNetworkPrivateLobby();
			}
			else if (_selectionContext == SelectionContext.PublicMatch)
			{
				StartPublicSearch();
			}
			else
			{
				OpenRankedHome();
			}
		}

		private void BeginLevelSelection(bool pRank)
		{
			_pendingLevelPRank = pRank;
			OpenLevelSelectForContext(pRank, _selectionContext);
		}

		private void OnLevelSelected()
		{
			if (_selectionContext == SelectionContext.PublicMatch)
			{
				StartPublicSearch();
			}
			else if (_selectionContext == SelectionContext.PrivateLobby)
			{
				OpenNetworkPrivateLobby();
			}
			else
			{
				OpenRankedHome();
			}
		}

		private void OpenPrivateLobby()
		{
			_selectionContext = SelectionContext.PrivateLobby;
			OpenNetworkPrivateLobby();
		}

		private void OpenProfile()
		{
			OpenNetworkProfile();
		}

		private void OpenError(string reason)
		{
			ClosePanel();
			_panel = new RankedPanel(_styleTemplate, "RANKED UNAVAILABLE");
			_panel.AddButton(reason, delegate
			{
			});
			_panel.AddButton("BACK", OpenRankedHome);
		}

		private void ClosePanel()
		{
			if (_panel != null)
			{
				_panel.Destroy();
			}
			_panel = null;
		}
	}
	public sealed class PauseMenuRewriter : MonoBehaviour
	{
		private MatchManager _matches;

		private ManualLogSource _log;

		private GameObject _hiddenVanilla;

		private GameObject _leaveMatchClone;

		private float _nextScan;

		public void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
		}

		private void Update()
		{
			if (!_matches.IsMatchActive)
			{
				Restore();
			}
			else if (!(Time.unscaledTime < _nextScan))
			{
				_nextScan = Time.unscaledTime + 0.25f;
				if ((Object)(object)_leaveMatchClone == (Object)null)
				{
					TryReplaceLeaveLevel();
				}
			}
		}

		private void TryReplaceLeaveLevel()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			Button val = ((IEnumerable<Button>)Resources.FindObjectsOfTypeAll<Button>()).FirstOrDefault((Func<Button, bool>)delegate(Button b)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)b != (Object)null)
				{
					Scene scene = ((Component)b).gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && ((Component)b).gameObject.activeInHierarchy)
					{
						return IsLeaveLevelText(UiText.Get(((Component)b).gameObject));
					}
				}
				return false;
			});
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Button val2 = Object.Instantiate<Button>(val, ((Component)val).transform.parent);
			((Object)((Component)val2).gameObject).name = "UKSRR_LeaveMatch";
			((Component)val2).transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex());
			UiText.Set(((Component)val2).gameObject, "LEAVE MATCH");
			ButtonClickedEvent vanillaExit = val.onClick;
			val2.onClick = new ButtonClickedEvent();
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				_matches.Forfeit("LEFT MATCH");
				Restore();
				if (vanillaExit != null)
				{
					((UnityEvent)vanillaExit).Invoke();
				}
			});
			_hiddenVanilla = ((Component)val).gameObject;
			_hiddenVanilla.SetActive(false);
			_leaveMatchClone = ((Component)val2).gameObject;
			_log.LogInfo((object)"Pause menu: LEAVE LEVEL replaced with LEAVE MATCH.");
		}

		private static bool IsLeaveLevelText(string raw)
		{
			string text = (raw ?? "").Trim().ToUpperInvariant();
			switch (text)
			{
			default:
				return text == "LEVEL SELECT";
			case "LEAVE LEVEL":
			case "QUIT MISSION":
			case "EXIT LEVEL":
				return true;
			}
		}

		private void Restore()
		{
			if ((Object)(object)_hiddenVanilla != (Object)null)
			{
				_hiddenVanilla.SetActive(true);
			}
			if ((Object)(object)_leaveMatchClone != (Object)null)
			{
				Object.Destroy((Object)(object)_leaveMatchClone);
			}
			_hiddenVanilla = null;
			_leaveMatchClone = null;
		}
	}
	public sealed class RankedHud : MonoBehaviour
	{
		private MatchManager _matches;

		private SteamRankedBridge _network;

		private GUIStyle _label;

		private GUIStyle _timerLabel;

		private Texture2D _bg;

		private Texture2D _rankedIcon;

		public void Initialize(MatchManager matches, SteamRankedBridge network, string iconPath)
		{
			_matches = matches;
			_network = network;
			LoadRankedIcon(iconPath);
		}

		private void LoadRankedIcon(string path)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (string.IsNullOrEmpty(path) || !File.Exists(path))
			{
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (ImageConversion.LoadImage(val, array, false))
				{
					((Object)val).name = "UKSR_RankedBadge";
					_rankedIcon = val;
				}
				else
				{
					Object.Destroy((Object)(object)val);
				}
			}
			catch
			{
				_rankedIcon = null;
			}
		}

		private void Ensure()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0038: 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_0062: Expected O, but got Unknown
			//IL_0086: 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_00a1: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_bg != (Object)null))
			{
				_bg = new Texture2D(1, 1);
				_bg.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.72f));
				_bg.Apply();
				_label = new GUIStyle(GUI.skin.label);
				_label.fontSize = 18;
				_label.fontStyle = (FontStyle)1;
				_label.normal.textColor = Color.white;
				_timerLabel = new GUIStyle(_label);
				_timerLabel.normal.textColor = new Color(0.18f, 1f, 0.28f, 1f);
			}
		}

		private void OnGUI()
		{
			if (_matches != null && _matches.IsMatchActive)
			{
				Ensure();
				if (RankedSettings.TimerEnabled)
				{
					DrawTimer();
				}
				DrawRankedBadge();
			}
		}

		private void DrawTimer()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			Rect val = TimerRect();
			GUI.DrawTexture(val, (Texture)(object)_bg);
			string text = ((_matches.Category == null) ? "RANKED" : _matches.Category.DisplayName);
			float num = ((Rect)(ref val)).x + 12f;
			float num2 = ((Rect)(ref val)).y + 10f;
			GUI.Label(new Rect(num, num2, 306f, 24f), "UKSR // " + text, _label);
			GUI.Label(new Rect(num, num2 + 28f, 290f, 24f), "RTA  " + Format(_matches.RtaSeconds), _timerLabel);
			GUI.Label(new Rect(num, num2 + 54f, 290f, 24f), "IGT  " + Format(_matches.IgtSeconds), _timerLabel);
			string text2 = ((!_matches.RtaStarted) ? (_matches.GameplayReady ? "RTA ARMED // MOVE TO START" : "WAITING FOR PLAYER") : (_matches.GameplayTimerAvailable ? _matches.Status : "RUNNING // IGT WAITING"));
			GUI.Label(new Rect(num, num2 + 80f, 290f, 24f), text2, _label);
			if ((Object)(object)_network != (Object)null && _network.LivePeers.Count > 0)
			{
				int num3 = Mathf.Min(4, _network.LivePeers.Count);
				for (int i = 0; i < num3; i++)
				{
					RankedLivePeer rankedLivePeer = _network.LivePeers[i];
					string text3 = rankedLivePeer.Name + "  IGT " + Format(rankedLivePeer.Igt) + (string.IsNullOrEmpty(rankedLivePeer.Level) ? "" : ("  " + rankedLivePeer.Level));
					GUI.Label(new Rect(num, num2 + 108f + (float)i * 22f, 306f, 22f), text3, _timerLabel);
				}
				if (_network.LivePeers.Count > num3)
				{
					GUI.Label(new Rect(num, num2 + 108f + (float)num3 * 22f, 306f, 22f), "+" + (_network.LivePeers.Count - num3) + " MORE", _label);
				}
			}
		}

		private void DrawRankedBadge()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor((float)Screen.width - 24f - 7f, (float)Screen.height - 24f - 7f, 24f, 24f);
			if ((Object)(object)_rankedIcon != (Object)null)
			{
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, 0.68f);
				GUI.DrawTexture(val, (Texture)(object)_rankedIcon, (ScaleMode)2, true);
				GUI.color = color;
			}
			else
			{
				GUI.Label(new Rect(((Rect)(ref val)).x - 28f, ((Rect)(ref val)).y, 52f, 24f), "UKSR", _label);
			}
		}

		private Rect TimerRect()
		{
			//IL_009a: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			int num = ((!((Object)(object)_network == (Object)null)) ? Mathf.Min(4, _network.LivePeers.Count) : 0);
			float num2 = 142f + (float)num * 22f + (((Object)(object)_network != (Object)null && _network.LivePeers.Count > 4) ? 22f : 0f);
			return (Rect)(RankedSettings.TimerPosition switch
			{
				TimerPosition.TopLeft => new Rect(18f, 18f, 330f, num2), 
				TimerPosition.TopCenter => new Rect(((float)Screen.width - 330f) * 0.5f, 18f, 330f, num2), 
				TimerPosition.TopRight => new Rect((float)Screen.width - 330f - 18f, 18f, 330f, num2), 
				TimerPosition.BottomLeft => new Rect(18f, (float)Screen.height - num2 - 18f, 330f, num2), 
				TimerPosition.BottomCenter => new Rect(((float)Screen.width - 330f) * 0.5f, (float)Screen.height - num2 - 18f, 330f, num2), 
				_ => new Rect((float)Screen.width - 330f - 18f, (float)Screen.height - num2 - 18f, 330f, num2), 
			});
		}

		private static string Format(double t)
		{
			int num = (int)(t / 3600.0);
			int num2 = (int)(t % 3600.0 / 60.0);
			double num3 = t % 60.0;
			if (num <= 0)
			{
				return $"{num2:00}:{num3:00.000}";
			}
			return $"{num:00}:{num2:00}:{num3:00.000}";
		}
	}
	public sealed class RankedNotificationManager : MonoBehaviour
	{
		private sealed class Toast
		{
			public string Text;

			public float Expires;
		}

		private readonly List<Toast> _toasts = new List<Toast>();

		private MatchManager _matches;

		private ManualLogSource _log;

		private GUIStyle _style;

		private Texture2D _background;

		public void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
		}

		public void Checkpoint(string who, string checkpoint)
		{
			if (RankedSettings.ProgressNotifications)
			{
				Show(who + " HIT CHECKPOINT " + checkpoint);
			}
		}

		public void BossKilled(string who, string boss)
		{
			if (RankedSettings.ProgressNotifications)
			{
				Show(who + " KILLED " + boss);
			}
		}

		public void LevelCompleted(string who, string level, double rtaSeconds, double igtSeconds)
		{
			if (RankedSettings.ProgressNotifications)
			{
				Show(who + " BEAT " + level + "   RTA " + FormatTime(rtaSeconds) + "   IGT " + FormatTime(igtSeconds));
			}
		}

		public void SystemMessage(string message)
		{
			if (RankedSettings.ProgressNotifications)
			{
				Show(message);
			}
		}

		private void Show(string message)
		{
			_toasts.Add(new Toast
			{
				Text = message,
				Expires = Time.unscaledTime + 4.5f
			});
			if (_log != null)
			{
				_log.LogInfo((object)("UKSR NOTIFY: " + message));
			}
		}

		private void EnsureStyle()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0038: 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_0062: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_background != (Object)null))
			{
				_background = new Texture2D(1, 1);
				_background.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.78f));
				_background.Apply();
				_style = new GUIStyle(GUI.skin.label);
				_style.fontSize = 17;
				_style.fontStyle = (FontStyle)1;
				_style.normal.textColor = Color.white;
				_style.alignment = (TextAnchor)3;
			}
		}

		private void Update()
		{
			for (int num = _toasts.Count - 1; num >= 0; num--)
			{
				if (Time.unscaledTime >= _toasts[num].Expires)
				{
					_toasts.RemoveAt(num);
				}
			}
		}

		private void OnGUI()
		{
			//IL_0070: 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)
			if (_toasts.Count != 0 && RankedSettings.ProgressNotifications)
			{
				EnsureStyle();
				Rect val = default(Rect);
				for (int i = 0; i < _toasts.Count; i++)
				{
					float num = (float)Screen.height - 24f - 46f - (float)(_toasts.Count - 1 - i) * 54f;
					((Rect)(ref val))..ctor(((float)Screen.width - 620f) * 0.5f, num, 620f, 46f);
					GUI.DrawTexture(val, (Texture)(object)_background);
					GUI.Label(new Rect(((Rect)(ref val)).x + 12f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 24f, ((Rect)(ref val)).height), _toasts[i].Text, _style);
				}
			}
		}

		public static string FormatTime(double t)
		{
			int num = (int)(t / 3600.0);
			int num2 = (int)(t % 3600.0 / 60.0);
			double num3 = t % 60.0;
			if (num > 0)
			{
				return $"{num:00}:{num2:00}:{num3:00.000}";
			}
			return $"{num2:00}:{num3:00.000}";
		}
	}
	internal sealed class RankedPanel
	{
		internal sealed class GridItem
		{
			public string Label;

			public Action OnClick;

			public GridItem(string label, Action onClick)
			{
				Label = label;
				OnClick = onClick;
			}
		}

		internal sealed class BrowserItem
		{
			public string Label;

			public Action OnClick;

			public BrowserItem(string label, Action onClick)
			{
				Label = label;
				OnClick = onClick;
			}
		}

		internal sealed class PreviewItem
		{
			public string Title;

			public string Subtitle;

			public string SpriteKey;

			public Action OnClick;

			public PreviewItem(string title, string subtitle, string spriteKey, Action onClick)
			{
				Title = title;
				Subtitle = subtitle;
				SpriteKey = spriteKey;
				OnClick = onClick;
			}
		}

		private readonly GameObject _root;

		private readonly RectTransform _content;

		private readonly Button _template;

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

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

		private float _cursorY;

		private readonly float _buttonWidth;

		private readonly float _rowStep;

		private readonly string _title;

		private readonly bool _browserLayout;

		private readonly bool _lobbyLayout;

		private readonly bool _resultsLayout;

		private static readonly Dictionary<string, Sprite> PreviewCache = new Dictionary<string, Sprite>();

		public bool Alive => (Object)(object)_root != (Object)null;

		public RankedPanel(Button template, string title)
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_026a: 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_02ca: 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_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Expected O, but got Unknown
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: 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_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: 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_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: 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_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			_template = template;
			_title = title ?? "";
			_browserLayout = _title.IndexOf("PUBLIC MATCH", StringComparison.OrdinalIgnoreCase) >= 0 || _title.IndexOf("SELECT", StringComparison.OrdinalIgnoreCase) >= 0 || _title.IndexOf("BROWSER", StringComparison.OrdinalIgnoreCase) >= 0;
			_lobbyLayout = _title.IndexOf("PRIVATE LOBBY", StringComparison.OrdinalIgnoreCase) >= 0;
			_resultsLayout = _title.IndexOf("MATCH RESULTS", StringComparison.OrdinalIgnoreCase) >= 0 || _title.IndexOf("SPECTATING REMAINING RUNNERS", StringComparison.OrdinalIgnoreCase) >= 0;
			Canvas componentInParent = ((Component)template).GetComponentInParent<Canvas>();
			Selectable[] componentsInChildren = ((Component)componentInParent).GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeSelf)
				{
					_hiddenUnderlying.Add(((Component)val).gameObject);
					((Component)val).gameObject.SetActive(false);
				}
			}
			_root = new GameObject("UKSRR_Panel", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			_root.transform.SetParent(((Component)componentInParent).transform, false);
			_root.transform.SetAsLastSibling();
			RectTransform val2 = (RectTransform)_root.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			Image component = _root.GetComponent<Image>();
			((Graphic)component).color = new Color(0.01f, 0.01f, 0.01f, 0.985f);
			((Graphic)component).raycastTarget = true;
			GameObject val3 = new GameObject("UKSRR_Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(_root.transform, false);
			_content = (RectTransform)val3.transform;
			if (_browserLayout || _lobbyLayout || _resultsLayout)
			{
				_content.anchorMin = new Vector2(0.045f, 0.085f);
				_content.anchorMax = new Vector2(0.955f, 0.905f);
			}
			else
			{
				_content.anchorMin = new Vector2(0.075f, 0.1f);
				_content.anchorMax = new Vector2(0.925f, 0.9f);
			}
			_content.offsetMin = Vector2.zero;
			_content.offsetMax = Vector2.zero;
			GameObject val4 = new GameObject("UKSRR_Frame", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val4.transform.SetParent(_root.transform, false);
			val4.transform.SetSiblingIndex(0);
			RectTransform val5 = (RectTransform)val4.transform;
			val5.anchorMin = new Vector2(0.025f, 0.035f);
			val5.anchorMax = new Vector2(0.975f, 0.965f);
			val5.offsetMin = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Image component2 = val4.GetComponent<Image>();
			((Graphic)component2).color = new Color(0.04f, 0.04f, 0.04f, 0.985f);
			((Graphic)component2).raycastTarget = false;
			GameObject val6 = new GameObject("UKSRR_Accent", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val6.transform.SetParent(val4.transform, false);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = new Vector2(0f, 1f);
			val7.anchorMax = new Vector2(1f, 1f);
			val7.pivot = new Vector2(0.5f, 1f);
			val7.sizeDelta = new Vector2(0f, 5f);
			val7.anchoredPosition = Vector2.zero;
			Image component3 = val6.GetComponent<Image>();
			((Graphic)component3).color = new Color(0.82f, 0.06f, 0.06f, 1f);
			((Graphic)component3).raycastTarget = false;
			float num = (float)Screen.width / 1920f;
			float num2 = (float)Screen.height / 1080f;
			float num3 = Mathf.Clamp(Mathf.Min(num, num2) * 0.64f, 0.46f, 0.92f);
			Canvas.ForceUpdateCanvases();
			Rect rect = _content.rect;
			float num4 = Mathf.Max(300f, ((Rect)(ref rect)).height * 0.5f);
			float num5 = ((_browserLayout || _lobbyLayout || _resultsLayout) ? 430f : 500f) * num3;
			rect = _content.rect;
			_buttonWidth = Mathf.Clamp(num5, 230f, ((Rect)(ref rect)).width * ((_browserLayout || _lobbyLayout || _resultsLayout) ? 0.22f : 0.25f));
			_rowStep = Mathf.Clamp(108f * num3, 58f, 86f);
			_cursorY = Mathf.Min(300f * num3, num4 - 66f * num3);
			AddBrand();
			AddTitle(title);
		}

		private static float scaleForScreen()
		{
			return Mathf.Clamp((float)Screen.height / 1080f * 0.72f, 0.58f, 0.9f);
		}

		private void AddBrand()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton("UKSR RANKED", null);
			((Selectable)obj).interactable = false;
			MakeTextOnly(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			((Transform)component).SetParent(_root.transform, false);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 1f);
			float num = Mathf.Clamp((float)Screen.width * 0.028f, 18f, 46f);
			float num2 = Mathf.Clamp((float)Screen.height * 0.028f, 16f, 38f);
			component.anchoredPosition = new Vector2(num, 0f - num2);
			component.sizeDelta = new Vector2(Mathf.Clamp((float)Screen.width * 0.22f, 220f, 460f), 42f);
		}

		public void AddTitle(string title)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(title, null);
			((Selectable)obj).interactable = false;
			MakeTextOnly(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(0f, _cursorY);
			component.sizeDelta = new Vector2(_buttonWidth * 1.22f, Mathf.Clamp(58f * scaleForScreen(), 38f, 54f));
			_cursorY -= _rowStep * 0.96f;
		}

		public void AddLabel(string label)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(label, null);
			((Selectable)obj).interactable = false;
			MakeTextOnly(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(0f, _cursorY);
			component.sizeDelta = new Vector2(_buttonWidth * 1.22f, Mathf.Clamp(46f * scaleForScreen(), 30f, 44f));
			_cursorY -= _rowStep * 0.78f;
		}

		public Button AddButton(string label, Action onClick)
		{
			//IL_00f4: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			Button val = CloneButton(label, onClick);
			MakeCleanButton(val);
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			if (string.Equals(label, "BACK", StringComparison.OrdinalIgnoreCase))
			{
				((Transform)component).SetParent(_root.transform, false);
				((Vector2)(ref val2))..ctor(0f, 0f);
				component.anchorMax = val2;
				component.anchorMin = val2;
				component.pivot = new Vector2(0f, 0f);
				float num = 0f;
				float num2 = Mathf.Clamp((float)Screen.height * 0.012f, 6f, 14f);
				component.anchoredPosition = new Vector2(num, num2);
				component.sizeDelta = new Vector2(Mathf.Clamp((float)Screen.width * 0.14f, 170f, 280f), Mathf.Clamp((float)Screen.height * 0.052f, 34f, 52f));
				return val;
			}
			((Vector2)(ref val2))..ctor(0f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(0f, _cursorY);
			component.sizeDelta = new Vector2(_buttonWidth, Mathf.Clamp(42f * ((float)Screen.height / 1080f), 32f, 46f));
			_cursorY -= _rowStep;
			return val;
		}

		public Button AddRightColumnButton(string label, Action onClick, int slot)
		{
			//IL_0049: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(label, onClick);
			MakeCleanButton(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			float num = Mathf.Clamp((float)Screen.height / 1080f * 0.62f, 0.46f, 0.78f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(1f, 0.5f);
			Rect rect = _content.rect;
			component.sizeDelta = new Vector2(Mathf.Clamp(((Rect)(ref rect)).width * 0.23f, 160f, 330f), Mathf.Clamp(56f * num, 32f, 46f));
			component.anchoredPosition = new Vector2(0f, 155f * num - (float)slot * 88f * num);
			return obj;
		}

		public void AddRightColumnLabel(string label, int slot)
		{
			//IL_004f: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			Button obj = CloneButton(label, null);
			((Selectable)obj).interactable = false;
			MakeTextOnly(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			float num = Mathf.Clamp((float)Screen.height / 1080f * 0.62f, 0.46f, 0.78f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(1f, 0.5f);
			Rect rect = _content.rect;
			component.sizeDelta = new Vector2(Mathf.Clamp(((Rect)(ref rect)).width * 0.25f, 170f, 360f), Mathf.Clamp(42f * num, 30f, 42f));
			component.anchoredPosition = new Vector2(0f, 285f * num - (float)slot * 62f * num);
		}

		public Button AddBottomLeftAction(string label, Action onClick, int index)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(label, onClick);
			MakeCleanButton(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			((Transform)component).SetParent(_root.transform, false);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 0f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0f, 0f);
			float num = Mathf.Clamp((float)Screen.height * 0.05f, 32f, 50f);
			float num2 = Mathf.Clamp((float)Screen.width * 0.12f, 140f, 240f);
			float num3 = 6f;
			component.anchoredPosition = new Vector2((float)index * (num2 + num3), Mathf.Clamp((float)Screen.height * 0.012f, 6f, 14f));
			component.sizeDelta = new Vector2(num2, num);
			FitRectToViewport(component, 110f, 28f);
			return obj;
		}

		public Button AddBottomRightButton(string label, Action onClick, int slot)
		{
			//IL_0049: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(label, onClick);
			MakeCleanButton(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			float num = Mathf.Clamp((float)Screen.height / 1080f * 0.62f, 0.46f, 0.78f);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(1f, 0f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(1f, 0f);
			Rect rect = _content.rect;
			component.sizeDelta = new Vector2(Mathf.Clamp(((Rect)(ref rect)).width * 0.23f, 160f, 330f), Mathf.Clamp(58f * num, 34f, 48f));
			component.anchoredPosition = new Vector2(0f, (float)slot * 72f * num);
			return obj;
		}

		private void FitRectToViewport(RectTransform rt, float minimumWidth, float minimumHeight)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rt == (Object)null))
			{
				Vector2 sizeDelta = rt.sizeDelta;
				float num = Mathf.Max(minimumWidth, (float)Screen.width * 0.42f);
				float num2 = Mathf.Max(minimumHeight, (float)Screen.height * 0.12f);
				sizeDelta.x = Mathf.Clamp(sizeDelta.x, minimumWidth, num);
				sizeDelta.y = Mathf.Clamp(sizeDelta.y, minimumHeight, num2);
				rt.sizeDelta = sizeDelta;
			}
		}

		private static void MakeCleanButton(Button button)
		{
			//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_006b: 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_00ab: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				Image component = ((Component)button).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					component.sprite = null;
					component.type = (Type)0;
					((Graphic)component).color = new Color(0.11f, 0.11f, 0.11f, 0.96f);
					((Graphic)component).raycastTarget = true;
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = new Color(1f, 1f, 1f, 1f);
				((ColorBlock)(ref colors)).highlightedColor = new Color(1.15f, 1.15f, 1.15f, 1f);
				((ColorBlock)(ref colors)).pressedColor = new Color(0.8f, 0.8f, 0.8f, 1f);
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
				((ColorBlock)(ref colors)).fadeDuration = 0.06f;
				((Selectable)button).colors = colors;
			}
		}

		private static void MakeTextOnly(Button button)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			Image[] componentsInChildren = ((Component)button).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Color color = ((Graphic)val).color;
					color.a = 0f;
					((Graphic)val).color = color;
					((Graphic)val).raycastTarget = false;
				}
			}
		}

		public void ForceRefresh()
		{
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			Graphic[] componentsInChildren = _root.GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.SetVerticesDirty();
					val.SetMaterialDirty();
				}
			}
			Canvas.ForceUpdateCanvases();
		}

		public void AddGrid(IList<GridItem> items, int columns, float buttonWidth, float rowHeight)
		{
			//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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if (items != null && items.Count != 0)
			{
				columns = Mathf.Max(1, columns);
				Rect rect = _content.rect;
				float num = Mathf.Max(320f, ((Rect)(ref rect)).width);
				int num2 = Mathf.Max(1, Mathf.FloorToInt(num / Mathf.Max(220f, buttonWidth + 26f)));
				columns = Mathf.Min(columns, num2);
				float num3 = 38f;
				float num4 = 34f;
				float num5 = (num - num3 * (float)(columns - 1)) / (float)columns;
				float num6 = Mathf.Min(Mathf.Max(buttonWidth, 280f), num5);
				float cursorY = _cursorY;
				Vector2 val = default(Vector2);
				for (int i = 0; i < items.Count; i++)
				{
					int num7 = i % columns;
					int num8 = i / columns;
					GridItem gridItem = items[i];
					Button obj = CloneButton(gridItem.Label, gridItem.OnClick);
					MakeCleanButton(obj);
					RectTransform component = ((Component)obj).GetComponent<RectTransform>();
					((Vector2)(ref val))..ctor(0f, 0.5f);
					component.anchorMax = val;
					component.anchorMin = val;
					component.pivot = new Vector2(0f, 0.5f);
					component.anchoredPosition = new Vector2((float)num7 * (num6 + num3), cursorY - (float)num8 * (rowHeight + num4));
					component.sizeDelta = new Vector2(num6, Mathf.Max(60f, rowHeight));
				}
				int num9 = Mathf.CeilToInt((float)items.Count / (float)columns);
				_cursorY = cursorY - (float)num9 * (rowHeight + num4) - 34f;
			}
		}

		public void AddPagedGrid(IList<GridItem> items, int page, int requestedColumns, Action<int> changePage)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (items == null || items.Count == 0)
			{
				return;
			}
			Canvas.ForceUpdateCanvases();
			Rect rect = _content.rect;
			float num = Mathf.Max(420f, ((Rect)(ref rect)).width);
			rect = _content.rect;
			float num2 = Mathf.Max(300f, ((Rect)(ref rect)).height - 185f);
			int num3 = Mathf.Clamp(requestedColumns, 1, (num >= 1500f) ? 4 : ((num >= 1040f) ? 3 : 2));
			float buttonWidth = Mathf.Clamp(num / (float)num3 - 28f, 210f, 430f);
			float num4 = Mathf.Clamp((float)Screen.height * 0.072f, 54f, 82f);
			float num5 = Mathf.Clamp((float)Screen.height * 0.02f, 14f, 28f);
			int num6 = Mathf.Max(2, Mathf.FloorToInt(num2 / (num4 + num5)));
			int num7 = Mathf.Max(1, num3 * num6);
			int num8 = Mathf.Max(1, Mathf.CeilToInt((float)items.Count / (float)num7));
			page = Mathf.Clamp(page, 0, num8 - 1);
			int num9 = page * num7;
			int num10 = Mathf.Min(num7, items.Count - num9);
			List<GridItem> list = new List<GridItem>();
			for (int i = 0; i < num10; i++)
			{
				list.Add(items[num9 + i]);
			}
			AddGrid(list, num3, buttonWidth, num4);
			AddBottomCenterLabel("PAGE " + (page + 1) + " / " + num8);
			if (num8 <= 1 || changePage == null)
			{
				return;
			}
			if (page > 0)
			{
				AddBottomLeftAction("< PREVIOUS", delegate
				{
					changePage(page - 1);
				}, 1);
			}
			if (page < num8 - 1)
			{
				AddBottomRightButton("NEXT >", delegate
				{
					changePage(page + 1);
				}, 0);
			}
		}

		public void AddBottomCenterLabel(string label)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			Button obj = CloneButton(label, null);
			((Selectable)obj).interactable = false;
			MakeTextOnly(obj);
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			((Transform)component).SetParent(_root.transform, false);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, Mathf.Clamp((float)Screen.height * 0.016f, 8f, 18f));
			component.sizeDelta = new Vector2(Mathf.Clamp((float)Screen.width * 0.18f, 180f, 360f), Mathf.Clamp((float)Screen.height * 0.04f, 28f, 44f));
		}

		public void AddTwoPaneBrowser(IList<BrowserItem> left, IList<PreviewItem> right, string selectedLeft, Action selectCurrent)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			Canvas.ForceUpdateCanvases();
			Rect rect = _content.rect;
			float num = Mathf.Max(360f, ((Rect)(ref rect)).height - 135f);
			float cursorY = _cursorY;
			rect = _content.rect;
			float num2 = Mathf.Min(cursorY, ((Rect)(ref rect)).height * 0.5f - 125f);
			rect = _content.rect;
			bool flag = ((Rect)(ref rect)).width < 900f;
			float num3;
			if (!flag)
			{
				rect = _content.rect;
				num3 = Mathf.Clamp(((Rect)(ref rect)).width * 0.2f, 190f, 300f);
			}
			else
			{
				rect = _content.rect;
				num3 = Mathf.Clamp(((Rect)(ref rect)).width * 0.28f, 150f, 240f);
			}
			float num4 = num3;
			float num5 = num4 + (flag ? 18f : 28f);
			float num6 = (flag ? 260f : 420f);
			rect = _content.rect;
			float num7 = Mathf.Max(num6, ((Rect)(ref rect)).width - num5);
			float num8 = Mathf.Clamp(num / Mathf.Max(9.5f, (float)left.Count + 1.5f), 44f, 62f);
			Vector2 val = default(Vector2);
			for (int i = 0; i < left.Count; i++)
			{
				BrowserItem browserItem = left[i];
				string label = ((browserItem.Label == selectedLeft) ? ("> " + browserItem.Label + " <") : browserItem.Label);
				Button obj = CloneButton(label, browserItem.OnClick);
				MakeCleanButton(obj);
				RectTransform component = ((Component)obj).GetComponent<RectTransform>();
				((Vector2)(ref val))..ctor(0f, 0.5f);
				component.anchorMax = val;
				component.anchorMin = val;
				component.pivot = new Vector2(0f, 0.5f);
				component.anchoredPosition = new Vector2(0f, num2 - (float)i * num8);
				component.sizeDelta = new Vector2(num4, Mathf.Max(50f, num8 - 9f));
			}
			if (selectCurrent != null)
			{
				Button obj2 = CloneButton("SELECT " + selectedLeft, selectCurrent);
				MakeCleanButton(obj2);
				RectTransform component2 = ((Component)obj2).GetComponent<RectTransform>();
				((Vector2)(ref val))..ctor(0f, 0.5f);
				component2.anchorMax = val;
				component2.anchorMin = val;
				component2.pivot = new Vector2(0f, 0.5f);
				component2.anchoredPosition = new Vector2(0f, num2 - (float)left.Count * num8 - 12f);
				component2.sizeDelta = new Vector2(num4, 64f);
			}
			int num9 = ((num7 >= 1250f) ? 3 : 2);
			float num10 = 40f;
			float num11 = 34f;
			int num12 = Mathf.Max(1, Mathf.CeilToInt((float)right.Count / (float)num9));
			float num13 = (num7 - num10 * (float)(num9 - 1)) / (float)num9;
			float num14 = Mathf.Clamp((num - num11 * (float)(num12 - 1)) / (float)num12, 105f, 155f);
			for (int j = 0; j < right.Count; j++)
			{
				int num15 = j % num9;
				int num16 = j / num9;
				PreviewItem previewItem = right[j];
				Button val2 = CloneButton(previewItem.Title, previewItem.OnClick);
				MakeCleanButton(val2);
				RectTransform component3 = ((Component)val2).GetComponent<RectTransform>();
				((Vector2)(ref val))..ctor(0f, 0.5f);
				component3.anchorMax = val;
				component3.anchorMin = val;
				component3.pivot = new Vector2(0f, 0.5f);
				component3.anchoredPosition = new Vector2(num5 + (float)num15 * (num13 + num10), num2 - (float)num16 * (num14 + num11));
				component3.sizeDelta = new Vector2(num13, num14);
				LayoutPreviewText(((Component)val2).gameObject);
				AddPreviewImage(((Component)val2).gameObject, previewItem.SpriteKey, previewItem.Subtitle);
			}
			float num17 = Mathf.Max((float)left.Count * num8 + 84f, (float)num12 * (num14 + num11));
			_cursorY = num2 - num17 - 30f;
		}

		private static void LayoutPreviewText(GameObject buttonObject)
		{
			//IL_0075: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			Component[] componentsInChildren = buttonObject.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PropertyInfo property = ((object)val).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(property == null) && !(property.PropertyType != typeof(string)))
				{
					Transform transform = val.transform;
					RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						val2.anchorMin = new Vector2(0.06f, 0.035f);
						val2.anchorMax = new Vector2(0.94f, 0.25f);
						val2.offsetMin = Vector2.zero;
						val2.offsetMax = Vector2.zero;
					}
				}
			}
		}

		private void AddPreviewImage(GameObject buttonObject, string spriteKey, string subtitle)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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: 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)
			Sprite val = FindPreviewSprite(spriteKey);
			if ((Object)(object)val == (Object)null)
			{
				val = CreateFallbackPreviewSprite(spriteKey);
			}
			GameObject val2 = new GameObject("UKSRR_Preview", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val2.transform.SetParent(buttonObject.transform, false);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = new Vector2(0.055f, 0.3f);
			val3.anchorMax = new Vector2(0.945f, 0.94f);
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			Image component = val2.GetComponent<Image>();
			component.sprite = val;
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
		}

		private static Sprite CreateFallbackPreviewSprite(string key)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(320, 180, (TextureFormat)4, false);
			int num = ((!string.IsNullOrEmpty(key)) ? key.GetHashCode() : 0);
			byte b = (byte)(42 + Math.Abs(num % 70));
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor(b, b, b, byte.MaxValue);
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor((byte)Mathf.Min(255, b + 26), (byte)Mathf.Min(255, b + 26), (byte)Mathf.Min(255, b + 26), byte.MaxValue);
			Color32[] array = (Color32[])(object)new Color32[57600];
			for (int i = 0; i < 180; i++)
			{
				for (int j = 0; j < 320; j++)
				{
					array[i * 320 + j] = (((j + i) / 20 % 2 == 0) ? val2 : val3);
				}
			}
			val.SetPixels32(array);
			val.Apply();
			((Object)val).name = "UKSR_Fallback_" + (key ?? "LEVEL");
			return Sprite.Create(val, new Rect(0f, 0f, 320f, 180f), new Vector2(0.5f, 0.5f), 100f);
		}

		private static Sprite FindPreviewSprite(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			Sprite sprite = ThumbnailCatalog.GetSprite(key);
			if ((Object)(object)sprite != (Object)null)
			{
				return sprite;
			}
			string text = NormalizePreviewKey(key);
			if (PreviewCache.TryGetValue(text, out var value))
			{
				return value;
			}
			Sprite val = FindNamedSprite(text);
			if ((Object)(object)val != (Object)null)
			{
				PreviewCache[text] = val;
				return val;
			}
			Sprite val2 = FindSpriteFromMapMetadata(text);
			PreviewCache[text] = val2;
			return val2;
		}

		private static Sprite FindNamedSprite(string normalized)
		{
			Sprite result = null;
			int num = -1;
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val in array)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name))
				{
					string text = NormalizePreviewKey(((Object)val).name);
					int num2 = 0;
					if (text == normalized)
					{
						num2 = 100;
					}
					else if (text.Contains(normalized))
					{
						num2 = 60;
					}
					else if (normalized.Contains(text))
					{
						num2 = 25;
					}
					string value = ((normalized.Length == 2) ? (normalized.Substring(0, 1) + "x" + normalized.Substring(1, 1)) : normalized);
					if (text.Contains(value))
					{
						num2 += 5;
					}
					if (num2 > num)
					{
						result = val;
						num = num2;
					}
				}
			}
			if (num <= 0)
			{
				return null;
			}
			return result;
		}

		private static Sprite FindSpriteFromMapMetadata(string normalized)
		{
			ScriptableObject[] array = Resources.FindObjectsOfTypeAll<ScriptableObject>();
			foreach (ScriptableObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				string text = ((type.Name == null) ? "" : type.Name.ToLowerInvariant());
				if (!text.Contains("map") && !text.Contains("level"))
				{
					continue;
				}
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				bool flag = NormalizePreviewKey(((Object)val).name).Contains(normalized);
				Sprite val2 = null;
				FieldInfo[] fields = type.GetFields(bindingAttr);
				foreach (FieldInfo fieldInfo in fields)
				{
					object obj = null;
					try
					{
						obj = fieldInfo.GetValue(val);
					}
					catch
					{
					}
					string value = obj as string;
					if (!string.IsNullOrEmpty(value) && NormalizePreviewKey(value).Contains(normalized))
					{
						flag = true;
					}
					if ((Object)(object)val2 == (Object)null)
					{
						Sprite val3 = (Sprite)((obj is Sprite) ? obj : null);
						if ((Object)(object)val3 != (Object)null)
						{
							val2 = val3;
						}
					}
				}
				PropertyInfo[] properties = type.GetProperties(bindingAttr);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (!propertyInfo.CanRead || propertyInfo.GetIndexParameters().Length != 0)
					{
						continue;
					}
					object obj3 = null;
					try
					{
						obj3 = propertyInfo.GetValue(val, null);
					}
					catch
					{
					}
					string value2 = obj3 as string;
					if (!string.IsNullOrEmpty(value2) && NormalizePreviewKey(value2).Contains(normalized))
					{
						flag = true;
					}
					if ((Object)(object)val2 == (Object)null)
					{
						Sprite val4 = (Sprite)((obj3 is Sprite) ? obj3 : null);
						if ((Object)(object)val4 != (Object)null)
						{
							val2 = val4;
						}
					}
				}
				if (flag && (Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		private static string NormalizePreviewKey(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			return value.Replace("-", "").Replace("_", "").Replace(" ", "")
				.Replace("/", "")
				.ToLowerInvariant();
		}

		private static void FitButtonText(GameObject buttonObject)
		{
			Component[] componentsInChildren = buttonObject.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				PropertyInfo property = type.GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property == null || property.PropertyType != typeof(string))
				{
					continue;
				}
				string text = "";
				try
				{
					object value = property.GetValue(val, null);
					text = ((value == null) ? "" : value.ToString());
				}
				catch
				{
				}
				PropertyInfo property2 = type.GetProperty("resizeTextForBestFit", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property2 != null && property2.PropertyType == typeof(bool) && property2.CanWrite)
				{
					try
					{
						property2.SetValue(val, true, null);
					}
					catch
					{
					}
				}
				PropertyInfo property3 = type.GetProperty("enableAutoSizing", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property3 != null && property3.PropertyType == typeof(bool) && property3.CanWrite)
				{
					try
					{
						property3.SetValue(val, true, null);
					}
					catch
					{
					}
				}
				if (string.IsNullOrEmpty(text) || text.Length < 18)
				{
					continue;
				}
				PropertyInfo property4 = type.GetProperty("fontSize", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property4 != null && property4.CanRead && property4.CanWrite)
				{
					try
					{
						float num = Convert.ToSingle(property4.GetValue(val, null));
						float num2 = ((text.Length >= 28) ? 0.66f : 0.78f);
						object value2 = Convert.ChangeType(num * num2, property4.PropertyType);
						property4.SetValue(val, value2, null);
					}
					catch
					{
					}
				}
			}
		}

		private Button CloneButton(string label, Action onClick)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			Button val = Object.Instantiate<Button>(_template, (Transform)(object)_content);
			((Component)val).gameObject.SetActive(true);
			((Object)((Component)val).gameObject).name = "UKSRR_" + SafeName(label);
			Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(true);
				}
			}
			UiText.Set(((Component)val).gameObject, label);
			FitButtonText(((Component)val).gameObject);
			val.onClick = new ButtonClickedEvent();
			if (onClick != null)
			{
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			_created.Add(((Component)val).gameObject);
			ForceRefresh();
			return val;
		}

		private static string SafeName(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "Button";
			}
			return value.Replace(" ", "_").Replace("%", "Pct").Replace("/", "_")
				.Replace("\n", "_");
		}

		public void Destroy()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
			foreach (GameObject item in _hiddenUnderlying)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.SetActive(true);
				}
			}
			_hiddenUnderlying.Clear();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
		}
	}
	public enum TimerPosition
	{
		TopLeft,
		TopCenter,
		TopRight,
		BottomLeft,
		BottomCenter,
		BottomRight
	}
	public static class RankedSettings
	{
		private static ConfigEntry<bool> _timerEnabled;

		private static ConfigEntry<string> _timerPosition;

		private static ConfigEntry<bool> _progressNotifications;

		private static ConfigEntry<int> _rating;

		private static ConfigEntry<int> _wins;

		private static ConfigEntry<int> _losses;

		private static ConfigEntry<int> _draws;

		private static ConfigEntry<string> _lastRatedMatch;

		public static bool TimerEnabled
		{
			get
			{
				if (_timerEnabled != null)
				{
					return _timerEnabled.Value;
				}
				return true;
			}
			set
			{
				if (_timerEnabled != null)
				{
					_timerEnabled.Value = value;
					((ConfigEntryBase)_timerEnabled).ConfigFile.Save();
				}
			}
		}

		public static TimerPosition TimerPosition
		{
			get
			{
				if (_timerPosition == null)
				{
					return TimerPosition.TopRight;
				}
				if (Enum.TryParse<TimerPosition>(_timerPosition.Value, ignoreCase: true, out var result))
				{
					return result;
				}
				return TimerPosition.TopRight;
			}
			set
			{
				if (_timerPosition != null)
				{
					_timerPosition.Value = value.ToString();
					((ConfigEntryBase)_timerPosition).ConfigFile.Save();
				}
			}
		}

		public static bool ProgressNotifications
		{
			get
			{
				if (_progressNotifications != null)
				{
					return _progressNotifications.Value;
				}
				return true;
			}
			set
			{
				if (_progressNotifications != null)
				{
					_progressNotifications.Value = value;
					((ConfigEntryBase)_progressNotifications).ConfigFile.Save();
				}
			}
		}

		public static int Rating
		{
			get
			{
				if (_rating != null)
				{
					return _rating.Value;
				}
				return 1000;
			}
		}

		public static int Wins
		{
			get
			{
				if (_wins != null)
				{
					return _wins.Value;
				}
				return 0;
			}
		}

		public static int Losses
		{
			get
			{
				if (_losses != null)
				{
					return _losses.Value;
				}
				return 0;
			}
		}

		public static int Draws
		{
			get
			{
				if (_draws != null)
				{
					return _draws.Value;
				}
				return 0;
			}
		}

		public static string Record => Wins + " - " + Losses + ((Draws > 0) ? (" - " + Draws + " D") : "");

		public static void Initialize(ConfigFile config)
		{
			_timerEnabled = config.Bind<bool>("HUD", "TimerEnabled", true, "Show the UKSR ranked timer during a match.");
			_timerPosition = config.Bind<string>("HUD", "TimerPosition", "TopRight", "Timer position: TopLeft, TopCenter, TopRight, BottomLeft, BottomCenter, BottomRight.");
			_progressNotifications = config.Bind<bool>("HUD", "ProgressNotifications", true, "Show self/opponent progress notifications during ranked matches.");
			_rating = config.Bind<int>("Ranked", "Rating", 1000, "UKSR soft-match ELO rating.");
			_wins = config.Bind<int>("Ranked", "Wins", 0, "UKSR ranked wins.");
			_losses = config.Bind<int>("Ranked", "Losses", 0, "UKSR ranked losses.");
			_draws = config.Bind<int>("Ranked", "Draws", 0, "UKSR ranked draws.");
			_lastRatedMatch = config.Bind<string>("Ranked", "LastRatedMatch", "", "Internal guard preventing the same match from changing ELO twice.");
		}

		public static bool HasRatedMatch(string matchId)
		{
			if (_lastRatedMatch != null && !string.IsNullOrEmpty(matchId))
			{
				return string.Equals(_lastRatedMatch.Value, matchId, StringComparison.Ordinal);
			}
			return false;
		}

		public static void ApplyRatingResult(string matchId, int newRating, int outcome)
		{
			if (string.IsNullOrEmpty(matchId) || HasRatedMatch(matchId))
			{
				return;
			}
			if (_rating != null)
			{
				_rating.Value = Math.Max(100, newRating);
			}
			if (outcome > 0)
			{
				if (_wins != null)
				{
					ConfigEntry<int> wins = _wins;
					int value = wins.Value;
					wins.Value = value + 1;
				}
			}
			else if (outcome < 0)
			{
				if (_losses != null)
				{
					ConfigEntry<int> losses = _losses;
					int value = losses.Value;
					losses.Value = value + 1;
				}
			}
			else if (_draws != null)
			{
				ConfigEntry<int> draws = _draws;
				int value = draws.Value;
				draws.Value = value + 1;
			}
			if (_lastRatedMatch != null)
			{
				_lastRatedMatch.Value = matchId;
			}
			if (_rating != null)
			{
				((ConfigEntryBase)_rating).ConfigFile.Save();
			}
		}
	}
	public sealed class RankedSpectatorOverlay : MonoBehaviour
	{
		private MatchManager _matches;

		private SteamRankedBridge _network;

		private ManualLogSource _log;

		private Action _returnToResults;

		private int _selectedRunningIndex;

		private bool _spectating;

		private Camera _camera;

		private Vector3 _savedPosition;

		private Quaternion _savedRotation;

		private string _spectateLevel = "";

		private string _lastObservedScene = "";

		private float _lastLevelLoadRequest;

		private readonly List<Behaviour> _disabled = new List<Behaviour>();

		private GUIStyle _button;

		private GUIStyle _title;

		private Texture2D _panelTexture;

		private Texture2D _buttonTexture;

		public bool IsSpectating => _spectating;

		public void Initialize(MatchManager matches, SteamRankedBridge network, ManualLogSource log, Action returnToResults)
		{
			_matches = matches;
			_network = network;
			_log = log;
			_returnToResults = returnToResults;
		}

		private bool Eligible()
		{
			if (_matches != null && (Object)(object)_network != (Object)null)
			{
				return _matches.State == MatchState.Finished;
			}
			return false;
		}

		private void Update()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			if (_spectating && Input.GetKeyDown((KeyCode)27))
			{
				StopSpectating();
				Time.timeScale = 1f;
				if (_matches != null)
				{
					_matches.RequestResultsReturn();
				}
				RankedLevelLoader.ReturnToMainMenu(_log);
			}
			else if (!Eligible())
			{
				StopSpectating();
			}
			else
			{
				if (!_spectating)
				{
					return;
				}
				RankedLivePeer selectedRunner = GetSelectedRunner();
				if (selectedRunner == null || selectedRunner.State != "running")
				{
					return;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string text = ((Scene)(ref activeScene)).name ?? "";
				if (text != _lastObservedScene)
				{
					_lastObservedScene = text;
					_camera = null;
					_disabled.Clear();
				}
				if (!string.IsNullOrEmpty(selectedRunner.Level))
				{
					string b = "Level " + selectedRunner.Level;
					if (!string.Equals(text, b, StringComparison.OrdinalIgnoreCase))
					{
						if (_spectateLevel != selectedRunner.Level)
						{
							_spectateLevel = selectedRunner.Level;
							_lastLevelLoadRequest = Time.unscaledTime;
							if (_log != null)
							{
								_log.LogInfo((object)("UKSR spectator loading runner level " + selectedRunner.Level));
							}
							RankedLevelLoader.LoadLevel(selectedRunner.Level, _log);
						}
						return;
					}
				}
				if ((Object)(object)_camera == (Object)null)
				{
					_camera = Camera.main;
				}
				if (!((Object)(object)_camera == (Object)null))
				{
					if (_disabled.Count == 0)
					{
						DisableLocalControl();
					}
					if (selectedRunner.HasSpectatorPose)
					{
						Vector3 position = default(Vector3);
						((Vector3)(ref position))..ctor(selectedRunner.X, selectedRunner.Y, selectedRunner.Z);
						Quaternion rotation = Quaternion.Euler(selectedRunner.Pitch, selectedRunner.Yaw, selectedRunner.Roll);
						((Component)_camera).transform.position = position;
						((Component)_camera).transform.rotation = rotation;
					}
				}
			}
		}

		private RankedLivePeer GetSelectedRunner()
		{
			if ((Object)(object)_network == (Object)null)
			{
				return null;
			}
			int num = 0;
			for (int i = 0; i < _network.LivePeers.Count; i++)
			{
				RankedLivePeer rankedLivePeer = _network.LivePeers[i];
				if (rankedLivePeer != null && !(rankedLivePeer.State != "running"))
				{
					if (num == _selectedRunningIndex)
					{
						return rankedLivePeer;
					}
					num++;
				}
			}
			return null;
		}

		public void SpectateSteamId(string steamId)
		{
			if ((Object)(object)_network == (Object)null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < _network.LivePeers.Count; i++)
			{
				RankedLivePeer rankedLivePeer = _network.LivePeers[i];
				if (rankedLivePeer != null && !(rankedLivePeer.State != "running"))
				{
					if (string.Equals(rankedLivePeer.SteamId, steamId, StringComparison.Ordinal))
					{
						BeginSpectate(num);
						break;
					}
					num++;
				}
			}
		}

		private void BeginSpectate(int runningIndex)
		{
			//IL_004b: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			_selectedRunningIndex = runningIndex;
			if (GetSelectedRunner() != null)
			{
				if ((Object)(object)_camera == (Object)null)
				{
					_camera = Camera.main;
				}
				if ((Object)(object)_camera != (Object)null && !_spectating)
				{
					_savedPosition = ((Component)_camera).transform.position;
					_savedRotation = ((Component)_camera).transform.rotation;
				}
				_spectating = true;
				_spectateLevel = "";
			}
		}

		private void DisableLocalControl()
		{
			//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)
			_disabled.Clear();
			Behaviour[] array = Resources.FindObjectsOfTypeAll<Behaviour>();
			foreach (Behaviour val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)this || !val.enabled)
				{
					continue;
				}
				GameObject gameObject = ((Component)val).gameObject;
				if ((Object)(object)gameObject == (Object)null)
				{
					continue;
				}
				Scene scene = gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					switch (((object)val).GetType().Name.ToLowerInvariant())
					{
					case "newmovement":
					case "mouselook":
					case "cameracontroller":
						val.enabled = false;
						_disabled.Add(val);
						break;
					}
				}
			}
		}

		public void StopSpectatingFromUi()
		{
			StopSpectating();
		}

		private void StopSpectating()
		{
			//IL_0023: 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)
			if (!_spectating)
			{
				return;
			}
			if ((Object)(object)_camera != (Object)null)
			{
				((Component)_camera).transform.position = _savedPosition;
				((Component)_camera).transform.rotation = _savedRotation;
			}
			foreach (Behaviour item in _disabled)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.enabled = true;
				}
			}
			_disabled.Clear();
			_spectateLevel = "";
			_spectating = false;
		}

		private void EnsureGui()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0038: 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_005a: Expected O, but got Unknown
			//IL_0076: 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: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0127: 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)
			if (!((Object)(object)_panelTexture != (Object)null))
			{
				_panelTexture = new Texture2D(1, 1);
				_panelTexture.SetPixel(0, 0, new Color(0.02f, 0.02f, 0.02f, 0.96f));
				_panelTexture.Apply();
				_buttonTexture = new Texture2D(1, 1);
				_buttonTexture.SetPixel(0, 0, new Color(0.12f, 0.12f, 0.12f, 0.98f));
				_buttonTexture.Apply();
				_title = new GUIStyle(GUI.skin.label);
				_title.fontSize = 15;
				_title.fontStyle = (FontStyle)1;
				_title.normal.textColor = Color.white;
				_button = new GUIStyle(GUI.skin.button);
				_button.fontSize = 13;
				_button.normal.background = _buttonTexture;
				_button.hover.background = _buttonTexture;
				_button.normal.textColor = Color.white;
				_button.hover.textColor = Color.white;
			}
		}

		private void OnGUI()
		{
		}
	}
	internal static class ThumbnailCatalog
	{
		internal sealed class Entry
		{
			public string Code;

			public string Title;

			public string Folder;

			public string RelativePath;
		}

		private static readonly Dictionary<string, Entry> Entries = new Dictionary<string, Entry>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Sprite> Sprites = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static bool _loaded;

		private static string _pluginDirectory;

		private static ManualLogSource _log;

		public static void Initialize(string pluginDirectory, ManualLogSource log)
		{
			_pluginDirectory = pluginDirectory ?? "";
			_log = log;
			LoadCatalog();
		}

		public static string GetTitle(string code)
		{
			LoadCatalog();
			if (!Entries.TryGetValue(code ?? "", out var value))
			{
				return "";
			}
			return value.Title;
		}

		public static string GetFolder(string code)
		{
			LoadCatalog();
			if (!Entries.TryGetValue(code ?? "", out var value))
			{
				return "";
			}
			return value.Folder;
		}

		public static Sprite GetSprite(string code)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//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)
			if (string.IsNullOrEmpty(code))
			{
				return null;
			}
			LoadCatalog();
			if (Sprites.TryGetValue(code, out var value))
			{
				return value;
			}
			if (!Entries.TryGetValue(code, out var value2))
			{
				return null;
			}
			try
			{
				string text = Path.Combine(_pluginDirectory, value2.RelativePath.Replace('/', Path.DirectorySeparatorChar));
				if (!File.Exists(text))
				{
					if (_log != null)
					{
						_log.LogWarning((object)("UKSR thumbnail missing on disk: " + text));
					}
					Sprites[code] = null;
					return null;
				}
				byte[] array = File.ReadAllBytes(text);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array, false))
				{
					Object.Destroy((Object)(object)val);
					Sprites[code] = null;
					return null;
				}
				((Object)val).name = "UKSR_Thumb_" + code;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)val2).name = "UKSR_Thumb_" + code;
				Sprites[code] = val2;
				return val2;
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR thumbnail load failed for " + code + ": " + ex.Message));
				}
				Sprites[code] = null;
				return null;
			}
		}

		private static void LoadCatalog()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			if (string.IsNullOrEmpty(_pluginDirectory))
			{
				return;
			}
			string text = Path.Combine(_pluginDirectory, "Thumbnails", "catalog.tsv");
			if (!File.Exists(text))
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR thumbnail catalog missing: " + text));
				}
				return;
			}
			try
			{
				string[] array = File.ReadAllLines(text);
				for (int i = 1; i < array.Length; i++)
				{
					string text2 = array[i];
					if (string.IsNullOrWhiteSpace(text2))
					{
						continue;
					}
					string[] array2 = text2.Split('\t');
					if (array2.Length >= 4)
					{
						Entry entry = new Entry();
						entry.Code = array2[0].Trim();
						entry.Title = array2[1].Trim();
						entry.Folder = array2[2].Trim();
						entry.RelativePath = array2[3].Trim();
						if (!string.IsNullOrEmpty(entry.Code))
						{
							Entries[entry.Code] = entry;
						}
					}
				}
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR thumbnail catalog loaded: " + Entries.Count + " entries."));
				}
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR thumbnail catalog load failed: " + ex.Message));
				}
			}
		}
	}
	internal static class UiText
	{
		public static IEnumerable<string> GetAll(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				yield break;
			}
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
			Component[] array = componentsInChildren;
			foreach (Component val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PropertyInfo property = ((object)val).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(property == null) && !(property.PropertyType != typeof(string)) && property.CanRead)
				{
					string text = null;
					try
					{
						text = property.GetValue(val, null) as string;
					}
					catch
					{
					}
					if (!string.IsNullOrWhiteSpace(text))
					{
						yield return text;
					}
				}
			}
		}

		public static string Get(GameObject go)
		{
			using (IEnumerator<string> enumerator = GetAll(go).GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					return enumerator.Current;
				}
			}
			return "";
		}

		public static bool Contains(GameObject go, string wanted)
		{
			if ((Object)(object)go == (Object)null || string.IsNullOrWhiteSpace(wanted))
			{
				return false;
			}
			foreach (string item in GetAll(go))
			{
				if (string.Equals(Normalize(item), Normalize(wanted), StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static void Set(GameObject go, string value)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PropertyInfo property = ((object)val).GetType().GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.PropertyType == typeof(string) && property.CanWrite)
				{
					try
					{
						property.SetValue(val, value, null);
					}
					catch
					{
					}
				}
			}
		}

		public static string Normalize(string text)
		{
			if (text == null)
			{
				return "";
			}
			string text2 = text.Trim();
			while (true)
			{
				int num = text2.IndexOf('<');
				if (num < 0)
				{
					break;
				}
				int num2 = text2.IndexOf('>', num);
				if (num2 < 0)
				{
					break;
				}
				text2 = text2.Remove(num, num2 - num + 1);
			}
			return text2.Trim();
		}
	}
	internal sealed class VanillaMenuBridge
	{
		private readonly MonoBehaviour _runner;

		private readonly MatchManager _matches;

		private readonly ManualLogSource _log;

		private readonly Func<Button> _playButton;

		private readonly Action _openRankedHome;

		private readonly Action _openMatchSetup;

		private readonly Dictionary<Button, ButtonClickedEvent> _savedDifficultyEvents = new Dictionary<Button, ButtonClickedEvent>();

		private readonly Dictionary<Button, ButtonClickedEvent> _savedLevelEvents = new Dictionary<Button, ButtonClickedEvent>();

		private static readonly Regex LevelCode = new Regex("^(?:\\d+-\\d+|\\d+-S|P-\\d+|P-\\d|0-S|7-S|8-\\d+)$", RegexOptions.IgnoreCase);

		public VanillaMenuBridge(MonoBehaviour runner, MatchManager matches, ManualLogSource log, Func<Button> playButton, Action openRankedHome, Action openMatchSetup)
		{
			_runner = runner;
			_matches = matches;
			_log = log;
			_playButton = playButton;
			_openRankedHome = openRankedHome;
			_openMatchSetup = openMatchSetup;
		}

		public void OpenRealDifficultyMenu()
		{
			Button val = _playButton();
			if ((Object)(object)val == (Object)null)
			{
				_log.LogWarning((object)"UKSRR could not find vanilla PLAY button.");
			}
			else
			{
				_runner.StartCoroutine(DifficultyFlow(val));
			}
		}

		public void OpenRealLevelMenu(bool pRank)
		{
			List<Button> list = FindLevelButtons();
			if (list.Count > 0)
			{
				InterceptLevelButtons(list, pRank);
				return;
			}
			Button val = _playButton();
			if ((Object)(object)val == (Object)null)
			{
				_log.LogWarning((object)"UKSRR could not find vanilla PLAY button.");
			}
			else
			{
				_runner.StartCoroutine(LevelFlow(val, pRank));
			}
		}

		private IEnumerator DifficultyFlow(Button play)
		{
			RestoreDifficultyButtons();
			RestoreLevelButtons();
			((UnityEvent)play.onClick).Invoke();
			for (int frame = 0; frame < 240; frame++)
			{
				List<Button> list = FindDifficultyButtons();
				if (list.Count >= 3)
				{
					InterceptDifficultyButtons(list);
					yield break;
				}
				yield return null;
			}
			_log.LogWarning((object)"UKSRR timed out waiting for vanilla difficulty menu.");
		}

		private void InterceptDifficultyButtons(List<Button> buttons)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			RestoreDifficultyButtons();
			foreach (Button button in buttons)
			{
				string text = UiText.Normalize(UiText.Get(((Component)button).gameObject));
				if (DifficultyIndex(text) >= 0)
				{
					Button capturedButton = button;
					string capturedLabel = text;
					_savedDifficultyEvents[capturedButton] = capturedButton.onClick;
					capturedButton.onClick = new ButtonClickedEvent();
					((UnityEvent)capturedButton.onClick).AddListener((UnityAction)delegate
					{
						CaptureDifficulty(capturedButton, capturedLabel);
					});
				}
			}
			_log.LogInfo((object)("UKSRR intercepted " + _savedDifficultyEvents.Count + " vanilla difficulty buttons."));
		}

		private void CaptureDifficulty(Button selectedButton, string label)
		{
			int num = DifficultyIndex(label);
			if (num >= 0)
			{
				_matches.SetDifficulty(num, UiText.Normalize(label).ToUpperInvariant());
				ButtonClickedEvent value = null;
				_savedDifficultyEvents.TryGetValue(selectedButton, out value);
				RestoreDifficultyButtons();
				if (value == null)
				{
					_log.LogWarning((object)("UKSRR lost the saved vanilla difficulty action for " + label + "."));
					return;
				}
				((UnityEvent)value).Invoke();
				_runner.StartCoroutine(WaitForLevelMenuThenIntercept(pRank: false));
			}
		}

		private IEnumerator LevelFlow(Button play, bool pRank)
		{
			RestoreDifficultyButtons();
			RestoreLevelButtons();
			((UnityEvent)play.onClick).Invoke();
			List<Button> difficultyButtons = null;
			for (int frame = 0; frame < 240; frame++)
			{
				difficultyButtons = FindDifficultyButtons();
				if (difficultyButtons.Count >= 3)
				{
					break;
				}
				yield return null;
			}
			if (difficultyButtons == null || difficultyButtons.Count == 0)
			{
				_log.LogWarning((object)"UKSRR could not reach vanilla difficulty menu for level selection.");
				yield break;
			}
			Button val = ((IEnumerable<Button>)difficultyButtons).FirstOrDefault((Func<Button, bool>)((Button b) => string.Equals(UiText.Normalize(UiText.Get(((Component)b).gameObject)), _matches.DifficultyName, StringComparison.OrdinalIgnoreCase)));
			if ((Object)(object)val == (Object)null)
			{
				int wanted = _matches.Difficulty;
				val = ((IEnumerable<Button>)difficultyButtons).FirstOrDefault((Func<Button, bool>)((Button b) => DifficultyIndex(UiText.Get(((Component)b).gameObject)) == wanted));
			}
			if ((Object)(object)val == (Object)null)
			{
				_log.LogWarning((object)"UKSRR could not select the saved vanilla difficulty.");
				yield break;
			}
			((UnityEvent)val.onClick).Invoke();
			yield return _runner.StartCoroutine(WaitForLevelMenuThenIntercept(pRank));
		}

		private IEnumerator WaitForLevelMenuThenIntercept(bool pRank)
		{
			for (int frame = 0; frame < 360; frame++)
			{
				List<Button> list = FindLevelButtons();
				if (list.Count > 0)
				{
					InterceptLevelButtons(list, pRank);
					yield break;
				}
				yield return null;
			}
			_log.LogWarning((object)"UKSRR timed out waiting for vanilla level select.");
		}

		private void InterceptLevelButtons(List<Button> buttons, bool pRank)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			RestoreLevelButtons();
			foreach (Button button in buttons)
			{
				string text = UiText.Normalize(UiText.Get(((Component)button).gameObject));
				if (LooksLikeLevel(text))
				{
					Button capturedButton = button;
					string capturedLabel = text;
					_savedLevelEvents[capturedButton] = capturedButton.onClick;
					capturedButton.onClick = new ButtonClickedEvent();
					((UnityEvent)capturedButton.onClick).AddListener((UnityAction)delegate
					{
						CaptureLevel(capturedButton, capturedLabel, pRank);
					});
				}
			}
			_log.LogInfo((object)("UKSRR intercepted " + _savedLevelEvents.Count + " vanilla level buttons."));
		}

		private void CaptureLevel(Button button, string level, bool pRank)
		{
			if (!((Object)(object)button == (Object)null) && !string.IsNullOrEmpty(level))
			{
				_matches.SetSelectedLevel(level);
				CategoryDefinition category = (pRank ? CategoryDefinition.IndividualPRank(level) : CategoryDefinition.IndividualAny(level));
				_matches.SetCategory(category);
				RestoreLevelButtons();
				if (_openMatchSetup != null)
				{
					_openMatchSetup();
				}
			}
		}

		private void RestoreDifficultyButtons()
		{
			foreach (KeyValuePair<Button, ButtonClickedEvent> savedDifficultyEvent in _savedDifficultyEvents)
			{
				if ((Object)(object)savedDifficultyEvent.Key != (Object)null)
				{
					savedDifficultyEvent.Key.onClick = savedDifficultyEvent.Value;
				}
			}
			_savedDifficultyEvents.Clear();
		}

		public void RestoreDifficultyButtonsPublic()
		{
			RestoreDifficultyButtons();
		}

		public void RestoreLevelButtons()
		{
			foreach (KeyValuePair<Button, ButtonClickedEvent> savedLevelEvent in _savedLevelEvents)
			{
				if ((Object)(object)savedLevelEvent.Key != (Object)null)
				{
					savedLevelEvent.Key.onClick = savedLevelEvent.Value;
				}
			}
			_savedLevelEvents.Clear();
		}

		private static List<Button> FindDifficultyButtons()
		{
			return Resources.FindObjectsOfTypeAll<Button>().Where(delegate(Button b)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)b != (Object)null)
				{
					Scene scene = ((Component)b).gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && ((Component)b).gameObject.activeInHierarchy)
					{
						return DifficultyIndex(UiText.Get(((Component)b).gameObject)) >= 0;
					}
				}
				return false;
			}).ToList();
		}

		private static List<Button> FindLevelButtons()
		{
			return Resources.FindObjectsOfTypeAll<Button>().Where(delegate(Button b)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)b != (Object)null)
				{
					Scene scene = ((Component)b).gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && ((Component)b).gameObject.activeInHierarchy)
					{
						return LooksLikeLevel(UiText.Normalize(UiText.Get(((Component)b).gameObject)));
					}
				}
				return false;
			}).ToList();
		}

		private static bool LooksLikeLevel(string label)
		{
			if (string.IsNullOrWhiteSpace(label))
			{
				return false;
			}
			return LevelCode.IsMatch(label.Trim());
		}

		private static int DifficultyIndex(string raw)
		{
			return UiText.Normalize(raw).ToUpperInvariant() switch
			{
				"HARMLESS" => 0, 
				"LENIENT" => 1, 
				"STANDARD" => 2, 
				"VIOLENT" => 3, 
				"BRUTAL" => 4, 
				"ULTRAKILL MUST DIE" => 5, 
				_ => -1, 
			};
		}
	}
}
namespace UKSRR.Timing
{
	public sealed class RunClock
	{
		private readonly Stopwatch _rta = new Stopwatch();

		private double _igt;

		public bool Running { get; private set; }

		public double RtaSeconds => _rta.Elapsed.TotalSeconds;

		public double IgtSeconds => _igt;

		public void Reset()
		{
			_rta.Reset();
			_igt = 0.0;
			Running = false;
		}

		public void StartRta()
		{
			if (!Running)
			{
				Running = true;
				_rta.Start();
			}
		}

		public void Start()
		{
			Reset();
			StartRta();
		}

		public void SetIgt(double seconds)
		{
			if (seconds < 0.0)
			{
				seconds = 0.0;
			}
			_igt = seconds;
		}

		public void TickIgt(double unscaledDelta, bool advance)
		{
			if (Running && advance)
			{
				_igt += unscaledDelta;
			}
		}

		public void Stop()
		{
			if (Running)
			{
				_rta.Stop();
				Running = false;
			}
		}
	}
	internal sealed class VanillaTimerProbe
	{
		private sealed class Candidate
		{
			public Object Object;

			public PropertyInfo TextProperty;

			public string Path;

			public double LastValue;

			public int MovingHits;

			public int StableHits;
		}

		private readonly ManualLogSource _log;

		private readonly List<Type> _textTypes = new List<Type>();

		private readonly Dictionary<int, Candidate> _samples = new Dictionary<int, Candidate>();

		private Candidate _selected;

		private float _nextScan;

		private bool _loggedDiagnostics;

		private string _selectedPath = "";

		private Type _statsType;

		private FieldInfo _statsTimerField;

		private PropertyInfo _statsTimerProperty;

		private PropertyInfo _statsInstanceProperty;

		private FieldInfo _statsInstanceField;

		private bool _loggedBackingDiagnostics;

		private Object _statsInstance;

		private float _nextStatsResolve;

		private double _lastBackingTimer = -1.0;

		private int _backingTimerMoveHits;

		public string SelectedPath => _selectedPath;

		public VanillaTimerProbe(ManualLogSource log)
		{
			_log = log;
			ResolveTextTypes();
		}

		public void ResetScene()
		{
			_selected = null;
			_samples.Clear();
			_nextScan = 0f;
			_loggedDiagnostics = false;
			_selectedPath = "";
			_statsInstance = null;
			_nextStatsResolve = 0f;
			_lastBackingTimer = -1.0;
			_backingTimerMoveHits = 0;
			_loggedBackingDiagnostics = false;
		}

		public bool TryRead(out double seconds)
		{
			if (TryReadBackingTimer(out seconds))
			{
				return true;
			}
			seconds = 0.0;
			if (_selected != null && IsAlive(_selected.Object) && TryRead(_selected.Object, _selected.TextProperty, out var text) && TryParseTime(text, out seconds))
			{
				return true;
			}
			_selected = null;
			if (_textTypes.Count == 0)
			{
				ResolveTextTypes();
			}
			if (_textTypes.Count == 0)
			{
				return false;
			}
			if (Time.unscaledTime < _nextScan)
			{
				return false;
			}
			_nextScan = Time.unscaledTime + 0.15f;
			Scan();
			if (_selected != null && TryRead(_selected.Object, _selected.TextProperty, out var text2) && TryParseTime(text2, out seconds))
			{
				return true;
			}
			return false;
		}

		private bool TryReadBackingTimer(out double seconds)
		{
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			seconds = 0.0;
			try
			{
				if (_statsType == null)
				{
					_statsType = FindType("StatsManager");
				}
				if (_statsType == null)
				{
					return false;
				}
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
				BindingFlags bindingAttr2 = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
				if (_statsTimerField == null && _statsTimerProperty == null)
				{
					_statsTimerField = _statsType.GetField("timerTime", bindingAttr);
					_statsTimerProperty = _statsType.GetProperty("timerTime", bindingAttr);
				}
				if (_statsInstanceProperty == null && _statsInstanceField == null)
				{
					_statsInstanceProperty = _statsType.GetProperty("Instance", bindingAttr2) ?? _statsType.GetProperty("instance", bindingAttr2);
					_statsInstanceField = _statsType.GetField("Instance", bindingAttr2) ?? _statsType.GetField("instance", bindingAttr2);
				}
				object obj = (IsAlive(_statsInstance) ? _statsInstance : null);
				if (obj == null && _statsInstanceProperty != null)
				{
					obj = _statsInstanceProperty.GetValue(null, null);
				}
				if (obj == null && _statsInstanceField != null)
				{
					obj = _statsInstanceField.GetValue(null);
				}
				if (obj == null && Time.unscaledTime >= _nextStatsResolve)
				{
					_nextStatsResolve = Time.unscaledTime + 0.75f;
					Object[] array = Resources.FindObjectsOfTypeAll(_statsType);
					if (array != null && array.Length != 0)
					{
						for (int i = 0; i < array.Length; i++)
						{
							Object obj2 = array[i];
							Component val = (Component)(object)((obj2 is Component) ? obj2 : null);
							if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
							{
								continue;
							}
							Scene scene = val.gameObject.scene;
							if (((Scene)(ref scene)).IsValid())
							{
								_statsInstance = array[i];
								obj = _statsInstance;
								if (val.gameObject.activeInHierarchy)
								{
									break;
								}
							}
						}
						if (obj == null)
						{
							_statsInstance = array[0];
							obj = _statsInstance;
						}
					}
				}
				if (obj == null)
				{
					return false;
				}
				object obj3 = null;
				if (_statsTimerField != null)
				{
					obj3 = _statsTimerField.GetValue(obj);
				}
				else if (_statsTimerProperty != null)
				{
					obj3 = _statsTimerProperty.GetValue(obj, null);
				}
				if (obj3 == null)
				{
					if (!_loggedBackingDiagnostics && _log != null)
					{
						_loggedBackingDiagnostics = true;
						_log.LogWarning((object)"UKSR IGT StatsManager resolved but timerTime returned null.");
					}
					return false;
				}
				if (!TryConvertTimerValue(obj3, out var seconds2))
				{
					if (!_loggedBackingDiagnostics && _log != null)
					{
						_loggedBackingDiagnostics = true;
						_log.LogWarning((object)("UKSR IGT timerTime type unsupported: " + obj3.GetType().FullName));
					}
					return false;
				}
				if (!_loggedBackingDiagnostics && _log != null)
				{
					_loggedBackingDiagnostics = true;
					_log.LogInfo((object)("UKSR IGT backing source resolved: StatsManager.timerTime // type " + obj3.GetType().FullName));
				}
				if (_lastBackingTimer >= 0.0 && seconds2 > _lastBackingTimer + 0.0001 && seconds2 - _lastBackingTimer < 1.0)
				{
					_backingTimerMoveHits++;
				}
				_lastBackingTimer = seconds2;
				if (_backingTimerMoveHits >= 2)
				{
					_selectedPath = "StatsManager.timerTime";
					seconds = seconds2;
					return true;
				}
			}
			catch (Exception ex)
			{
				_statsInstance = null;
				if (!_loggedBackingDiagnostics && _log != null)
				{
					_loggedBackingDiagnostics = true;
					_log.LogWarning((object)("UKSR IGT backing timer exception: " + ex.GetBaseException().Message));
				}
			}
			return false;
		}

		private static bool TryConvertTimerValue(object raw, out double seconds)
		{
			seconds = 0.0;
			if (raw == null)
			{
				return false;
			}
			if (raw is float)
			{
				seconds = (float)raw;
				return true;
			}
			if (raw is double)
			{
				seconds = (double)raw;
				return true;
			}
			if (raw is int)
			{
				seconds = (int)raw;
				return true;
			}
			if (raw is long)
			{
				seconds = (long)raw;
				return true;
			}
			Type type = raw.GetType();
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[6] { "Seconds", "seconds", "Value", "value", "Time", "time" };
			foreach (string name in array)
			{
				PropertyInfo property = type.GetProperty(name, bindingAttr);
				if (property != null)
				{
					object value = property.GetValue(raw, null);
					if (value != null && value != raw && TryConvertTimerValue(value, out seconds))
					{
						return true;
					}
				}
				FieldInfo field = type.GetField(name, bindingAttr);
				if (field != null)
				{
					object value2 = field.GetValue(raw);
					if (value2 != null && value2 != raw && TryConvertTimerValue(value2, out seconds))
					{
						return true;
					}
				}
			}
			try
			{
				if (raw is IConvertible)
				{
					seconds = Convert.ToDouble(raw, CultureInfo.InvariantCulture);
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private void ResolveTextTypes()
		{
			_textTypes.Clear();
			Type type = FindType("TMPro.TMP_Text");
			Type type2 = FindType("TMPro.TextMeshProUGUI");
			Type type3 = FindType("UnityEngine.UI.Text");
			AddUnique(type);
			AddUnique(type2);
			AddUnique(type3);
			if (_textTypes.Count == 0 && _log != null)
			{
				_log.LogWarning((object)"UKSR IGT could not resolve any supported UI text type.");
			}
		}

		private void AddUnique(Type type)
		{
			if (type != null && !_textTypes.Contains(type))
			{
				_textTypes.Add(type);
			}
		}

		private void Scan()
		{
			Candidate candidate = null;
			int num = int.MinValue;
			List<string> list = new List<string>();
			foreach (Type textType in _textTypes)
			{
				PropertyInfo property = textType.GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property == null)
				{
					continue;
				}
				Object[] array;
				try
				{
					array = Resources.FindObjectsOfTypeAll(textType);
				}
				catch
				{
					continue;
				}
				Object[] array2 = array;
				foreach (Object val in array2)
				{
					if (!IsAlive(val) || !TryRead(val, property, out var text) || !TryParseTime(text, out var seconds))
					{
						continue;
					}
					string text2 = BuildPath((Component)(object)((val is Component) ? val : null));
					int instanceID = val.GetInstanceID();
					if (!_samples.TryGetValue(instanceID, out var value))
					{
						value = new Candidate
						{
							Object = val,
							TextProperty = property,
							Path = text2,
							LastValue = seconds
						};
						_samples[instanceID] = value;
						continue;
					}
					double num2 = seconds - value.LastValue;
					if (num2 > 0.001 && num2 < 0.5)
					{
						value.MovingHits++;
					}
					else if (Math.Abs(num2) < 0.0005)
					{
						value.StableHits++;
					}
					value.LastValue = seconds;
					value.Path = text2;
					value.TextProperty = property;
					int num3 = value.MovingHits * 100;
					string text3 = (text2 ?? "").ToLowerInvariant();
					if (text3.Contains("timer"))
					{
						num3 += 40;
					}
					if (text3.Contains("time"))
					{
						num3 += 20;
					}
					if (text3.Contains("stats"))
					{
						num3 += 10;
					}
					string[] array3 = new string[9] { "message", "notification", "leaderboard", "rank", "style", "cooldown", "weapon", "subtitle", "tip" };
					foreach (string value2 in array3)
					{
						if (text3.Contains(value2))
						{
							num3 -= 250;
						}
					}
					if (value.MovingHits > 0)
					{
						list.Add(text2 + " = " + seconds.ToString("0.000", CultureInfo.InvariantCulture) + " / hits " + value.MovingHits);
					}
					if (value.MovingHits >= 2 && num3 > num)
					{
						candidate = value;
						num = num3;
					}
				}
			}
			if (!_loggedDiagnostics && list.Count > 0)
			{
				_loggedDiagnostics = true;
				if (_log != null)
				{
					_log.LogInfo((object)"UKSR IGT moving timer candidates:");
					for (int k = 0; k < list.Count && k < 8; k++)
					{
						_log.LogInfo((object)("  " + list[k]));
					}
				}
			}
			if (candidate != null)
			{
				_selected = candidate;
				_selectedPath = candidate.Path;
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR IGT locked to visible gameplay timer: " + candidate.Path + " // " + candidate.LastValue.ToString("0.000", CultureInfo.InvariantCulture)));
				}
			}
		}

		private static bool TryRead(Object obj, PropertyInfo property, out string text)
		{
			text = "";
			if (!IsAlive(obj) || property == null)
			{
				return false;
			}
			try
			{
				object value = property.GetValue(obj, null);
				if (value == null)
				{
					return false;
				}
				text = value.ToString();
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryParseTime(string raw, out double seconds)
		{
			seconds = 0.0;
			if (string.IsNullOrWhiteSpace(raw))
			{
				return false;
			}
			string[] array = StripTags(raw).Trim().Split(new char[4] { ' ', '\n', '\r', '\t' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim().TrimEnd(',', ';', ')', ']', '}');
				if (!text.Contains(":"))
				{
					continue;
				}
				text = text.Replace(',', '.');
				string[] array2 = text.Split(':');
				double result;
				double result2;
				double result3;
				if (array2.Length == 2)
				{
					if (double.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out result) && double.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out result2) && !(result2 < 0.0) && !(result2 >= 60.0))
					{
						seconds = result * 60.0 + result2;
						return true;
					}
				}
				else if (array2.Length == 3 && double.TryParse(array2[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out result) && double.TryParse(array2[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2) && double.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out result3))
				{
					if (result2 >= 0.0 && result2 < 60.0 && result3 >= 0.0 && result3 < 60.0)
					{
						seconds = result * 3600.0 + result2 * 60.0 + result3;
						return true;
					}
					if (result2 >= 0.0 && result2 < 60.0 && result3 >= 0.0 && result3 < 1000.0)
					{
						seconds = result * 60.0 + result2 + result3 / 1000.0;
						return true;
					}
				}
			}
			return false;
		}

		private static string StripTags(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			char[] array = new char[text.Length];
			int length = 0;
			bool flag = false;
			foreach (char c in text)
			{
				if (c == '<')
				{
					flag = true;
				}
				else if (flag)
				{
					if (c == '>')
					{
						flag = false;
					}
				}
				else
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private static bool IsAlive(Object value)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (value == (Object)null)
			{
				return false;
			}
			Component val = (Component)(object)((value is Component) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if ((Object)(object)val.gameObject != (Object)null)
			{
				Scene scene = val.gameObject.scene;
				return ((Scene)(ref scene)).IsValid();
			}
			return false;
		}

		private static string BuildPath(Component component)
		{
			if ((Object)(object)component == (Object)null || (Object)(object)component.transform == (Object)null)
			{
				return "";
			}
			string text = ((Object)component.gameObject).name;
			Transform parent = component.transform.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null && num < 8)
			{
				text = ((Object)((Component)parent).gameObject).name + "/" + text;
				parent = parent.parent;
				num++;
			}
			return text;
		}

		private static Type FindType(string fullName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(fullName, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}
	}
}
namespace UKSRR.Network
{
	public sealed class NetworkClient
	{
		public bool Connected => false;
	}
	public sealed class RankedLivePeer
	{
		public string Name;

		public string SteamId;

		public string Level;

		public double Rta;

		public double Igt;

		public string State;

		public float X;

		public float Y;

		public float Z;

		public float Pitch;

		public float Yaw;

		public float Roll;

		public float Speed;

		public bool HasSpectatorPose;
	}
	public sealed class RankedStanding
	{
		public string Name;

		public string SteamId;

		public bool Finished;

		public bool Forfeit;

		public double Rta;

		public double Igt;

		public bool IsSelf;
	}
	public sealed class SteamRankedBridge : MonoBehaviour
	{
		private sealed class Peer
		{
			public string Id;

			public string SteamId;

			public string Name;

			public bool Ready;

			public int Rating;

			public double Rta;

			public double Igt;

			public string Level;

			public int Split;

			public string ResultState;

			public double ResultRta;

			public double ResultIgt;

			public float X;

			public float Y;

			public float Z;

			public float Pitch;

			public float Yaw;

			public float Roll;

			public float Speed;

			public bool HasSpectatorPose;

			public float LastSeen;
		}

		private sealed class HubCandidate
		{
			public object Member;

			public string SteamId = "";

			public string ClientId = "";

			public string Name = "";

			public int Category;

			public string Scope = "";

			public string Difficulty = "";

			public int Rating;

			public string MatchId = "";
		}

		private const string Protocol = "UKSRLAN1";

		private const string MulticastAddress = "239.255.83.83";

		private const int MulticastPort = 39083;

		private MatchManager _matches;

		private RankedNotificationManager _notifications;

		private ManualLogSource _log;

		private UdpClient _udp;

		private UdpClient _directUdp;

		private IPEndPoint _multicastEndpoint;

		private int _directPort;

		private bool _networkReady;

		private readonly Dictionary<string, IPEndPoint> _directPeers = new Dictionary<string, IPEndPoint>();

		private string _clientId;

		private string _ownerId;

		private string _pendingJoinCode;

		private string _currentMatchId;

		private bool _inLobby;

		private bool _isPrivate;

		private float _nextLobbyBroadcast;

		private float _nextJoinBroadcast;

		private float _nextSearchBroadcast;

		private float _nextLiveBroadcast;

		private float _nextCleanup;

		private float _nextResultHeartbeat;

		private Vector3 _lastSpectatorPosition;

		private float _lastSpectatorSampleTime;

		private bool _hasLastSpectatorPosition;

		private float _searchStartedAt;

		private float _publicStartAfter = -1f;

		private int _lastPublishedSplit = -1;

		private long _eventSequence;

		private MatchState _lastObservedMatchState;

		private readonly Dictionary<string, Peer> _peers = new Dictionary<string, Peer>();

		private readonly Dictionary<string, long> _lastRemoteEvent = new Dictionary<string, long>();

		private Type _steamClientType;

		private Type _steamMatchmakingType;

		private object _steamLobby;

		private object _pendingSteamTask;

		private string _pendingSteamMode = "";

		private ulong _pendingSteamLobbyId;

		private object _pendingSteamPublicQuery;

		private float _nextSteamPublicQuery;

		private bool _steamPublicCreated;

		private bool _publicHubMode;

		private string _publicMatchId = "";

		private string _publicPartnerClientId = "";

		private string _lastAppliedSteamLobbyConfig = "";

		private float _nextSteamLobbyStatePoll;

		private float _nextPeerPrune;

		private string _lastLobbyUiSnapshot = "";

		private bool _rematchVote;

		private bool _remoteRematchVote;

		private float _nextSteamPublish;

		private readonly Dictionary<string, string> _steamLastEvents = new Dictionary<string, string>();

		public readonly List<string> LobbyPlayers = new List<string>();

		private int _alternativeCategory;

		private string _alternativeScope = "";

		private string _alternativeDifficulty = "";

		public readonly List<RankedLivePeer> LivePeers = new List<RankedLivePeer>();

		private const string PrivateCodeAlphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

		private string _lastSteamMatchStart = "";

		public int LobbyUiRevision { get; private set; }

		public bool InLobby => _inLobby;

		public bool SteamAvailable { get; private set; }

		public bool SteamProfileReady { get; private set; }

		public string SteamConnectionError { get; private set; }

		public string SteamName { get; private set; }

		public string SteamId { get; private set; }

		public string ClientId => _clientId;

		public string Status { get; private set; }

		public string LobbyId { get; private set; }

		public bool IsSearching { get; private set; }

		public bool IsReady { get; private set; }

		public bool IsLobbyOwner { get; private set; }

		public bool AllPlayersReady { get; private set; }

		public string LobbyCode { get; private set; }

		public string SearchLevel { get; private set; }

		public string SearchDifficulty { get; private set; }

		public bool AlternativeQueueAvailable { get; private set; }

		public string AlternativeQueueLabel { get; private set; } = "";

		public bool AlternativeOfferPending { get; set; }

		public bool CurrentLobbyIsPrivate { get; private set; }

		public bool CurrentLobbyIsPublic
		{
			get
			{
				if (_inLobby)
				{
					return !_isPrivate;
				}
				return false;
			}
		}

		public bool RematchVote => _rematchVote;

		public bool RemoteRematchVote => _remoteRematchVote;

		public void Initialize(MatchManager matches, RankedNotificationManager notifications, ManualLogSource log)
		{
			_matches = matches;
			_notifications = notifications;
			_log = log;
			_clientId = Guid.NewGuid().ToString("N").Substring(0, 12)
				.ToUpperInvariant();
			SteamName = "STEAM UNAVAILABLE";
			SteamId = "";
			SteamProfileReady = false;
			SteamConnectionError = "STEAM PROFILE NOT CONNECTED";
			Status = "UKSR NETWORK INITIALIZING";
			LobbyId = "";
			LobbyCode = "";
			SearchLevel = "";
			SearchDifficulty = "";
			DiscoverOptionalSteamIdentity();
			InitializeTransport();
			RefreshFacade();
			if (_log != null)
			{
				_log.LogInfo((object)("UKSR client identity: " + LocalDisplayName() + " / " + _clientId));
				_log.LogInfo((object)("UKSR transport: local/LAN multicast 239.255.83.83:" + 39083 + " // Steam profile required for ranked networking"));
				_log.LogInfo((object)("UKSR rating: " + RankedSettings.Rating + " // record " + RankedSettings.Record));
			}
		}

		public bool RefreshSteamIdentity()
		{
			DiscoverOptionalSteamIdentity();
			RefreshFacade();
			return SteamProfileReady;
		}

		private void DiscoverOptionalSteamIdentity()
		{
			SteamAvailable = false;
			SteamProfileReady = false;
			SteamName = "STEAM UNAVAILABLE";
			SteamId = "";
			SteamConnectionError = "STEAM PROFILE NOT CONNECTED";
			_steamClientType = FindType("Steamworks.SteamClient");
			_steamMatchmakingType = FindType("Steamworks.SteamMatchmaking");
			if (_steamClientType == null || _steamMatchmakingType == null)
			{
				SteamConnectionError = "STEAMWORKS API NOT FOUND";
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam profile unavailable: " + SteamConnectionError));
				}
				return;
			}
			try
			{
				object obj = ReadStaticProperty(_steamClientType, "IsValid");
				if (obj is bool && !(bool)obj)
				{
					SteamConnectionError = "STEAM CLIENT IS NOT INITIALIZED";
					if (_log != null)
					{
						_log.LogWarning((object)("UKSR Steam profile unavailable: " + SteamConnectionError));
					}
					return;
				}
				object obj2 = ReadStaticProperty(_steamClientType, "SteamId");
				object obj3 = ReadStaticProperty(_steamClientType, "Name");
				string text = ((obj2 == null) ? "" : obj2.ToString());
				string text2 = ((obj3 == null) ? "" : obj3.ToString());
				if (string.IsNullOrWhiteSpace(text) || !ulong.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result == 0L)
				{
					SteamConnectionError = "NO VALID STEAM PROFILE ID";
					if (_log != null)
					{
						_log.LogWarning((object)("UKSR Steam profile unavailable: " + SteamConnectionError + " // raw id: " + text));
					}
					return;
				}
				SteamId = result.ToString(CultureInfo.InvariantCulture);
				SteamName = (string.IsNullOrWhiteSpace(text2) ? "STEAM USER" : text2);
				SteamAvailable = true;
				SteamProfileReady = true;
				SteamConnectionError = "";
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR Steam profile connected: " + SteamName + " / " + SteamId));
				}
			}
			catch (Exception ex)
			{
				SteamAvailable = false;
				SteamProfileReady = false;
				SteamName = "STEAM UNAVAILABLE";
				SteamId = "";
				SteamConnectionError = "STEAM PROFILE READ FAILED";
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam identity unavailable: " + ex));
				}
			}
		}

		private void InitializeTransport()
		{
			try
			{
				IPAddress iPAddress = IPAddress.Parse("239.255.83.83");
				_udp = new UdpClient(AddressFamily.InterNetwork);
				_udp.ExclusiveAddressUse = false;
				_udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue: true);
				_udp.Client.Bind(new IPEndPoint(IPAddress.Any, 39083));
				_udp.JoinMulticastGroup(iPAddress);
				_udp.MulticastLoopback = true;
				_udp.Client.Blocking = false;
				_multicastEndpoint = new IPEndPoint(iPAddress, 39083);
				_directUdp = new UdpClient(new IPEndPoint(IPAddress.Loopback, 0));
				_directUdp.Client.Blocking = false;
				_directPort = ((IPEndPoint)_directUdp.Client.LocalEndPoint).Port;
				_networkReady = true;
				Status = "UKSR NETWORK READY";
			}
			catch (Exception ex)
			{
				_networkReady = false;
				Status = "UKSR NETWORK ERROR";
				if (_log != null)
				{
					_log.LogError((object)("UKSR transport initialization failed: " + ex.Message));
				}
			}
		}

		private void Update()
		{
			if (!_networkReady)
			{
				return;
			}
			ReceivePackets();
			ReceiveDirectPackets();
			PollPendingSteamLobby();
			PollPendingSteamPublicQuery();
			PollSteamLobbyJoin();
			if (IsSearching && !_isPrivate && SteamProfileReady && Time.unscaledTime >= _nextSteamPublicQuery)
			{
				_nextSteamPublicQuery = Time.unscaledTime + 1f;
				BeginSteamPublicLobbyQuery();
			}
			if (_steamLobby != null && Time.unscaledTime >= _nextSteamPublish)
			{
				bool flag = _matches != null && (_matches.IsMatchActive || _matches.State == MatchState.Finished);
				_nextSteamPublish = Time.unscaledTime + (flag ? 0.1f : 0.35f);
				if (_matches != null && _matches.IsMatchActive)
				{
					PublishSteamLiveState();
				}
				PollSteamPeers();
				if (Time.unscaledTime >= _nextSteamLobbyStatePoll)
				{
					_nextSteamLobbyStatePoll = Time.unscaledTime + 0.35f;
					PollSteamLobbyState();
				}
			}
			if (!string.IsNullOrEmpty(_pendingJoinCode) && Time.unscaledTime >= _nextJoinBroadcast)
			{
				_nextJoinBroadcast = Time.unscaledTime + 0.5f;
				Send(_pendingJoinCode, "JOIN", LocalDisplayName(), RankedSettings.Rating.ToString(CultureInfo.InvariantCulture), _directPort.ToString(CultureInfo.InvariantCulture));
			}
			if (_inLobby && IsLobbyOwner && (_isPrivate || !SteamProfileReady || _steamLobby == null) && Time.unscaledTime >= _nextLobbyBroadcast)
			{
				_nextLobbyBroadcast = Time.unscaledTime + 0.35f;
				BroadcastLobbyState();
			}
			if (IsSearching && !SteamProfileReady && Time.unscaledTime >= _nextSearchBroadcast)
			{
				_nextSearchBroadcast = Time.unscaledTime + 0.45f;
				Send("", "SEARCH", ((int)CurrentCategory()).ToString(CultureInfo.InvariantCulture), SearchLevel ?? "", SearchDifficulty ?? "", RankedSettings.Rating.ToString(CultureInfo.InvariantCulture), LocalDisplayName());
			}
			if (_inLobby && _matches != null && _matches.IsMatchActive && (!SteamProfileReady || _steamLobby == null) && Time.unscaledTime >= _nextLiveBroadcast)
			{
				_nextLiveBroadcast = Time.unscaledTime + 0.25f;
				PublishLiveState();
			}
			if (_matches != null && _matches.State != _lastObservedMatchState)
			{
				_lastObservedMatchState = _matches.State;
				if (_inLobby && (_matches.State == MatchState.Finished || _matches.State == MatchState.Forfeited))
				{
					PublishResult();
				}
			}
			if (_inLobby && _matches != null && (_matches.State == MatchState.Finished || _matches.State == MatchState.Forfeited) && Time.unscaledTime >= _nextResultHeartbeat)
			{
				_nextResultHeartbeat = Time.unscaledTime + 0.5f;
				PublishResultHeartbeat();
				if (IsLobbyOwner && (!SteamProfileReady || _steamLobby == null))
				{
					BroadcastLobbyState();
				}
			}
			if (_inLobby && CurrentLobbyIsPublic && IsLobbyOwner && _peers.Count >= 2 && AllPlayersReady && _publicStartAfter > 0f && Time.unscaledTime >= _publicStartAfter && _matches != null && _matches.State == MatchState.Lobby)
			{
				_publicStartAfter = -1f;
				StartPrivateMatch();
			}
			if (Time.unscaledTime >= _nextCleanup)
			{
				_nextCleanup = Time.unscaledTime + 2f;
				CleanupPeers();
				RefreshFacade();
				TryApplyRating();
			}
		}

		public void CreateRoom()
		{
			Status = "CREATE ROOM";
			CreatePrivateLobby();
		}

		public void JoinRoomFromClipboard()
		{
			string systemCopyBuffer = GUIUtility.systemCopyBuffer;
			if (string.IsNullOrWhiteSpace(systemCopyBuffer))
			{
				Status = "NO UKSR CODE ON CLIPBOARD";
			}
			else
			{
				JoinRoom(systemCopyBuffer);
			}
		}

		public void JoinRoom(string code)
		{
			Status = "JOIN ROOM";
			JoinPrivateLobby(code);
		}

		public void LeaveRoom()
		{
			Status = "LEAVE ROOM";
			LeaveLobby();
		}

		public void SetRoomReady()
		{
			BeginReadyState();
		}

		public void StartRoom()
		{
			StartPrivateMatch();
		}

		public void CreatePrivateLobby()
		{
			if (!SteamProfileReady)
			{
				Status = "STEAM REQUIRED FOR PRIVATE LOBBIES";
				return;
			}
			LeaveLobby();
			_isPrivate = true;
			_inLobby = false;
			_ownerId = _clientId;
			_pendingJoinCode = "";
			LobbyCode = "";
			LobbyId = "";
			IsSearching = false;
			Status = "CREATING STEAM PRIVATE LOBBY";
			BeginSteamLobbyCreate(privateLobby: true);
			if (_log != null)
			{
				_log.LogInfo((object)"UKSR creating Steam private lobby.");
			}
		}

		public void JoinPrivateLobbyFromClipboard()
		{
			string code = ((GUIUtility.systemCopyBuffer == null) ? "" : GUIUtility.systemCopyBuffer.Trim());
			JoinPrivateLobby(code);
		}

		public void JoinPrivateLobby(string code)
		{
			if (!SteamProfileReady)
			{
				Status = "STEAM REQUIRED FOR PRIVATE LOBBIES";
				return;
			}
			string text = (string.IsNullOrWhiteSpace(code) ? "" : code.Trim());
			if (!TryDecodePrivateCode(text, out var lobbyId))
			{
				Status = "INVALID UKSR LOBBY CODE";
				return;
			}
			LeaveLobby();
			_isPrivate = true;
			_inLobby = false;
			_ownerId = "";
			_pendingJoinCode = "";
			LobbyCode = "";
			LobbyId = "";
			Status = "JOINING " + text.ToUpperInvariant();
			BeginSteamLobbyJoin(lobbyId);
			if (_log != null)
			{
				_log.LogInfo((object)("UKSR joining Steam private lobby " + lobbyId + " via " + LobbyCode));
			}
		}

		public void BeginReadyState()
		{
			if (_inLobby)
			{
				Peer peer = EnsureSelfPeer();
				peer.Ready = !peer.Ready;
				IsReady = peer.Ready;
				if (_steamLobby != null)
				{
					SetSteamMemberData("uksr_ready", IsReady ? "1" : "0");
				}
				Send(LobbyCode, "READY", IsReady ? "1" : "0");
				if (IsLobbyOwner)
				{
					BroadcastLobbyState();
				}
				Status = (IsReady ? "READY" : "NOT READY");
				RefreshFacade();
			}
		}

		public void BeginRankedSearchFor(string level, string difficulty)
		{
			if (!_networkReady && !SteamProfileReady)
			{
				IsSearching = false;
				Status = "NO NETWORK TRANSPORT AVAILABLE";
				return;
			}
			LeaveLobby();
			SearchLevel = level ?? "";
			SearchDifficulty = difficulty ?? "";
			IsSearching = true;
			AlternativeQueueAvailable = false;
			AlternativeOfferPending = false;
			AlternativeQueueLabel = "";
			_publicMatchId = "";
			_publicPartnerClientId = "";
			_searchStartedAt = Time.unscaledTime;
			Status = "SEARCHING // ELO " + RankedSettings.Rating + " // " + (string.IsNullOrEmpty(SearchLevel) ? "ANY SCOPE" : SearchLevel) + " // " + (string.IsNullOrEmpty(SearchDifficulty) ? "ANY DIFFICULTY" : SearchDifficulty);
			_nextSearchBroadcast = 0f;
			_nextSteamPublicQuery = 0f;
			_steamPublicCreated = false;
		}

		public void BeginRankedSearch()
		{
			BeginRankedSearchFor("", "");
		}

		public void AcceptAlternativeQueue()
		{
			if (!AlternativeQueueAvailable)
			{
				return;
			}
			AlternativeOfferPending = false;
			AlternativeQueueAvailable = false;
			SearchLevel = _alternativeScope;
			SearchDifficulty = _alternativeDifficulty;
			if (_matches != null)
			{
				CategoryDefinition categoryDefinition = BuildCategory((RankedCategory)_alternativeCategory, _alternativeScope);
				if (categoryDefinition != null)
				{
					_matches.SetCategory(categoryDefinition);
				}
			}
			_publicMatchId = "";
			if (_steamLobby != null)
			{
				TryInvokeSteamLobby("Leave");
				_steamLobby = null;
				_inLobby = false;
				LobbyId = "";
				LobbyCode = "";
			}
			_steamPublicCreated = false;
			_nextSteamPublicQuery = 0f;
			Status = "SWITCHED QUEUE // " + AlternativeQueueLabel;
		}

		public void DismissAlternativeQueue()
		{
			AlternativeOfferPending = false;
		}

		public void CancelRankedSearch()
		{
			IsSearching = false;
			Status = "SEARCH CANCELLED";
		}

		public void CopyUksrCode()
		{
			GUIUtility.systemCopyBuffer = LobbyCode ?? "";
			Status = (string.IsNullOrEmpty(LobbyCode) ? "LOBBY CODE NOT READY" : "UKSR LOBBY CODE COPIED");
		}

		public void CopySteamLobbyCode()
		{
			CopyUksrCode();
		}

		public void OpenInviteOverlay()
		{
			if (!SteamAvailable || _steamLobby == null)
			{
				Status = "STEAM LOBBY NOT READY";
				return;
			}
			try
			{
				object obj = ReadInstanceProperty(_steamLobby, "Id");
				if (obj == null || !ulong.TryParse(obj.ToString(), out var result))
				{
					Status = "STEAM LOBBY ID UNAVAILABLE";
					return;
				}
				Type type = FindType("Steamworks.SteamFriends");
				if (type == null)
				{
					Status = "STEAM FRIENDS API UNAVAILABLE";
					return;
				}
				MethodInfo methodInfo = null;
				MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo2 in methods)
				{
					if (methodInfo2.Name == "OpenGameInviteOverlay" && methodInfo2.GetParameters().Length == 1)
					{
						methodInfo = methodInfo2;
						break;
					}
				}
				if (methodInfo == null)
				{
					Status = "STEAM INVITE API NOT FOUND";
					return;
				}
				InvokeSteamSingleArg(methodInfo, result);
				Status = "STEAM FRIEND INVITE OPEN";
			}
			catch (Exception ex)
			{
				Status = "STEAM INVITE FAILED";
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam invite overlay failed: " + ex));
				}
			}
		}

		public void StartPrivateMatch()
		{
			if (!_inLobby)
			{
				Status = "NO LOBBY";
				return;
			}
			if (!IsLobbyOwner)
			{
				Status = "ONLY LOBBY OWNER CAN START";
				return;
			}
			RefreshFacade();
			if (_peers.Count < 2)
			{
				Status = "WAITING FOR ANOTHER PLAYER";
				return;
			}
			if (!AllPlayersReady)
			{
				Status = "WAITING FOR READY PLAYERS";
				return;
			}
			if (_matches == null || _matches.Category == null)
			{
				Status = "PICK A CATEGORY FIRST";
				return;
			}
			_currentMatchId = LobbyCode + "-" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
			string lobbyCode = LobbyCode;
			string[] obj = new string[5] { _currentMatchId, null, null, null, null };
			int category = (int)_matches.Category.Category;
			obj[1] = category.ToString(CultureInfo.InvariantCulture);
			obj[2] = _matches.Category.Scope ?? "";
			obj[3] = _matches.Difficulty.ToString(CultureInfo.InvariantCulture);
			obj[4] = _matches.DifficultyName ?? "";
			Send(lobbyCode, "START", obj);
			SetSteamLobbyData("uksr_match_id", _currentMatchId);
			category = (int)_matches.Category.Category;
			SetSteamLobbyData("uksr_match_category", category.ToString(CultureInfo.InvariantCulture));
			SetSteamLobbyData("uksr_match_scope", _matches.Category.Scope ?? "");
			SetSteamLobbyData("uksr_match_difficulty", _matches.Difficulty.ToString(CultureInfo.InvariantCulture));
			SetSteamLobbyData("uksr_match_difficulty_name", _matches.DifficultyName ?? "");
			SetSteamLobbyData("uksr_match_start", DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture));
			StartLocalMatchFromConfig(_matches.Category.Category, _matches.Category.Scope, _matches.Difficulty, _matches.DifficultyName);
			Status = "MATCH STARTED";
			if (_log != null)
			{
				_log.LogInfo((object)("UKSR synchronized match start: " + _currentMatchId));
			}
		}

		public List<RankedStanding> GetStandings()
		{
			EnsureSelfPeer();
			TryApplyRating();
			List<RankedStanding> list = new List<RankedStanding>();
			foreach (Peer value in _peers.Values)
			{
				bool flag = value.Id == _clientId;
				string text = value.ResultState;
				double rta = value.ResultRta;
				double igt = value.ResultIgt;
				if (flag && _matches != null)
				{
					if (_matches.State == MatchState.Finished)
					{
						text = "finished";
					}
					else if (_matches.State == MatchState.Forfeited)
					{
						text = "forfeit";
					}
					if (!string.IsNullOrEmpty(text))
					{
						rta = _matches.FinalRtaSeconds;
						igt = _matches.FinalIgtSeconds;
					}
				}
				list.Add(new RankedStanding
				{
					Name = value.Name,
					SteamId = (string.IsNullOrEmpty(value.SteamId) ? value.Id : value.SteamId),
					Finished = (text == "finished"),
					Forfeit = (text == "forfeit"),
					Rta = rta,
					Igt = igt,
					IsSelf = flag
				});
			}
			foreach (RankedLivePeer livePeer in LivePeers)
			{
				bool flag2 = false;
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].SteamId == livePeer.SteamId)
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					list.Add(new RankedStanding
					{
						Name = livePeer.Name,
						SteamId = livePeer.SteamId,
						Finished = (livePeer.State == "finished"),
						Forfeit = (livePeer.State == "forfeit"),
						Rta = livePeer.Rta,
						Igt = livePeer.Igt,
						IsSelf = false
					});
				}
			}
			list.Sort(delegate(RankedStanding a, RankedStanding b)
			{
				if (a.Finished && b.Finished)
				{
					return a.Igt.CompareTo(b.Igt);
				}
				if (a.Finished)
				{
					return -1;
				}
				if (b.Finished)
				{
					return 1;
				}
				if (a.Forfeit && !b.Forfeit)
				{
					return 1;
				}
				return (!a.Forfeit && b.Forfeit) ? (-1) : string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase);
			});
			return list;
		}

		public void VoteRematch()
		{
			_rematchVote = true;
			if (_steamLobby != null)
			{
				SetSteamMemberData("uksr_rematch", "1");
			}
			Status = "REMATCH VOTE SENT";
			MarkLobbyUiDirty();
			TryStartRematchIfReady();
		}

		public void ClearRematchVote()
		{
			_rematchVote = false;
			_remoteRematchVote = false;
			if (_steamLobby != null)
			{
				SetSteamMemberData("uksr_rematch", "0");
			}
		}

		private void TryStartRematchIfReady()
		{
			if (_rematchVote && _remoteRematchVote && _matches != null)
			{
				ClearRematchVote();
				if (IsLobbyOwner)
				{
					Status = "REMATCH STARTING";
					StartPrivateMatch();
				}
			}
		}

		public void LeaveLobby()
		{
			if (_inLobby)
			{
				Send(LobbyCode, "LEAVE");
			}
			if (_steamLobby != null)
			{
				TryInvokeSteamLobby("Leave");
				_steamLobby = null;
			}
			_inLobby = false;
			_isPrivate = false;
			_ownerId = "";
			_pendingJoinCode = "";
			_currentMatchId = "";
			_publicStartAfter = -1f;
			LobbyId = "";
			LobbyCode = "";
			IsSearching = false;
			AlternativeQueueAvailable = false;
			AlternativeOfferPending = false;
			AlternativeQueueLabel = "";
			IsReady = false;
			IsLobbyOwner = false;
			AllPlayersReady = false;
			CurrentLobbyIsPrivate = false;
			RemoveLocalLobbyRegistry();
			_directPeers.Clear();
			_peers.Clear();
			_lastRemoteEvent.Clear();
			LobbyPlayers.Clear();
			LivePeers.Clear();
			Status = (_networkReady ? "UKSR NETWORK READY" : "UKSR NETWORK ERROR");
		}

		public string PacketPreview(string kind, string payload)
		{
			return "UKSRLAN1|" + kind + "|" + payload;
		}

		public void ReceivePacket(string packet)
		{
		}

		private void ReceivePackets()
		{
			int num = 0;
			while (_udp != null && _udp.Available > 0 && num < 128)
			{
				num++;
				try
				{
					IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
					byte[] bytes = _udp.Receive(ref remoteEP);
					string packet = Encoding.UTF8.GetString(bytes);
					HandlePacket(packet);
				}
				catch (SocketException)
				{
					break;
				}
				catch (Exception ex2)
				{
					if (_log != null)
					{
						_log.LogWarning((object)("UKSR packet receive failed: " + ex2.Message));
					}
					break;
				}
			}
		}

		private void HandlePacket(string packet)
		{
			if (string.IsNullOrEmpty(packet))
			{
				return;
			}
			string[] array = packet.Split('|');
			if (array.Length < 4 || array[0] != "UKSRLAN1")
			{
				return;
			}
			string text = array[1];
			string text2 = array[2];
			string text3 = Decode(array[3]);
			if (text2 == _clientId)
			{
				return;
			}
			string[] array2 = new string[Math.Max(0, array.Length - 4)];
			for (int i = 4; i < array.Length; i++)
			{
				array2[i - 4] = Decode(array[i]);
			}
			switch (text)
			{
			case "SEARCH":
				HandleSearch(text2, array2);
				return;
			case "MATCH":
				HandleMatch(text2, array2);
				return;
			case "JOIN":
				HandleJoin(text2, text3, array2);
				return;
			}
			if ((_inLobby && text3 != LobbyCode) || (!_inLobby && !string.IsNullOrEmpty(_pendingJoinCode) && text3 != _pendingJoinCode) || text == null)
			{
				return;
			}
			switch (text.Length)
			{
			case 5:
				switch (text[3])
				{
				case 'B':
					if (text == "LOBBY")
					{
						HandleLobby(text2, text3, array2);
					}
					break;
				case 'D':
					if (text == "READY")
					{
						HandleReady(text2, array2);
					}
					break;
				case 'R':
					if (text == "START")
					{
						HandleStart(text2, array2);
					}
					break;
				case 'N':
					if (text == "EVENT")
					{
						HandleEvent(text2, array2);
					}
					break;
				case 'V':
					if (text == "LEAVE")
					{
						HandleLeave(text2);
					}
					break;
				}
				break;
			case 4:
				switch (text[0])
				{
				case 'P':
					if (text == "PEER")
					{
						HandlePeer(array2);
					}
					break;
				case 'L':
					if (text == "LIVE")
					{
						HandleLive(text2, array2);
					}
					break;
				}
				break;
			case 6:
				if (text == "RESULT")
				{
					HandleResult(text2, array2);
				}
				break;
			}
		}

		private void HandleSearch(string sender, string[] fields)
		{
			if (SteamProfileReady || !IsSearching || _inLobby || fields.Length < 5)
			{
				return;
			}
			int.TryParse(fields[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
			int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2);
			string text = fields[1];
			string text2 = fields[2];
			string remoteName = fields[4];
			if (result == (int)CurrentCategory() && string.Equals(text ?? "", SearchLevel ?? "", StringComparison.OrdinalIgnoreCase) && string.Equals(text2 ?? "", SearchDifficulty ?? "", StringComparison.OrdinalIgnoreCase))
			{
				float num = Time.unscaledTime - _searchStartedAt;
				int num2 = Math.Abs(RankedSettings.Rating - result2);
				int num3 = 200 + (int)(num * 100f);
				if ((!(num < 6f) || num2 <= num3) && string.CompareOrdinal(_clientId, sender) < 0)
				{
					CreatePublicMatchLobby(sender, remoteName, result2);
				}
			}
		}

		private void CreatePublicMatchLobby(string remoteId, string remoteName, int remoteRating)
		{
			_isPrivate = false;
			_inLobby = true;
			_ownerId = _clientId;
			LobbyCode = "UKSR-P" + RandomCode().Substring(0, 5);
			LobbyId = LobbyCode;
			IsSearching = false;
			Peer peer = EnsureSelfPeer();
			peer.Ready = true;
			peer.Rating = RankedSettings.Rating;
			Peer orCreatePeer = GetOrCreatePeer(remoteId, remoteName);
			orCreatePeer.Ready = true;
			orCreatePeer.Rating = remoteRating;
			Send("", "MATCH", remoteId, LobbyCode, LocalDisplayName(), RankedSettings.Rating.ToString(CultureInfo.InvariantCulture));
			Status = "MATCH FOUND";
			if (_matches != null)
			{
				_matches.EnterLobby();
			}
			RefreshFacade();
			BroadcastLobbyState();
			_publicStartAfter = Time.unscaledTime + 1f;
		}

		private void HandleMatch(string sender, string[] fields)
		{
			if (!SteamProfileReady && IsSearching && fields.Length >= 4 && !(fields[0] != _clientId))
			{
				string text = NormalizeCode(fields[1]);
				if (!string.IsNullOrEmpty(text))
				{
					string name = fields[2];
					int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
					IsSearching = false;
					_pendingJoinCode = text;
					LobbyCode = text;
					Status = "MATCH FOUND // JOINING";
					_nextJoinBroadcast = 0f;
					Peer orCreatePeer = GetOrCreatePeer(sender, name);
					orCreatePeer.Ready = true;
					orCreatePeer.Rating = result;
				}
			}
		}

		private void HandleJoin(string sender, string code, string[] fields)
		{
			if (!_inLobby || !IsLobbyOwner || code != LobbyCode)
			{
				return;
			}
			int num = (_isPrivate ? 8 : 2);
			if (_peers.Count < num || _peers.ContainsKey(sender))
			{
				string name = ((fields.Length != 0) ? fields[0] : "PLAYER");
				int result = 1000;
				if (fields.Length > 1)
				{
					int.TryParse(fields[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
				}
				Peer orCreatePeer = GetOrCreatePeer(sender, name);
				orCreatePeer.Rating = ((result > 0) ? result : 1000);
				orCreatePeer.Ready = !_isPrivate;
				orCreatePeer.LastSeen = Time.unscaledTime;
				if (fields.Length > 2 && int.TryParse(fields[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2) && result2 > 0)
				{
					_directPeers[sender] = new IPEndPoint(IPAddress.Loopback, result2);
				}
				Status = "PLAYER JOINED";
				RefreshFacade();
				BroadcastLobbyState();
				if (!_isPrivate && _peers.Count >= 2)
				{
					_publicStartAfter = Time.unscaledTime + 1f;
				}
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR player joined " + LobbyCode + " // " + orCreatePeer.Name + " // client " + orCreatePeer.Id + " // ELO " + orCreatePeer.Rating));
				}
			}
		}

		private void HandleLobby(string sender, string code, string[] fields)
		{
			if (fields.Length < 8)
			{
				return;
			}
			string text = fields[0];
			string name = fields[1];
			bool isPrivate = fields[2] == "1";
			if (!_inLobby)
			{
				if (string.IsNullOrEmpty(_pendingJoinCode) || code != _pendingJoinCode)
				{
					return;
				}
				_inLobby = true;
				_isPrivate = isPrivate;
				_ownerId = text;
				LobbyCode = code;
				LobbyId = code;
				_pendingJoinCode = "";
				IsSearching = false;
				EnsureSelfPeer();
				if (_matches != null)
				{
					_matches.EnterLobby();
				}
				Status = "JOINED " + code;
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR joined platform-neutral lobby " + code + " // owner client " + text));
				}
			}
			_ownerId = text;
			_isPrivate = isPrivate;
			int result = 1000;
			int.TryParse(fields[7], NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
			Peer orCreatePeer = GetOrCreatePeer(text, name);
			orCreatePeer.Rating = ((result > 0) ? result : 1000);
			orCreatePeer.LastSeen = Time.unscaledTime;
			int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2);
			int.TryParse(fields[5], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3);
			if (text != _clientId && _matches != null)
			{
				CategoryDefinition categoryDefinition = BuildCategory((RankedCategory)result2, fields[4]);
				if (categoryDefinition != null)
				{
					_matches.SetCategory(categoryDefinition);
				}
				_matches.SetDifficulty(result3, fields[6]);
			}
			if (fields.Length > 8 && SteamProfileReady && _steamLobby == null && ulong.TryParse(fields[8], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4) && result4 != 0)
			{
				BeginSteamLobbyJoin(result4);
			}
			RefreshFacade();
		}

		private void HandlePeer(string[] fields)
		{
			if (fields.Length >= 8)
			{
				string id = fields[0];
				string name = fields[1];
				Peer orCreatePeer = GetOrCreatePeer(id, name);
				orCreatePeer.Ready = fields[2] == "1";
				int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
				orCreatePeer.Rating = ((result > 0) ? result : 1000);
				orCreatePeer.ResultState = fields[4];
				orCreatePeer.ResultRta = ParseDouble(fields[5]);
				orCreatePeer.ResultIgt = ParseDouble(fields[6]);
				orCreatePeer.LastSeen = Time.unscaledTime;
				RefreshFacade();
			}
		}

		private void HandleReady(string sender, string[] fields)
		{
			if (IsLobbyOwner && fields.Length >= 1)
			{
				Peer orCreatePeer = GetOrCreatePeer(sender, "PLAYER");
				orCreatePeer.Ready = fields[0] == "1";
				orCreatePeer.LastSeen = Time.unscaledTime;
				RefreshFacade();
				BroadcastLobbyState();
			}
		}

		private void HandleStart(string sender, string[] fields)
		{
			if (_inLobby && !(sender != _ownerId) && fields.Length >= 5)
			{
				_currentMatchId = fields[0];
				int.TryParse(fields[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
				int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2);
				StartLocalMatchFromConfig((RankedCategory)result, fields[2], result2, fields[4]);
				Status = "MATCH STARTED BY OWNER";
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage("MATCH STARTED");
				}
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR remote synchronized start received // " + _currentMatchId));
				}
			}
		}

		private void StartLocalMatchFromConfig(RankedCategory categoryType, string scope, int difficulty, string difficultyName)
		{
			if (_matches != null)
			{
				CategoryDefinition categoryDefinition = BuildCategory(categoryType, scope);
				if (categoryDefinition != null)
				{
					_matches.SetCategory(categoryDefinition);
				}
				_matches.SetDifficulty(difficulty, string.IsNullOrEmpty(difficultyName) ? difficulty.ToString() : difficultyName);
				ClearRunState();
				_matches.StartLocalMatch();
				string text = ((_matches.Category != null && _matches.Category.ExpectedLevels.Count > 0) ? _matches.Category.ExpectedLevels[0] : _matches.SelectedLevel);
				if (!string.IsNullOrEmpty(text))
				{
					RankedLevelLoader.LoadLevel(text, _log);
				}
			}
		}

		private void ClearRunState()
		{
			_lastPublishedSplit = -1;
			_eventSequence = 0L;
			_nextLiveBroadcast = 0f;
			LivePeers.Clear();
			foreach (Peer value in _peers.Values)
			{
				value.Rta = 0.0;
				value.Igt = 0.0;
				value.Level = "";
				value.Split = 0;
				value.ResultState = "";
				value.ResultRta = 0.0;
				value.ResultIgt = 0.0;
			}
		}

		private void PublishLiveState()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: 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_009e: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			if (_matches == null)
			{
				return;
			}
			string text = CurrentExpectedLevel();
			Vector3 val = Vector3.zero;
			Vector3 val2 = Vector3.zero;
			float speed = 0f;
			bool flag = false;
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null && (Object)(object)((Component)main).transform != (Object)null)
			{
				val = ((Component)main).transform.position;
				val2 = ((Component)main).transform.eulerAngles;
				flag = true;
				float unscaledTime = Time.unscaledTime;
				if (_hasLastSpectatorPosition && unscaledTime > _lastSpectatorSampleTime)
				{
					speed = Vector3.Distance(_lastSpectatorPosition, val) / Mathf.Max(0.001f, unscaledTime - _lastSpectatorSampleTime);
				}
				_lastSpectatorPosition = val;
				_lastSpectatorSampleTime = unscaledTime;
				_hasLastSpectatorPosition = true;
			}
			Send(LobbyCode, "LIVE", _matches.RtaSeconds.ToString("R", CultureInfo.InvariantCulture), _matches.IgtSeconds.ToString("R", CultureInfo.InvariantCulture), text, _matches.Splits.ToString(CultureInfo.InvariantCulture), flag ? "1" : "0", val.x.ToString("R", CultureInfo.InvariantCulture), val.y.ToString("R", CultureInfo.InvariantCulture), val.z.ToString("R", CultureInfo.InvariantCulture), val2.x.ToString("R", CultureInfo.InvariantCulture), val2.y.ToString("R", CultureInfo.InvariantCulture), val2.z.ToString("R", CultureInfo.InvariantCulture), speed.ToString("R", CultureInfo.InvariantCulture));
			Peer peer = EnsureSelfPeer();
			peer.Rta = _matches.RtaSeconds;
			peer.Igt = _matches.IgtSeconds;
			peer.Level = text;
			peer.Split = _matches.Splits;
			peer.HasSpectatorPose = flag;
			peer.X = val.x;
			peer.Y = val.y;
			peer.Z = val.z;
			peer.Pitch = val2.x;
			peer.Yaw = val2.y;
			peer.Roll = val2.z;
			peer.Speed = speed;
			if (_matches.Splits <= _lastPublishedSplit)
			{
				return;
			}
			if (_lastPublishedSplit >= 0)
			{
				string scope = "";
				if (_matches.Category != null && _matches.Splits - 1 < _matches.Category.ExpectedLevels.Count)
				{
					scope = _matches.Category.ExpectedLevels[_matches.Splits - 1];
				}
				PublishEvent("level", scope, _matches.RtaSeconds, _matches.IgtSeconds);
			}
			_lastPublishedSplit = _matches.Splits;
		}

		private void HandleLive(string sender, string[] fields)
		{
			if (fields.Length >= 4)
			{
				Peer orCreatePeer = GetOrCreatePeer(sender, "OPPONENT");
				orCreatePeer.Rta = ParseDouble(fields[0]);
				orCreatePeer.Igt = ParseDouble(fields[1]);
				orCreatePeer.Level = fields[2];
				int.TryParse(fields[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
				orCreatePeer.Split = result;
				if (fields.Length >= 12)
				{
					orCreatePeer.HasSpectatorPose = fields[4] == "1";
					orCreatePeer.X = (float)ParseDouble(fields[5]);
					orCreatePeer.Y = (float)ParseDouble(fields[6]);
					orCreatePeer.Z = (float)ParseDouble(fields[7]);
					orCreatePeer.Pitch = (float)ParseDouble(fields[8]);
					orCreatePeer.Yaw = (float)ParseDouble(fields[9]);
					orCreatePeer.Roll = (float)ParseDouble(fields[10]);
					orCreatePeer.Speed = (float)ParseDouble(fields[11]);
				}
				orCreatePeer.LastSeen = Time.unscaledTime;
				RefreshLivePeers();
			}
		}

		private void PublishEvent(string type, string scope, double rta, double igt)
		{
			_eventSequence++;
			Send(LobbyCode, "EVENT", _eventSequence.ToString(CultureInfo.InvariantCulture), type ?? "", scope ?? "", rta.ToString("R", CultureInfo.InvariantCulture), igt.ToString("R", CultureInfo.InvariantCulture));
		}

		private void HandleEvent(string sender, string[] fields)
		{
			if (fields.Length < 5 || !long.TryParse(fields[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || (_lastRemoteEvent.TryGetValue(sender, out var value) && result <= value))
			{
				return;
			}
			_lastRemoteEvent[sender] = result;
			Peer orCreatePeer = GetOrCreatePeer(sender, "OPPONENT");
			string text = fields[1];
			string level = fields[2];
			double rtaSeconds = ParseDouble(fields[3]);
			double num = ParseDouble(fields[4]);
			switch (text)
			{
			case "level":
				if (_matches != null)
				{
					_matches.NotifyOpponentLevelCompleted(orCreatePeer.Name, level, rtaSeconds, num);
				}
				break;
			case "finish":
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage(orCreatePeer.Name + " FINISHED   IGT " + RankedNotificationManager.FormatTime(num));
				}
				break;
			case "forfeit":
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage(orCreatePeer.Name + " FORFEITED");
				}
				break;
			}
		}

		private void PublishResult()
		{
			if (_matches != null)
			{
				string text = ((_matches.State == MatchState.Finished) ? "finished" : "forfeit");
				Peer peer = EnsureSelfPeer();
				peer.ResultState = text;
				peer.ResultRta = _matches.FinalRtaSeconds;
				peer.ResultIgt = _matches.FinalIgtSeconds;
				Send(LobbyCode, "RESULT", text, peer.ResultRta.ToString("R", CultureInfo.InvariantCulture), peer.ResultIgt.ToString("R", CultureInfo.InvariantCulture));
				SetSteamMemberData("uksr_result_state", text);
				SetSteamMemberData("uksr_result_rta", peer.ResultRta.ToString("R", CultureInfo.InvariantCulture));
				SetSteamMemberData("uksr_result_igt", peer.ResultIgt.ToString("R", CultureInfo.InvariantCulture));
				PublishEvent((text == "finished") ? "finish" : "forfeit", "", peer.ResultRta, peer.ResultIgt);
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR network result published // " + text + " // IGT " + peer.ResultIgt.ToString("0.000", CultureInfo.InvariantCulture)));
				}
				TryApplyRating();
			}
		}

		private void PublishResultHeartbeat()
		{
			if (_matches != null && _inLobby)
			{
				string text = ((_matches.State == MatchState.Finished) ? "finished" : ((_matches.State == MatchState.Forfeited) ? "forfeit" : ""));
				if (!string.IsNullOrEmpty(text))
				{
					Peer peer = EnsureSelfPeer();
					peer.ResultState = text;
					peer.ResultRta = _matches.FinalRtaSeconds;
					peer.ResultIgt = _matches.FinalIgtSeconds;
					Send(LobbyCode, "RESULT", text, peer.ResultRta.ToString("R", CultureInfo.InvariantCulture), peer.ResultIgt.ToString("R", CultureInfo.InvariantCulture));
					SetSteamMemberData("uksr_result_state", text);
					SetSteamMemberData("uksr_result_rta", peer.ResultRta.ToString("R", CultureInfo.InvariantCulture));
					SetSteamMemberData("uksr_result_igt", peer.ResultIgt.ToString("R", CultureInfo.InvariantCulture));
				}
			}
		}

		private void HandleResult(string sender, string[] fields)
		{
			if (fields.Length >= 3)
			{
				Peer orCreatePeer = GetOrCreatePeer(sender, "OPPONENT");
				orCreatePeer.ResultState = fields[0];
				orCreatePeer.ResultRta = ParseDouble(fields[1]);
				orCreatePeer.ResultIgt = ParseDouble(fields[2]);
				orCreatePeer.LastSeen = Time.unscaledTime;
				if (IsLobbyOwner)
				{
					BroadcastLobbyState();
				}
				TryApplyRating();
			}
		}

		private void HandleLeave(string sender)
		{
			if (_peers.Remove(sender))
			{
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage("PLAYER LEFT LOBBY");
				}
				RefreshFacade();
			}
		}

		private void BroadcastLobbyState()
		{
			if (!_inLobby || !IsLobbyOwner)
			{
				return;
			}
			RankedCategory rankedCategory = CurrentCategory();
			string text = ((_matches != null && _matches.Category != null) ? _matches.Category.Scope : "");
			int num = ((_matches == null) ? 2 : _matches.Difficulty);
			string text2 = ((_matches == null) ? "STANDARD" : _matches.DifficultyName);
			PublishSteamLobbyConfig();
			string lobbyCode = LobbyCode;
			string[] obj = new string[9]
			{
				_clientId,
				LocalDisplayName(),
				_isPrivate ? "1" : "0",
				null,
				null,
				null,
				null,
				null,
				null
			};
			int num2 = (int)rankedCategory;
			obj[3] = num2.ToString(CultureInfo.InvariantCulture);
			obj[4] = text ?? "";
			obj[5] = num.ToString(CultureInfo.InvariantCulture);
			obj[6] = text2 ?? "";
			obj[7] = RankedSettings.Rating.ToString(CultureInfo.InvariantCulture);
			obj[8] = SteamLobbyIdText();
			Send(lobbyCode, "LOBBY", obj);
			foreach (Peer value in _peers.Values)
			{
				Send(LobbyCode, "PEER", value.Id, value.Name ?? "PLAYER", value.Ready ? "1" : "0", value.Rating.ToString(CultureInfo.InvariantCulture), value.ResultState ?? "", value.ResultRta.ToString("R", CultureInfo.InvariantCulture), value.ResultIgt.ToString("R", CultureInfo.InvariantCulture), value.LastSeen.ToString("R", CultureInfo.InvariantCulture));
			}
		}

		private void CleanupPeers()
		{
			if (!_inLobby)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (Peer value in _peers.Values)
			{
				if (!(value.Id == _clientId))
				{
					bool num = !string.IsNullOrEmpty(value.ResultState);
					bool flag = _matches != null && (_matches.State == MatchState.Finished || _matches.State == MatchState.Forfeited);
					if (!num && !flag && Time.unscaledTime - value.LastSeen > 6f)
					{
						list.Add(value.Id);
					}
				}
			}
			foreach (string item in list)
			{
				_peers.Remove(item);
			}
		}

		private void RefreshFacade()
		{
			IsLobbyOwner = _inLobby && _ownerId == _clientId;
			CurrentLobbyIsPrivate = _inLobby && _isPrivate;
			LobbyId = (_inLobby ? LobbyCode : "");
			Peer peer = null;
			if (_inLobby)
			{
				peer = EnsureSelfPeer();
			}
			IsReady = peer?.Ready ?? false;
			LobbyPlayers.Clear();
			if (_inLobby)
			{
				List<Peer> list = new List<Peer>(_peers.Values);
				list.Sort(delegate(Peer a, Peer b)
				{
					if (a.Id == _ownerId)
					{
						return -1;
					}
					return (b.Id == _ownerId) ? 1 : string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase);
				});
				foreach (Peer item in list)
				{
					string text = item.Name + "  [" + item.Rating + "]";
					if (item.Id == _ownerId)
					{
						text += "  HOST";
					}
					if (item.Id == _clientId)
					{
						text += "  YOU";
					}
					if (item.Ready)
					{
						text += "  READY";
					}
					LobbyPlayers.Add(text);
				}
			}
			AllPlayersReady = _inLobby && _peers.Count >= 2;
			if (AllPlayersReady)
			{
				foreach (Peer value in _peers.Values)
				{
					if (!value.Ready)
					{
						AllPlayersReady = false;
						break;
					}
				}
			}
			RefreshLivePeers();
		}

		private void RefreshLivePeers()
		{
			LivePeers.Clear();
			foreach (Peer value in _peers.Values)
			{
				if (!(value.Id == _clientId))
				{
					LivePeers.Add(new RankedLivePeer
					{
						Name = value.Name,
						SteamId = (string.IsNullOrEmpty(value.SteamId) ? value.Id : value.SteamId),
						Level = value.Level,
						State = (string.IsNullOrEmpty(value.ResultState) ? "running" : value.ResultState),
						Rta = ((!string.IsNullOrEmpty(value.ResultState)) ? value.ResultRta : value.Rta),
						Igt = ((!string.IsNullOrEmpty(value.ResultState)) ? value.ResultIgt : value.Igt),
						X = value.X,
						Y = value.Y,
						Z = value.Z,
						Pitch = value.Pitch,
						Yaw = value.Yaw,
						Roll = value.Roll,
						Speed = value.Speed,
						HasSpectatorPose = value.HasSpectatorPose
					});
				}
			}
		}

		private Peer EnsureSelfPeer()
		{
			if (!_peers.TryGetValue(_clientId, out var value))
			{
				value = new Peer
				{
					Id = _clientId,
					SteamId = SteamId,
					Name = LocalDisplayName(),
					Rating = RankedSettings.Rating,
					LastSeen = Time.unscaledTime
				};
				_peers[_clientId] = value;
			}
			else
			{
				value.Name = LocalDisplayName();
				value.SteamId = SteamId;
				value.Rating = RankedSettings.Rating;
				value.LastSeen = Time.unscaledTime;
			}
			return value;
		}

		private Peer GetOrCreatePeer(string id, string name)
		{
			if (!_peers.TryGetValue(id, out var value))
			{
				value = new Peer
				{
					Id = id,
					Name = (string.IsNullOrEmpty(name) ? "PLAYER" : name),
					Rating = 1000,
					LastSeen = Time.unscaledTime
				};
				_peers[id] = value;
			}
			else if (!string.IsNullOrEmpty(name) && name != "PLAYER" && name != "OPPONENT")
			{
				value.Name = name;
			}
			value.LastSeen = Time.unscaledTime;
			return value;
		}

		private void TryApplyRating()
		{
			if (string.IsNullOrEmpty(_currentMatchId) || RankedSettings.HasRatedMatch(_currentMatchId) || _peers.Count < 2)
			{
				return;
			}
			Peer peer = EnsureSelfPeer();
			if (string.IsNullOrEmpty(peer.ResultState))
			{
				return;
			}
			double num = 0.0;
			double num2 = 0.0;
			int num3 = 0;
			bool flag = true;
			bool flag2 = false;
			foreach (Peer value in _peers.Values)
			{
				if (!(value.Id == _clientId) && !string.IsNullOrEmpty(value.ResultState))
				{
					double num4 = ScoreAgainst(peer, value);
					double num5 = 1.0 / (1.0 + Math.Pow(10.0, (double)(value.Rating - RankedSettings.Rating) / 400.0));
					num += num4;
					num2 += num5;
					num3++;
					if (num4 < 1.0)
					{
						flag = false;
					}
					if (num4 < 0.5)
					{
						flag2 = true;
					}
				}
			}
			if (num3 != 0)
			{
				double num6 = num / (double)num3;
				double num7 = num2 / (double)num3;
				int num8 = (int)Math.Round(32.0 * (num6 - num7));
				int rating = RankedSettings.Rating;
				int newRating = Math.Max(100, rating + num8);
				int outcome = (flag ? 1 : (flag2 ? (-1) : 0));
				RankedSettings.ApplyRatingResult(_currentMatchId, newRating, outcome);
				peer.Rating = RankedSettings.Rating;
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR ELO // " + rating + " -> " + RankedSettings.Rating + " // delta " + num8.ToString("+0;-0;0", CultureInfo.InvariantCulture) + " // " + RankedSettings.Record));
				}
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage("ELO " + rating + " -> " + RankedSettings.Rating + " (" + num8.ToString("+0;-0;0", CultureInfo.InvariantCulture) + ")");
				}
			}
		}

		private static double ScoreAgainst(Peer self, Peer opponent)
		{
			if (self.ResultState == "forfeit" && opponent.ResultState == "forfeit")
			{
				return 0.5;
			}
			if (self.ResultState == "forfeit")
			{
				return 0.0;
			}
			if (opponent.ResultState == "forfeit")
			{
				return 1.0;
			}
			if (self.ResultState != "finished" || opponent.ResultState != "finished")
			{
				return 0.5;
			}
			double num = self.ResultIgt - opponent.ResultIgt;
			if (Math.Abs(num) < 0.0005)
			{
				return 0.5;
			}
			if (!(num < 0.0))
			{
				return 0.0;
			}
			return 1.0;
		}

		private string CurrentExpectedLevel()
		{
			if (_matches == null || _matches.Category == null)
			{
				return "";
			}
			if (_matches.Splits >= 0 && _matches.Splits < _matches.Category.ExpectedLevels.Count)
			{
				return _matches.Category.ExpectedLevels[_matches.Splits];
			}
			return "";
		}

		private RankedCategory CurrentCategory()
		{
			if (_matches == null || _matches.Category == null)
			{
				return RankedCategory.FullGameAny;
			}
			return _matches.Category.Category;
		}

		private string LocalDisplayName()
		{
			return ((string.IsNullOrWhiteSpace(SteamName) || SteamName == "UNKNOWN" || SteamName == "STEAM UNAVAILABLE") ? "PLAYER" : SteamName) + " #" + _clientId.Substring(_clientId.Length - 4);
		}

		private void Send(string code, string type, params string[] fields)
		{
			if (!_networkReady || _udp == null || _multicastEndpoint == null)
			{
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("UKSRLAN1");
				stringBuilder.Append('|');
				stringBuilder.Append(type ?? "");
				stringBuilder.Append('|');
				stringBuilder.Append(_clientId);
				stringBuilder.Append('|');
				stringBuilder.Append(Encode(code ?? ""));
				if (fields != null)
				{
					foreach (string text in fields)
					{
						stringBuilder.Append('|');
						stringBuilder.Append(Encode(text ?? ""));
					}
				}
				byte[] bytes = Encoding.UTF8.GetBytes(stringBuilder.ToString());
				_udp.Send(bytes, bytes.Length, _multicastEndpoint);
				if (_directUdp == null)
				{
					return;
				}
				foreach (IPEndPoint value in _directPeers.Values)
				{
					try
					{
						_directUdp.Send(bytes, bytes.Length, value);
					}
					catch
					{
					}
				}
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR packet send failed: " + ex.Message));
				}
			}
		}

		private static string Encode(string value)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(value ?? ""));
		}

		private static string Decode(string value)
		{
			try
			{
				return Encoding.UTF8.GetString(Convert.FromBase64String(value ?? ""));
			}
			catch
			{
				return "";
			}
		}

		private static double ParseDouble(string text)
		{
			double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result);
			return result;
		}

		private static string NormalizeCode(string code)
		{
			if (string.IsNullOrWhiteSpace(code))
			{
				return "";
			}
			string text = code.Trim().ToUpperInvariant().Replace(" ", "");
			if (!text.StartsWith("UKSR-", StringComparison.Ordinal))
			{
				return "";
			}
			if (text.Length < 8)
			{
				return "";
			}
			return text;
		}

		private static string RandomCode()
		{
			return Guid.NewGuid().ToString("N").ToUpperInvariant()
				.Substring(0, 7);
		}

		private static CategoryDefinition BuildCategory(RankedCategory category, string scope)
		{
			return category switch
			{
				RankedCategory.FullGameAny => CategoryDefinition.FullGameAny(), 
				RankedCategory.FullGamePRank => CategoryDefinition.FullGamePRank(), 
				RankedCategory.ActAny => CategoryDefinition.ActAny(scope), 
				RankedCategory.ActPRank => CategoryDefinition.ActPRank(scope), 
				RankedCategory.LayerAny => CategoryDefinition.LayerAny(scope), 
				RankedCategory.LayerPRank => CategoryDefinition.LayerPRank(scope), 
				RankedCategory.IndividualLevelAny => CategoryDefinition.IndividualAny(scope), 
				RankedCategory.IndividualLevelPRank => CategoryDefinition.IndividualPRank(scope), 
				_ => null, 
			};
		}

		private static Type FindType(string fullName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(fullName, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}

		private static object ReadStaticProperty(Type type, string name)
		{
			if (type == null)
			{
				return null;
			}
			PropertyInfo property = type.GetProperty(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null)
			{
				return null;
			}
			return property.GetValue(null, null);
		}

		private void ReceiveDirectPackets()
		{
			int num = 0;
			while (_directUdp != null && _directUdp.Available > 0 && num < 128)
			{
				num++;
				try
				{
					IPEndPoint remoteEP = new IPEndPoint(IPAddress.Loopback, 0);
					byte[] bytes = _directUdp.Receive(ref remoteEP);
					string packet = Encoding.UTF8.GetString(bytes);
					HandlePacket(packet);
				}
				catch (SocketException)
				{
					break;
				}
				catch
				{
					break;
				}
			}
		}

		private static string RegistryDirectory()
		{
			return Path.Combine(Path.GetTempPath(), "UKSRRanked", "lobbies");
		}

		private string RegistryPath(string code)
		{
			string text = (code ?? "").Replace("-", "_");
			return Path.Combine(RegistryDirectory(), text + ".txt");
		}

		private void WriteLocalLobbyRegistry()
		{
			if (!IsLobbyOwner || string.IsNullOrEmpty(LobbyCode) || _directPort <= 0)
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(RegistryDirectory());
				File.WriteAllText(RegistryPath(LobbyCode), _directPort.ToString(CultureInfo.InvariantCulture) + "|" + _clientId);
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR local lobby registry write failed: " + ex.Message));
				}
			}
		}

		private void TryAttachLocalRegistry(string code)
		{
			try
			{
				string path = RegistryPath(code);
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllText(path).Split('|');
				if (array.Length >= 1 && int.TryParse(array[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0)
				{
					string key = ((array.Length > 1) ? array[1] : "LOCALHOST");
					_directPeers[key] = new IPEndPoint(IPAddress.Loopback, result);
					if (_log != null)
					{
						_log.LogInfo((object)("UKSR local lobby code resolved directly to 127.0.0.1:" + result));
					}
				}
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR local lobby registry read failed: " + ex.Message));
				}
			}
		}

		private void RemoveLocalLobbyRegistry()
		{
			if (string.IsNullOrEmpty(LobbyCode))
			{
				return;
			}
			try
			{
				string path = RegistryPath(LobbyCode);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			}
			catch
			{
			}
		}

		private static string EncodePrivateCode(ulong lobbyId)
		{
			if (lobbyId == 0L)
			{
				return "";
			}
			char[] array = new char[32];
			int num = array.Length;
			for (ulong num2 = lobbyId; num2 != 0; num2 /= 36)
			{
				ulong num3 = num2 % 36;
				array[--num] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[(int)num3];
			}
			return "UKSR-" + new string(array, num, array.Length - num);
		}

		private static bool TryDecodePrivateCode(string code, out ulong lobbyId)
		{
			lobbyId = 0uL;
			if (string.IsNullOrWhiteSpace(code))
			{
				return false;
			}
			string text = code.Trim().ToUpperInvariant();
			if (!text.StartsWith("UKSR-", StringComparison.Ordinal))
			{
				return false;
			}
			text = text.Substring(5).Replace("-", "");
			if (text.Length == 0)
			{
				return false;
			}
			try
			{
				ulong num = 0uL;
				string text2 = text;
				foreach (char value in text2)
				{
					int num2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".IndexOf(value);
					if (num2 < 0)
					{
						return false;
					}
					num = checked(num * 36 + (ulong)num2);
				}
				lobbyId = num;
				return lobbyId != 0;
			}
			catch
			{
				return false;
			}
		}

		private static object ConvertSteamIdFor(Type targetType, ulong value)
		{
			if (targetType == null || targetType == typeof(ulong))
			{
				return value;
			}
			try
			{
				ConstructorInfo constructor = targetType.GetConstructor(new Type[1] { typeof(ulong) });
				if (constructor != null)
				{
					return constructor.Invoke(new object[1] { value });
				}
			}
			catch
			{
			}
			try
			{
				MethodInfo[] methods = targetType.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if ((methodInfo.Name == "op_Implicit" || methodInfo.Name == "op_Explicit") && methodInfo.ReturnType == targetType)
					{
						ParameterInfo[] parameters = methodInfo.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ulong))
						{
							return methodInfo.Invoke(null, new object[1] { value });
						}
					}
				}
			}
			catch
			{
			}
			return value;
		}

		private static object InvokeSteamSingleArg(MethodInfo method, ulong value)
		{
			if (method == null)
			{
				return null;
			}
			ParameterInfo[] parameters = method.GetParameters();
			if (parameters.Length != 1)
			{
				return null;
			}
			object obj = ConvertSteamIdFor(parameters[0].ParameterType, value);
			return method.Invoke(null, new object[1] { obj });
		}

		private void BeginSteamLobbyCreate(bool privateLobby)
		{
			if (!SteamAvailable || _steamMatchmakingType == null || _pendingSteamTask != null)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = null;
				MethodInfo[] methods = _steamMatchmakingType.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo2 in methods)
				{
					if (methodInfo2.Name == "CreateLobbyAsync" && methodInfo2.GetParameters().Length == 1)
					{
						methodInfo = methodInfo2;
						break;
					}
				}
				if (methodInfo == null)
				{
					Status = "STEAM CREATE API NOT FOUND";
					return;
				}
				ParameterInfo parameterInfo = methodInfo.GetParameters()[0];
				object obj = Convert.ChangeType(privateLobby ? 8 : 2, parameterInfo.ParameterType, CultureInfo.InvariantCulture);
				_pendingSteamTask = methodInfo.Invoke(null, new object[1] { obj });
				_pendingSteamMode = (privateLobby ? "private-create" : "public-create");
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam lobby create failed; local/LAN transport remains active: " + ex.Message));
				}
			}
		}

		private void BeginSteamLobbyJoin(ulong lobbyId)
		{
			if (!SteamAvailable || _steamMatchmakingType == null || lobbyId == 0L)
			{
				return;
			}
			ulong result = 0uL;
			ulong.TryParse(SteamLobbyIdText(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
			if (result == lobbyId || (_pendingSteamTask != null && _pendingSteamLobbyId == lobbyId) || _pendingSteamTask != null)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = null;
				MethodInfo[] methods = _steamMatchmakingType.GetMethods(BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo2 in methods)
				{
					if (methodInfo2.Name == "JoinLobbyAsync" && methodInfo2.GetParameters().Length == 1)
					{
						methodInfo = methodInfo2;
						break;
					}
				}
				if (methodInfo == null)
				{
					Status = "STEAM JOIN API NOT FOUND";
					return;
				}
				_pendingSteamTask = InvokeSteamSingleArg(methodInfo, lobbyId);
				_pendingSteamMode = "join";
				_pendingSteamLobbyId = lobbyId;
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam lobby join failed: " + ex.Message));
				}
			}
		}

		private void PollPendingSteamLobby()
		{
			if (_pendingSteamTask == null)
			{
				return;
			}
			try
			{
				Type type = _pendingSteamTask.GetType();
				PropertyInfo property = type.GetProperty("IsCompleted");
				if (property == null || !(bool)property.GetValue(_pendingSteamTask, null))
				{
					return;
				}
				PropertyInfo property2 = type.GetProperty("Result");
				object obj = ((property2 == null) ? null : property2.GetValue(_pendingSteamTask, null));
				_pendingSteamTask = null;
				_pendingSteamLobbyId = 0uL;
				if (obj == null)
				{
					Status = "STEAM LOBBY FAILED";
					return;
				}
				_steamLobby = obj;
				object obj2 = ReadInstanceProperty(obj, "Id");
				ulong result = 0uL;
				if (obj2 != null)
				{
					ulong.TryParse(obj2.ToString(), out result);
				}
				if (result != 0)
				{
					LobbyId = result.ToString(CultureInfo.InvariantCulture);
					LobbyCode = EncodePrivateCode(result);
				}
				bool flag = _pendingSteamMode == "private-create";
				bool flag2 = _pendingSteamMode == "public-create";
				bool flag3 = _pendingSteamMode == "join";
				if (flag)
				{
					_isPrivate = true;
					_ownerId = _clientId;
				}
				else if (flag2)
				{
					_isPrivate = false;
					_ownerId = _clientId;
				}
				else if (flag3)
				{
					_isPrivate = GetSteamLobbyData("uksr_private") == "1";
					_publicHubMode = false;
					string steamLobbyData = GetSteamLobbyData("uksr_owner_client");
					_ownerId = (string.IsNullOrEmpty(steamLobbyData) ? "STEAM-HOST" : steamLobbyData);
					if (!_isPrivate && GetSteamLobbyData("uksr_queue") == "1")
					{
						IsSearching = true;
						IsReady = true;
					}
				}
				_inLobby = true;
				EnsureSelfPeer();
				if (_matches != null && _matches.State != MatchState.Lobby)
				{
					_matches.EnterLobby();
				}
				SetSteamMemberData("uksr_client_id", _clientId);
				SetSteamMemberData("uksr_name", LocalDisplayName());
				SetSteamMemberData("uksr_rating", RankedSettings.Rating.ToString(CultureInfo.InvariantCulture));
				SetSteamMemberData("uksr_ready", IsReady ? "1" : "0");
				if (_publicHubMode)
				{
					PublishPublicQueueMemberData();
				}
				if (flag || flag2)
				{
					SetSteamLobbyData("uksr_protocol", "UKSRLAN1");
					SetSteamLobbyData("uksr_private", flag ? "1" : "0");
					SetSteamLobbyData("uksr_owner_client", _clientId);
					SetSteamLobbyData("uksr_code", LobbyCode);
				}
				if (flag)
				{
					TryInvokeSteamLobby("SetPublic");
					TryInvokeSteamLobby("SetJoinable", true);
				}
				else if (flag2)
				{
					TryInvokeSteamLobby("SetPublic");
					TryInvokeSteamLobby("SetJoinable", true);
				}
				if (_pendingSteamMode == "public-create")
				{
					_steamPublicCreated = true;
					_isPrivate = false;
					_ownerId = _clientId;
					_publicHubMode = false;
					IsSearching = true;
					IsReady = true;
					SetSteamLobbyData("uksr_protocol", "UKSRLAN1");
					SetSteamLobbyData("uksr_private", "0");
					SetSteamLobbyData("uksr_queue", "1");
					SetSteamLobbyData("uksr_category", ((int)CurrentCategory()).ToString(CultureInfo.InvariantCulture));
					SetSteamLobbyData("uksr_scope", SearchLevel ?? "");
					SetSteamLobbyData("uksr_difficulty", SearchDifficulty ?? "");
					SetSteamLobbyData("uksr_rating", RankedSettings.Rating.ToString(CultureInfo.InvariantCulture));
					SetSteamLobbyData("uksr_owner_client", _clientId);
					SetSteamMemberData("uksr_ready", "1");
					EnsureSelfPeer().Ready = true;
				}
				Status = "HYBRID LOBBY READY";
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR Steam internet path attached: " + SteamLobbyIdText()));
				}
			}
			catch (Exception ex)
			{
				_pendingSteamTask = null;
				_pendingSteamLobbyId = 0uL;
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam lobby completion failed; local/LAN transport remains active: " + ex.Message));
				}
			}
		}

		private object InvokeSteamLobbyQueryBuilder(object query, string methodName, params object[] args)
		{
			if (query == null)
			{
				return null;
			}
			MethodInfo[] methods = query.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.Name != methodName) && methodInfo.GetParameters().Length == args.Length)
				{
					try
					{
						return methodInfo.Invoke(query, args) ?? query;
					}
					catch
					{
					}
				}
			}
			return query;
		}

		private void BeginSteamPublicLobbyQuery()
		{
			if (!SteamProfileReady || _steamMatchmakingType == null || _pendingSteamPublicQuery != null)
			{
				return;
			}
			try
			{
				PropertyInfo property = _steamMatchmakingType.GetProperty("LobbyList", BindingFlags.Static | BindingFlags.Public);
				if (property == null)
				{
					Status = "STEAM LOBBY LIST API NOT FOUND";
					return;
				}
				object value = property.GetValue(null, null);
				if (value != null)
				{
					value = InvokeSteamLobbyQueryBuilder(value, "DistanceFilterWorldwide");
					MethodInfo method = value.GetType().GetMethod("RequestAsync", BindingFlags.Instance | BindingFlags.Public);
					if (method == null)
					{
						Status = "STEAM LOBBY QUERY API NOT FOUND";
					}
					else
					{
						_pendingSteamPublicQuery = method.Invoke(value, null);
					}
				}
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam public query failed: " + ex.GetBaseException().Message));
				}
			}
		}

		private void PollPendingSteamPublicQuery()
		{
			if (_pendingSteamPublicQuery == null || !IsSearching)
			{
				return;
			}
			try
			{
				Type type = _pendingSteamPublicQuery.GetType();
				PropertyInfo property = type.GetProperty("IsCompleted");
				if (property == null || !(bool)property.GetValue(_pendingSteamPublicQuery, null))
				{
					return;
				}
				PropertyInfo property2 = type.GetProperty("Result");
				object? obj = ((property2 == null) ? null : property2.GetValue(_pendingSteamPublicQuery, null));
				_pendingSteamPublicQuery = null;
				IEnumerable enumerable = obj as IEnumerable;
				ulong result = 0uL;
				ulong.TryParse(SteamLobbyIdText(), NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
				ulong num = 0uL;
				int num2 = int.MaxValue;
				int num3 = 0;
				if (enumerable != null)
				{
					foreach (object item in enumerable)
					{
						if (item == null || GetLobbyData(item, "uksr_protocol") != "UKSRLAN1" || GetLobbyData(item, "uksr_private") == "1" || GetLobbyData(item, "uksr_queue") != "1")
						{
							continue;
						}
						int num4 = ParseInt(GetLobbyData(item, "uksr_category"), -1);
						string a = GetLobbyData(item, "uksr_scope") ?? "";
						string a2 = GetLobbyData(item, "uksr_difficulty") ?? "";
						if (num4 != (int)CurrentCategory() || !string.Equals(a, SearchLevel ?? "", StringComparison.OrdinalIgnoreCase) || !string.Equals(a2, SearchDifficulty ?? "", StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						object obj2 = ReadInstanceProperty(item, "Id");
						if (obj2 != null && ulong.TryParse(obj2.ToString(), out var result2) && result2 != 0L)
						{
							num3++;
							int num5 = ParseInt(GetLobbyData(item, "uksr_rating"), 1000);
							int num6 = Math.Abs(RankedSettings.Rating - num5);
							float num7 = Mathf.Max(0f, Time.unscaledTime - _searchStartedAt);
							int num8 = 200 + Mathf.FloorToInt(num7 * 100f);
							if ((!(num7 < 6f) || num6 <= num8) && (num == 0L || result2 < num || (result2 == num && num6 < num2)))
							{
								num = result2;
								num2 = num6;
							}
						}
					}
				}
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR public query // exact queues " + num3 + " // own " + result + " // target " + num));
				}
				if (num != 0L)
				{
					if (result != 0L && result <= num)
					{
						Status = "PUBLIC QUEUE // WAITING FOR OPPONENT";
						return;
					}
					if (_steamLobby != null)
					{
						TryInvokeSteamLobby("Leave");
						_steamLobby = null;
						_inLobby = false;
						LobbyId = "";
						LobbyCode = "";
						_steamPublicCreated = false;
					}
					BeginSteamLobbyJoin(num);
					Status = "PUBLIC MATCH FOUND // CONNECTING";
				}
				else
				{
					float num9 = Mathf.Max(0f, Time.unscaledTime - _searchStartedAt);
					if (_steamLobby == null && !_steamPublicCreated && _pendingSteamTask == null && num9 >= 2.5f)
					{
						BeginSteamLobbyCreate(privateLobby: false);
						Status = "PUBLIC QUEUE OPEN";
					}
					else if (_steamLobby == null)
					{
						Status = "SEARCHING FOR PUBLIC MATCH";
					}
				}
			}
			catch (Exception ex)
			{
				_pendingSteamPublicQuery = null;
				if (_log != null)
				{
					_log.LogWarning((object)("UKSR Steam public query completion failed: " + ex.GetBaseException().Message));
				}
			}
		}

		private void PublishPublicQueueMemberData()
		{
			if (_steamLobby != null && _publicHubMode)
			{
				SetSteamMemberData("uksr_queue", "1");
				SetSteamMemberData("uksr_category", ((int)CurrentCategory()).ToString(CultureInfo.InvariantCulture));
				SetSteamMemberData("uksr_scope", SearchLevel ?? "");
				SetSteamMemberData("uksr_difficulty", SearchDifficulty ?? "");
				SetSteamMemberData("uksr_rating", RankedSettings.Rating.ToString(CultureInfo.InvariantCulture));
				SetSteamMemberData("uksr_match_id", _publicMatchId ?? "");
				SetSteamMemberData("uksr_client_id", _clientId);
				SetSteamMemberData("uksr_name", LocalDisplayName());
			}
		}

		private void PollPublicHubMatchmaking()
		{
			if (_steamLobby == null || !_publicHubMode || !IsSearching)
			{
				return;
			}
			PublishPublicQueueMemberData();
			if (!(ReadInstanceProperty(_steamLobby, "Members") is IEnumerable enumerable))
			{
				return;
			}
			List<HubCandidate> list = new List<HubCandidate>();
			HubCandidate hubCandidate = null;
			foreach (object item in enumerable)
			{
				object obj = ReadInstanceProperty(item, "Id") ?? ReadInstanceProperty(item, "SteamId");
				string text = ((obj == null) ? "" : obj.ToString());
				if (!string.IsNullOrEmpty(text) && (string.IsNullOrEmpty(SteamId) || !(text == SteamId)) && !(GetSteamMemberData(item, "uksr_queue") != "1"))
				{
					HubCandidate hubCandidate2 = new HubCandidate();
					hubCandidate2.Member = item;
					hubCandidate2.SteamId = text;
					hubCandidate2.ClientId = GetSteamMemberData(item, "uksr_client_id");
					if (string.IsNullOrEmpty(hubCandidate2.ClientId))
					{
						hubCandidate2.ClientId = "STEAM-" + text;
					}
					hubCandidate2.Name = GetSteamMemberData(item, "uksr_name");
					hubCandidate2.Category = ParseInt(GetSteamMemberData(item, "uksr_category"), -1);
					hubCandidate2.Scope = GetSteamMemberData(item, "uksr_scope") ?? "";
					hubCandidate2.Difficulty = GetSteamMemberData(item, "uksr_difficulty") ?? "";
					hubCandidate2.Rating = ParseInt(GetSteamMemberData(item, "uksr_rating"), 1000);
					hubCandidate2.MatchId = GetSteamMemberData(item, "uksr_match_id") ?? "";
					if (hubCandidate2.Category == (int)CurrentCategory() && string.Equals(hubCandidate2.Scope, SearchLevel ?? "", StringComparison.OrdinalIgnoreCase) && string.Equals(hubCandidate2.Difficulty, SearchDifficulty ?? "", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(hubCandidate2);
					}
					else if (hubCandidate == null || Math.Abs(RankedSettings.Rating - hubCandidate2.Rating) < Math.Abs(RankedSettings.Rating - hubCandidate.Rating))
					{
						hubCandidate = hubCandidate2;
					}
				}
			}
			if (list.Count == 0)
			{
				if (hubCandidate != null && !AlternativeOfferPending)
				{
					_alternativeCategory = hubCandidate.Category;
					_alternativeScope = hubCandidate.Scope;
					_alternativeDifficulty = hubCandidate.Difficulty;
					AlternativeQueueLabel = FormatQueueLabel(hubCandidate.Category, hubCandidate.Scope);
					AlternativeQueueAvailable = true;
					AlternativeOfferPending = true;
					_publicPartnerClientId = hubCandidate.ClientId;
					Status = "OTHER QUEUE FOUND // " + AlternativeQueueLabel;
				}
				return;
			}
			list.Sort(delegate(HubCandidate a, HubCandidate b)
			{
				int num = a.Rating.CompareTo(b.Rating);
				return (num != 0) ? num : string.CompareOrdinal(a.SteamId, b.SteamId);
			});
			HubCandidate hubCandidate3 = list[0];
			string text2 = SteamId ?? "";
			if (string.IsNullOrEmpty(text2))
			{
				text2 = _clientId;
			}
			string text3 = ((string.CompareOrdinal(text2, hubCandidate3.SteamId) <= 0) ? text2 : hubCandidate3.SteamId);
			string text4 = ((text3 == text2) ? hubCandidate3.SteamId : text2);
			string publicMatchId = "UKSRM-" + text3 + "-" + text4;
			if (string.IsNullOrEmpty(_publicMatchId))
			{
				_publicMatchId = publicMatchId;
				_publicPartnerClientId = hubCandidate3.ClientId;
				SetSteamMemberData("uksr_match_id", _publicMatchId);
				Status = "MATCH FOUND // SYNCING";
			}
			if (string.Equals(hubCandidate3.MatchId, _publicMatchId, StringComparison.Ordinal))
			{
				IsSearching = false;
				AlternativeQueueAvailable = false;
				AlternativeOfferPending = false;
				SetSteamMemberData("uksr_queue", "0");
				Status = "MATCH FOUND";
				_publicStartAfter = Time.unscaledTime + 0.75f;
				_peers.Clear();
				EnsureSelfPeer();
				PollSteamPeers();
				if (_log != null)
				{
					_log.LogInfo((object)("UKSR public hub paired " + _clientId + " with " + _publicPartnerClientId + " as " + _publicMatchId));
				}
			}
		}

		private static string FormatQueueLabel(int category, string scope)
		{
			string text = (string.IsNullOrEmpty(scope) ? "FULL GAME" : scope);
			return (RankedCategory)category switch
			{
				RankedCategory.FullGameAny => "FULL GAME ANY%", 
				RankedCategory.FullGamePRank => "FULL GAME P-RANK", 
				RankedCategory.ActAny => text + " ACT ANY%", 
				RankedCategory.ActPRank => text + " ACT P-RANK", 
				RankedCategory.LayerAny => text + " LAYER ANY%", 
				RankedCategory.LayerPRank => text + " LAYER P-RANK", 
				RankedCategory.IndividualLevelAny => text + " LEVEL ANY%", 
				RankedCategory.IndividualLevelPRank => text + " LEVEL P-RANK", 
				_ => text + " RANKED", 
			};
		}

		private static string GetLobbyData(object lobby, string key)
		{
			if (lobby == null)
			{
				return "";
			}
			MethodInfo[] methods = lobby.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.Name != "GetData") && methodInfo.GetParameters().Length == 1)
				{
					try
					{
						object obj = methodInfo.Invoke(lobby, new object[1] { key });
						return (obj == null) ? "" : obj.ToString();
					}
					catch
					{
					}
				}
			}
			return "";
		}

		private void PublishSteamLobbyConfig()
		{
			if (_steamLobby != null && IsLobbyOwner && _matches != null)
			{
				RankedCategory rankedCategory = CurrentCategory();
				string value = ((_matches.Category == null) ? "" : (_matches.Category.Scope ?? ""));
				string value2 = _matches.SelectedLevel ?? "";
				int num = (int)rankedCategory;
				SetSteamLobbyData("uksr_lobby_category", num.ToString(CultureInfo.InvariantCulture));
				SetSteamLobbyData("uksr_lobby_scope", value);
				SetSteamLobbyData("uksr_lobby_level", value2);
				SetSteamLobbyData("uksr_lobby_difficulty", _matches.Difficulty.ToString(CultureInfo.InvariantCulture));
				SetSteamLobbyData("uksr_lobby_difficulty_name", _matches.DifficultyName ?? "STANDARD");
			}
		}

		private void MarkLobbyUiDirty()
		{
			LobbyUiRevision++;
		}

		private void PruneStaleSteamPeers()
		{
			if (_steamLobby == null || Time.unscaledTime < _nextPeerPrune)
			{
				return;
			}
			_nextPeerPrune = Time.unscaledTime + 0.75f;
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Peer> peer in _peers)
			{
				if (!(peer.Key == _clientId) && Time.unscaledTime - peer.Value.LastSeen > 2.5f)
				{
					list.Add(peer.Key);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			foreach (string item in list)
			{
				_peers.Remove(item);
			}
			MarkLobbyUiDirty();
			RefreshFacade();
		}

		private void PollSteamLobbyState()
		{
			if (_steamLobby == null || _matches == null)
			{
				return;
			}
			if (_isPrivate && IsLobbyOwner)
			{
				PublishSteamLobbyConfig();
			}
			if (_isPrivate && !IsLobbyOwner)
			{
				string steamLobbyData = GetSteamLobbyData("uksr_lobby_category");
				string steamLobbyData2 = GetSteamLobbyData("uksr_lobby_scope");
				string steamLobbyData3 = GetSteamLobbyData("uksr_lobby_level");
				string steamLobbyData4 = GetSteamLobbyData("uksr_lobby_difficulty");
				string steamLobbyData5 = GetSteamLobbyData("uksr_lobby_difficulty_name");
				string text = steamLobbyData + "|" + steamLobbyData2 + "|" + steamLobbyData3 + "|" + steamLobbyData4 + "|" + steamLobbyData5;
				if (!string.IsNullOrEmpty(steamLobbyData) && text != _lastAppliedSteamLobbyConfig)
				{
					CategoryDefinition categoryDefinition = BuildCategory((RankedCategory)ParseInt(steamLobbyData, 0), steamLobbyData2 ?? "");
					if (categoryDefinition != null)
					{
						_matches.SetCategory(categoryDefinition);
					}
					if (!string.IsNullOrEmpty(steamLobbyData3))
					{
						_matches.SetSelectedLevel(steamLobbyData3);
					}
					else if (categoryDefinition != null && categoryDefinition.IsLevelSpecific)
					{
						_matches.SetSelectedLevel(steamLobbyData2 ?? "");
					}
					int value = ParseInt(steamLobbyData4, _matches.Difficulty);
					_matches.SetDifficulty(value, string.IsNullOrEmpty(steamLobbyData5) ? _matches.DifficultyName : steamLobbyData5);
					_lastAppliedSteamLobbyConfig = text;
					RefreshFacade();
				}
			}
			if (_isPrivate || !IsSearching)
			{
				return;
			}
			PollSteamPeers();
			if (_peers.Count < 2)
			{
				return;
			}
			IsSearching = false;
			IsReady = true;
			EnsureSelfPeer().Ready = true;
			SetSteamMemberData("uksr_ready", "1");
			foreach (Peer value2 in _peers.Values)
			{
				value2.Ready = true;
			}
			AllPlayersReady = true;
			Status = "MATCH FOUND";
			if (IsLobbyOwner)
			{
				SetSteamLobbyData("uksr_queue", "0");
				TryInvokeSteamLobby("SetJoinable", false);
				if (_publicStartAfter <= 0f)
				{
					_publicStartAfter = Time.unscaledTime + 0.75f;
				}
			}
		}

		private void PollSteamLobbyJoin()
		{
			if (_steamLobby == null || _matches == null)
			{
				return;
			}
			string steamLobbyData = GetSteamLobbyData("uksr_match_start");
			if (string.IsNullOrEmpty(steamLobbyData) || steamLobbyData == _lastSteamMatchStart)
			{
				return;
			}
			_lastSteamMatchStart = steamLobbyData;
			string steamLobbyData2 = GetSteamLobbyData("uksr_match_id");
			if (!(steamLobbyData2 == _currentMatchId))
			{
				int.TryParse(GetSteamLobbyData("uksr_match_category"), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
				int.TryParse(GetSteamLobbyData("uksr_match_difficulty"), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2);
				_currentMatchId = steamLobbyData2;
				StartLocalMatchFromConfig((RankedCategory)result, GetSteamLobbyData("uksr_match_scope"), result2, GetSteamLobbyData("uksr_match_difficulty_name"));
				if ((Object)(object)_notifications != (Object)null)
				{
					_notifications.SystemMessage("MATCH STARTED THROUGH STEAM");
				}
			}
		}

		private void PublishSteamLiveState()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (_steamLobby == null || _matches == null)
			{
				return;
			}
			Camera main = Camera.main;
			bool flag = (Object)(object)main != (Object)null && (Object)(object)((Component)main).transform != (Object)null;
			Vector3 val = (flag ? ((Component)main).transform.position : Vector3.zero);
			Vector3 val2 = (flag ? ((Component)main).transform.eulerAngles : Vector3.zero);
			float num = 0f;
			if (flag)
			{
				float unscaledTime = Time.unscaledTime;
				if (_hasLastSpectatorPosition && unscaledTime > _lastSpectatorSampleTime)
				{
					num = Vector3.Distance(_lastSpectatorPosition, val) / Mathf.Max(0.001f, unscaledTime - _lastSpectatorSampleTime);
				}
				_lastSpectatorPosition = val;
				_lastSpectatorSampleTime = unscaledTime;
				_hasLastSpectatorPosition = true;
			}
			string value = _matches.RtaSeconds.ToString("R", CultureInfo.InvariantCulture) + "|" + _matches.IgtSeconds.ToString("R", CultureInfo.InvariantCulture) + "|" + CurrentExpectedLevel() + "|" + _matches.Splits.ToString(CultureInfo.InvariantCulture) + "|" + (flag ? "1" : "0") + "|" + val.x.ToString("R", CultureInfo.InvariantCulture) + "|" + val.y.ToString("R", CultureInfo.InvariantCulture) + "|" + val.z.ToString("R", CultureInfo.InvariantCulture) + "|" + val2.x.ToString("R", CultureInfo.InvariantCulture) + "|" + val2.y.ToString("R", CultureInfo.InvariantCulture) + "|" + val2.z.ToString("R", CultureInfo.InvariantCulture) + "|" + num.ToString("R", CultureInfo.InvariantCulture);
			SetSteamMemberData("uksr_live_v2", value);
		}

		private void PollSteamPeers()
		{
			if (_steamLobby == null || !(ReadInstanceProperty(_steamLobby, "Members") is IEnumerable enumerable))
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (object item in enumerable)
			{
				object obj = ReadInstanceProperty(item, "Id") ?? ReadInstanceProperty(item, "SteamId");
				string text = ((obj == null) ? "" : obj.ToString());
				if (!string.IsNullOrEmpty(text))
				{
					hashSet.Add(text);
				}
				if (!string.IsNullOrEmpty(SteamId) && text == SteamId)
				{
					continue;
				}
				if (_publicHubMode && !string.IsNullOrEmpty(_publicMatchId))
				{
					if (!string.Equals(GetSteamMemberData(item, "uksr_match_id"), _publicMatchId, StringComparison.Ordinal))
					{
						continue;
					}
				}
				else if (_publicHubMode)
				{
					continue;
				}
				string text2 = GetSteamMemberData(item, "uksr_client_id");
				if (string.IsNullOrEmpty(text2))
				{
					text2 = "STEAM-" + text;
				}
				string steamMemberData = GetSteamMemberData(item, "uksr_name");
				Peer orCreatePeer = GetOrCreatePeer(text2, string.IsNullOrEmpty(steamMemberData) ? "STEAM PLAYER" : steamMemberData);
				orCreatePeer.SteamId = text;
				orCreatePeer.Rating = ParseInt(GetSteamMemberData(item, "uksr_rating"), 1000);
				orCreatePeer.Ready = GetSteamMemberData(item, "uksr_ready") == "1";
				string steamMemberData2 = GetSteamMemberData(item, "uksr_live_v2");
				string[] array = (string.IsNullOrEmpty(steamMemberData2) ? null : steamMemberData2.Split('|'));
				if (array != null && array.Length >= 12)
				{
					orCreatePeer.Rta = ParseDouble(array[0]);
					orCreatePeer.Igt = ParseDouble(array[1]);
					orCreatePeer.Level = array[2];
					int.TryParse(array[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
					orCreatePeer.Split = result;
					orCreatePeer.HasSpectatorPose = array[4] == "1";
					orCreatePeer.X = (float)ParseDouble(array[5]);
					orCreatePeer.Y = (float)ParseDouble(array[6]);
					orCreatePeer.Z = (float)ParseDouble(array[7]);
					orCreatePeer.Pitch = (float)ParseDouble(array[8]);
					orCreatePeer.Yaw = (float)ParseDouble(array[9]);
					orCreatePeer.Roll = (float)ParseDouble(array[10]);
					orCreatePeer.Speed = (float)ParseDouble(array[11]);
				}
				else
				{
					orCreatePeer.Rta = ParseDouble(GetSteamMemberData(item, "uksr_live_rta"));
					orCreatePeer.Igt = ParseDouble(GetSteamMemberData(item, "uksr_live_igt"));
					orCreatePeer.Level = GetSteamMemberData(item, "uksr_live_level");
					orCreatePeer.HasSpectatorPose = GetSteamMemberData(item, "uksr_spec_has") == "1";
					orCreatePeer.X = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_x"));
					orCreatePeer.Y = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_y"));
					orCreatePeer.Z = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_z"));
					orCreatePeer.Pitch = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_pitch"));
					orCreatePeer.Yaw = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_yaw"));
					orCreatePeer.Roll = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_roll"));
					orCreatePeer.Speed = (float)ParseDouble(GetSteamMemberData(item, "uksr_spec_speed"));
				}
				orCreatePeer.ResultState = GetSteamMemberData(item, "uksr_result_state");
				orCreatePeer.ResultRta = ParseDouble(GetSteamMemberData(item, "uksr_result_rta"));
				orCreatePeer.ResultIgt = ParseDouble(GetSteamMemberData(item, "uksr_result_igt"));
				orCreatePeer.LastSeen = Time.unscaledTime;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Peer> peer in _peers)
			{
				if (!(peer.Key == _clientId))
				{
					string text3 = peer.Value.SteamId ?? "";
					if (!string.IsNullOrEmpty(text3) && !hashSet.Contains(text3) && Time.unscaledTime - peer.Value.LastSeen > 1f)
					{
						list.Add(peer.Key);
					}
				}
			}
			foreach (string item2 in list)
			{
				_peers.Remove(item2);
			}
			PruneStaleSteamPeers();
			List<string> list2 = new List<string>();
			foreach (Peer value in _peers.Values)
			{
				list2.Add(value.Id + ":" + value.Name + ":" + (value.Ready ? "1" : "0"));
			}
			list2.Sort(StringComparer.Ordinal);
			string text4 = string.Join(";", list2.ToArray());
			if (text4 != _lastLobbyUiSnapshot)
			{
				_lastLobbyUiSnapshot = text4;
				MarkLobbyUiDirty();
			}
			TryStartRematchIfReady();
			RefreshFacade();
		}

		private string SteamLobbyIdText()
		{
			if (_steamLobby == null)
			{
				return "";
			}
			object obj = ReadInstanceProperty(_steamLobby, "Id");
			if (obj != null)
			{
				return obj.ToString();
			}
			return "";
		}

		private void SetSteamLobbyData(string key, string value)
		{
			if (_steamLobby != null)
			{
				TryInvokeSteamLobby("SetData", key, value ?? "");
			}
		}

		private string GetSteamLobbyData(string key)
		{
			if (_steamLobby == null)
			{
				return "";
			}
			object obj = InvokeSteamLobby("GetData", key);
			if (obj != null)
			{
				return obj.ToString();
			}
			return "";
		}

		private void SetSteamMemberData(string key, string value)
		{
			if (_steamLobby != null)
			{
				TryInvokeSteamLobby("SetMemberData", key, value ?? "");
			}
		}

		private string GetSteamMemberData(object member, string key)
		{
			if (_steamLobby == null || member == null)
			{
				return "";
			}
			object obj = InvokeSteamLobby("GetMemberData", member, key);
			if (obj != null)
			{
				return obj.ToString();
			}
			return "";
		}

		private object InvokeSteamLobby(string methodName, params object[] args)
		{
			if (_steamLobby == null)
			{
				return null;
			}
			MethodInfo[] methods = _steamLobby.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.Name != methodName) && methodInfo.GetParameters().Length == args.Length)
				{
					try
					{
						return methodInfo.Invoke(_steamLobby, args);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		private void TryInvokeSteamLobby(string methodName, params object[] args)
		{
			InvokeSteamLobby(methodName, args);
		}

		private static object ReadInstanceProperty(object target, string name)
		{
			if (target == null)
			{
				return null;
			}
			PropertyInfo property = target.GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null)
			{
				return null;
			}
			try
			{
				return property.GetValue(target, null);
			}
			catch
			{
				return null;
			}
		}

		private static int ParseInt(string text, int fallback)
		{
			if (!int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}

		private void OnDestroy()
		{
			RemoveLocalLobbyRegistry();
			if (_udp != null)
			{
				try
				{
					_udp.Close();
				}
				catch
				{
				}
				_udp = null;
			}
			if (_directUdp != null)
			{
				try
				{
					_directUdp.Close();
				}
				catch
				{
				}
				_directUdp = null;
			}
		}
	}
	public enum RankedPacketType
	{
		Hello,
		Ready,
		Checkpoint,
		BossKill,
		LevelComplete,
		Finish,
		Forfeit,
		Ping
	}
	public sealed class RankedPacket
	{
		public RankedPacketType Type;

		public string Player;

		public string Scope;

		public double Rta;

		public double Igt;

		public long Sequence;

		public string Encode()
		{
			string[] obj = new string[12]
			{
				"UKSR1|", null, null, null, null, null, null, null, null, null,
				null, null
			};
			int type = (int)Type;
			obj[1] = type.ToString(CultureInfo.InvariantCulture);
			obj[2] = "|";
			obj[3] = Escape(Player);
			obj[4] = "|";
			obj[5] = Escape(Scope);
			obj[6] = "|";
			obj[7] = Rta.ToString("R", CultureInfo.InvariantCulture);
			obj[8] = "|";
			obj[9] = Igt.ToString("R", CultureInfo.InvariantCulture);
			obj[10] = "|";
			obj[11] = Sequence.ToString(CultureInfo.InvariantCulture);
			return string.Concat(obj);
		}

		public static bool TryDecode(string raw, out RankedPacket packet)
		{
			packet = null;
			if (string.IsNullOrEmpty(raw))
			{
				return false;
			}
			string[] array = raw.Split('|');
			if (array.Length != 7 || array[0] != "UKSR1")
			{
				return false;
			}
			if (!int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (!double.TryParse(array[4], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			if (!double.TryParse(array[5], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			if (!long.TryParse(array[6], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4))
			{
				return false;
			}
			if (!Enum.IsDefined(typeof(RankedPacketType), result))
			{
				return false;
			}
			packet = new RankedPacket
			{
				Type = (RankedPacketType)result,
				Player = Unescape(array[2]),
				Scope = Unescape(array[3]),
				Rta = result2,
				Igt = result3,
				Sequence = result4
			};
			return true;
		}

		private static string Escape(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			return value.Replace("%", "%25").Replace("|", "%7C").Replace("\r", "")
				.Replace("\n", " ");
		}

		private static string Unescape(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			return value.Replace("%7C", "|").Replace("%25", "%");
		}
	}
}
namespace UKSRR.Match
{
	public enum RankedCategory
	{
		FullGameAny,
		FullGamePRank,
		ActAny,
		ActPRank,
		LayerAny,
		LayerPRank,
		IndividualLevelAny,
		IndividualLevelPRank
	}
	public sealed class CategoryDefinition
	{
		public RankedCategory Category;

		public string DisplayName;

		public bool RequiresPRank;

		public bool MultiLevel;

		public string Scope;

		public readonly List<string> ExpectedLevels = new List<string>();

		public bool IsLevelSpecific
		{
			get
			{
				if (Category != RankedCategory.IndividualLevelAny)
				{
					return Category == RankedCategory.IndividualLevelPRank;
				}
				return true;
			}
		}

		public bool NeedsScopeSelection
		{
			get
			{
				if (Category != RankedCategory.ActAny && Category != RankedCategory.ActPRank && Category != RankedCategory.LayerAny && Category != RankedCategory.LayerPRank)
				{
					return IsLevelSpecific;
				}
				return true;
			}
		}

		public static CategoryDefinition FullGameAny()
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.FullGameAny, "FULL GAME ANY%", pRank: false, multi: true, "FULL GAME");
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetFullGameLevels());
			return categoryDefinition;
		}

		public static CategoryDefinition FullGamePRank()
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.FullGamePRank, "FULL GAME P-RANK", pRank: true, multi: true, "FULL GAME");
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetFullGameLevels());
			return categoryDefinition;
		}

		public static CategoryDefinition ActAny(string act)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.ActAny, act + " ANY%", pRank: false, multi: true, act);
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetLevelsForAct(act));
			return categoryDefinition;
		}

		public static CategoryDefinition ActPRank(string act)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.ActPRank, act + " P-RANK", pRank: true, multi: true, act);
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetLevelsForAct(act));
			return categoryDefinition;
		}

		public static CategoryDefinition LayerAny(string layer)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.LayerAny, layer + " ANY%", pRank: false, multi: true, layer);
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetLevelsForLayer(layer));
			return categoryDefinition;
		}

		public static CategoryDefinition LayerPRank(string layer)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.LayerPRank, layer + " P-RANK", pRank: true, multi: true, layer);
			categoryDefinition.ExpectedLevels.AddRange(LevelCatalog.GetLevelsForLayer(layer));
			return categoryDefinition;
		}

		public static CategoryDefinition IndividualAny(string level)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.IndividualLevelAny, level + " ANY%", pRank: false, multi: false, level);
			categoryDefinition.ExpectedLevels.Add(level);
			return categoryDefinition;
		}

		public static CategoryDefinition IndividualPRank(string level)
		{
			CategoryDefinition categoryDefinition = New(RankedCategory.IndividualLevelPRank, level + " P-RANK", pRank: true, multi: false, level);
			categoryDefinition.ExpectedLevels.Add(level);
			return categoryDefinition;
		}

		private static CategoryDefinition New(RankedCategory category, string name, bool pRank, bool multi, string scope)
		{
			return new CategoryDefinition
			{
				Category = category,
				DisplayName = name,
				RequiresPRank = pRank,
				MultiLevel = multi,
				Scope = scope
			};
		}
	}
	public static class LevelCatalog
	{
		public sealed class LayerInfo
		{
			public string Name;

			public string[] Levels;

			public LayerInfo(string name, params string[] levels)
			{
				Name = name;
				Levels = levels;
			}
		}

		public static readonly LayerInfo[] Layers = new LayerInfo[9]
		{
			new LayerInfo("OVERTURE", "0-1", "0-2", "0-3", "0-4", "0-5"),
			new LayerInfo("LIMBO", "1-1", "1-2", "1-3", "1-4"),
			new LayerInfo("LUST", "2-1", "2-2", "2-3", "2-4"),
			new LayerInfo("GLUTTONY", "3-1", "3-2"),
			new LayerInfo("GREED", "4-1", "4-2", "4-3", "4-4"),
			new LayerInfo("WRATH", "5-1", "5-2", "5-3", "5-4"),
			new LayerInfo("HERESY", "6-1", "6-2"),
			new LayerInfo("VIOLENCE", "7-1", "7-2", "7-3", "7-4"),
			new LayerInfo("FRAUD", "8-1", "8-2", "8-3", "8-4")
		};

		public static string[] GetLevelsForLayer(string layer)
		{
			LayerInfo layerInfo = Layers.FirstOrDefault((LayerInfo x) => x.Name == layer);
			if (layerInfo != null)
			{
				return layerInfo.Levels;
			}
			return new string[0];
		}

		public static string[] GetLevelsForAct(string act)
		{
			return act switch
			{
				"PRELUDE" => GetLevelsForLayer("OVERTURE"), 
				"ACT I" => Concat("LIMBO", "LUST", "GLUTTONY"), 
				"ACT II" => Concat("GREED", "WRATH", "HERESY"), 
				"ACT III" => Concat("VIOLENCE", "FRAUD"), 
				_ => new string[0], 
			};
		}

		public static string[] GetFullGameLevels()
		{
			List<string> list = new List<string>();
			LayerInfo[] layers = Layers;
			foreach (LayerInfo layerInfo in layers)
			{
				list.AddRange(layerInfo.Levels);
			}
			return list.ToArray();
		}

		public static string FindLayerForLevel(string level)
		{
			LayerInfo[] layers = Layers;
			foreach (LayerInfo layerInfo in layers)
			{
				if (layerInfo.Levels.Contains(level))
				{
					return layerInfo.Name;
				}
			}
			return "";
		}

		private static string[] Concat(params string[] layers)
		{
			List<string> list = new List<string>();
			foreach (string layer in layers)
			{
				list.AddRange(GetLevelsForLayer(layer));
			}
			return list.ToArray();
		}
	}
	public sealed class MatchManager
	{
		private readonly ManualLogSource _log;

		private readonly RunClock _clock = new RunClock();

		private readonly VanillaTimerProbe _vanillaTimer;

		private RankedNotificationManager _notifications;

		private double _completedIgt;

		private double _lastVanillaIgt;

		private bool _pendingAttemptReset;

		private bool _rtaStarted;

		public MatchState State { get; private set; }

		public CategoryDefinition Category { get; private set; }

		public int Difficulty { get; private set; }

		public string DifficultyName { get; private set; }

		public string SelectedLevel { get; private set; }

		public string CurrentScene { get; private set; }

		public string Status { get; private set; }

		public int Splits { get; private set; }

		public RunProgressIntent ProgressIntent { get; private set; }

		public string NextExpectedLevel { get; private set; }

		public bool GameplayTimerAvailable { get; private set; }

		public bool GameplayReady { get; private set; }

		public bool ReturnToLobbyOnMenuRequested { get; private set; }

		public bool RtaStarted => _rtaStarted;

		public double FinalRtaSeconds { get; private set; }

		public double FinalIgtSeconds { get; private set; }

		public bool IsMatchActive
		{
			get
			{
				if (State != MatchState.WaitingForFirstInput)
				{
					return State == MatchState.Running;
				}
				return true;
			}
		}

		public double RtaSeconds => _clock.RtaSeconds;

		public double IgtSeconds => _clock.IgtSeconds;

		public double CurrentLevelIgt => _lastVanillaIgt;

		public MatchManager(ManualLogSource log)
		{
			_log = log;
			_vanillaTimer = new VanillaTimerProbe(log);
			State = MatchState.Idle;
			Difficulty = 2;
			DifficultyName = "STANDARD";
			SelectedLevel = "";
			CurrentScene = "";
			Status = "";
		}

		public void InitializeNotifications(RankedNotificationManager notifications)
		{
			_notifications = notifications;
		}

		public void SetSelectedLevel(string level)
		{
			SelectedLevel = level ?? "";
			Status = (string.IsNullOrEmpty(SelectedLevel) ? "NO MAP SELECTED" : ("MAP: " + SelectedLevel));
		}

		public void SetDifficulty(int value, string name)
		{
			Difficulty = value;
			DifficultyName = name;
			Status = "DIFFICULTY: " + name;
		}

		public void SetCategory(CategoryDefinition category)
		{
			Category = category;
			Status = "CATEGORY: " + category.DisplayName;
		}

		public void EnterLobby()
		{
			State = MatchState.Lobby;
			Status = "READY";
		}

		public void StartLocalMatch()
		{
			if (Category == null)
			{
				Category = CategoryDefinition.FullGameAny();
			}
			Splits = 0;
			ProgressIntent = RunProgressIntent.None;
			NextExpectedLevel = ((Category.ExpectedLevels.Count > 0) ? Category.ExpectedLevels[0] : "");
			_clock.Reset();
			_completedIgt = 0.0;
			_lastVanillaIgt = -1.0;
			_pendingAttemptReset = false;
			_rtaStarted = false;
			FinalRtaSeconds = 0.0;
			FinalIgtSeconds = 0.0;
			GameplayTimerAvailable = false;
			GameplayReady = false;
			_vanillaTimer.ResetScene();
			State = MatchState.WaitingForFirstInput;
			Status = "LOADING LEVEL";
			_log.LogInfo((object)("Match armed: " + Category.DisplayName + " / " + DifficultyName));
		}

		public void Tick()
		{
			if (!IsMatchActive)
			{
				GameplayTimerAvailable = false;
				return;
			}
			double seconds;
			bool flag = (GameplayTimerAvailable = _vanillaTimer.TryRead(out seconds));
			if (!_rtaStarted && GameplayReady && HasMeaningfulInput())
			{
				_clock.StartRta();
				_rtaStarted = true;
				State = MatchState.Running;
				Status = ((flag && seconds > 0.0001) ? "RUNNING" : "RUNNING // IGT WAITING");
			}
			if (!flag)
			{
				return;
			}
			if (_lastVanillaIgt >= 0.0 && seconds + 0.25 < _lastVanillaIgt)
			{
				if (!_pendingAttemptReset)
				{
					_completedIgt += _lastVanillaIgt;
				}
				_pendingAttemptReset = false;
				_log.LogInfo((object)("UKSR banked exact vanilla timer: +" + _lastVanillaIgt.ToString("0.000") + " // cumulative " + _completedIgt.ToString("0.000")));
			}
			_lastVanillaIgt = seconds;
			_clock.SetIgt(_completedIgt + seconds);
			if (_rtaStarted && seconds > 0.0001)
			{
				Status = "RUNNING";
			}
		}

		public void OnSceneChanged(string previous, string next)
		{
			CurrentScene = next;
			GameplayTimerAvailable = false;
			_lastVanillaIgt = -1.0;
			_vanillaTimer.ResetScene();
			if (!IsMatchActive)
			{
				GameplayReady = false;
			}
			else
			{
				_log.LogInfo((object)("Ranked scene transition: " + previous + " -> " + next));
			}
		}

		public void NotifyGameplayReady()
		{
			if (IsMatchActive && !GameplayReady)
			{
				GameplayReady = true;
				Status = "READY // WAITING FOR INPUT";
				_log.LogInfo((object)"UKSR gameplay-ready signal received.");
			}
		}

		public void RegisterLevelResult(string level, double vanillaIgt, bool pRank)
		{
			if (!IsMatchActive)
			{
				return;
			}
			ProgressIntent = RunProgressIntent.None;
			if (Category != null && Category.RequiresPRank && !pRank)
			{
				if (_lastVanillaIgt > 0.0001)
				{
					_completedIgt += _lastVanillaIgt;
					_lastVanillaIgt = -1.0;
					_clock.SetIgt(_completedIgt);
					_pendingAttemptReset = true;
				}
				NextExpectedLevel = level;
				ProgressIntent = RunProgressIntent.RestartCurrentLevel;
				Status = "P-RANK FAILED // REPLAY " + level;
				return;
			}
			if (_lastVanillaIgt > 0.0001)
			{
				_completedIgt += _lastVanillaIgt;
				_lastVanillaIgt = -1.0;
				_clock.SetIgt(_completedIgt);
				_pendingAttemptReset = true;
			}
			Splits++;
			if ((Object)(object)_notifications != (Object)null)
			{
				_notifications.LevelCompleted("YOU", level, RtaSeconds, IgtSeconds);
			}
			int num = ((Category == null) ? 1 : Category.ExpectedLevels.Count);
			if (num <= 1 || Splits >= num)
			{
				NextExpectedLevel = "";
				ProgressIntent = RunProgressIntent.FinishAndReturnToMenu;
				Finish("RUN COMPLETE // " + RtaSeconds.ToString("0.000"));
			}
			else
			{
				NextExpectedLevel = Category.ExpectedLevels[Splits];
				ProgressIntent = RunProgressIntent.AdvanceToNextLevel;
				Status = "VALID SPLIT: " + level + " // NEXT " + NextExpectedLevel;
			}
		}

		public RunProgressIntent ConsumeProgressIntent()
		{
			RunProgressIntent progressIntent = ProgressIntent;
			ProgressIntent = RunProgressIntent.None;
			return progressIntent;
		}

		public void NotifyCheckpoint(string who, string checkpoint)
		{
			if ((Object)(object)_notifications != (Object)null)
			{
				_notifications.Checkpoint(who, checkpoint);
			}
		}

		public void NotifyBossKilled(string who, string boss)
		{
			if ((Object)(object)_notifications != (Object)null)
			{
				_notifications.BossKilled(who, boss);
			}
		}

		public void NotifyOpponentLevelCompleted(string opponent, string level, double rtaSeconds, double igtSeconds)
		{
			if ((Object)(object)_notifications != (Object)null)
			{
				_notifications.LevelCompleted(opponent, level, rtaSeconds, igtSeconds);
			}
		}

		public void Finish(string reason)
		{
			FinalRtaSeconds = RtaSeconds;
			FinalIgtSeconds = IgtSeconds;
			RankedResultLog.MatchComplete(_log, this, "", "");
			_clock.Stop();
			GameplayTimerAvailable = false;
			GameplayReady = false;
			State = MatchState.Finished;
			ReturnToLobbyOnMenuRequested = true;
			Status = reason;
		}

		public void Forfeit(string reason)
		{
			FinalRtaSeconds = RtaSeconds;
			FinalIgtSeconds = IgtSeconds;
			RankedResultLog.Forfeit(_log, this, "");
			_clock.Stop();
			GameplayTimerAvailable = false;
			GameplayReady = false;
			State = MatchState.Forfeited;
			ReturnToLobbyOnMenuRequested = true;
			Status = "FORFEIT: " + reason;
			_log.LogWarning((object)Status);
		}

		public void RequestResultsReturn()
		{
			ReturnToLobbyOnMenuRequested = true;
		}

		public bool ConsumeReturnToLobbyRequest()
		{
			if (!ReturnToLobbyOnMenuRequested)
			{
				return false;
			}
			ReturnToLobbyOnMenuRequested = false;
			return true;
		}

		public void ResetToIdle()
		{
			_clock.Stop();
			GameplayTimerAvailable = false;
			GameplayReady = false;
			ReturnToLobbyOnMenuRequested = false;
			_rtaStarted = false;
			_pendingAttemptReset = false;
			State = MatchState.Idle;
			Status = "";
		}

		private static bool IsGameplayScene(string scene)
		{
			if (string.IsNullOrEmpty(scene))
			{
				return false;
			}
			return scene.StartsWith("Level ", StringComparison.OrdinalIgnoreCase);
		}

		private static bool HasMeaningfulInput()
		{
			if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2))
			{
				return true;
			}
			if (Mathf.Abs(Input.GetAxisRaw("Mouse X")) > 0.001f || Mathf.Abs(Input.GetAxisRaw("Mouse Y")) > 0.001f)
			{
				return true;
			}
			if (!Input.GetKeyDown((KeyCode)119) && !Input.GetKeyDown((KeyCode)97) && !Input.GetKeyDown((KeyCode)115) && !Input.GetKeyDown((KeyCode)100) && !Input.GetKeyDown((KeyCode)32) && !Input.GetKeyDown((KeyCode)304))
			{
				return Input.GetKeyDown((KeyCode)306);
			}
			return true;
		}
	}
	public enum MatchState
	{
		Idle,
		Lobby,
		WaitingForFirstInput,
		Running,
		Finished,
		Forfeited
	}
	public enum RunProgressIntent
	{
		None,
		RestartCurrentLevel,
		AdvanceToNextLevel,
		FinishAndReturnToMenu
	}
}
namespace UKSRR.Integrity
{
	public static class IntegrityScanner
	{
		public static void LogLoadedPlugins(ManualLogSource log)
		{
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				BepInPlugin metadata = pluginInfo.Value.Metadata;
				log.LogInfo((object)("PLUGIN " + metadata.GUID + " | " + metadata.Name + " | " + metadata.Version));
			}
		}

		public static bool IsCleanForRanked(out string reason)
		{
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (!(pluginInfo.Value.Metadata.GUID == "com.uksrr.client"))
				{
					reason = "EXTRA MOD LOADED: " + pluginInfo.Value.Metadata.Name;
					return false;
				}
			}
			reason = "";
			return true;
		}
	}
}
namespace UKSRR.Game
{
	public static class DifficultyBridge
	{
		public static bool Apply(int difficulty, ManualLogSource log)
		{
			PlayerPrefs.SetInt("difficulty", difficulty);
			PlayerPrefs.Save();
			try
			{
				_ = typeof(DifficultyBridge).Assembly;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					Type type = assemblies[i].GetType("PrefsManager");
					if (type == null)
					{
						continue;
					}
					object obj = GetStaticMember(type, "Instance") ?? GetStaticMember(type, "instance");
					if (obj != null)
					{
						MethodInfo method = type.GetMethod("SetInt", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
						{
							typeof(string),
							typeof(int)
						}, null);
						if (method != null)
						{
							method.Invoke(obj, new object[2] { "difficulty", difficulty });
							log.LogInfo((object)("Difficulty applied through PrefsManager: " + difficulty));
							return true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("PrefsManager difficulty bridge failed: " + ex.Message));
			}
			log.LogInfo((object)("Difficulty applied through PlayerPrefs fallback: " + difficulty));
			return true;
		}

		private static object GetStaticMember(Type type, string name)
		{
			PropertyInfo property = type.GetProperty(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				return property.GetValue(null, null);
			}
			FieldInfo field = type.GetField(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field == null))
			{
				return field.GetValue(null);
			}
			return null;
		}
	}
	public sealed class GameplayProbe : MonoBehaviour
	{
		private MatchManager _matches;

		private ManualLogSource _log;

		private Type _movementType;

		private float _nextProbe;

		public void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
			_movementType = AccessTools.TypeByName("NewMovement");
		}

		private void Update()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (_matches == null || !_matches.IsMatchActive || _matches.GameplayReady || Time.unscaledTime < _nextProbe)
			{
				return;
			}
			_nextProbe = Time.unscaledTime + 0.25f;
			if (_movementType == null)
			{
				_movementType = AccessTools.TypeByName("NewMovement");
				if (_movementType == null)
				{
					return;
				}
			}
			try
			{
				Object obj = Object.FindObjectOfType(_movementType);
				Component val = (Component)(object)((obj is Component) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
				{
					return;
				}
				Scene scene = val.gameObject.scene;
				if (((Scene)(ref scene)).IsValid() && val.gameObject.activeInHierarchy)
				{
					_matches.NotifyGameplayReady();
					if (_log != null)
					{
						_log.LogInfo((object)"UKSR gameplay detected from active NewMovement.");
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class RankedFinalRankHook
	{
		internal sealed class ResultEvent
		{
			public object Instance;

			public object RankValue;

			public int Sequence;
		}

		private static MatchManager _matches;

		private static ManualLogSource _log;

		private static int _sequence;

		private static readonly Queue<ResultEvent> _pending = new Queue<ResultEvent>();

		public static void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
		}

		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("FinalRank");
			if (type == null)
			{
				if (_log != null)
				{
					_log.LogWarning((object)"UKSR could not find FinalRank for SetRank hook.");
				}
				return null;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "SetRank", (Type[])null, (Type[])null);
			if (methodInfo == null && _log != null)
			{
				_log.LogWarning((object)"UKSR could not find FinalRank.SetRank.");
			}
			return methodInfo;
		}

		private static void Postfix(object __instance, object[] __args)
		{
			if (_matches == null || !_matches.IsMatchActive || __instance == null)
			{
				return;
			}
			object obj = null;
			if (__args != null && __args.Length != 0 && __args[0] != null)
			{
				obj = __args[0];
			}
			if (obj == null)
			{
				try
				{
					FieldInfo fieldInfo = AccessTools.Field(__instance.GetType(), "rank");
					if (fieldInfo != null)
					{
						obj = fieldInfo.GetValue(__instance);
					}
				}
				catch
				{
				}
			}
			_pending.Enqueue(new ResultEvent
			{
				Instance = __instance,
				RankValue = obj,
				Sequence = ++_sequence
			});
			if (_log != null)
			{
				_log.LogInfo((object)("UKSR FinalRank.SetRank fired // arg=" + ((obj == null) ? "<null>" : obj.ToString())));
			}
		}

		public static bool TryDequeue(out ResultEvent result)
		{
			if (_pending.Count > 0)
			{
				result = _pending.Dequeue();
				return true;
			}
			result = null;
			return false;
		}

		public static void Clear()
		{
			_pending.Clear();
		}
	}
	[HarmonyPatch]
	internal static class RankedHooks
	{
	}
	internal static class RankedLevelLoader
	{
		public static void LoadLevel(string levelCode, ManualLogSource log)
		{
			if (string.IsNullOrWhiteSpace(levelCode))
			{
				return;
			}
			string text = "Level " + levelCode.Trim();
			if (!TrySceneHelperLoad(text, log))
			{
				if (log != null)
				{
					log.LogInfo((object)("UKSR SceneHelper load unavailable; falling back to SceneManager.LoadScene: " + text));
				}
				SceneManager.LoadScene(text);
			}
		}

		public static void RestartCurrent(ManualLogSource log)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (TryInvokeActiveZeroArg(new string[2] { "RestartMissionNoConfirm", "RestartMission" }, log, "restart"))
			{
				return;
			}
			Type type = FindType("SceneHelper");
			if (type != null)
			{
				MethodInfo methodInfo = FindStaticZeroArg(type, new string[2] { "RestartScene", "RestartSceneAsync" });
				if (methodInfo != null)
				{
					try
					{
						RunEnumeratorIfNeeded(methodInfo.Invoke(null, null));
						if (log != null)
						{
							log.LogInfo((object)("UKSR restarted through SceneHelper." + methodInfo.Name));
						}
						return;
					}
					catch (Exception ex)
					{
						if (log != null)
						{
							log.LogWarning((object)("UKSR SceneHelper restart failed: " + ex.GetBaseException().Message));
						}
					}
				}
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).IsValid() && !string.IsNullOrEmpty(((Scene)(ref activeScene)).name))
			{
				if (log != null)
				{
					log.LogWarning((object)("UKSR game-native restart unavailable; falling back to active-scene reload: " + ((Scene)(ref activeScene)).name));
				}
				SceneManager.LoadScene(((Scene)(ref activeScene)).name);
			}
		}

		public static void ReturnToMainMenu(ManualLogSource log)
		{
			if (!TrySceneHelperLoad("Main Menu", log))
			{
				if (log != null)
				{
					log.LogInfo((object)"UKSR returning to main menu for lobby reopen.");
				}
				SceneManager.LoadScene("Main Menu");
			}
		}

		private static bool TrySceneHelperLoad(string scene, ManualLogSource log)
		{
			Type type = FindType("SceneHelper");
			if (type == null)
			{
				return false;
			}
			BindingFlags bindingAttr = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[3] { "LoadScene", "LoadSceneAsync", "GoToLevel" };
			foreach (string b in array)
			{
				MethodInfo[] methods = type.GetMethods(bindingAttr);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!string.Equals(methodInfo.Name, b, StringComparison.Ordinal))
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length == 0 || parameters[0].ParameterType != typeof(string))
					{
						continue;
					}
					object[] array2 = new object[parameters.Length];
					array2[0] = scene;
					bool flag = true;
					for (int k = 1; k < parameters.Length; k++)
					{
						if (parameters[k].HasDefaultValue)
						{
							array2[k] = parameters[k].DefaultValue;
							continue;
						}
						if (parameters[k].ParameterType == typeof(bool))
						{
							array2[k] = false;
							continue;
						}
						if (parameters[k].ParameterType.IsEnum)
						{
							array2[k] = Activator.CreateInstance(parameters[k].ParameterType);
							continue;
						}
						flag = false;
						break;
					}
					if (!flag)
					{
						continue;
					}
					try
					{
						RunEnumeratorIfNeeded(methodInfo.Invoke(null, array2));
						if (log != null)
						{
							log.LogInfo((object)("UKSR loading through SceneHelper." + methodInfo.Name + ": " + scene));
						}
						return true;
					}
					catch (Exception ex)
					{
						if (log != null)
						{
							log.LogWarning((object)("UKSR SceneHelper." + methodInfo.Name + " failed: " + ex.GetBaseException().Message));
						}
					}
				}
			}
			return false;
		}

		private static bool TryInvokeActiveZeroArg(string[] names, ManualLogSource log, string action)
		{
			//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)
			Component[] array = Resources.FindObjectsOfTypeAll<Component>();
			foreach (Component val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
				{
					continue;
				}
				Scene scene = val.gameObject.scene;
				if (!((Scene)(ref scene)).IsValid() || !val.gameObject.activeInHierarchy)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				foreach (string name in names)
				{
					MethodInfo method = type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
					if (method == null)
					{
						continue;
					}
					try
					{
						RunEnumeratorIfNeeded(method.Invoke(val, null));
						if (log != null)
						{
							log.LogInfo((object)("UKSR invoked game-native " + action + ": " + type.Name + "." + method.Name));
						}
						return true;
					}
					catch (Exception ex)
					{
						if (log != null)
						{
							log.LogWarning((object)("UKSR " + type.Name + "." + method.Name + " failed: " + ex.GetBaseException().Message));
						}
					}
				}
			}
			return false;
		}

		private static MethodInfo FindStaticZeroArg(Type type, string[] names)
		{
			foreach (string name in names)
			{
				MethodInfo method = type.GetMethod(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				if (method != null)
				{
					return method;
				}
			}
			return null;
		}

		private static Type FindType(string name)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(name, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}

		private static void RunEnumeratorIfNeeded(object result)
		{
			if (result is IEnumerator enumerator && (Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(enumerator);
			}
		}
	}
	internal static class RankedResultLog
	{
		public static void Split(ManualLogSource log, MatchManager matches, string level, string rankText, bool pRank)
		{
			if (log != null && matches != null)
			{
				log.LogInfo((object)("UKSR RESULT // " + level + " // RANK " + NormalizeRank(rankText, pRank)));
				log.LogInfo((object)("UKSR SPLIT  // RTA " + Format(matches.RtaSeconds) + " // IGT " + Format(matches.IgtSeconds)));
				log.LogInfo((object)("UKSR TOTAL  // RTA " + Format(matches.RtaSeconds) + " // IGT " + Format(matches.IgtSeconds)));
			}
		}

		public static void MatchComplete(ManualLogSource log, MatchManager matches, string playerName, string finalRank)
		{
			if (log != null && matches != null)
			{
				log.LogInfo((object)"UKSR ===== MATCH COMPLETE =====");
				log.LogInfo((object)("UKSR CATEGORY // " + ((matches.Category == null) ? "UNKNOWN" : matches.Category.DisplayName)));
				log.LogInfo((object)("UKSR PLAYER   // " + (string.IsNullOrEmpty(playerName) ? "UNKNOWN" : playerName)));
				if (!string.IsNullOrEmpty(finalRank))
				{
					log.LogInfo((object)("UKSR RANK     // " + finalRank));
				}
				log.LogInfo((object)("UKSR RTA      // " + Format(matches.FinalRtaSeconds)));
				log.LogInfo((object)("UKSR IGT      // " + Format(matches.FinalIgtSeconds)));
				log.LogInfo((object)"UKSR ==========================");
			}
		}

		public static void Forfeit(ManualLogSource log, MatchManager matches, string playerName)
		{
			if (log != null && matches != null)
			{
				log.LogInfo((object)"UKSR ===== MATCH FORFEIT =====");
				log.LogInfo((object)("UKSR CATEGORY // " + ((matches.Category == null) ? "UNKNOWN" : matches.Category.DisplayName)));
				log.LogInfo((object)("UKSR PLAYER   // " + (string.IsNullOrEmpty(playerName) ? "UNKNOWN" : playerName)));
				log.LogInfo((object)("UKSR RTA      // " + Format(matches.FinalRtaSeconds)));
				log.LogInfo((object)("UKSR IGT      // " + Format(matches.FinalIgtSeconds)));
				log.LogInfo((object)"UKSR =========================");
			}
		}

		private static string NormalizeRank(string rankText, bool pRank)
		{
			if (pRank)
			{
				return "P";
			}
			string text = (rankText ?? "").Trim();
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "UNKNOWN";
		}

		private static string Format(double seconds)
		{
			if (seconds < 0.0)
			{
				seconds = 0.0;
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			if (timeSpan.TotalHours >= 1.0)
			{
				return $"{(int)timeSpan.TotalHours:00}:{timeSpan.Minutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
			}
			return $"{timeSpan.Minutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}
	}
	public sealed class RankedResultWatcher : MonoBehaviour
	{
		private MatchManager _matches;

		private ManualLogSource _log;

		private int _lastHandledSequence;

		private object _lastHandledFinalRankInstance;

		public void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
		}

		private void Update()
		{
			if (_matches == null || !_matches.IsMatchActive)
			{
				_lastHandledFinalRankInstance = null;
				RankedFinalRankHook.Clear();
				return;
			}
			RankedFinalRankHook.ResultEvent result;
			while (RankedFinalRankHook.TryDequeue(out result))
			{
				if (result == null || result.Sequence <= _lastHandledSequence)
				{
					continue;
				}
				_lastHandledSequence = result.Sequence;
				if (_lastHandledFinalRankInstance == result.Instance)
				{
					continue;
				}
				_lastHandledFinalRankInstance = result.Instance;
				string text = ExpectedCurrentLevel();
				if (!string.IsNullOrEmpty(text))
				{
					string text2 = ConvertRankToText(result.RankValue);
					bool pRank = IsP(text2);
					if (_log != null)
					{
						_log.LogInfo((object)("UKSR finalized result: " + text + " // rank=" + (string.IsNullOrEmpty(text2) ? "<unknown>" : text2) + " // pRank=" + pRank));
					}
					RankedResultLog.Split(_log, _matches, text, text2, pRank);
					_matches.RegisterLevelResult(text, _matches.CurrentLevelIgt, pRank);
					RunProgressIntent runProgressIntent = _matches.ConsumeProgressIntent();
					if (_log != null)
					{
						_log.LogInfo((object)("UKSR progression intent: " + runProgressIntent.ToString() + (string.IsNullOrEmpty(_matches.NextExpectedLevel) ? "" : (" / " + _matches.NextExpectedLevel))));
					}
					switch (runProgressIntent)
					{
					case RunProgressIntent.RestartCurrentLevel:
						RankedLevelLoader.RestartCurrent(_log);
						break;
					case RunProgressIntent.AdvanceToNextLevel:
						RankedLevelLoader.LoadLevel(_matches.NextExpectedLevel, _log);
						break;
					case RunProgressIntent.FinishAndReturnToMenu:
						RankedLevelLoader.ReturnToMainMenu(_log);
						break;
					}
				}
			}
		}

		private string ExpectedCurrentLevel()
		{
			if (_matches.Category != null && _matches.Category.ExpectedLevels != null && _matches.Splits >= 0 && _matches.Splits < _matches.Category.ExpectedLevels.Count)
			{
				return _matches.Category.ExpectedLevels[_matches.Splits];
			}
			if (!string.IsNullOrEmpty(_matches.SelectedLevel))
			{
				return _matches.SelectedLevel;
			}
			return _matches.NextExpectedLevel;
		}

		private static string ConvertRankToText(object rankValue)
		{
			if (rankValue == null)
			{
				return "";
			}
			string text = StripRichText(Convert.ToString(rankValue)).Trim().ToUpperInvariant();
			if (IsP(text) || IsNormalRank(text))
			{
				return text;
			}
			Type type = AccessTools.TypeByName("RankHelper");
			if (type == null)
			{
				return text;
			}
			BindingFlags bindingAttr = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			string[] array = new string[2] { "GetRankLetter", "GetRank" };
			foreach (string b in array)
			{
				MethodInfo[] methods = type.GetMethods(bindingAttr);
				foreach (MethodInfo methodInfo in methods)
				{
					if (!string.Equals(methodInfo.Name, b, StringComparison.Ordinal))
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length != 1 || !TryCoerce(rankValue, parameters[0].ParameterType, out var converted))
					{
						continue;
					}
					try
					{
						string text2 = StripRichText(Convert.ToString(methodInfo.Invoke(null, new object[1] { converted }))).Trim().ToUpperInvariant();
						if (!string.IsNullOrEmpty(text2))
						{
							return text2;
						}
					}
					catch
					{
					}
				}
			}
			return text;
		}

		private static bool TryCoerce(object value, Type targetType, out object converted)
		{
			converted = null;
			if (value == null)
			{
				return false;
			}
			Type type = value.GetType();
			if (targetType.IsAssignableFrom(type))
			{
				converted = value;
				return true;
			}
			try
			{
				if (targetType.IsEnum)
				{
					object value2 = Convert.ChangeType(value, Enum.GetUnderlyingType(targetType));
					converted = Enum.ToObject(targetType, value2);
					return true;
				}
				converted = Convert.ChangeType(value, targetType);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string StripRichText(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			char[] array = new char[text.Length];
			int length = 0;
			bool flag = false;
			foreach (char c in text)
			{
				if (c == '<')
				{
					flag = true;
				}
				else if (flag)
				{
					if (c == '>')
					{
						flag = false;
					}
				}
				else
				{
					array[length++] = c;
				}
			}
			return new string(array, 0, length);
		}

		private static bool IsP(string text)
		{
			string text2 = StripRichText(text ?? "").Trim().ToUpperInvariant();
			switch (text2)
			{
			default:
				return text2.Contains("PERFECT");
			case "P":
			case "P-RANK":
			case "P RANK":
				return true;
			}
		}

		private static bool IsNormalRank(string text)
		{
			string text2 = StripRichText(text ?? "").Trim().ToUpperInvariant();
			switch (text2)
			{
			default:
				return text2 == "D";
			case "S":
			case "A":
			case "B":
			case "C":
				return true;
			}
		}
	}
	public sealed class SceneWatcher : MonoBehaviour
	{
		private MatchManager _matches;

		private ManualLogSource _log;

		public void Initialize(MatchManager matches, ManualLogSource log)
		{
			_matches = matches;
			_log = log;
		}

		private void OnEnable()
		{
			SceneManager.activeSceneChanged += Changed;
		}

		private void OnDisable()
		{
			SceneManager.activeSceneChanged -= Changed;
		}

		private void Changed(Scene oldScene, Scene newScene)
		{
			_log.LogDebug((object)("Scene " + ((Scene)(ref oldScene)).name + " -> " + ((Scene)(ref newScene)).name));
			_matches.OnSceneChanged(((Scene)(ref oldScene)).name, ((Scene)(ref newScene)).name);
		}
	}
}