using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using ProMLGStats.Stats;
using ProMLGStats.UI;
using ProMLGStats.Utils;
using TMPro;
using UnboundLib;
using UnboundLib.GameModes;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
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("ProMLGStats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.5+55b73cdce38371846b742abe42a0fd48a4a387b1")]
[assembly: AssemblyProduct("ProMLGStats")]
[assembly: AssemblyTitle("ProMLGStats")]
[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 ProMLGStats
{
	internal class Configs
	{
		public ConfigEntry<bool> EnableStatsHud { get; }

		public ConfigEntry<bool> StatsHudVisible { get; }

		public ConfigEntry<bool> StatsHudCollapsed { get; }

		public ConfigEntry<bool> StatsHudSimpleMode { get; }

		public ConfigEntry<bool> StatsHudUltraCompact { get; }

		public ConfigEntry<bool> StatsHudPeekMode { get; }

		public ConfigEntry<KeyCode> StatsHudPeekKey { get; }

		public ConfigEntry<bool> HideStatsHudDuringPick { get; }

		public ConfigEntry<bool> HideStatsHudDuringBattle { get; }

		public ConfigEntry<KeyCode> StatsHudToggleKey { get; }

		public ConfigEntry<float> StatsHudOpacity { get; }

		public ConfigEntry<float> StatsHudFontScale { get; }

		public ConfigEntry<float> StatsHudColorR { get; }

		public ConfigEntry<float> StatsHudColorG { get; }

		public ConfigEntry<float> StatsHudColorB { get; }

		public ConfigEntry<bool> ShowPickDeltasOnHud { get; }

		public ConfigEntry<bool> EnableStatsTab { get; }

		public ConfigEntry<KeyCode> StatsTabKey { get; }

		public ConfigEntry<KeyCode> TabCompareKey { get; }

		public ConfigEntry<bool> EnableTabCompare { get; }

		public ConfigEntry<float> TabPanelWidth { get; }

		public ConfigEntry<float> TabPanelHeightFraction { get; }

		public ConfigEntry<float> TabPanelOpacity { get; }

		public ConfigEntry<float> TabPosX { get; }

		public ConfigEntry<float> TabPosY { get; }

		public ConfigEntry<bool> ShowPing { get; }

		public ConfigEntry<bool> AutoCloseTabDuringPick { get; }

		public ConfigEntry<bool> ShowTabInfoStats { get; }

		public ConfigEntry<float> StatsPanelScale { get; }

		public ConfigEntry<float> StatsHudOffsetX { get; }

		public ConfigEntry<float> StatsHudOffsetY { get; }

		public ConfigEntry<float> StatsAccentR { get; }

		public ConfigEntry<float> StatsAccentG { get; }

		public ConfigEntry<float> StatsAccentB { get; }

		public Configs(ConfigFile config)
		{
			EnableStatsHud = config.Bind<bool>("Stats HUD", "Enabled", true, "Always-on stats panel in the bottom-left corner.");
			StatsHudVisible = config.Bind<bool>("Stats HUD", "Visible", true, "Whether the HUD is currently shown (toggle in-game with ToggleKey).");
			StatsHudCollapsed = config.Bind<bool>("Stats HUD", "Collapsed", false, "Show the HUD as a minimal strip instead of the full panel.");
			StatsHudSimpleMode = config.Bind<bool>("Stats HUD", "SimpleMode", true, "Show a compact stat list instead of every stat.");
			StatsHudUltraCompact = config.Bind<bool>("Stats HUD", "UltraCompact", false, "Narrow HUD with fewer lines.");
			StatsHudPeekMode = config.Bind<bool>("Stats HUD", "PeekMode", false, "Only show the HUD while holding the peek key.");
			StatsHudPeekKey = config.Bind<KeyCode>("Stats HUD", "PeekKey", (KeyCode)308, "Hold to show HUD when PeekMode is enabled.");
			HideStatsHudDuringPick = config.Bind<bool>("Stats HUD", "HideDuringPick", false, "Hide the always-on HUD during card pick.");
			HideStatsHudDuringBattle = config.Bind<bool>("Stats HUD", "HideDuringBattle", false, "Hide the always-on HUD during battle rounds.");
			StatsHudToggleKey = config.Bind<KeyCode>("Stats HUD", "ToggleKey", (KeyCode)111, "Toggle the always-on HUD visibility. Set to None to disable the shortcut.");
			StatsHudOpacity = config.Bind<float>("Stats HUD", "Opacity", 0f, "Background opacity for the HUD panel (0 = text only).");
			StatsHudFontScale = config.Bind<float>("Stats HUD", "FontScale", 1f, "Text scale multiplier (auto-scales with resolution too).");
			StatsHudColorR = config.Bind<float>("Stats HUD", "ColorR", 1f, "HUD text red channel.");
			StatsHudColorG = config.Bind<float>("Stats HUD", "ColorG", 1f, "HUD text green channel.");
			StatsHudColorB = config.Bind<float>("Stats HUD", "ColorB", 1f, "HUD text blue channel.");
			ShowPickDeltasOnHud = config.Bind<bool>("Stats HUD", "ShowPickDeltas", true, "During picks, show card deltas on the HUD for whoever is picking (hover a card to preview).");
			EnableStatsTab = config.Bind<bool>("Stats Tab", "Enabled", true, "Full-player Tab overlay. Press the Tab key in-game.");
			StatsTabKey = config.Bind<KeyCode>("Stats Tab", "OpenKey", (KeyCode)9, "Opens the Tab overlay. Rebind if another mod already uses Tab. None disables it.");
			TabCompareKey = config.Bind<KeyCode>("Stats Tab", "CompareKey", (KeyCode)99, "Toggles compare mode while the Tab overlay is open.");
			EnableTabCompare = config.Bind<bool>("Stats Tab", "EnableCompare", true, "Compare mode inside the Tab overlay ([ and ] switch opponent).");
			TabPanelWidth = config.Bind<float>("Stats Tab", "PanelWidth", 480f, "Tab overlay width in pixels (before scale).");
			TabPanelHeightFraction = config.Bind<float>("Stats Tab", "PanelHeightFraction", 0.82f, "Tab overlay height as a fraction of screen height.");
			TabPanelOpacity = config.Bind<float>("Stats Tab", "PanelOpacity", 0.94f, "Tab overlay background opacity.");
			TabPosX = config.Bind<float>("Stats Tab", "PosX", -1f, "Tab overlay X in canvas pixels. Negative = default centered.");
			TabPosY = config.Bind<float>("Stats Tab", "PosY", -1f, "Tab overlay Y in canvas pixels. Negative = default centered.");
			ShowPing = config.Bind<bool>("Stats Tab", "ShowPing", true, "Show Photon ping next to player names (online games).");
			AutoCloseTabDuringPick = config.Bind<bool>("Stats Tab", "AutoCloseDuringPick", true, "Close the Tab overlay automatically when a card pick starts.");
			ShowTabInfoStats = config.Bind<bool>("Stats Tab", "ShowTabInfoStats", true, "If willuwontu's TabInfo is installed, also show stats other mods registered with it.");
			StatsPanelScale = config.Bind<float>("Stats Layout", "PanelScale", 1f, "Global UI scale multiplier.");
			StatsHudOffsetX = config.Bind<float>("Stats Layout", "HudOffsetX", 14f, "HUD distance from left edge.");
			StatsHudOffsetY = config.Bind<float>("Stats Layout", "HudOffsetY", 14f, "HUD distance from bottom edge.");
			StatsAccentR = config.Bind<float>("Stats Layout", "AccentR", 0.35f, "Accent color red.");
			StatsAccentG = config.Bind<float>("Stats Layout", "AccentG", 0.82f, "Accent color green.");
			StatsAccentB = config.Bind<float>("Stats Layout", "AccentB", 0.72f, "Accent color blue.");
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.ljindustries.rounds.promlgstats", "Pro MLG Stats", "1.0.5")]
	[BepInProcess("Rounds.exe")]
	public class Plugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__9_0;

			internal void <Start>b__9_0()
			{
			}
		}

		public const string ModId = "com.ljindustries.rounds.promlgstats";

		public const string ModName = "Pro MLG Stats";

		public const string Version = "1.0.5";

		internal static Configs Configs;

		public static Plugin Instance { get; private set; }

		private void Awake()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			Instance = this;
			Configs = new Configs(((BaseUnityPlugin)this).Config);
			try
			{
				Harmony val = new Harmony("com.ljindustries.rounds.promlgstats");
				Type[] types;
				try
				{
					types = typeof(Plugin).Assembly.GetTypes();
				}
				catch (ReflectionTypeLoadException ex)
				{
					types = ex.Types;
					ManualLogSource logger = ((BaseUnityPlugin)this).Logger;
					Exception?[] loaderExceptions = ex.LoaderExceptions;
					logger.LogWarning((object)$"GetTypes partial load: {((loaderExceptions != null) ? loaderExceptions.Length : 0)} loader error(s)");
				}
				Type[] array = types;
				foreach (Type type in array)
				{
					if (!(type == null))
					{
						try
						{
							val.CreateClassProcessor(type).Patch();
						}
						catch (Exception ex2)
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)("Harmony skip " + type.FullName + ": " + ex2.GetType().Name + ": " + ex2.Message));
						}
					}
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Harmony patching failed: {arg}");
			}
		}

		private void Start()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Unbound.RegisterClientSideMod("com.ljindustries.rounds.promlgstats");
			object obj = <>c.<>9__9_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
				};
				<>c.<>9__9_0 = val;
				obj = (object)val;
			}
			Unbound.RegisterMenu("Pro MLG Stats", (UnityAction)obj, (Action<GameObject>)MenuBuilder.Build, (GameObject)null, true);
			ExtensionMethods.GetOrAddComponent<StatsController>(((Component)this).gameObject, false);
			StatsController.RegisterHooks();
		}

		internal void Log(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[Pro MLG Stats] " + message));
		}

		internal void LogWarn(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("[Pro MLG Stats] " + message));
		}
	}
	[HarmonyPatch(typeof(CardChoice), "StartPick")]
	internal static class StartPickTrackerPatch
	{
		private static void Postfix(int pickerIDToSet)
		{
			PickPhase.NoteActingPicker(pickerIDToSet);
		}
	}
}
namespace ProMLGStats.Utils
{
	internal static class PickPhase
	{
		private static readonly FieldInfo PickerTypeField = AccessTools.Field(typeof(CardChoice), "pickerType");

		private static readonly FieldInfo SpawnedCardsField = AccessTools.Field(typeof(CardChoice), "spawnedCards");

		private static int _actingPickerId = -1;

		internal static void NoteActingPicker(int pickerId)
		{
			_actingPickerId = pickerId;
		}

		internal static void ClearActingPicker()
		{
			_actingPickerId = -1;
		}

		internal static Player GetCurrentPicker()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			CardChoice instance = CardChoice.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			if (instance.IsPicking && _actingPickerId >= 0)
			{
				Player val = FindPlayer(_actingPickerId);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			if (PickerTypeField != null && (int)(PickerType)PickerTypeField.GetValue(instance) == 0)
			{
				Player[] array = (((Object)(object)PlayerManager.instance != (Object)null) ? PlayerManager.instance.GetPlayersInTeam(instance.pickrID) : null);
				if (array != null && array.Length != 0)
				{
					return DesignateFromTeam(array);
				}
			}
			return FindPlayer(instance.pickrID);
		}

		internal static Player FindPlayer(int playerId)
		{
			List<Player> list = PlayerManager.instance?.players;
			if (list == null)
			{
				return null;
			}
			foreach (Player item in list)
			{
				if ((Object)(object)item != (Object)null && item.playerID == playerId)
				{
					return item;
				}
			}
			return null;
		}

		internal static List<GameObject> GetSpawnedCards()
		{
			CardChoice instance = CardChoice.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return null;
			}
			return SpawnedCardsField?.GetValue(instance) as List<GameObject>;
		}

		internal static bool PickerHoldsCardNamed(string cardName)
		{
			if (string.IsNullOrEmpty(cardName))
			{
				return false;
			}
			Player currentPicker = GetCurrentPicker();
			if ((Object)(object)currentPicker == (Object)null || !PlayerStatsSnapshot.IsLocallyControlled(currentPicker))
			{
				return false;
			}
			List<CardInfo> list = currentPicker.data?.currentCards;
			if (list == null)
			{
				return false;
			}
			foreach (CardInfo item in list)
			{
				if (!((Object)(object)item == (Object)null) && string.Equals(item.cardName, cardName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static Player DesignateFromTeam(Player[] team)
		{
			if (team == null || team.Length == 0)
			{
				return null;
			}
			Player val = null;
			Player val2 = null;
			foreach (Player val3 in team)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					if ((Object)(object)val2 == (Object)null || val3.playerID < val2.playerID)
					{
						val2 = val3;
					}
					if ((Object)(object)val == (Object)null && PlayerStatsSnapshot.IsLocallyControlled(val3))
					{
						val = val3;
					}
				}
			}
			return val ?? val2;
		}
	}
	internal static class RoundsWithBotsBridge
	{
		private const string ExtensionTypeName = "RoundsWithBots.Extensions.CharacterDataExtension";

		private const string AdditionalDataTypeName = "RoundsWithBots.Extensions.CharacterDataAdditionalData";

		private static bool _probed;

		private static bool _logged;

		private static MethodInfo _getAdditionalData;

		private static PropertyInfo _isBot;

		private static Type _playerAiPhilip;

		internal static bool IsAvailable
		{
			get
			{
				Probe();
				if (_getAdditionalData != null)
				{
					return _isBot != null;
				}
				return false;
			}
		}

		internal static bool IsBot(Player player)
		{
			if ((Object)(object)player?.data == (Object)null)
			{
				return false;
			}
			Probe();
			if (_getAdditionalData != null && _isBot != null)
			{
				try
				{
					object obj = _getAdditionalData.Invoke(null, new object[1] { player.data });
					if (obj != null)
					{
						object value = _isBot.GetValue(obj);
						if (value is bool && (bool)value)
						{
							return true;
						}
					}
				}
				catch
				{
				}
			}
			return HasEnabledAi(player);
		}

		internal static string DisplayName(Player player, string fallback)
		{
			if ((Object)(object)player == (Object)null || !IsBot(player))
			{
				if (!string.IsNullOrEmpty(fallback))
				{
					return fallback;
				}
				return "?";
			}
			return $"<color=#07e0f0>[BOT]</color> P{player.playerID + 1}";
		}

		private static bool HasEnabledAi(Player player)
		{
			if (_playerAiPhilip == null || (Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				Component component = ((Component)player).GetComponent(_playerAiPhilip);
				Behaviour val = (Behaviour)(((object)((component is Behaviour) ? component : null)) ?? ((object)/*isinst with value type is only supported in some contexts*/));
				return (Object)(object)val != (Object)null && val.enabled;
			}
			catch
			{
				return false;
			}
		}

		private static void Probe()
		{
			if (_probed)
			{
				return;
			}
			_probed = true;
			try
			{
				Type type = AccessTools.TypeByName("RoundsWithBots.Extensions.CharacterDataExtension");
				if (type != null)
				{
					_getAdditionalData = AccessTools.Method(type, "GetAdditionalData", new Type[1] { typeof(CharacterData) }, (Type[])null);
					Type type2 = AccessTools.TypeByName("RoundsWithBots.Extensions.CharacterDataAdditionalData") ?? _getAdditionalData?.ReturnType;
					_isBot = ((type2 == null) ? null : AccessTools.Property(type2, "IsBot"));
				}
			}
			catch
			{
				_getAdditionalData = null;
				_isBot = null;
			}
			_playerAiPhilip = AccessTools.TypeByName("PlayerAIPhilip");
			if (!_logged && _getAdditionalData != null && _isBot != null)
			{
				_logged = true;
				Plugin.Instance?.Log("RoundsWithBots detected - bots are listed separately and are not treated as the local player.");
			}
		}
	}
	internal static class TabInfoBridge
	{
		private const string ManagerTypeName = "TabInfo.Utils.TabInfoManager";

		private static bool _probed;

		private static MethodInfo _getVisibleStats;

		private static object _basicStats;

		private static FieldInfo _rowCategory;

		private static FieldInfo _rowStat;

		private static FieldInfo _rowValue;

		private static FieldInfo _categoryName;

		private static FieldInfo _statName;

		internal static bool IsAvailable
		{
			get
			{
				Probe();
				return _getVisibleStats != null;
			}
		}

		internal static IEnumerable<(string category, string label, string value)> GetExtensionStats(Player player)
		{
			if ((Object)(object)player == (Object)null || (Plugin.Configs != null && !Plugin.Configs.ShowTabInfoStats.Value))
			{
				yield break;
			}
			Probe();
			if (_getVisibleStats == null)
			{
				yield break;
			}
			IEnumerable enumerable;
			try
			{
				enumerable = _getVisibleStats.Invoke(null, new object[1] { player }) as IEnumerable;
			}
			catch (Exception ex)
			{
				Plugin.Instance?.LogWarn("TabInfo GetVisibleStats failed: " + ex.Message);
				yield break;
			}
			if (enumerable == null)
			{
				yield break;
			}
			foreach (object item in enumerable)
			{
				if (item == null)
				{
					continue;
				}
				string text;
				string text2;
				string text3;
				try
				{
					object obj = _rowCategory?.GetValue(item);
					if (obj == null || (_basicStats != null && obj == _basicStats))
					{
						continue;
					}
					object obj2 = _rowStat?.GetValue(item);
					text = _categoryName?.GetValue(obj) as string;
					text2 = ((obj2 != null) ? (_statName?.GetValue(obj2) as string) : null);
					text3 = _rowValue?.GetValue(item) as string;
					goto IL_0191;
				}
				catch
				{
				}
				continue;
				IL_0191:
				if (!string.IsNullOrEmpty(text2))
				{
					yield return (category: text ?? string.Empty, label: text2, value: text3 ?? string.Empty);
				}
			}
		}

		private static void Probe()
		{
			if (_probed)
			{
				return;
			}
			_probed = true;
			Type type = AccessTools.TypeByName("TabInfo.Utils.TabInfoManager");
			if (type == null)
			{
				return;
			}
			_getVisibleStats = AccessTools.Method(type, "GetVisibleStats", new Type[1] { typeof(Player) }, (Type[])null);
			if (_getVisibleStats == null)
			{
				return;
			}
			try
			{
				_basicStats = AccessTools.Field(type, "basicStats")?.GetValue(null) ?? AccessTools.Property(type, "basicStats")?.GetValue(null);
			}
			catch
			{
				_basicStats = null;
			}
			Type type2 = (_getVisibleStats.ReturnType.IsGenericType ? _getVisibleStats.ReturnType.GetGenericArguments()[0] : null);
			if (type2 == null)
			{
				_getVisibleStats = null;
				return;
			}
			_rowCategory = AccessTools.Field(type2, "category");
			_rowStat = AccessTools.Field(type2, "stat");
			_rowValue = AccessTools.Field(type2, "value");
			if (_rowCategory == null || _rowStat == null || _rowValue == null)
			{
				_getVisibleStats = null;
				return;
			}
			_categoryName = AccessTools.Field(_rowCategory.FieldType, "name");
			_statName = AccessTools.Field(_rowStat.FieldType, "name");
			Plugin.Instance?.Log("TabInfo detected — extension stats will be shown in the Tab panel.");
		}
	}
}
namespace ProMLGStats.UI
{
	internal static class MenuBuilder
	{
		public static void Build(GameObject menu)
		{
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			Configs cfg = Plugin.Configs;
			TextMeshProUGUI val = default(TextMeshProUGUI);
			MenuHandler.CreateText("Pro MLG Stats", menu, ref val, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateText("Client-side only. Other players do not need this mod.", menu, ref val, 26, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateText("Stats HUD", menu, ref val, 40, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.EnableStatsHud.Value, "Enable HUD", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.EnableStatsHud.Value = v;
				StatsController.Instance?.RebuildHud();
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.StatsHudSimpleMode.Value, "Compact stat list", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.StatsHudSimpleMode.Value = v;
				StatsController.Instance?.RebuildHud();
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.HideStatsHudDuringPick.Value, "Hide HUD during pick", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.HideStatsHudDuringPick.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.HideStatsHudDuringBattle.Value, "Hide HUD during battle", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.HideStatsHudDuringBattle.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.ShowPickDeltasOnHud.Value, "Show card deltas while picking", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.ShowPickDeltasOnHud.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			Slider val2 = default(Slider);
			MenuHandler.CreateSlider("HUD opacity", menu, 30, 0f, 1f, cfg.StatsHudOpacity.Value, (UnityAction<float>)delegate(float v)
			{
				cfg.StatsHudOpacity.Value = v;
				StatsController.Instance?.RebuildHud();
			}, ref val2, false, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateSlider("HUD text scale", menu, 30, 0.6f, 2f, cfg.StatsHudFontScale.Value, (UnityAction<float>)delegate(float v)
			{
				cfg.StatsHudFontScale.Value = v;
				StatsController.Instance?.RebuildHud();
			}, ref val2, false, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateText("Tab overlay", menu, ref val, 40, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.EnableStatsTab.Value, "Enable Tab overlay", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.EnableStatsTab.Value = v;
				StatsController.Instance?.RebuildTab();
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.EnableTabCompare.Value, "Enable compare mode", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.EnableTabCompare.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.AutoCloseTabDuringPick.Value, "Close automatically on pick", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.AutoCloseTabDuringPick.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateToggle(cfg.ShowPing.Value, "Show ping", menu, (UnityAction<bool>)delegate(bool v)
			{
				cfg.ShowPing.Value = v;
			}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			if (TabInfoBridge.IsAvailable)
			{
				MenuHandler.CreateToggle(cfg.ShowTabInfoStats.Value, "Include TabInfo stats", menu, (UnityAction<bool>)delegate(bool v)
				{
					cfg.ShowTabInfoStats.Value = v;
					StatsController.Instance?.RebuildTab();
				}, 32, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			}
			MenuHandler.CreateSlider("Tab panel width", menu, 30, 280f, 640f, cfg.TabPanelWidth.Value, (UnityAction<float>)delegate(float v)
			{
				cfg.TabPanelWidth.Value = v;
				StatsController.Instance?.RebuildTab();
			}, ref val2, false, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateSlider("Global UI scale", menu, 30, 0.6f, 1.8f, cfg.StatsPanelScale.Value, (UnityAction<float>)delegate(float v)
			{
				cfg.StatsPanelScale.Value = v;
				StatsController.Instance?.RebuildHud();
				StatsController.Instance?.RebuildTab();
			}, ref val2, false, (Color?)null, (Direction)0, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			MenuHandler.CreateText("Keys are rebindable in BepInEx/config/com.ljindustries.rounds.promlgstats.cfg " + $"(currently {cfg.StatsTabKey.Value} for the panel, {cfg.StatsHudToggleKey.Value} for the HUD).", menu, ref val, 24, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		}
	}
	internal sealed class OverlayDrag : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
	{
		internal RectTransform Target;

		internal bool ResizeWidth;

		private Vector2 _startPointer;

		private Vector2 _startPos;

		private Vector2 _startSize;

		public void OnBeginDrag(PointerEventData eventData)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null))
			{
				_startPos = Target.anchoredPosition;
				_startSize = Target.sizeDelta;
				ScreenToParent(eventData, out _startPointer);
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null))
			{
				ScreenToParent(eventData, out var local);
				Vector2 val = local - _startPointer;
				Vector2 overlaySize = StatsUiHelper.OverlaySize;
				if (ResizeWidth)
				{
					float num = Mathf.Min(640f, overlaySize.x * 0.55f);
					float num2 = Mathf.Clamp(_startSize.x - val.x, 280f, num);
					float num3 = _startSize.x - num2;
					Target.sizeDelta = new Vector2(num2, _startSize.y);
					Target.anchoredPosition = Clamp(_startPos + new Vector2(num3, 0f), Target.sizeDelta, overlaySize);
				}
				else
				{
					Target.anchoredPosition = Clamp(_startPos + val, _startSize, overlaySize);
				}
			}
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0026: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null) && Plugin.Configs != null)
			{
				Plugin.Configs.TabPosX.Value = Target.anchoredPosition.x;
				Plugin.Configs.TabPosY.Value = Target.anchoredPosition.y;
				Plugin.Configs.TabPanelWidth.Value = Target.sizeDelta.x;
			}
		}

		private void ScreenToParent(PointerEventData eventData, out Vector2 local)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)Target).parent;
			RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), eventData.position, eventData.pressEventCamera, ref local);
		}

		private static Vector2 Clamp(Vector2 pos, Vector2 size, Vector2 canvas)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = 8f;
			pos.x = Mathf.Clamp(pos.x, num, Mathf.Max(num, canvas.x - size.x - num));
			pos.y = Mathf.Clamp(pos.y, num, Mathf.Max(num, canvas.y - size.y - num));
			return pos;
		}
	}
	internal sealed class StatsController : MonoBehaviour
	{
		private const string BlindDraftCardName = "Blind Draft";

		private StatsHudPanel _hud;

		private StatsTabOverlay _tab;

		private CardInfo _hoveredCard;

		private CardInfo _hoveredVisual;

		private PlayerStatsSnapshot _previewDelta;

		private readonly Dictionary<int, PlayerStatsSnapshot> _pickBaselines = new Dictionary<int, PlayerStatsSnapshot>();

		private float _refreshTimer;

		private static float _readyCacheUntil;

		private static bool _readyCache;

		private static readonly FieldInfo SpawnedCardsField = AccessTools.Field(typeof(CardChoice), "spawnedCards");

		private static readonly FieldInfo IsHoveredField = AccessTools.Field(typeof(CardVisuals), "isHovered");

		private static readonly FieldInfo IsSelectedField = AccessTools.Field(typeof(CardVisuals), "isSelected");

		private static readonly FieldInfo CurrentlySelectedCardField = AccessTools.Field(typeof(CardChoice), "currentlySelectedCard");

		private static readonly PropertyInfo CurrentlySelectedCardProp = AccessTools.Property(typeof(CardChoice), "currentlySelectedCard");

		internal static StatsController Instance { get; private set; }

		internal static bool InPickPhase { get; private set; }

		internal static bool InBattlePhase { get; private set; }

		internal static bool MatchSessionActive { get; private set; }

		internal static int CurrentRound { get; private set; }

		internal static int CurrentPoint { get; private set; }

		internal static string HoveredCardName => Instance?._hoveredCard?.cardName;

		internal static bool IsCardPickActive
		{
			get
			{
				if (InPickPhase && (Object)(object)CardChoice.instance != (Object)null)
				{
					return CardChoice.instance.IsPicking;
				}
				return false;
			}
		}

		private void Awake()
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			_hud = ((Component)this).gameObject.AddComponent<StatsHudPanel>();
			_tab = ((Component)this).gameObject.AddComponent<StatsTabOverlay>();
		}

		internal static void RegisterHooks()
		{
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
			GameModeManager.AddHook("GameEnd", (Func<IGameModeHandler, IEnumerator>)OnGameEnd);
			GameModeManager.AddHook("PickStart", (Func<IGameModeHandler, IEnumerator>)OnPickStart);
			GameModeManager.AddHook("PickEnd", (Func<IGameModeHandler, IEnumerator>)OnPickEnd);
			GameModeManager.AddHook("PlayerPickStart", (Func<IGameModeHandler, IEnumerator>)OnPlayerPickStart);
			GameModeManager.AddHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)OnRoundStart);
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)OnBattleStart);
		}

		private static IEnumerator OnGameStart(IGameModeHandler gm)
		{
			MatchSessionActive = true;
			CurrentRound = 0;
			CurrentPoint = 0;
			InPickPhase = false;
			InBattlePhase = false;
			Instance?._tab?.SetOpen(open: false);
			Instance?.ClearPickBaselines();
			yield break;
		}

		private static IEnumerator OnGameEnd(IGameModeHandler gm)
		{
			MatchSessionActive = false;
			InPickPhase = false;
			InBattlePhase = false;
			Instance?._tab?.SetOpen(open: false);
			Instance?.ClearPickBaselines();
			yield break;
		}

		private static IEnumerator OnPickStart(IGameModeHandler gm)
		{
			InPickPhase = true;
			InBattlePhase = false;
			Instance?.CaptureAllPickBaselines();
			yield break;
		}

		private static IEnumerator OnPickEnd(IGameModeHandler gm)
		{
			InPickPhase = false;
			Instance?.ClearPreview();
			yield break;
		}

		private static IEnumerator OnPlayerPickStart(IGameModeHandler gm)
		{
			Instance?.CapturePickBaseline();
			Instance?.ClearPreview();
			yield return null;
			Instance?.CapturePickBaseline();
		}

		private static IEnumerator OnRoundStart(IGameModeHandler gm)
		{
			CurrentRound++;
			CurrentPoint = 0;
			InPickPhase = false;
			yield break;
		}

		private static IEnumerator OnPointStart(IGameModeHandler gm)
		{
			CurrentPoint++;
			yield break;
		}

		private static IEnumerator OnBattleStart(IGameModeHandler gm)
		{
			InBattlePhase = true;
			InPickPhase = false;
			yield break;
		}

		private void CapturePickBaseline()
		{
			Player val = PickPhase.GetCurrentPicker() ?? PlayerStatsSnapshot.LocalPlayer();
			if (!((Object)(object)val == (Object)null) && PlayerStatsSnapshot.TryFrom(val, out var snapshot))
			{
				_pickBaselines[val.playerID] = snapshot;
			}
		}

		private void CaptureAllPickBaselines()
		{
			foreach (Player item in PlayerStatsSnapshot.ActivePlayers())
			{
				if (PlayerStatsSnapshot.TryFrom(item, out var snapshot))
				{
					_pickBaselines[item.playerID] = snapshot;
				}
			}
		}

		private void CaptureMissingPickBaselines()
		{
			foreach (Player item in PlayerStatsSnapshot.ActivePlayers())
			{
				if (!_pickBaselines.ContainsKey(item.playerID) && PlayerStatsSnapshot.TryFrom(item, out var snapshot))
				{
					_pickBaselines[item.playerID] = snapshot;
				}
			}
		}

		private void ClearPickBaselines()
		{
			_pickBaselines.Clear();
		}

		private PlayerStatsSnapshot GetPickBaselineFor(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			if (!_pickBaselines.TryGetValue(player.playerID, out var value))
			{
				return null;
			}
			return value;
		}

		internal static Player GetHudPlayer()
		{
			if (InPickPhase && (Object)(object)CardChoice.instance != (Object)null && CardChoice.instance.IsPicking)
			{
				return PickPhase.GetCurrentPicker() ?? PlayerStatsSnapshot.LocalPlayer();
			}
			return PlayerStatsSnapshot.LocalPlayer();
		}

		internal static bool IsWatchingOtherPicker()
		{
			if (!InPickPhase || (Object)(object)CardChoice.instance == (Object)null || !CardChoice.instance.IsPicking)
			{
				return false;
			}
			Player currentPicker = PickPhase.GetCurrentPicker();
			Player val = PlayerStatsSnapshot.LocalPlayer();
			if ((Object)(object)currentPicker == (Object)null || (Object)(object)val == (Object)null)
			{
				return false;
			}
			return currentPicker.playerID != val.playerID;
		}

		internal void NotifyHoveredCard(Player picker, CardInfo cardInfo, CardInfo pickVisual = null)
		{
			if ((Object)(object)picker == (Object)null || (Object)(object)cardInfo == (Object)null)
			{
				ClearPreview();
			}
			else if (!((Object)(object)_hoveredCard == (Object)(object)cardInfo) || !((Object)(object)_hoveredVisual == (Object)(object)pickVisual) || _previewDelta == null)
			{
				_hoveredCard = cardInfo;
				_hoveredVisual = pickVisual;
				if (CardStatPreview.TryPreview(picker, cardInfo, out var delta, pickVisual))
				{
					_previewDelta = delta;
				}
				else
				{
					_previewDelta = null;
				}
				_hud?.SetPreviewDelta(_previewDelta);
				_refreshTimer = 0f;
			}
		}

		internal void ClearPreview()
		{
			bool num = (Object)(object)_hoveredCard != (Object)null || _previewDelta != null;
			_hoveredCard = null;
			_hoveredVisual = null;
			_previewDelta = null;
			_hud?.SetPreviewDelta(null);
			if (num)
			{
				_refreshTimer = 0f;
			}
		}

		internal static bool InActiveMatch()
		{
			if (!HasReadyPlayers())
			{
				return false;
			}
			if (MatchSessionActive)
			{
				return true;
			}
			return IsSandboxMode();
		}

		private static bool HasReadyPlayers()
		{
			if (Time.unscaledTime < _readyCacheUntil)
			{
				return _readyCache;
			}
			List<Player> list = PlayerManager.instance?.players;
			bool flag = false;
			if (list != null && list.Count > 0)
			{
				foreach (Player item in list)
				{
					if ((Object)(object)item?.data?.weaponHandler?.gun != (Object)null && (Object)(object)item.data.block != (Object)null)
					{
						flag = true;
						break;
					}
				}
			}
			_readyCache = flag;
			_readyCacheUntil = Time.unscaledTime + 0.25f;
			return flag;
		}

		private static bool IsSandboxMode()
		{
			try
			{
				if (GameModeManager.CurrentHandler is SandboxHandler)
				{
					return true;
				}
				string currentHandlerID = GameModeManager.CurrentHandlerID;
				if (!string.IsNullOrEmpty(currentHandlerID) && currentHandlerID.IndexOf("Sandbox", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		internal void RebuildHud()
		{
			_hud?.Rebuild();
		}

		internal void RebuildTab()
		{
			_tab?.RebuildLayout();
		}

		private void Update()
		{
			HandleTabToggle();
			HandleHudToggle();
			_tab?.HandleShortcuts();
			PollHoveredCard();
			PingTracker.Tick();
			_refreshTimer -= Time.unscaledDeltaTime;
			if (!(_refreshTimer > 0f))
			{
				_refreshTimer = (((Object)(object)_tab != (Object)null && _tab.IsOpen) ? 0.25f : 0.2f);
				if (InPickPhase)
				{
					CaptureMissingPickBaselines();
				}
				Player hudPlayer = GetHudPlayer();
				_hud?.Refresh(GetPickBaselineFor(hudPlayer), hudPlayer, IsWatchingOtherPicker());
				if ((Object)(object)_tab != (Object)null && _tab.IsOpen)
				{
					_tab.Refresh();
				}
			}
		}

		private static void HandleTabToggle()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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)
			if ((Object)(object)Instance?._tab == (Object)null)
			{
				return;
			}
			if (!InActiveMatch())
			{
				if (Instance._tab.IsOpen)
				{
					Instance._tab.SetOpen(open: false);
				}
				return;
			}
			KeyCode value = Plugin.Configs.StatsTabKey.Value;
			if ((int)value != 0 && Input.GetKeyDown(value))
			{
				Instance._tab.Toggle();
			}
			if (Input.GetKeyDown((KeyCode)27) && Instance._tab.IsOpen)
			{
				Instance._tab.SetOpen(open: false);
			}
		}

		internal static void HandleHudToggle()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance == (Object)null))
			{
				KeyCode value = Plugin.Configs.StatsHudToggleKey.Value;
				if ((int)value != 0 && Input.GetKeyDown(value))
				{
					Plugin.Configs.StatsHudVisible.Value = !Plugin.Configs.StatsHudVisible.Value;
				}
			}
		}

		private void PollHoveredCard()
		{
			if (!InPickPhase)
			{
				if (_previewDelta != null)
				{
					ClearPreview();
				}
				return;
			}
			if ((Object)(object)CardChoice.instance == (Object)null || !CardChoice.instance.IsPicking)
			{
				if (_previewDelta != null)
				{
					ClearPreview();
				}
				return;
			}
			Player currentPicker = PickPhase.GetCurrentPicker();
			CardInfo source;
			CardInfo visual;
			if ((Object)(object)currentPicker == (Object)null)
			{
				if (_previewDelta != null)
				{
					ClearPreview();
				}
			}
			else if (PickPhase.PickerHoldsCardNamed("Blind Draft"))
			{
				if (_previewDelta != null || (Object)(object)_hoveredCard != (Object)null)
				{
					ClearPreview();
				}
			}
			else if (!TryGetHighlightedCard(out source, out visual))
			{
				if (_previewDelta != null || (Object)(object)_hoveredCard != (Object)null)
				{
					ClearPreview();
				}
			}
			else
			{
				NotifyHoveredCard(currentPicker, source, visual);
			}
		}

		private static bool TryGetHighlightedCard(out CardInfo source, out CardInfo visual)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			source = null;
			visual = null;
			CardChoice instance = CardChoice.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			object raw = CurrentlySelectedCardField?.GetValue(instance) ?? CurrentlySelectedCardProp?.GetValue(instance);
			if (TryResolveCard(instance, raw, out source, out visual))
			{
				return true;
			}
			if (!(SpawnedCardsField?.GetValue(instance) is IList list))
			{
				return false;
			}
			CardInfo val = null;
			CardInfo val2 = null;
			float num = 1.04f;
			foreach (object item in list)
			{
				GameObject val3 = (GameObject)((item is GameObject) ? item : null);
				if (val3 == null || (Object)(object)val3 == (Object)null)
				{
					continue;
				}
				CardInfo component = val3.GetComponent<CardInfo>();
				if (!((Object)(object)component == (Object)null))
				{
					CardVisuals componentInChildren = val3.GetComponentInChildren<CardVisuals>(true);
					if ((Object)(object)componentInChildren != (Object)null && (ReadFlag(componentInChildren, IsHoveredField) || ReadFlag(componentInChildren, IsSelectedField)))
					{
						visual = component;
						source = instance.GetSourceCard(component) ?? component.sourceCard ?? component;
						return (Object)(object)source != (Object)null;
					}
					float x = val3.transform.localScale.x;
					if (!(x < num))
					{
						num = x;
						val2 = component;
						val = instance.GetSourceCard(component) ?? component.sourceCard ?? component;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			source = val;
			visual = val2;
			return true;
		}

		private static bool TryResolveCard(CardChoice choice, object raw, out CardInfo source, out CardInfo visual)
		{
			source = null;
			visual = null;
			if (raw == null)
			{
				return false;
			}
			GameObject val = (GameObject)((raw is GameObject) ? raw : null);
			CardInfo val2 = (CardInfo)((raw is CardInfo) ? raw : null);
			if (val2 != null)
			{
				visual = val2;
				if (val == null)
				{
					val = ((Component)val2).gameObject;
				}
			}
			if ((Object)(object)visual == (Object)null && (Object)(object)val != (Object)null)
			{
				visual = val.GetComponent<CardInfo>() ?? val.GetComponentInChildren<CardInfo>();
			}
			if ((Object)(object)visual == (Object)null)
			{
				return false;
			}
			source = choice.GetSourceCard(visual) ?? visual.sourceCard ?? visual;
			return (Object)(object)source != (Object)null;
		}

		private static bool ReadFlag(CardVisuals visuals, FieldInfo field)
		{
			if (field == null || (Object)(object)visuals == (Object)null)
			{
				return false;
			}
			try
			{
				object value = field.GetValue(visuals);
				return value is bool && (bool)value;
			}
			catch
			{
				return false;
			}
		}
	}
	internal sealed class StatsHudPanel : MonoBehaviour
	{
		private const float HorizontalPadding = 12f;

		private const float VerticalPadding = 12f;

		private GameObject _root;

		private TextMeshProUGUI _body;

		private PlayerStatsSnapshot _previewDelta;

		internal void Rebuild()
		{
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
				_body = null;
			}
		}

		internal void EnsureBuilt()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root != (Object)null) && StatsUiHelper.OverlayReady)
			{
				float uiScale = StatsUiHelper.UiScale;
				float num = GetPanelWidth() * uiScale;
				Vector2 anchoredPos = default(Vector2);
				((Vector2)(ref anchoredPos))..ctor(Plugin.Configs.StatsHudOffsetX.Value * uiScale, Plugin.Configs.StatsHudOffsetY.Value * uiScale);
				_root = StatsUiHelper.CreateModernPanel(StatsUiHelper.OverlayRoot, "MM_StatsHud", new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f), anchoredPos, new Vector2(num, 160f * uiScale), 0f);
				Image component = _root.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = new Color(0f, 0f, 0f, 0f);
					((Graphic)component).raycastTarget = false;
				}
				_body = StatsUiHelper.CreateText(_root.transform, "Body", "", StatsUiHelper.BaseFont, (TextAlignmentOptions)257);
				RectTransform rectTransform = ((TMP_Text)_body).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = new Vector2(12f, 12f);
				rectTransform.offsetMax = new Vector2(-12f, -12f);
				((TMP_Text)_body).enableWordWrapping = true;
				((TMP_Text)_body).overflowMode = (TextOverflowModes)0;
				((Graphic)_body).raycastTarget = false;
			}
		}

		internal void SetPreviewDelta(PlayerStatsSnapshot delta)
		{
			_previewDelta = delta;
		}

		internal void Refresh(PlayerStatsSnapshot pickBaseline, Player hudPlayer, bool watchingPicker)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			bool value = Plugin.Configs.StatsHudVisible.Value;
			bool flag = StatsController.InActiveMatch();
			if ((Object)(object)hudPlayer == (Object)null || !PlayerStatsSnapshot.TryFrom(hudPlayer, out var snapshot))
			{
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
				}
				return;
			}
			if (!value || !flag)
			{
				if ((Object)(object)_root != (Object)null)
				{
					_root.SetActive(false);
				}
				return;
			}
			EnsureBuilt();
			if (!((Object)(object)_root == (Object)null) && !((Object)(object)_body == (Object)null))
			{
				_root.SetActive(true);
				((TMP_Text)_body).lineSpacing = 2f;
				((TMP_Text)_body).fontSize = StatsUiHelper.BaseFont;
				((Graphic)_body).color = Color.white;
				((TMP_Text)_body).outlineWidth = 0.35f;
				((TMP_Text)_body).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 0.95f));
				((TMP_Text)_body).fontMaterial.EnableKeyword("OUTLINE_ON");
				bool isCardPickActive = StatsController.IsCardPickActive;
				string text = (watchingPicker ? " · picking" : "");
				if (isCardPickActive && !string.IsNullOrEmpty(StatsController.HoveredCardName))
				{
					text = text + " · " + StatsController.HoveredCardName;
				}
				string text2 = StatsViewBuilder.BuildHud(snapshot, simple: true, isCardPickActive ? null : pickBaseline, isCardPickActive ? _previewDelta : null, null, string.IsNullOrEmpty(text) ? null : text, StatsController.InBattlePhase, isCardPickActive);
				if (((TMP_Text)_body).text != text2)
				{
					((TMP_Text)_body).text = text2;
					LayoutToContent();
				}
			}
		}

		private void LayoutToContent()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			float uiScale = StatsUiHelper.UiScale;
			Vector2 overlaySize = StatsUiHelper.OverlaySize;
			float num = GetPanelWidth() * uiScale;
			float num2 = 0.72f;
			bool visible = false;
			((TMP_Text)_body).ForceMeshUpdate();
			float num3 = Mathf.Max(((TMP_Text)_body).preferredHeight, 36f) + 24f + 6f;
			num3 = Mathf.Min(num3, Mathf.Max(64f, overlaySize.y - 24f));
			num = Mathf.Min(num, Mathf.Max(120f, overlaySize.x - 24f));
			float num4 = Mathf.Clamp(Plugin.Configs.StatsHudOffsetX.Value * uiScale, 8f, Mathf.Max(8f, overlaySize.x - num - 8f));
			float num5 = Mathf.Clamp(Plugin.Configs.StatsHudOffsetY.Value * uiScale, 8f, Mathf.Max(8f, overlaySize.y - num3 - 8f));
			StatsUiHelper.ApplyRect(_root, new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(0f, 0f), new Vector2(num4, num5), new Vector2(num, num3));
			Image component = _root.GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(0.02f, 0.03f, 0.05f, num2);
				((Graphic)component).raycastTarget = false;
			}
			StatsUiHelper.SetAccentVisible(_root, visible);
			Transform val = _root.transform.Find("AccentTop") ?? _root.transform.Find("Accent");
			Transform val2 = _root.transform.Find("AccentBottom");
			if ((Object)(object)val != (Object)null)
			{
				((Graphic)((Component)val).GetComponent<Image>()).color = StatsUiHelper.AccentColor;
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Graphic)((Component)val2).GetComponent<Image>()).color = StatsUiHelper.AccentColor;
			}
		}

		private static float GetPanelWidth()
		{
			return 260f;
		}
	}
	internal sealed class StatsTabOverlay : MonoBehaviour
	{
		private GameObject _root;

		private TextMeshProUGUI _title;

		private TextMeshProUGUI _hint;

		private RectTransform _content;

		private readonly List<TextMeshProUGUI> _playerBlocks = new List<TextMeshProUGUI>();

		private bool _compareMode;

		private int _compareTargetPlayerId = -1;

		private PlayerStatsSnapshot _pinnedLocal;

		private int _pinnedLocalPlayerId = -1;

		internal bool IsOpen { get; private set; }

		internal void EnsureBuilt()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Expected O, but got Unknown
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Expected O, but got Unknown
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Expected O, but got Unknown
			if (!((Object)(object)_root != (Object)null) && StatsUiHelper.OverlayReady)
			{
				ApplyPanelLayout();
				_title = StatsUiHelper.CreateText(_root.transform, "Title", "Player Stats", StatsUiHelper.TitleFont, (TextAlignmentOptions)257, StatsUiHelper.TitleColor);
				RectTransform rectTransform = ((TMP_Text)_title).rectTransform;
				rectTransform.anchorMin = new Vector2(0f, 1f);
				rectTransform.anchorMax = new Vector2(1f, 1f);
				rectTransform.pivot = new Vector2(0f, 1f);
				rectTransform.anchoredPosition = new Vector2(18f, -12f);
				rectTransform.sizeDelta = new Vector2(-18f, 26f);
				_hint = StatsUiHelper.CreateText(_root.transform, "Hint", "", StatsUiHelper.BaseFont * 0.78f, (TextAlignmentOptions)257, StatsUiHelper.HintColor);
				RectTransform rectTransform2 = ((TMP_Text)_hint).rectTransform;
				rectTransform2.anchorMin = new Vector2(0f, 1f);
				rectTransform2.anchorMax = new Vector2(1f, 1f);
				rectTransform2.pivot = new Vector2(0f, 1f);
				rectTransform2.anchoredPosition = new Vector2(18f, -36f);
				rectTransform2.sizeDelta = new Vector2(-18f, 16f);
				RectTransform component = ((Component)StatsUiHelper.CreateGhostButton(_root.transform, "Close", (UnityAction)delegate
				{
					SetOpen(open: false);
				}, new Vector2(72f, 24f))).GetComponent<RectTransform>();
				component.anchorMin = new Vector2(1f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(1f, 1f);
				component.anchoredPosition = new Vector2(-14f, -12f);
				RectTransform component2 = ((Component)StatsUiHelper.CreateGhostButton(_root.transform, "Compare", new UnityAction(ToggleCompareMode), new Vector2(78f, 24f))).GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(1f, 1f);
				component2.anchorMax = new Vector2(1f, 1f);
				component2.pivot = new Vector2(1f, 1f);
				component2.anchoredPosition = new Vector2(-92f, -12f);
				GameObject val = new GameObject("Scroll", new Type[3]
				{
					typeof(RectTransform),
					typeof(ScrollRect),
					typeof(Image)
				});
				val.transform.SetParent(_root.transform, false);
				RectTransform component3 = val.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0f, 0f);
				component3.anchorMax = new Vector2(1f, 1f);
				component3.offsetMin = new Vector2(8f, 10f);
				component3.offsetMax = new Vector2(-8f, -56f);
				Image component4 = val.GetComponent<Image>();
				((Graphic)component4).color = new Color(1f, 1f, 1f, 0f);
				((Graphic)component4).raycastTarget = false;
				GameObject val2 = new GameObject("Viewport", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Mask)
				});
				val2.transform.SetParent(val.transform, false);
				RectTransform component5 = val2.GetComponent<RectTransform>();
				component5.anchorMin = Vector2.zero;
				component5.anchorMax = Vector2.one;
				component5.offsetMin = Vector2.zero;
				component5.offsetMax = Vector2.zero;
				Image component6 = val2.GetComponent<Image>();
				((Graphic)component6).color = new Color(1f, 1f, 1f, 0.01f);
				((Graphic)component6).raycastTarget = true;
				val2.GetComponent<Mask>().showMaskGraphic = false;
				GameObject val3 = new GameObject("Content", new Type[3]
				{
					typeof(RectTransform),
					typeof(VerticalLayoutGroup),
					typeof(ContentSizeFitter)
				});
				val3.transform.SetParent(val2.transform, false);
				_content = val3.GetComponent<RectTransform>();
				_content.anchorMin = new Vector2(0f, 1f);
				_content.anchorMax = new Vector2(1f, 1f);
				_content.pivot = new Vector2(0.5f, 1f);
				_content.anchoredPosition = Vector2.zero;
				_content.sizeDelta = new Vector2(0f, 0f);
				VerticalLayoutGroup component7 = val3.GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component7).spacing = 8f;
				((LayoutGroup)component7).padding = new RectOffset(10, 10, 4, 8);
				((HorizontalOrVerticalLayoutGroup)component7).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component7).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component7).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component7).childForceExpandWidth = true;
				((LayoutGroup)component7).childAlignment = (TextAnchor)0;
				val3.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
				ScrollRect component8 = val.GetComponent<ScrollRect>();
				component8.viewport = component5;
				component8.content = _content;
				component8.horizontal = false;
				component8.vertical = true;
				component8.scrollSensitivity = 28f;
				component8.movementType = (MovementType)2;
				component8.verticalScrollbar = null;
				component8.horizontalScrollbar = null;
				component8.inertia = true;
				Image component9 = _root.GetComponent<Image>();
				if ((Object)(object)component9 != (Object)null)
				{
					((Graphic)component9).raycastTarget = false;
				}
				AddDragHandles();
				_root.SetActive(false);
			}
		}

		internal void RebuildLayout()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root == (Object)null))
			{
				ApplyPanelLayout();
				Image component = _root.GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					StatsUiHelper.ApplyRounded(component, StatsUiHelper.PanelColor);
					((Graphic)component).raycastTarget = false;
				}
				StatsUiHelper.SetAccentVisible(_root, visible: false);
			}
		}

		private void ApplyPanelLayout()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (StatsUiHelper.OverlayReady)
			{
				Vector2 overlaySize = StatsUiHelper.OverlaySize;
				float num = 16f;
				float num2 = Mathf.Clamp(Plugin.Configs.TabPanelWidth.Value, 280f, Mathf.Min(640f, overlaySize.x * 0.55f));
				float num3 = Mathf.Min(overlaySize.y * 0.74f, overlaySize.y - num * 2f);
				Vector2 savedOrDefaultPosition = GetSavedOrDefaultPosition(overlaySize, num2, num3);
				if ((Object)(object)_root == (Object)null)
				{
					_root = StatsUiHelper.CreateGlassPanel(StatsUiHelper.OverlayRoot, "MM_StatsTab", savedOrDefaultPosition, new Vector2(num2, num3), StatsUiHelper.PanelColor.a);
				}
				else
				{
					StatsUiHelper.ApplyRect(_root, Vector2.zero, Vector2.zero, Vector2.zero, savedOrDefaultPosition, new Vector2(num2, num3));
				}
			}
		}

		private static Vector2 GetSavedOrDefaultPosition(Vector2 canvas, float width, float height)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Configs.TabPosX.Value < 0f || Plugin.Configs.TabPosY.Value < 0f)
			{
				return new Vector2((canvas.x - width) * 0.5f, (canvas.y - height) * 0.5f);
			}
			return new Vector2(Mathf.Clamp(Plugin.Configs.TabPosX.Value, 8f, Mathf.Max(8f, canvas.x - width - 8f)), Mathf.Clamp(Plugin.Configs.TabPosY.Value, 8f, Mathf.Max(8f, canvas.y - height - 8f)));
		}

		private void AddDragHandles()
		{
			//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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root == (Object)null) && !((Object)(object)_root.transform.Find("HeaderDrag") != (Object)null))
			{
				RectTransform component = _root.GetComponent<RectTransform>();
				GameObject val = new GameObject("HeaderDrag", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(OverlayDrag)
				});
				val.transform.SetParent(_root.transform, false);
				val.transform.SetSiblingIndex(0);
				RectTransform component2 = val.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 1f);
				component2.anchorMax = new Vector2(1f, 1f);
				component2.pivot = new Vector2(0.5f, 1f);
				component2.anchoredPosition = Vector2.zero;
				component2.sizeDelta = new Vector2(0f, 58f);
				Image component3 = val.GetComponent<Image>();
				((Graphic)component3).color = new Color(1f, 1f, 1f, 0.01f);
				((Graphic)component3).raycastTarget = true;
				val.GetComponent<OverlayDrag>().Target = component;
				GameObject val2 = new GameObject("Resize", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(OverlayDrag)
				});
				val2.transform.SetParent(_root.transform, false);
				RectTransform component4 = val2.GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0f, 0f);
				component4.anchorMax = new Vector2(0f, 1f);
				component4.pivot = new Vector2(0f, 0.5f);
				component4.offsetMin = new Vector2(0f, 0f);
				component4.offsetMax = new Vector2(12f, -58f);
				Image component5 = val2.GetComponent<Image>();
				((Graphic)component5).color = new Color(1f, 1f, 1f, 0.01f);
				((Graphic)component5).raycastTarget = true;
				OverlayDrag component6 = val2.GetComponent<OverlayDrag>();
				component6.Target = component;
				component6.ResizeWidth = true;
				Transform obj = _root.transform.Find("Close_Btn");
				if (obj != null)
				{
					obj.SetAsLastSibling();
				}
				Transform obj2 = _root.transform.Find("Compare_Btn");
				if (obj2 != null)
				{
					obj2.SetAsLastSibling();
				}
			}
		}

		internal void SetOpen(bool open)
		{
			bool flag = open && StatsController.InActiveMatch();
			if (flag)
			{
				EnsureBuilt();
			}
			IsOpen = flag;
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(flag);
			}
			if (flag)
			{
				RebuildLayout();
				EnsureCompareTarget();
				Refresh();
			}
		}

		internal void Toggle()
		{
			SetOpen(!IsOpen);
		}

		internal void ToggleCompareMode()
		{
			_compareMode = !_compareMode;
			EnsureCompareTarget();
			Refresh();
		}

		internal void CycleCompareTarget(int direction)
		{
			if (!_compareMode)
			{
				return;
			}
			List<Player> otherPlayers = GetOtherPlayers();
			if (otherPlayers.Count != 0)
			{
				int num = otherPlayers.FindIndex((Player p) => p.playerID == _compareTargetPlayerId);
				if (num < 0)
				{
					num = 0;
				}
				num = (num + direction + otherPlayers.Count) % otherPlayers.Count;
				_compareTargetPlayerId = otherPlayers[num].playerID;
				Refresh();
			}
		}

		internal void PinLocalBaseline()
		{
			Player val = PlayerStatsSnapshot.LocalPlayer();
			if (!((Object)(object)val == (Object)null) && PlayerStatsSnapshot.TryFrom(val, out var snapshot))
			{
				_pinnedLocal = snapshot;
				_pinnedLocalPlayerId = val.playerID;
			}
		}

		internal void ResetPinnedBaseline()
		{
			_pinnedLocal = null;
			_pinnedLocalPlayerId = -1;
		}

		internal void HandleShortcuts()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!IsOpen)
			{
				return;
			}
			KeyCode value = Plugin.Configs.TabCompareKey.Value;
			if ((int)value != 0 && Input.GetKeyDown(value))
			{
				ToggleCompareMode();
			}
			if (_compareMode)
			{
				if (Input.GetKeyDown((KeyCode)91) || Input.GetKeyDown((KeyCode)44))
				{
					CycleCompareTarget(-1);
				}
				if (Input.GetKeyDown((KeyCode)93) || Input.GetKeyDown((KeyCode)46))
				{
					CycleCompareTarget(1);
				}
			}
			if (Input.GetKeyDown((KeyCode)112))
			{
				PinLocalBaseline();
			}
			if (Input.GetKeyDown((KeyCode)8) || Input.GetKeyDown((KeyCode)127))
			{
				ResetPinnedBaseline();
			}
		}

		internal void Refresh()
		{
			if (!((Object)(object)_root == (Object)null) && _root.activeSelf)
			{
				if (_compareMode)
				{
					RefreshCompareView();
				}
				else
				{
					RefreshAllPlayersView();
				}
			}
		}

		private void RefreshAllPlayersView()
		{
			List<Player> list = new List<Player>();
			foreach (Player item in PlayerStatsSnapshot.ActivePlayers())
			{
				list.Add(item);
			}
			EnsureBlockCount(list.Count);
			bool flag = false;
			for (int i = 0; i < _playerBlocks.Count; i++)
			{
				bool flag2 = i < list.Count;
				GameObject gameObject = ((Component)((TMP_Text)_playerBlocks[i]).transform.parent).gameObject;
				if (gameObject.activeSelf != flag2)
				{
					gameObject.SetActive(flag2);
					flag = true;
				}
				if (flag2)
				{
					if (!PlayerStatsSnapshot.TryFrom(list[i], out var snapshot))
					{
						flag |= AssignBlockText(_playerBlocks[i], "Unavailable");
						continue;
					}
					PlayerStatsSnapshot pinnedBaselineFor = GetPinnedBaselineFor(list[i]);
					string text = ((pinnedBaselineFor != null) ? StatsViewBuilder.BuildHud(snapshot, simple: false, pinnedBaselineFor, null, TabInfoBridge.GetExtensionStats(list[i])) : StatsViewBuilder.BuildTabBlock(snapshot, TabInfoBridge.GetExtensionStats(list[i])));
					flag |= AssignBlockText(_playerBlocks[i], text);
				}
			}
			if (flag)
			{
				RelayoutBlocks();
			}
			((TMP_Text)_title).text = FormatAllPlayersTitle();
			((TMP_Text)_hint).text = "Drag the header to move";
		}

		private void RefreshCompareView()
		{
			Player val = PlayerStatsSnapshot.LocalPlayer();
			if ((Object)(object)val == (Object)null)
			{
				using IEnumerator<Player> enumerator = PlayerStatsSnapshot.ActivePlayers().GetEnumerator();
				if (enumerator.MoveNext())
				{
					val = enumerator.Current;
				}
			}
			List<Player> otherPlayers = GetOtherPlayers();
			Player val2 = otherPlayers.Find((Player p) => p.playerID == _compareTargetPlayerId) ?? ((otherPlayers.Count > 0) ? otherPlayers[0] : null);
			if ((Object)(object)val2 != (Object)null)
			{
				_compareTargetPlayerId = val2.playerID;
			}
			EnsureBlockCount((!((Object)(object)val2 != (Object)null)) ? 1 : 2);
			for (int num = 0; num < _playerBlocks.Count; num++)
			{
				((Component)((TMP_Text)_playerBlocks[num]).transform.parent).gameObject.SetActive(num < ((!((Object)(object)val2 != (Object)null)) ? 1 : 2));
			}
			PlayerStatsSnapshot snapshot2;
			if ((Object)(object)val == (Object)null || !PlayerStatsSnapshot.TryFrom(val, out var snapshot))
			{
				AssignBlockText(_playerBlocks[0], "Local player unavailable");
				RelayoutBlocks();
				((TMP_Text)_title).text = "Compare";
				((TMP_Text)_hint).text = "No local player";
			}
			else if ((Object)(object)val2 == (Object)null || !PlayerStatsSnapshot.TryFrom(val2, out snapshot2))
			{
				AssignBlockText(_playerBlocks[0], StatsViewBuilder.BuildTabBlock(snapshot, TabInfoBridge.GetExtensionStats(val)));
				RelayoutBlocks();
				((TMP_Text)_title).text = "Compare";
				((TMP_Text)_hint).text = "Need another player to compare";
			}
			else
			{
				PlayerStatsSnapshot opponent = snapshot2;
				PlayerStatsSnapshot pinnedLocal = ((_pinnedLocal != null && _pinnedLocalPlayerId == val.playerID) ? _pinnedLocal : null);
				AssignBlockText(_playerBlocks[0], StatsViewBuilder.BuildTabCompare(snapshot, opponent, pinnedLocal, TabInfoBridge.GetExtensionStats(val)));
				AssignBlockText(_playerBlocks[1], StatsViewBuilder.BuildTabBlock(snapshot2, TabInfoBridge.GetExtensionStats(val2)));
				RelayoutBlocks();
				((TMP_Text)_title).text = "You vs " + snapshot2.PlayerName;
				((TMP_Text)_hint).text = "[ ] switch player · C back to all";
			}
		}

		private static string FormatAllPlayersTitle()
		{
			string text = $"All players · R{StatsController.CurrentRound} P{StatsController.CurrentPoint}";
			int num = PingTracker.LocalPing();
			if (num < 0)
			{
				return text;
			}
			return $"{text} · you {num}ms";
		}

		private static bool AssignBlockText(TextMeshProUGUI block, string text)
		{
			if ((Object)(object)block == (Object)null)
			{
				return false;
			}
			((TMP_Text)block).lineSpacing = 4f;
			if (((TMP_Text)block).text == text)
			{
				return false;
			}
			((TMP_Text)block).text = text;
			return true;
		}

		private PlayerStatsSnapshot GetPinnedBaselineFor(Player player)
		{
			Player val = PlayerStatsSnapshot.LocalPlayer();
			if ((Object)(object)val == (Object)null || player.playerID != val.playerID)
			{
				return null;
			}
			if (_pinnedLocal == null || _pinnedLocalPlayerId != val.playerID)
			{
				return null;
			}
			return _pinnedLocal;
		}

		private void EnsureCompareTarget()
		{
			if (_compareMode)
			{
				List<Player> otherPlayers = GetOtherPlayers();
				if (otherPlayers.Count == 0)
				{
					_compareTargetPlayerId = -1;
				}
				else if (otherPlayers.All((Player p) => p.playerID != _compareTargetPlayerId))
				{
					_compareTargetPlayerId = otherPlayers[0].playerID;
				}
			}
		}

		private static List<Player> GetOtherPlayers()
		{
			Player val = PlayerStatsSnapshot.LocalPlayer();
			List<Player> list = new List<Player>();
			foreach (Player item in PlayerStatsSnapshot.ActivePlayers())
			{
				if (!((Object)(object)val != (Object)null) || item.playerID != val.playerID)
				{
					list.Add(item);
				}
			}
			if ((Object)(object)val == (Object)null && list.Count > 1)
			{
				list.RemoveAt(0);
			}
			return list;
		}

		private void EnsureBlockCount(int count)
		{
			//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_0070: 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_0096: 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_00bf: 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_00d0: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			while (_playerBlocks.Count < count)
			{
				GameObject val = new GameObject($"Player_{_playerBlocks.Count}", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(LayoutElement)
				});
				val.transform.SetParent((Transform)(object)_content, false);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
				component.sizeDelta = new Vector2(0f, 120f);
				Image component2 = val.GetComponent<Image>();
				StatsUiHelper.ApplyRounded(component2, StatsUiHelper.BlockColor);
				((Graphic)component2).raycastTarget = false;
				LayoutElement component3 = val.GetComponent<LayoutElement>();
				component3.minHeight = 96f;
				component3.preferredHeight = 120f;
				component3.flexibleWidth = 1f;
				component3.flexibleHeight = 0f;
				TextMeshProUGUI val2 = StatsUiHelper.CreateText(val.transform, "Text", "", StatsUiHelper.BaseFont, (TextAlignmentOptions)257);
				((TMP_Text)val2).enableWordWrapping = true;
				((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
				((TMP_Text)val2).lineSpacing = 4f;
				((TMP_Text)val2).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)val2).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)val2).rectTransform.offsetMin = new Vector2(10f, 8f);
				((TMP_Text)val2).rectTransform.offsetMax = new Vector2(-10f, -8f);
				_playerBlocks.Add(val2);
			}
		}

		private void RelayoutBlocks()
		{
			if ((Object)(object)_content == (Object)null)
			{
				return;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
			foreach (TextMeshProUGUI playerBlock in _playerBlocks)
			{
				if (!((Object)(object)playerBlock == (Object)null) && ((Component)playerBlock).gameObject.activeInHierarchy)
				{
					UpdateBlockHeight(((Component)((TMP_Text)playerBlock).transform.parent).gameObject, playerBlock);
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(_content);
		}

		private static void UpdateBlockHeight(GameObject block, TextMeshProUGUI text)
		{
			((TMP_Text)text).ForceMeshUpdate();
			LayoutElement component = block.GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				float preferredHeight = (component.minHeight = Mathf.Max(96f, ((TMP_Text)text).preferredHeight + 20f));
				component.preferredHeight = preferredHeight;
			}
		}
	}
	internal static class StatsUiHelper
	{
		private static Canvas _overlay;

		private static Sprite _roundedSprite;

		internal static float UiScale => 1f;

		internal static float BaseFont => 13.5f * UiScale;

		internal static float HeaderFont => 15f * UiScale;

		internal static float TitleFont => 18f * UiScale;

		internal static float HeroFont => 15.5f * UiScale;

		internal static Color AccentColor => new Color(0.78f, 0.8f, 0.84f);

		internal static Color TitleColor => new Color(0.93f, 0.94f, 0.96f, 0.98f);

		internal static Color HintColor => new Color(0.84f, 0.87f, 0.92f, 0.96f);

		internal static Color PanelColor => new Color(0.07f, 0.08f, 0.1f, 0.9f);

		internal static Color BlockColor => new Color(1f, 1f, 1f, 0.04f);

		internal static Color ButtonFill => new Color(1f, 1f, 1f, 0.07f);

		internal static Transform OverlayRoot
		{
			get
			{
				EnsureOverlayCanvas();
				return ((Component)_overlay).transform;
			}
		}

		internal static Vector2 OverlaySize
		{
			get
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: 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_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				EnsureOverlayCanvas();
				Rect rect = ((Component)_overlay).GetComponent<RectTransform>().rect;
				Vector2 size = ((Rect)(ref rect)).size;
				if (size.x < 8f || size.y < 8f)
				{
					return new Vector2(1920f, 1080f);
				}
				return size;
			}
		}

		internal static bool OverlayReady
		{
			get
			{
				EnsureOverlayCanvas();
				return (Object)(object)_overlay != (Object)null;
			}
		}

		internal static Sprite RoundedSprite
		{
			get
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_roundedSprite != (Object)null)
				{
					return _roundedSprite;
				}
				Texture2D val = new Texture2D(64, 64, (TextureFormat)5, false)
				{
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)1
				};
				Color[] array = (Color[])(object)new Color[4096];
				for (int i = 0; i < 64; i++)
				{
					for (int j = 0; j < 64; j++)
					{
						array[i * 64 + j] = new Color(1f, 1f, 1f, RoundedAlpha((float)j + 0.5f, (float)i + 0.5f, 64, 14));
					}
				}
				val.SetPixels(array);
				val.Apply(false, false);
				_roundedSprite = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(14f, 14f, 14f, 14f));
				((Object)_roundedSprite).name = "MM_RoundedPanel";
				return _roundedSprite;
			}
		}

		private static void EnsureOverlayCanvas()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_overlay != (Object)null))
			{
				GameObject val = new GameObject("MM_StatsOverlay", new Type[4]
				{
					typeof(RectTransform),
					typeof(Canvas),
					typeof(CanvasScaler),
					typeof(GraphicRaycaster)
				});
				Object.DontDestroyOnLoad((Object)val);
				_overlay = val.GetComponent<Canvas>();
				_overlay.renderMode = (RenderMode)0;
				_overlay.sortingOrder = 300;
				_overlay.pixelPerfect = false;
				CanvasScaler component = val.GetComponent<CanvasScaler>();
				component.uiScaleMode = (ScaleMode)1;
				component.referenceResolution = new Vector2(1920f, 1080f);
				component.screenMatchMode = (ScreenMatchMode)0;
				component.matchWidthOrHeight = 1f;
			}
		}

		private static float RoundedAlpha(float x, float y, int size, int radius)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			int num = size - radius;
			int num2 = size - radius;
			if (x >= (float)radius && x <= (float)num)
			{
				if (!(x >= 0f) || !(x <= (float)size) || !(y >= 0f) || !(y <= (float)size))
				{
					return 0f;
				}
				return 1f;
			}
			if (y >= (float)radius && y <= (float)num2)
			{
				if (!(x >= 0f) || !(x <= (float)size) || !(y >= 0f) || !(y <= (float)size))
				{
					return 0f;
				}
				return 1f;
			}
			int num3 = ((x < (float)radius) ? radius : num);
			int num4 = ((y < (float)radius) ? radius : num2);
			float num5 = Vector2.Distance(new Vector2(x, y), new Vector2((float)num3, (float)num4));
			return Mathf.Clamp01((float)radius - num5 + 0.5f);
		}

		internal static void ApplyRounded(Image image, Color color)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				image.sprite = RoundedSprite;
				image.type = (Type)1;
				((Graphic)image).color = color;
			}
		}

		internal static GameObject CreateModernPanel(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPos, Vector2 sizeDelta, float alpha = 0.88f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePanel(parent, name, anchorMin, anchorMax, pivot, anchoredPos, sizeDelta, new Color(0.05f, 0.07f, 0.1f), alpha);
			CreateAccentBar(obj.transform, "AccentTop", top: true);
			CreateAccentBar(obj.transform, "AccentBottom", top: false);
			return obj;
		}

		internal static GameObject CreateGlassPanel(Transform parent, string name, Vector2 anchoredPos, Vector2 sizeDelta, float alpha = 0.9f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_002f: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePanel(parent, name, Vector2.zero, Vector2.zero, Vector2.zero, anchoredPos, sizeDelta, PanelColor, alpha);
			ApplyRounded(obj.GetComponent<Image>(), new Color(PanelColor.r, PanelColor.g, PanelColor.b, alpha));
			((Graphic)obj.GetComponent<Image>()).raycastTarget = false;
			return obj;
		}

		internal static void SetAccentVisible(GameObject root, bool visible)
		{
			if (!((Object)(object)root == (Object)null))
			{
				Transform val = root.transform.Find("AccentTop") ?? root.transform.Find("Accent");
				Transform val2 = root.transform.Find("AccentBottom");
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(visible);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(visible);
				}
			}
		}

		private static void CreateAccentBar(Transform parent, string name, bool top)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00c0: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			if (top)
			{
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
			}
			else
			{
				component.anchorMin = new Vector2(0f, 0f);
				component.anchorMax = new Vector2(1f, 0f);
				component.pivot = new Vector2(0.5f, 0f);
			}
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(0f, 3f);
			((Graphic)val.GetComponent<Image>()).color = AccentColor;
			((Graphic)val.GetComponent<Image>()).raycastTarget = false;
		}

		internal static GameObject CreatePanel(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPos, Vector2 sizeDelta, Color bg, float alpha = 0.82f)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.pivot = pivot;
			component.anchoredPosition = anchoredPos;
			component.sizeDelta = sizeDelta;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = new Color(bg.r, bg.g, bg.b, alpha);
			((Graphic)component2).raycastTarget = false;
			return val;
		}

		internal static TextMeshProUGUI CreateText(Transform parent, string name, string text, float fontSize, TextAlignmentOptions align = (TextAlignmentOptions)257, Color? color = null)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component2).text = text;
			((TMP_Text)component2).fontSize = fontSize;
			((TMP_Text)component2).alignment = align;
			((Graphic)component2).color = (Color)(((??)color) ?? Color.white);
			((Graphic)component2).raycastTarget = false;
			((TMP_Text)component2).richText = true;
			((TMP_Text)component2).enableWordWrapping = true;
			((TMP_Text)component2).lineSpacing = 0f;
			((TMP_Text)component2).overflowMode = (TextOverflowModes)0;
			return component2;
		}

		internal static Button CreateButton(Transform parent, string label, UnityAction onClick, Vector2 size)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return CreateGhostButton(parent, label, onClick, size);
		}

		internal static Button CreateGhostButton(Transform parent, string label, UnityAction onClick, Vector2 size)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(label + "_Btn", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = size;
			Image component = val.GetComponent<Image>();
			ApplyRounded(component, ButtonFill);
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			ColorBlock colors = ((Selectable)component2).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.85f, 0.85f, 0.85f, 1f);
			((Selectable)component2).colors = colors;
			((UnityEvent)component2.onClick).AddListener(onClick);
			CreateText(val.transform, "Label", label, BaseFont * 0.88f, (TextAlignmentOptions)514, (Color?)new Color(0.86f, 0.88f, 0.91f, 0.95f));
			return component2;
		}

		internal static void ApplyRect(GameObject root, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPos, Vector2 sizeDelta)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)root == (Object)null))
			{
				RectTransform component = root.GetComponent<RectTransform>();
				component.anchorMin = anchorMin;
				component.anchorMax = anchorMax;
				component.pivot = pivot;
				component.anchoredPosition = anchoredPos;
				component.sizeDelta = sizeDelta;
			}
		}
	}
	internal static class StatsViewBuilder
	{
		private static readonly Color LabelColor = new Color(1f, 1f, 1f, 1f);

		private static readonly Color ValueColor = new Color(1f, 1f, 1f, 1f);

		private static readonly Color SectionColor = new Color(0.94f, 0.95f, 0.97f, 1f);

		private static readonly (string label, string key)[] PreviewExtraStats = new(string, string)[12]
		{
			("Lives", "Lives"),
			("Regen", "Regen"),
			("Blocks", "BlockCount"),
			("Projectiles", "Bullets"),
			("Knockback", "Knockback"),
			("Life Steal", "LifeSteal"),
			("Jump", "Jump"),
			("Size", "Size"),
			("Bullet SPD", "BulletSPD"),
			("Range", "Range"),
			("Bursts", "Bursts"),
			("Gravity", "Gravity")
		};

		internal static string BuildHud(PlayerStatsSnapshot snap, bool simple, PlayerStatsSnapshot baseline, PlayerStatsSnapshot preview, IEnumerable<(string category, string label, string value)> extensions, string headerSuffix = null, bool omitHealthDelta = false, bool pickHoverMode = false)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string value = (string.IsNullOrEmpty(headerSuffix) ? "" : headerSuffix);
			stringBuilder.Append("<size=105%><b>").Append(snap.PlayerName).Append(value)
				.Append("</b>");
			AppendPing(stringBuilder, snap.PingMs);
			stringBuilder.Append("</size>").AppendLine();
			PlayerStatsSnapshot baseline2 = (omitHealthDelta ? null : baseline);
			AppendHeroRow(stringBuilder, "HP", snap.GetDisplay("HP"), snap, baseline2, preview, isHero: true, pickHoverMode);
			AppendHeroRow(stringBuilder, "DMG", snap.GetDisplay("DMG"), snap, baseline, preview, isHero: true, pickHoverMode);
			if (HasCount(snap, "Nulls"))
			{
				AppendRow(stringBuilder, "Nulls", snap.GetDisplay("Nulls"), "Nulls", snap, baseline, preview, pickHoverMode);
			}
			if (HasCount(snap, "NullCards"))
			{
				AppendRow(stringBuilder, "Null cards", snap.GetDisplay("NullCards"), "NullCards", snap, baseline, preview, pickHoverMode);
			}
			if (!simple)
			{
				AppendSection(stringBuilder, "Survival");
				AppendRow(stringBuilder, "Lives", snap.GetDisplay("Lives"), "Lives", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Block CD", snap.GetDisplay("BlockCD"), "BlockCD", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Blocks", snap.GetDisplay("BlockCount"), "BlockCount", snap, baseline, preview, pickHoverMode);
				if (HasCount(snap, "Regen"))
				{
					AppendRow(stringBuilder, "Regen", snap.GetDisplay("Regen"), "Regen", snap, baseline, preview, pickHoverMode);
				}
			}
			else
			{
				AppendRow(stringBuilder, "Block CD", snap.GetDisplay("BlockCD"), "BlockCD", snap, baseline, preview, pickHoverMode);
				if (HasNonDefault(snap, "BlockCount", 1f))
				{
					AppendRow(stringBuilder, "Blocks", snap.GetDisplay("BlockCount"), "BlockCount", snap, baseline, preview, pickHoverMode);
				}
				if (HasCount(snap, "Regen"))
				{
					AppendRow(stringBuilder, "Regen", snap.GetDisplay("Regen"), "Regen", snap, baseline, preview, pickHoverMode);
				}
			}
			AppendSection(stringBuilder, "Combat");
			AppendRow(stringBuilder, "Attack SPD", snap.GetDisplay("AttackSPD"), "AttackSPD", snap, baseline, preview, pickHoverMode);
			AppendRow(stringBuilder, "Reload", snap.GetDisplay("Reload"), "Reload", snap, baseline, preview, pickHoverMode);
			if (simple)
			{
				AppendRow(stringBuilder, "Ammo", snap.GetDisplay("Ammo"), "Ammo", snap, baseline, preview, pickHoverMode);
				if (HasNonDefaultProjectiles(snap))
				{
					AppendRow(stringBuilder, "Projectiles", snap.GetDisplay("Bullets"), "Bullets", snap, baseline, preview, pickHoverMode);
				}
				AppendRow(stringBuilder, "Bounces", snap.GetDisplay("Bounces"), "Bounces", snap, baseline, preview, pickHoverMode);
				if (HasNonDefault(snap, "Knockback", 1f))
				{
					AppendRow(stringBuilder, "Knockback", snap.GetDisplay("Knockback"), "Knockback", snap, baseline, preview, pickHoverMode);
				}
			}
			else
			{
				AppendRow(stringBuilder, "Projectiles", snap.GetDisplay("Bullets"), "Bullets", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Knockback", snap.GetDisplay("Knockback"), "Knockback", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Life Steal", snap.GetDisplay("LifeSteal"), "LifeSteal", snap, baseline, preview, pickHoverMode);
			}
			AppendSection(stringBuilder, "Mobility");
			AppendRow(stringBuilder, "Move SPD", snap.GetDisplay("MoveSPD"), "MoveSPD", snap, baseline, preview, pickHoverMode);
			if (!simple)
			{
				AppendRow(stringBuilder, "Jump", snap.GetDisplay("Jump"), "Jump", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Size", snap.GetDisplay("Size"), "Size", snap, baseline, preview, pickHoverMode);
			}
			if (!simple)
			{
				AppendSection(stringBuilder, "Projectile");
				AppendRow(stringBuilder, "Bullet SPD", snap.GetDisplay("BulletSPD"), "BulletSPD", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Ammo", snap.GetDisplay("Ammo"), "Ammo", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Range", snap.GetDisplay("Range"), "Range", snap, baseline, preview, pickHoverMode);
				AppendRow(stringBuilder, "Bounces", snap.GetDisplay("Bounces"), "Bounces", snap, baseline, preview, pickHoverMode);
			}
			if (pickHoverMode && simple)
			{
				AppendPreviewExtras(stringBuilder, snap, preview);
			}
			if (extensions != null)
			{
				string text = null;
				foreach (var extension in extensions)
				{
					if (!IsNullStat(extension.label))
					{
						if (extension.category != text)
						{
							AppendSection(stringBuilder, extension.category);
							(text, _, _) = extension;
						}
						stringBuilder.Append(Label(extension.label)).Append("  ").Append(Value(extension.value))
							.AppendLine();
					}
				}
			}
			return stringBuilder.ToString().Trim();
		}

		internal static string BuildCompareColumn(PlayerStatsSnapshot snap, PlayerStatsSnapshot baseline)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<size=108%><b>").Append(snap.PlayerName).Append("</b>");
			AppendPing(stringBuilder, snap.PingMs);
			stringBuilder.Append("</size>").AppendLine();
			AppendHeroRow(stringBuilder, "HP", snap.GetDisplay("HP"), snap, baseline, null, isHero: true);
			AppendHeroRow(stringBuilder, "DMG", snap.GetDisplay("DMG"), snap, baseline, null, isHero: true);
			if (HasCount(snap, "Nulls"))
			{
				AppendRow(stringBuilder, "Nulls", snap.GetDisplay("Nulls"), "Nulls", snap, baseline, null);
			}
			if (HasCount(snap, "NullCards"))
			{
				AppendRow(stringBuilder, "Null cards", snap.GetDisplay("NullCards"), "NullCards", snap, baseline, null);
			}
			AppendRow(stringBuilder, "Block", snap.GetDisplay("BlockCD"), "BlockCD", snap, baseline, null);
			AppendRow(stringBuilder, "Move", snap.GetDisplay("MoveSPD"), "MoveSPD", snap, baseline, null);
			AppendRow(stringBuilder, "Atk", snap.GetDisplay("AttackSPD"), "AttackSPD", snap, baseline, null);
			return stringBuilder.ToString().Trim();
		}

		internal static string BuildTabCompare(PlayerStatsSnapshot local, PlayerStatsSnapshot opponent, PlayerStatsSnapshot pinnedLocal, IEnumerable<(string category, string label, string value)> extensions)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("<size=108%><b>You vs " + opponent.PlayerName + "</b></size>");
			stringBuilder.AppendLine("<size=82%><color=#9AA8B5>Numbers in ( ) compare you to their current build</color></size>");
			stringBuilder.AppendLine();
			stringBuilder.Append(BuildHud(local, simple: false, opponent, null, extensions));
			if (pinnedLocal != null)
			{
				stringBuilder.AppendLine();
				stringBuilder.AppendLine("<size=88%><color=#9AA8B5>Since your pin</color></size>");
				stringBuilder.Append(BuildHud(local, simple: true, pinnedLocal, null, null));
			}
			return stringBuilder.ToString().Trim();
		}

		internal static string BuildTabBlock(PlayerStatsSnapshot snap, IEnumerable<(string category, string label, string value)> extensions)
		{
			return BuildHud(snap, simple: false, null, null, extensions);
		}

		private static bool HasCount(PlayerStatsSnapshot snap, string key)
		{
			if (snap != null && snap.TryGetNumeric(key, out var value))
			{
				return value > 0.05f;
			}
			return false;
		}

		private static bool HasNonDefaultProjectiles(PlayerStatsSnapshot snap)
		{
			if (snap != null && snap.TryGetNumeric("Bullets", out var value))
			{
				return Mathf.Abs(value - 1f) >= 0.05f;
			}
			return false;
		}

		private static bool HasNonDefault(PlayerStatsSnapshot snap, string key, float defaultValue)
		{
			if (snap != null && snap.TryGetNumeric(key, out var value))
			{
				return Mathf.Abs(value - defaultValue) >= 0.05f;
			}
			return false;
		}

		private static bool IsNullStat(string label)
		{
			if (string.IsNullOrEmpty(label))
			{
				return false;
			}
			if (!label.Equals("Nulls", StringComparison.OrdinalIgnoreCase) && !label.Equals("Null", StringComparison.OrdinalIgnoreCase))
			{
				return label.Equals("Null cards", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static void AppendPing(StringBuilder sb, int pingMs)
		{
			if (pingMs >= 0)
			{
				string value = ((pingMs < 80) ? "7CFF7C" : ((pingMs < 150) ? "FFE27C" : "FF8585"));
				sb.Append("  <size=90%><color=#").Append(value).Append(">")
					.Append(pingMs)
					.Append("ms</color></size>");
			}
		}

		private static void AppendSection(StringBuilder sb, string title)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine();
			sb.Append("<size=90%><b><color=#").Append(ColorToHex(SectionColor)).Append(">— ")
				.Append(title)
				.Append(" —</color></b></size>")
				.AppendLine();
		}

		private static void AppendPreviewExtras(StringBuilder sb, PlayerStatsSnapshot snap, PlayerStatsSnapshot preview)
		{
			if (preview == null)
			{
				return;
			}
			bool flag = false;
			(string, string)[] previewExtraStats = PreviewExtraStats;
			for (int i = 0; i < previewExtraStats.Length; i++)
			{
				var (label, text) = previewExtraStats[i];
				if (preview.TryGetNumeric(text, out var value) && !(Mathf.Abs(value) < 0.005f) && (!(text == "Regen") || !HasCount(snap, "Regen")))
				{
					if (!flag)
					{
						AppendSection(sb, "This card");
						flag = true;
					}
					AppendRow(sb, label, snap.GetDisplay(text), text, snap, null, preview, pickHoverMode: true);
				}
			}
		}

		private static void AppendHeroRow(StringBuilder sb, string label, string value, PlayerStatsSnapshot snap, PlayerStatsSnapshot baseline, PlayerStatsSnapshot preview, bool isHero, bool pickHoverMode = false)
		{
			string value2 = (isHero ? "102%" : "100%");
			sb.Append("<size=").Append(value2).Append(">")
				.Append(Label(label))
				.Append("  ")
				.Append(Value(value));
			AppendDeltaSuffix(sb, label, snap, baseline, preview, pickHoverMode);
			sb.Append("</size>").AppendLine();
		}

		private static void AppendRow(StringBuilder sb, string label, string value, string key, PlayerStatsSnapshot snap, PlayerStatsSnapshot baseline, PlayerStatsSnapshot preview, bool pickHoverMode = false)
		{
			sb.Append(Label(label)).Append("  ").Append(Value(value));
			AppendDeltaSuffix(sb, key, snap, baseline, preview, pickHoverMode);
			sb.AppendLine();
		}

		private static void AppendDeltaSuffix(StringBuilder sb, string key, PlayerStatsSnapshot snap, PlayerStatsSnapshot baseline, PlayerStatsSnapshot preview, bool pickHoverMode = false)
		{
			string text = MapKey(key);
			if (!pickHoverMode && baseline != null && snap.TryGetNumeric(text, out var value) && baseline.TryGetNumeric(text, out var value2))
			{
				float num = value - value2;
				if (Mathf.Abs(num) >= 0.005f)
				{
					string value3 = (GunStatReader.IsPositiveChange(text, num) ? "7CFF7C" : "FF8585");
					sb.Append(" <color=#").Append(value3).Append(">(")
						.Append((num > 0f) ? "+" : "")
						.Append(FormatDelta(text, num))
						.Append(")</color>");
				}
			}
			if (preview != null && TryPreviewDiff(preview, text, out var previewDiff))
			{
				bool flag = GunStatReader.IsPositiveChange(text, previewDiff);
				string value4 = ((!pickHoverMode) ? (flag ? "9DFFB0" : "FFB0B0") : (flag ? "7CFF7C" : "FF8585"));
				string value5 = (pickHoverMode ? "(" : "[");
				string value6 = (pickHoverMode ? ")" : "]");
				sb.Append(" <color=#").Append(value4).Append(">")
					.Append(value5)
					.Append((previewDiff > 0f) ? "+" : "")
					.Append(FormatDelta(text, previewDiff))
					.Append(value6)
					.Append("</color>");
			}
		}

		private static bool TryPreviewDiff(PlayerStatsSnapshot preview, string statKey, out float previewDiff)
		{
			if (preview.TryGetNumeric(statKey, out previewDiff) && Mathf.Abs(previewDiff) >= 0.005f)
			{
				return true;
			}
			if (statKey == "HP" && preview.TryGetNumeric("MaxHP", out previewDiff) && Mathf.Abs(previewDiff) >= 0.005f)
			{
				return true;
			}
			previewDiff = 0f;
			return false;
		}

		private static string FormatDelta(string key, float diff)
		{
			switch (key)
			{
			case "LifeSteal":
				return (diff * 100f).ToString("F0") + "%";
			case "Regen":
				return diff.ToString("F1") + "/s";
			case "DMG":
			case "HP":
			case "MaxHP":
			case "Bullets":
			case "Bounces":
			case "Bursts":
			case "Ammo":
			case "BlockCount":
			case "Lives":
			case "Nulls":
			case "NullCards":
				return diff.ToString("F0");
			default:
				return diff.ToString("F1");
			}
		}

		private static string Label(string text)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorToHex(LabelColor) + "><b>" + text + "</b></color>";
		}

		private static string Value(string text)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return "<color=#" + ColorToHex(ValueColor) + "><b>" + text + "</b></color>";
		}

		private static string MapKey(string label)
		{
			switch (label)
			{
			case "Nulls":
				return "Nulls";
			case "Null cards":
				return "NullCards";
			case "HP":
				return "HP";
			case "DMG":
				return "DMG";
			case "Lives":
				return "Lives";
			case "Regen":
				return "Regen";
			case "Block":
			case "Block CD":
				return "BlockCD";
			case "Blocks":
				return "BlockCount";
			case "Move SPD":
			case "Move":
				return "MoveSPD";
			case "Attack SPD":
			case "Atk":
				return "AttackSPD";
			case "Jump":
				return "Jump";
			case "Size":
				return "Size";
			case "Knockback":
				return "Knockback";
			case "Life Steal":
				return "LifeSteal";
			case "Bullets":
			case "Projectiles":
				return "Bullets";
			case "Bullet SPD":
				return "BulletSPD";
			case "Reload":
				return "Reload";
			case "Ammo":
				return "Ammo";
			case "Range":
				return "Range";
			case "Bounces":
				return "Bounces";
			default:
				return label;
			}
		}

		private static string ColorToHex(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			float num = Mathf.Clamp01(c.r);
			float num2 = Mathf.Clamp01(c.g);
			float num3 = Mathf.Clamp01(c.b);
			return ColorUtility.ToHtmlStringRGB(new Color(num, num2, num3));
		}
	}
}
namespace ProMLGStats.Stats
{
	internal static class CardStatPreview
	{
		private static readonly object Gate = new object();

		private static readonly FieldInfo MyGunStatsField = AccessTools.Field(typeof(ApplyCardStats), "myGunStats");

		private static readonly FieldInfo MyPlayerStatsField = AccessTools.Field(typeof(ApplyCardStats), "myPlayerStats");

		public static bool TryPreview(Player player, CardInfo cardInfo, out PlayerStatsSnapshot delta, CardInfo pickVisual = null)
		{
			delta = null;
			if ((Object)(object)player == (Object)null || (Object)(object)cardInfo == (Object)null)
			{
				return false;
			}
			if (!PlayerStatsSnapshot.TryFrom(player, out var snapshot))
			{
				return false;
			}
			lock (Gate)
			{
				PlayerStatRawBackup playerStatRawBackup = PlayerStatRawBackup.Capture(player);
				CardInfo val = pickVisual ?? cardInfo;
				ApplyPreview(player, cardInfo, val);
				if (!PlayerStatsSnapshot.TryFrom(player, out var snapshot2))
				{
					playerStatRawBackup.Apply(player);
					return false;
				}
				NullStatReader.ApplyPickPreview(player, val, snapshot2);
				delta = snapshot2.Delta(snapshot);
				playerStatRawBackup.Apply(player);
				return delta != null;
			}
		}

		private static void ApplyPreview(Player player, CardInfo cardInfo, CardInfo pickVisual)
		{
			try
			{
				CharacterData data = player.data;
				if ((Object)(object)data == (Object)null)
				{
					return;
				}
				Gun val = data.weaponHandler?.gun;
				Gun val2 = ResolveCardGun(pickVisual) ?? ResolveCardGun(cardInfo);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val != (Object)null)
				{
					GunAmmo val3 = ((Component)val).GetComponent<GunAmmo>() ?? ((Component)val).GetComponentInChildren<GunAmmo>(true);
					if ((Object)(object)val3 != (Object)null)
					{
						val3.maxAmmo += val2.ammo;
						val3.maxAmmo = Mathf.Clamp(val3.maxAmmo, 1, 90);
						if (val2.reloadTime != 0f)
						{
							val3.reloadTimeMultiplier *= val2.reloadTime;
						}
						val3.reloadTimeAdd += val2.reloadTimeAdd;
					}
					if (val2.projectiles != null && val2.projectiles.Length != 0 && val.projectiles != null && val.projectiles.Length != 0)
					{
						val.projectiles[0].objectToSpawn = val2.projectiles[0].objectToSpawn;
					}
					ApplyCardStats.CopyGunStats(val2, val);
				}
				CharacterStatModifiers val4 = ResolveCardStats(pickVisual) ?? ResolveCardStats(cardInfo);
				CharacterStatModifiers stats = data.stats;
				if ((Object)(object)val4 != (Object)null && (Object)(object)stats != (Object)null)
				{
					if (val4.sizeMultiplier != 0f)
					{
						stats.sizeMultiplier *= val4.sizeMultiplier;
					}
					if (val4.health != 0f)
					{
						data.maxHealth *= val4.health;
						data.health *= val4.health;
					}
					if (val4.movementSpeed != 0f)
					{
						stats.movementSpeed *= val4.movementSpeed;
					}
					if (val4.jump != 0f)
					{
						stats.jump *= val4.jump;
					}
					data.jumps += val4.numberOfJumps;
					stats.lifeSteal += val4.lifeSteal;
					stats.respawns += val4.respawns;
					HealthHandler healthHandler = data.healthHandler;
					if ((Object)(object)healthHandler != (Object)null)
					{
						healthHandler.regeneration += val4.regen;
					}
				}
				Block val5 = ((Component)cardInfo).GetComponent<Block>() ?? ((Component)cardInfo).GetComponentInChildren<Block>(true) ?? ((pickVisual != null) ? ((Component)pickVisual).GetComponent<Block>() : null) ?? ((pickVisual != null) ? ((Component)pickVisual).GetComponentInChildren<Block>(true) : null);
				Block block = data.block;
				if ((Object)(object)val5 != (Object)null && (Object)(object)block != (Object)null)
				{
					block.additionalBlocks += val5.additionalBlocks;
					block.cdAdd += val5.cdAdd;
					if (val5.cdMultiplier != 0f)
					{
						block.cdMultiplier *= val5.cdMultiplier;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Instance?.LogWarn("Card preview failed for " + cardInfo?.cardName + ": " + ex.Message);
			}
		}

		private static Gun ResolveCardGun(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return null;
			}
			ApplyCardStats component = ((Component)card).GetComponent<ApplyCardStats>();
			if ((Object)(object)component != (Object)null)
			{
				try
				{
					object? obj = MyGunStatsField?.GetValue(component);
					Gun val = (Gun)((obj is Gun) ? obj : null);
					if (val != null && (Object)(object)val != (Object)null)
					{
						return val;
					}
				}
				catch
				{
				}
				Gun component2 = ((Component)component).GetComponent<Gun>();
				if ((Object)(object)component2 != (Object)null)
				{
					return component2;
				}
			}
			return ((Component)card).GetComponent<Gun>();
		}

		private static CharacterStatModifiers ResolveCardStats(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return null;
			}
			ApplyCardStats component = ((Component)card).GetComponent<ApplyCardStats>();
			if ((Object)(object)component != (Object)null)
			{
				try
				{
					object? obj = MyPlayerStatsField?.GetValue(component);
					CharacterStatModifiers val = (CharacterStatModifiers)((obj is CharacterStatModifiers) ? obj : null);
					if (val != null && (Object)(object)val != (Object)null)
					{
						return val;
					}
				}
				catch
				{
				}
				CharacterStatModifiers component2 = ((Component)component).GetComponent<CharacterStatModifiers>();
				if ((Object)(object)component2 != (Object)null)
				{
					return component2;
				}
			}
			return ((Component)card).GetComponent<CharacterStatModifiers>();
		}
	}
	internal static class GunStatReader
	{
		internal static float ComputeDamage(Gun gun)
		{
			if ((Object)(object)gun == (Object)null)
			{
				return 0f;
			}
			try
			{
				if (gun.projectiles != null && gun.projectiles.Length != 0)
				{
					GameObject val = gun.projectiles[0]?.objectToSpawn;
					ProjectileHit val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ProjectileHit>() : null);
					if ((Object)(object)val2 != (Object)null)
					{
						return gun.damage * gun.bulletDamageMultiplier * val2.damage;
					}
				}
			}
			catch
			{
			}
			return gun.damage * 55f * gun.bulletDamageMultiplier;
		}

		internal static bool TryReadCurrentAmmo(GunAmmo ammo, out int current)
		{
			current = 0;
			if ((Object)(object)ammo == (Object)null)
			{
				return false;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(GunAmmo), "currentAmmo") ?? AccessTools.Field(typeof(GunAmmo), "ammo");
			if (fieldInfo == null)
			{
				return false;
			}
			try
			{
				object value = fieldInfo.GetValue(ammo);
				if (value is int num)
				{
					current = num;
					return true;
				}
				if (value is float num2)
				{
					current = Mathf.RoundToInt(num2);
					return true;
				}
				if (value is IList list)
				{
					int num3 = 0;
					foreach (object item in list)
					{
						Component val = (Component)((item is Component) ? item : null);
						if (val != null)
						{
							if ((Object)(object)val != (Object)null && val.gameObject.activeSelf)
							{
								num3++;
							}
							continue;
						}
						GameObject val2 = (GameObject)((item is GameObject) ? item : null);
						if (val2 != null)
						{
							if ((Object)(object)val2 != (Object)null && val2.activeSelf)
							{
								num3++;
							}
						}
						else if (item != null)
						{
							num3++;
						}
					}
					current = num3;
					return true;
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		internal static string FormatAmmo(GunAmmo ammo)
		{
			if ((Object)(object)ammo == (Object)null)
			{
				return "-";
			}
			if (TryReadCurrentAmmo(ammo, out var current))
			{
				return $"{current}/{ammo.maxAmmo}";
			}
			return ammo.maxAmmo.ToString("F0");
		}

		internal static string FormatLifeSteal(float lifeSteal)
		{
			return $"{lifeSteal * 100f:F0}%";
		}

		internal static float ComputeReloadSeconds(GunAmmo ammo)
		{
			if ((Object)(object)ammo == (Object)null)
			{
				return float.NaN;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(GunAmmo), "ReloadTime", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					object obj = methodInfo.Invoke(ammo, null);
					if (obj is float)
					{
						return (float)obj;
					}
				}
			}
			catch
			{
			}
			return (ammo.reloadTime + ammo.reloadTimeAdd) * ammo.reloadTimeMultiplier;
		}

		internal static bool LowerIsBetter(string key)
		{
			switch (key)
			{
			case "BlockCD":
			case "AttackSPD":
			case "Reload":
			case "BulletSlow":
				return true;
			default:
				return false;
			}
		}

		internal static bool IsPositiveChange(string key, float diff)
		{
			if (Mathf.Abs(diff) < 0.005f)
			{
				return false;
			}
			if (!LowerIsBetter(key))
			{
				return diff > 0f;
			}
			return diff < 0f;
		}
	}
	internal sealed class PlayerStatRawBackup
	{
		public float Health;

		public float MaxHealth;

		public float MovementSpeed;

		public float Jump;

		public float SizeMultiplier;

		public float LifeSteal;

		public int Respawns;

		public float GunDamage;

		public float BulletDamageMultiplier;

		public float Knockback;

		public float DamageAfterDistanceMultiplier;

		public float Slow;

		public float AttackSpeed;

		public float AttackSpeedMultiplier;

		public float ProjectileSpeed;

		public float ProjectileSimulationSpeed;

		public int NumberOfProjectiles;

		public float DestroyBulletAfter;

		public int Reflects;

		public int Bursts;

		public float Gravity;

		public float Spread;

		public float EvenSpread;

		public float MultiplySpread;

		public int GunAmmoCount;

		public int Jumps;

		public float Regeneration;

		public ObjectsToSpawn[] ObjectsToSpawn;

		public GameObject ProjectileToSpawn;

		public int AdditionalBlocks;

		public float BlockCdMultiplier;

		public float BlockCdAdd;

		public int MaxAmmo;

		public float ReloadTime;

		public float ReloadTimeAdd;

		public float ReloadTimeMultiplier;

		public static PlayerStatRawBackup Capture(Player player)
		{
			Gun gun = player.data.weaponHandler.gun;
			Block block = player.data.block;
			CharacterData data = player.data;
			GunAmmo componentInChildren = ((Component)gun).GetComponentInChildren<GunAmmo>();
			return new PlayerStatRawBackup
			{
				Health = data.health,
				MaxHealth = data.maxHealth,
				MovementSpeed = data.stats.movementSpeed,
				Jump = data.stats.jump,
				SizeMultiplier = data.stats.sizeMultiplier,
				LifeSteal = data.stats.lifeSteal,
				Respawns = data.stats.respawns,
				GunDamage = gun.damage,
				BulletDamageMultiplier = gun.bulletDamageMultiplier,
				Knockback = gun.knockback,
				DamageAfterDistanceMultiplier = gun.damageAfterDistanceMultiplier,
				Slow = gun.slow,
				AttackSpeed = gun.attackSpeed,
				AttackSpeedMultiplier = gun.attackSpeedMultiplier,
				ProjectileSpeed = gun.projectileSpeed,
				ProjectileSimulationSpeed = gun.projectielSimulatonSpeed,
				NumberOfProjectiles = gun.numberOfProjectiles,
				DestroyBulletAfter = gun.destroyBulletAfter,
				Reflects = gun.reflects,
				Bursts = gun.bursts,
				Gravity = gun.gravity,
				Spread = gun.spread,
				EvenSpread = gun.evenSpread,
				MultiplySpread = gun.multiplySpread,
				GunAmmoCount = gun.ammo,
				Jumps = data.jumps,
				Regeneration = (((Object)(object)data.healthHandler != (Object)null) ? data.healthHandler.regeneration : 0f),
				ObjectsToSpawn = gun.objectsToSpawn,
				ProjectileToSpawn = ((gun.projectiles != null && gun.projectiles.Length != 0) ? gun.projectiles[0].objectToSpawn : null),
				AdditionalBlocks = block.additionalBlocks,
				BlockCdMultiplier = block.cdMultiplier,
				BlockCdAdd = block.cdAdd,
				MaxAmmo = (componentInChildren?.maxAmmo ?? 0),
				ReloadTime = (componentInChildren?.reloadTime ?? 0f),
				ReloadTimeAdd = (componentInChildren?.reloadTimeAdd ?? 0f),
				ReloadTimeMultiplier = (componentInChildren?.reloadTimeMultiplier ?? 1f)
			};
		}

		public void Apply(Player player)
		{
			Gun gun = player.data.weaponHandler.gun;
			Block block = player.data.block;
			CharacterData data = player.data;
			GunAmmo componentInChildren = ((Component)gun).GetComponentInChildren<GunAmmo>();
			bool flag = !Mathf.Approximately(data.stats.sizeMultiplier, SizeMultiplier);
			data.health = Health;
			data.maxHealth = MaxHealth;
			data.stats.movementSpeed = MovementSpeed;
			data.stats.jump = Jump;
			data.stats.sizeMultiplier = SizeMultiplier;
			data.stats.lifeSteal = LifeSteal;
			data.stats.respawns = Respawns;
			gun.damage = GunDamage;
			gun.bulletDamageMultiplier = BulletDamageMultiplier;
			gun.knockback = Knockback;
			gun.damageAfterDistanceMultiplier = DamageAfterDistanceMultiplier;
			gun.slow = Slow;
			gun.attackSpeed = AttackSpeed;
			gun.attackSpeedMultiplier = AttackSpeedMultiplier;
			gun.projectileSpeed = ProjectileSpeed;
			gun.projectielSimulatonSpeed = ProjectileSimulationSpeed;
			gun.numberOfProjectiles = NumberOfProjectiles;
			gun.destroyBulletAfter = DestroyBulletAfter;
			gun.reflects = Reflects;
			gun.bursts = Bursts;
			gun.gravity = Gravity;
			gun.spread = Spread;
			gun.evenSpread = EvenSpread;
			gun.multiplySpread = MultiplySpread;
			gun.ammo = GunAmmoCount;
			gun.objectsToSpawn = ObjectsToSpawn;
			if (gun.projectiles != null && gun.projectiles.Length != 0)
			{
				gun.projectiles[0].objectToSpawn = ProjectileToSpawn;
			}
			data.jumps = Jumps;
			if ((Object)(object)data.healthHandler != (Object)null)
			{
				data.healthHandler.regeneration = Regeneration;
			}
			block.additionalBlocks = AdditionalBlocks;
			block.cdMultiplier = BlockCdMultiplier;
			block.cdAdd = BlockCdAdd;
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.maxAmmo = MaxAmmo;
				componentInChildren.reloadTime = ReloadTime;
				componentInChildren.reloadTimeAdd = ReloadTimeAdd;
				componentInChildren.reloadTimeMultiplier = ReloadTimeMultiplier;
			}
			if (flag)
			{
				AccessTools.Method(typeof(CharacterStatModifiers), "ConfigureMassAndSize", (Type[])null, (Type[])null)?.Invoke(data.stats, null);
			}
		}
	}
	internal static class NullStatReader
	{
		private static MethodInfo _getNulls;

		private static MethodInfo _getNullCount;

		private static MethodInfo _getNullValue;

		private static Type _nullCardInfo;

		private static bool _resolved;

		internal static float GetRemaining(Player player)
		{
			if ((Object)(object)player?.data?.stats == (Object)null)
			{
				return 0f;
			}
			EnsureResolved();
			if (_getNulls == null)
			{
				return 0f;
			}
			try
			{
				return ToFloat(_getNulls.Invoke(null, new object[1] { player.data.stats }));
			}
			catch
			{
				return 0f;
			}
		}

		internal static int GetOwned(Player player)
		{
			if (player?.data?.currentCards == null)
			{
				return 0;
			}
			EnsureResolved();
			if (_getNullCount != null)
			{
				try
				{
					int num = Mathf.RoundToInt(ToFloat(_getNullCount.Invoke(null, new object[1] { player })));
					if (num > 0)
					{
						return num;
					}
				}
				catch
				{
				}
			}
			int num2 = 0;
			foreach (CardInfo currentCard in player.data.currentCards)
			{
				if (IsNullPlaceholder(currentCard))
				{
					num2++;
				}
			}
			return num2;
		}

		internal static bool IsPlaceholder(CardInfo card)
		{
			EnsureResolved();
			return IsNullPlaceholder(card);
		}

		internal static void ApplyPickPreview(Player player, CardInfo card, PlayerStatsSnapshot after)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)card == (Object)null) && after != null && IsPlaceholder(card))
			{
				float value;
				float num = (after.TryGetNumeric("Nulls", out value) ? value : GetRemaining(player));
				float value2;
				int num2 = (after.TryGetNumeric("NullCards", out value2) ? Mathf.RoundToInt(value2) : GetOwned(player));
				float pickCost = GetPickCost(card);
				after.WriteCount("Nulls", Mathf.Max(0f, num - pickCost));
				after.WriteCount("NullCards", num2 + 1);
			}
		}

		internal static float GetPickCost(CardInfo card)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			EnsureResolved();
			if ((Object)(object)card == (Object)null)
			{
				return 1f;
			}
			CardInfo val = GetNulledSource(card) ?? card;
			if (_getNullValue != null)
			{
				try
				{
					float num = ToFloat(InvokeNullValue(val));
					if (num > 0.05f)
					{
						return num;
					}
				}
				catch
				{
				}
			}
			return DefaultCost(val.rarity);
		}

		private static void EnsureResolved()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			try
			{
				Type type = AccessTools.TypeByName("Nullmanager.CharacterStatModifiersExtension");
				_getNulls = ((type == null) ? null : AccessTools.Method(type, "GetNulls", new Type[1] { typeof(CharacterStatModifiers) }, (Type[])null));
			}
			catch
			{
				_getNulls = null;
			}
			try
			{
				Type type2 = AccessTools.TypeByName("Nullmanager.PlayerExtensions");
				_getNullCount = ((type2 == null) ? null : AccessTools.Method(type2, "GetNullCount", new Type[1] { typeof(Player) }, (Type[])null));
			}
			catch
			{
				_getNullCount = null;
			}
			_nullCardInfo = AccessTools.TypeByName("Nullmanager.NullCardInfo");
			string[] array = new string[4] { "Nullmanager.NullManager", "Nullmanager.Main", "Nullmanager.CharacterStatModifiersExtension", "Nullmanager.NullSpawnLogic" };
			foreach (string text in array)
			{
				try
				{
					Type type3 = AccessTools.TypeByName(text);
					_getNullValue = ((type3 == null) ? null : AccessTools.Method(type3, "GetNullValue", (Type[])null, (Type[])null));
					if (_getNullValue != null)
					{
						break;
					}
				}
				catch
				{
					_getNullValue = null;
				}
			}
		}

		private static object InvokeNullValue(CardInfo source)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			if (_getNullValue == null || (Object)(object)source == (Object)null)
			{
				return null;
			}
			ParameterInfo[] parameters = _getNullValue.GetParameters();
			object obj = (_getNullValue.IsStatic ? null : AccessTools.Property(_getNullValue.DeclaringType, "instance")?.GetValue(null));
			if (parameters.Length == 0)
			{
				return _getNullValue.Invoke(obj, null);
			}
			if (parameters.Length == 1)
			{
				if (parameters[0].ParameterType == typeof(CardInfo))
				{
					return _getNullValue.Invoke(obj, new object[1] { source });
				}
				if (parameters[0].ParameterType == typeof(Rarity))
				{
					return _getNullValue.Invoke(obj, new object[1] { source.rarity });
				}
			}
			if (parameters.Length == 2 && parameters[1].ParameterType == typeof(Rarity))
			{
				return _getNullValue.Invoke(obj, new object[2]
				{
					parameters[0].ParameterType.IsInstanceOfType(source) ? source : null,
					source.rarity
				});
			}
			return _getNullValue.Invoke(obj, new object[1] { source.rarity });
		}

		private static CardInfo GetNulledSource(CardInfo card)
		{
			if (_nullCardInfo == null || (Object)(object)card == (Object)null)
			{
				return null;
			}
			object obj = (_nullCardInfo.IsInstanceOfType(card) ? card : null);
			if (obj == null && (Object)(object)((Component)card).gameObject != (Object)null)
			{
				obj = ((Component)card).gameObject.GetComponent(_nullCardInfo) ?? ((Component)card).gameObject.GetComponentInChildren(_nullCardInfo);
			}
			if (obj == null)
			{
				return null;
			}
			try
			{
				object? obj2 = AccessTools.Field(obj.GetType(), "NulledSorce")?.GetValue(obj);
				return (CardInfo)((obj2 is CardInfo) ? obj2 : null);
			}
			catch
			{
				return null;
			}
		}

		private static float DefaultCost(Rarity rarity)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)rarity != 1)
			{
				if ((int)rarity == 2)
				{
					return 3f;
				}
				return 1f;
			}
			return 2f;
		}

		private static bool IsNullPlaceholder(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return false;
			}
			if (_nullCardInfo != null && _nullCardInfo.IsInstanceOfType(card))
			{
				return true;
			}
			string text = (card.cardName ?? "").Trim();
			if (text.StartsWith("[]", StringComparison.Ordinal))
			{
				return true;
			}
			if (text.Equals("null", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (text.Equals("NullCard", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private static float ToFloat(object value)
		{
			if (value == null)
			{
				return 0f;
			}
			try
			{
				return Convert.ToSingle(value);
			}
			catch
			{
				return 0f;
			}
		}
	}
	internal static class PingTracker
	{
		private const string PropKey = "MM_P";

		private const float PublishInterval = 2f;

		private const float HeartbeatInterval = 8f;

		private const int MinDeltaToPublish = 5;

		private static float _nextPublish;

		private static float _lastPublishTime = -999f;

		private static int _lastPublished = int.MinValue;

		internal static bool Online
		{
			get
			{
				try
				{
					return PhotonNetwork.IsConnected && !PhotonNetwork.OfflineMode && PhotonNetwork.InRoom;
				}
				catch
				{
					return false;
				}
			}
		}

		internal static int LocalPing()
		{
			if (!Online)
			{
				return -1;
			}
			try
			{
				int ping = PhotonNetwork.GetPing();
				if (ping > 0)
				{
					return ping;
				}
				LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
				int? obj;
				if (networkingClient == null)
				{
					obj = null;
				}
				else
				{
					LoadBalancingPeer loadBalancingPeer = networkingClient.LoadBalancingPeer;
					obj = ((loadBalancingPeer != null) ? new int?(((PhotonPeer)loadBalancingPeer).RoundTripTime) : ((int?)null));
				}
				int? num = obj;
				int valueOrDefault = num.GetValueOrDefault();
				return (valueOrDefault > 0) ? valueOrDefault : ping;
			}
			catch
			{
				return -1;
			}
		}

		internal static int Read(Player player)
		{
			if (!Online || (Object)(object)player == (Object)null)
			{
				return -1;
			}
			if (RoundsWithBotsBridge.IsBot(player))
			{
				return -1;
			}
			try
			{
				CharacterData data = player.data;
				object obj;
				if (data == null)
				{
					obj = null;
				}
				else
				{
					PhotonView view = data.view;
					obj = ((view != null) ? view.Owner : null);
				}
				Player val = (Player)obj;
				if (val == null)
				{
					return -1;
				}
				if (val.IsLocal)
				{
					return LocalPing();
				}
				Hashtable customProperties = val.CustomProperties;
				if (customProperties == null || !((Dictionary<object, object>)(object)customProperties).ContainsKey((object)"MM_P"))
				{
					return -1;
				}
				return ToInt(customProperties[(object)"MM_P"]);
			}
			catch
			{
				return -1;
			}
		}

		internal static void Tick()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_007a: Expected O, but got Unknown
			if (!Online || Time.unscaledTime < _nextPublish)
			{
				return;
			}
			_nextPublish = Time.unscaledTime + 2f;
			int num = LocalPing();
			if (num < 0 || (!(Time.unscaledTime - _lastPublishTime >= 8f) && Mathf.Abs(num - _lastPublished) < 5))
			{
				return;
			}
			try
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"MM_P", (object)num);
				localPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
				_lastPublished = num;
				_lastPublishTime = Time.unscaledTime;
			}
			catch
			{
			}
		}

		private static int ToInt(object raw)
		{
			if (raw is int)
			{
				return (int)raw;
			}
			if (raw is byte)
			{
				return (byte)raw;
			}
			if (raw is short)
			{
				return (short)raw;
			}
			if (raw is long num)
			{
				return (int)num;
			}
			return -1;
		}
	}
	internal struct StatValue
	{
		public readonly string Label;

		public readonly string Value;

		public readonly float Numeric;

		public StatValue(string label, string value, float numeric = float.NaN)
		{
			Label = label;
			Value = value;
			Numeric = numeric;
		}
	}
	internal sealed class PlayerStatsSnapshot
	{
		private readonly Dictionary<string, float> _numbers = new Dictionary<string, float>();

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

		public int PlayerId { get; private set; } = -1;

		public string PlayerName { get; private set; } = "?";

		public int PingMs { get; private set; } = -1;

		public static bool TryFrom(Player player, out PlayerStatsSnapshot snapshot)
		{
			snapshot = null;
			if ((Object)(object)player?.data == (Object)null)
			{
				return false;
			}
			Gun val = player.data.weaponHandler?.gun;
			Block block = player.data.block;
			CharacterData data = player.data;
			if ((Object)(object)val == (Object)null || (Object)(object)block == (Object)null || (Object)(object)data.stats == (Object)null)
			{
				return false;
			}
			GunAmmo componentInChildren = ((Component)val).GetComponentInChildren<GunAmmo>();
			float num = GunStatReader.ComputeDamage(val);
			PlayerStatsSnapshot obj = new PlayerStatsSnapshot
			{
				PlayerId = player.playerID
			};
			PhotonView view = player.data.view;
			object obj2;
			if (view == null)
			{
				obj2 = null;
			}
			else
			{
				Player owner = view.Owner;
				obj2 = ((owner != null) ? owner.NickName : null);
			}
			if (obj2 == null)
			{
				obj2 = $"P{player.playerID + 1}";
			}
			obj.PlayerName = RoundsWithBotsBridge.DisplayName(player, (string)obj2);
			obj.PingMs = PingTracker.Read(player);
			snapshot = obj;
			snapshot.Set("HP", data.health, $"{data.health:F0}/{data.maxHealth:F0}");
			snapshot.Set("MaxHP", data.maxHealth, $"{data.maxHealth:F0}");
			snapshot.Set("DMG", num, $"{num:F0}");
			float remaining = NullStatReader.GetRemaining(player);
			if (remaining > 0.05f)
			{
				snapshot.Set("Nulls", remaining, FormatCount(remaining));
			}
			int owned = NullStatReader.GetOwned(player);
			if (owned > 0)
			{
				snapshot.Set("NullCards", owned, owned.ToString("F0"));
			}
			snapshot.Set("Lives", (float)data.stats.respawns + 1f, $"{data.stats.respawns + 1:F0}");
			snapshot.Set("Regen", ((Object)(object)data.healthHandler != (Object)null) ? data.healthHandler.regeneration : 0f, FormatRegen(((Object)(object)data.healthHandler != (Object)null) ? data.healthHandler.regeneration : 0f));
			snapshot.Set("BlockCD", block.Cooldown(), $"{block.Cooldown():F2}s");
			snapshot.Set("BlockCount", (float)block.additionalBlocks + 1f, $"{block.additionalBlocks + 1:F0}");
			snapshot.Set("MoveSPD", data.stats.movementSpeed, $"{data.stats.movementSpeed:F2}");
			snapshot.Set("Jump", data.stats.jump, $"{data.stats.jump:F2}");
			snapshot.Set("Size", data.stats.sizeMultiplier, $"{data.stats.sizeMultiplier:F2}");
			snapshot.Set("Knockback", val.knockback, $"{val.knockback:F2}");
			snapshot.Set("LifeSteal", data.stats.lifeSteal, GunStatReader.FormatLifeSteal(data.stats.lifeSteal));
			snapshot.Set("DmgGrow", val.damageAfterDistanceMultiplier, $"{val.damageAfterDistanceMultiplier:F2}");
			snapshot.Set("BulletSlow", val.slow, $"{val.slow:F2}");
			snapshot.Set("AttackSPD", val.attackSpeed * val.attackSpeedMultiplier, $"{val.attackSpeed * val.attackSpeedMultiplier:F2}s");
			snapshot.Set("BulletSPD", val.projectileSpeed, $"{val.projectileSpeed:F2}");
			snapshot.Set("ProjectileSPD", val.projectielSimulatonSpeed, $"{val.projectielSimulatonSpeed:F2}");
			if ((Object)(object)componentInChildren != (Object)null)
			{
				float num2 = GunStatReader.ComputeReloadSeconds(componentInChildren);
				snapshot.Set("Reload", num2, $"{num2:F2}s");
				snapshot.Set("Ammo", componentInChildren.maxAmmo, GunStatReader.FormatAmmo(componentInChildren));
			}
			snapshot.Set("Bullets", val.numberOfProjectiles, $"{val.numberOfProjectiles:F0}");
			snapshot.Set("Range", val.destroyBulletAfter, $"{val.destroyBulletAfter:F2}");
			snapshot.Set("Bounces", val.reflects, $"{val.reflects:F0}");
			snapshot.Set("Bursts", val.bursts, $"{val.bursts:F0}");
			snapshot.Set("Gravity", val.gravity, $"{val.gravity:F2}");
			return true;
		}

		public static Player LocalPlayer()
		{
			List<Player> list = PlayerManager.instance?.players;
			if (list == null || list.Count == 0)
			{
				return null;
			}
			Player val = null;
			Player val2 = null;
			try
			{
				foreach (Player item in list)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = item;
					}
					if (RoundsWithBotsBridge.IsBot(item))
					{
						continue;
					}
					if ((Object)(object)val == (Object)null)
					{
						val = item;
					}
					try
					{
						PlayerAPI component = ((Component)item).GetComponent<PlayerAPI>();
						if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
						{
							return item;
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			try
			{
				if (PhotonNetwork.LocalPlayer != null)
				{
					int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
					foreach (Player item2 in list)
					{
						if (!((Object)(object)item2 == (Object)null) && !RoundsWithBotsBridge.IsBot(item2))
						{
							PhotonView val3 = item2.data?.view ?? ((Component)item2).GetComponent<PhotonView>();
							if ((Object)(object)val3 != (Object)null && val3.OwnerActorNr == actorNumber)
							{
								return item2;
							}
						}
					}
				}
			}
			catch
			{
			}
			foreach (Player item3 in list)
			{
				if (!((Object)(object)item3 == (Object)null) && !RoundsWithBotsBridge.IsBot(item3) && IsLocallyControlled(item3))
				{
					return item3;
				}
			}
			try
			{
				string nickName = PhotonNetwork.NickName;
				if (!string.IsNullOrEmpty(nickName))
				{
					foreach (Player item4 in list)
					{
						if ((Object)(object)item4 == (Object)null || RoundsWithBotsBridge.IsBot(item4))
						{
							continue;
						}
						CharacterData data = item4.data;
						object obj4;
						if (data == null)
						{
							obj4 = null;
						}
						else
						{
							PhotonView view = data.view;
							if (view == null)
							{
								obj4 = null;
							}
							else
							{
								Player owner = view.Owner;
								obj4 = ((owner != null) ? owner.NickName : null);
							}
						}
						string text = (string)obj4;
						if (!string.IsNullOrEmpty(text) && string.Equals(text, nickName, StringComparison.OrdinalIgnoreCase))
						{
							return item4;
						}
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (PhotonNetwork.OfflineMode)
			{
				return val2;
			}
			return val ?? val2;
		}

		internal static bool IsLocallyControlled(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (RoundsWithBotsBridge.IsBot(player))
			{
				return false;
			}
			try
			{
				PlayerAPI component = ((Component)player).GetComponent<PlayerAPI>();
				if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
				{
					return true;
				}
			}
			catch
			{
			}
			PhotonView val = player.data?.view ?? ((Component)player).GetComponent<PhotonView>();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				if (val.IsMine)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (val.Owner != null && val.Owner.IsLocal)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				if (localPlayer != null && val.OwnerActorNr == localPlayer.ActorNumber)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		public static IEnumerable<Player> ActivePlayers()
		{
			if (PlayerManager.instance?.players == null)
			{
				yield break;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player?.data != (Object)null)
				{
					yield return player;
				}
			}
		}

		public bool TryGetNumeric(string key, out float value)
		{
			return _numbers.TryGetValue(key, out value);
		}

		public string GetDisplay(string key)
		{
			if (!_display.TryGetValue(key, out var value))
			{
				return "-";
			}
			return value;
		}

		public IEnumerable<StatValue> CompactStats()
		{
			yield return new StatValue("HP", GetDisplay("HP"), GetNumeric("HP"));
			yield return new StatValue("DMG", GetDisplay("DMG"), GetNumeric("DMG"));
			if (HasCount("Nulls"))
			{
				yield return new StatValue("Nulls", GetDisplay("Nulls"), GetNumeric("Nulls"));
			}
			if (HasCount("NullCards"))
			{
				yield return new StatValue("Null cards", GetDisplay("NullCards"), GetNumeric("NullCards"));
			}
			if (HasCount("Regen"))
			{
				yield return new StatValue("Regen", GetDisplay("Regen"), GetNumeric("Regen"));
			}
			yield return new StatValue("Block CD", GetDisplay("BlockCD"), GetNumeric("BlockCD"));
			yield return new StatValue("Move", GetDisplay("MoveSPD"), GetNumeric("MoveSPD"));
			yield return new StatValue("Atk SPD", GetDisplay("AttackSPD"), GetNumeric("AttackSPD"));
			if (HasNonDefault("Knockback", 1f))
			{
				yield return new StatValue("Knockback", GetDisplay("Knockback"), GetNumeric("Knockback"));
			}
		}

		public IEnumerable<StatValue> FullStats()
		{
			yield return new StatValue("HP", GetDisplay("HP"), GetNumeric("HP"));
			yield return new StatValue("DMG", GetDisplay("DMG"), GetNumeric("DMG"));
			if (HasCount("Nulls"))
			{
				yield return new StatValue("Nulls", GetDisplay("Nulls"), GetNumeric("Nulls"));
			}
			if (HasCount("NullCards"))
			{
				yield return new StatValue("Null cards", GetDisplay("NullCards"), GetNumeric("NullCards"));
			}
			yield return new StatValue("Lives", GetDisplay("Lives"), GetNumeric("Lives"));
			if (HasCount("Regen"))
			{
				yield return new StatValue("Regen", GetDisplay("Regen"), GetNumeric("Regen"));
			}
			yield return new StatValue("Block CD", GetDisplay("BlockCD"), GetNumeric("BlockCD"));
			yield return new StatValue("Blocks", GetDisplay("BlockCount"), GetNumeric("BlockCount"));
			yield return new StatValue("Move SPD", GetDisplay("MoveSPD"), GetNumeric("MoveSPD"));
			yield return new StatValue("Jump", GetDisplay("Jump"), GetNumeric("Jump"));
			yield return new StatValue("Size", GetDisplay("Size"), GetNumeric("Size"));
			yield return new StatValue("Knockback", GetDisplay("Knockback"), GetNumeric("Knockback"));
			yield return new StatValue("Life Steal", GetDisplay("LifeSteal"), GetNumeric("LifeSteal"));
			yield return new StatValue("Dmg Grow", GetDisplay("DmgGrow"), GetNumeric("DmgGrow"));
			yield return new StatValue("Bullet Slow", GetDisplay("BulletSlow"), GetNumeric("BulletSlow"));
			yield return new StatValue("Attack SPD", GetDisplay("AttackSPD"), GetNumeric("AttackSPD"));
			yield return new StatValue("Bullet SPD", GetDisplay("BulletSPD"), GetNumeric("BulletSPD"));
			yield return new StatValue("Projectile SPD", GetDisplay("ProjectileSPD"), GetNumeric("ProjectileSPD"));
			yield return new StatValue("Reload", GetDisplay("Reload"), GetNumeric("Reload"));
			yield return new StatValue("Ammo", GetDisplay("Ammo"), GetNumeric("Ammo"));
			yield return new StatValue("Projectiles", GetDisplay("Bullets"), GetNumeric("Bullets"));
			yield return new StatValue("Range", GetDisplay("Range"), GetNumeric("Range"));
			yield return new StatValue("Bounces", GetDisplay("Bounces"), GetNumeric("Bounces"));
			yield return new StatValue("Bursts", GetDisplay("Bursts"), GetNumeric("Bursts"));
			yield return new StatValue("Gravity", GetDisplay("Gravity"), GetNumeric("Gravity"));
		}

		public PlayerStatsSnapshot Delta(PlayerStatsSnapshot other)
		{
			PlayerStatsSnapshot playerStatsSnapshot = CloneMeta();
			foreach (KeyValuePair<string, float> number in _numbers)
			{
				if (!other._numbers.TryGetValue(number.Key, out var value) || float.IsNaN(value) || float.IsNaN(number.Value))
				{
					playerStatsSnapshot.Set(number.Key, number.Value, GetDisplay(number.Key));
					continue;
				}
				float num = number.Value - value;
				if (Mathf.Abs(num) < 0.005f)
				{
					playerStatsSnapshot.Set(number.Key, 0f, "±0");
					continue;
				}
				string arg = ((num > 0f) ? "+" : "");
				playerStatsSnapshot.Set(number.Key, num, $"{arg}{num:F2}");
			}
			return playerStatsSnapshot;
		}

		public string FormatLines(bool simple, PlayerStatsSnapshot baseline = null, PlayerStatsSnapshot previewDelta = null)
		{
			IEnumerable<StatValue> obj = (simple ? CompactStats() : FullStats());
			StringBuilder stringBuilder = new StringBuilder();
			foreach (StatValue item in obj)
			{
				stringBuilder.Append(item.Label).Append(": ").Append(item.Value);
				if (baseline != null && baseline.TryGetNumeric(StatKey(item.Label), out var value) && !float.IsNaN(item.Numeric))
				{
					float num = item.Numeric - value;
					if (Mathf.Abs(num) >= 0.005f)
					{
						stringBuilder.Append(" (").Append((num > 0f) ? "+" : "").Append(num.ToString("F2", CultureInfo.InvariantCulture))
							.Append(')');
					}
				}
				if (previewDelta != null && previewDelta.TryGetNumeric(StatKey(item.Label), out var value2) && Mathf.Abs(value2) >= 0.005f)
				{
					stringBuilder.Append(" <color=#7CFF7C>[").Append((value2 > 0f) ? "+" : "").Append(value2.ToString("F2", CultureInfo.InvariantCulture))
						.Append("]</color>");
				}
				stringBuilder.AppendLine();
			}
			return stringBuilder.ToString().Trim();
		}

		private static string StatKey(string label)
		{
			switch (label)
			{
			case "Nulls":
				return "Nulls";
			case "Null cards":
				return "NullCards";
			case "HP":
				return "HP";
			case "DMG":
				return "DMG";
			case "Lives":
				return "Lives";
			case "Regen":
				return "Regen";
			case "Block CD":
				return "BlockCD";
			case "Blocks":
				return "BlockCount";
			case "Move":
				return "MoveSPD";
			case "Move SPD":
				return "MoveSPD";
			case "Jump":
				return "Jump";
			case "Size":
				return "Size";
			case "Knockback":
				return "Knockback";
			case "Life Steal":
				return "LifeSteal";
			case "Projectiles":
			case "Bullets":
				return "Bullets";
			case "Dmg Grow":
				return "DmgGrow";
			case "Bullet Slow":
				return "BulletSlow";
			case "Attack SPD":
			case "Atk SPD":
				return "AttackSPD";
			case "Bullet SPD":
				return "BulletSPD";
			case "Projectile SPD":
				return "ProjectileSPD";
			case "Reload":
				return "Reload";
			case "Ammo":
				return "Ammo";
			case "Range":
				return "Range";
			case "Bounces":
				return "Bounces";
			case "Bursts":
				return "Bursts";
			case "Gravity":
				return "Gravity";
			default:
				return label;
			}
		}

		private float GetNumeric(string key)
		{
			if (!_numbers.TryGetValue(key, out var value))
			{
				return float.NaN;
			}
			return value;
		}

		private bool HasCount(string key)
		{
			if (TryGetNumeric(key, out var value))
			{
				return value > 0.05f;
			}
			return false;
		}

		private bool HasNonDefault(string key, float defaultValue)
		{
			if (TryGetNumeric(key, out var value))
			{
				return Mathf.Abs(value - defaultValue) >= 0.05f;
			}
			return false;
		}

		private static string FormatRegen(float regen)
		{
			if (!(Mathf.Abs(regen - Mathf.Round(regen)) < 0.05f))
			{
				return $"{regen:F1}/s";
			}
			return $"{Mathf.Round(regen):F0}/s";
		}

		private static string FormatCount(float value)
		{
			if (!(Mathf.Abs(value - Mathf.Round(value)) < 0.05f))
			{
				return value.ToString("F1");
			}
			return Mathf.Round(value).ToString("F0");
		}

		internal void WriteCount(string key, float value)
		{
			float num = Mathf.Max(0f, value);
			Set(key, num, FormatCount(num));
		}

		private void Set(string key, float numeric, string display)
		{
			_numbers[key] = numeric;
			_display[key] = display;
		}

		private PlayerStatsSnapshot CloneMeta()
		{
			return new PlayerStatsSnapshot
			{
				PlayerId = PlayerId,
				PlayerName = PlayerName
			};
		}
	}
}