using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("HowToRounds")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.17.6.0")]
[assembly: AssemblyInformationalVersion("0.17.6")]
[assembly: AssemblyProduct("HowToRounds")]
[assembly: AssemblyTitle("HowToRounds")]
[assembly: AssemblyVersion("0.17.6.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 HowToRoundsMod
{
	internal sealed class AmmoHud : MonoBehaviour
	{
		private GameObject _canvasObject;

		private TextMeshProUGUI _ammoText;

		private TextMeshProUGUI _reloadText;

		private Image _reloadFill;

		private void Update()
		{
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (!RoundUpgradeEffects.ModeActive || RoundUpgradeEffects.LocalEliminated)
			{
				SetVisible(visible: false);
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Weapon val = (((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Holding != (Object)null && (Object)(object)localPlayer.Holding.HeldItem != (Object)null) ? localPlayer.Holding.HeldItem.Weapon : null);
			if ((Object)(object)val == (Object)null || ((Object)val).name.IndexOf("pistol", StringComparison.OrdinalIgnoreCase) < 0)
			{
				SetVisible(visible: false);
				return;
			}
			EnsureUi();
			SetVisible(visible: true);
			int num = (((Object)(object)val.Attachments != (Object)null) ? val.Attachments.AmmoPerMag : 0);
			((TMP_Text)_ammoText).text = val.Ammo + " / " + num;
			bool flag = (bool)(AccessTools.Field(typeof(Weapon), "_isReloading")?.GetValue(val) ?? ((object)false));
			float num2 = (flag ? GetReloadProgress(val) : 0f);
			_reloadFill.fillAmount = num2;
			((TMP_Text)_reloadText).text = (flag ? ("RELOADING  " + Mathf.RoundToInt(num2 * 100f) + "%") : "READY");
			((Graphic)_reloadText).color = (flag ? new Color(0.2f, 0.85f, 1f) : new Color(0.78f, 0.84f, 0.92f));
		}

		private static float GetReloadProgress(Weapon weapon)
		{
			try
			{
				object obj = AccessTools.Field(typeof(Tool), "_anim")?.GetValue(weapon);
				string text = AccessTools.Field(typeof(Weapon), "_activeReloadAnimName")?.GetValue(weapon) as string;
				if (obj == null || string.IsNullOrEmpty(text))
				{
					return 0f;
				}
				object obj2 = obj.GetType().GetProperty("Item")?.GetValue(obj, new object[1] { text });
				if (obj2 == null)
				{
					return 0f;
				}
				object obj3 = obj2.GetType().GetProperty("normalizedTime")?.GetValue(obj2, null);
				return (obj3 != null) ? Mathf.Clamp01(Convert.ToSingle(obj3)) : 0f;
			}
			catch
			{
				return 0f;
			}
		}

		private void EnsureUi()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_009a: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvasObject != (Object)null))
			{
				TMP_Text val = Object.FindObjectOfType<TMP_Text>();
				TMP_FontAsset font = (((Object)(object)val != (Object)null) ? val.font : null);
				_canvasObject = new GameObject("HowToRounds_AmmoHud", new Type[1] { typeof(RectTransform) });
				_canvasObject.transform.SetParent(((Component)this).transform, false);
				Canvas obj = _canvasObject.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 32060;
				CanvasScaler obj2 = _canvasObject.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				GameObject val2 = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
				val2.transform.SetParent(_canvasObject.transform, false);
				RectTransform component = val2.GetComponent<RectTransform>();
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(1f, 0f);
				component.pivot = val3;
				Vector2 val4 = (component.anchorMin = (component.anchorMax = val3));
				component.anchoredPosition = new Vector2(-32f, 42f);
				component.sizeDelta = new Vector2(270f, 118f);
				((Graphic)val2.AddComponent<Image>()).color = new Color(0.1f, 0.17f, 0.29f, 0.94f);
				Outline obj3 = val2.AddComponent<Outline>();
				((Shadow)obj3).effectColor = new Color(0.92f, 0.95f, 1f, 0.95f);
				((Shadow)obj3).effectDistance = new Vector2(2f, -2f);
				AddText((Transform)(object)component, "AMMO", 19f, new Color(0.7f, 0.78f, 0.89f), new Vector2(0f, 42f), new Vector2(240f, 28f), font, out var _);
				AddText((Transform)(object)component, "3 / 3", 38f, Color.white, new Vector2(0f, 10f), new Vector2(240f, 46f), font, out _ammoText);
				GameObject val7 = new GameObject("ReloadTrack", new Type[1] { typeof(RectTransform) });
				val7.transform.SetParent((Transform)(object)component, false);
				RectTransform component2 = val7.GetComponent<RectTransform>();
				((Vector2)(ref val4))..ctor(0.5f, 0.5f);
				component2.anchorMax = val4;
				component2.anchorMin = val4;
				component2.anchoredPosition = new Vector2(0f, -27f);
				component2.sizeDelta = new Vector2(226f, 11f);
				((Graphic)val7.AddComponent<Image>()).color = new Color(0.025f, 0.05f, 0.09f, 0.95f);
				GameObject val8 = new GameObject("Fill", new Type[1] { typeof(RectTransform) });
				val8.transform.SetParent((Transform)(object)component2, false);
				RectTransform component3 = val8.GetComponent<RectTransform>();
				component3.anchorMin = Vector2.zero;
				component3.anchorMax = Vector2.one;
				val4 = (component3.offsetMin = (component3.offsetMax = Vector2.zero));
				_reloadFill = val8.AddComponent<Image>();
				((Graphic)_reloadFill).color = new Color(0.12f, 0.78f, 1f, 1f);
				_reloadFill.type = (Type)3;
				_reloadFill.fillMethod = (FillMethod)0;
				_reloadFill.fillOrigin = 0;
				_reloadFill.fillAmount = 0f;
				AddText((Transform)(object)component, "READY", 16f, new Color(0.78f, 0.84f, 0.92f), new Vector2(0f, -46f), new Vector2(240f, 25f), font, out _reloadText);
			}
		}

		private static void AddText(Transform parent, string value, float size, Color color, Vector2 position, Vector2 dimensions, TMP_FontAsset font, out TextMeshProUGUI text)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(value, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.anchoredPosition = position;
			component.sizeDelta = dimensions;
			text = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)text).font = font;
			}
			((TMP_Text)text).text = value;
			((TMP_Text)text).fontSize = size;
			((Graphic)text).color = color;
			((TMP_Text)text).alignment = (TextAlignmentOptions)514;
			((Graphic)text).raycastTarget = false;
		}

		private void SetVisible(bool visible)
		{
			if ((Object)(object)_canvasObject != (Object)null && _canvasObject.activeSelf != visible)
			{
				_canvasObject.SetActive(visible);
			}
		}
	}
	internal sealed class ArenaRuntime
	{
		private static readonly Vector3 ArenaOrigin = new Vector3(0f, 750f, 0f);

		private readonly Plugin _plugin;

		private AssetBundle _bundle;

		private GameObject _arena;

		private Transform[] _spawns;

		private Collider _killVolume;

		private CSteamID _lobby;

		private Vector3 _localSpawnPosition;

		private float _localSpawnYaw;

		private float _killPlaneY;

		private bool _deploymentStarted;

		private bool _ready;

		private UpgradeDraft _draft;

		private readonly List<CSteamID> _members = new List<CSteamID>();

		private bool _isHost;

		private int _localSlot = -1;

		private string _roundId = string.Empty;

		private string _roundState = string.Empty;

		private bool _preparingRound;

		private bool _draftFinished;

		private bool _combatStarted;

		private bool _localEliminated;

		private int _lastAliveSlot = -1;

		private int _upgradeEpoch;

		private float _nextNetworkPoll;

		private float _nextVitalsRefresh;

		private float _roundOverAt;

		private RoundResultUi _resultUi;

		private MatchDecisionUi _matchUi;

		private SpectatorController _spectator;

		private string _arenaId = "arena03";

		private string _arenaName = "Arena03";

		private const string RoundIdKey = "htr_round_id";

		private const string RoundStateKey = "htr_round_state";

		private const string RoundNumberKey = "htr_round_number";

		private const string EligibleKey = "htr_round_eligible";

		private const string WinnerKey = "htr_round_winner";

		private const string UpgradeEpochKey = "htr_upgrade_epoch";

		private const int WinsPerMatch = 10;

		internal ArenaRuntime(Plugin plugin)
		{
			_plugin = plugin;
		}

		internal void Begin(CSteamID lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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)
			_lobby = lobby;
			if (!_deploymentStarted)
			{
				_arenaId = NormalizeArenaId(SteamMatchmaking.GetLobbyData(lobby, "htr_arena"));
				_arenaName = DisplayName(_arenaId);
				_deploymentStarted = true;
				RoundUpgradeEffects.ModeActive = true;
				((MonoBehaviour)_plugin).StartCoroutine(DeployWhenPlayerExists());
			}
		}

		internal void Tick()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			_draft?.Tick();
			RoundUpgradeEffects.Tick();
			if (!_ready || (Object)(object)Player.LocalPlayer == (Object)null)
			{
				return;
			}
			if (_roundState == "combat")
			{
				CheckLocalElimination();
			}
			if (_draft != null && _draft.IsComplete && !_draftFinished)
			{
				_draftFinished = true;
				StartCombatLocally();
				if (_isHost)
				{
					SteamMatchmaking.SetLobbyData(_lobby, "htr_round_state", "combat");
				}
			}
			if (!(Time.unscaledTime < _nextNetworkPoll))
			{
				_nextNetworkPoll = Time.unscaledTime + 0.1f;
				RefreshRoundState();
				if (_isHost && Time.unscaledTime >= _nextVitalsRefresh)
				{
					_nextVitalsRefresh = Time.unscaledTime + 0.5f;
					RefillVitals(_roundState != "combat");
				}
				if (_isHost && _roundState == "combat")
				{
					EvaluateWinner();
				}
				if (_isHost && _roundState == "over" && Time.unscaledTime >= _roundOverAt + 3f)
				{
					BeginNextRound();
				}
			}
		}

		private IEnumerator DeployWhenPlayerExists()
		{
			Plugin.Log.LogInfo((object)("Waiting for the local player before loading " + _arenaName + "..."));
			while ((Object)(object)Player.LocalPlayer == (Object)null || !((Component)Player.LocalPlayer).gameObject.activeInHierarchy)
			{
				yield return (object)new WaitForSecondsRealtime(0.25f);
			}
			yield return (object)new WaitForSecondsRealtime(1.25f);
			if (!LoadArena(_arenaId))
			{
				yield break;
			}
			if (_spawns.Length == 0)
			{
				Plugin.Log.LogError((object)(_arenaName + " contains no HTR_Spawn_1-4 markers."));
				yield break;
			}
			int spawnIndex = UpdateLocalSpawn();
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				localPlayer.LocalTeleport(_localSpawnPosition, _localSpawnYaw, true);
			}
			yield return (object)new WaitForSecondsRealtime(0.45f);
			localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer != (Object)null && Vector3.Distance(GetPhysicalPosition(localPlayer), _localSpawnPosition) > 5f)
			{
				localPlayer.LocalTeleport(_localSpawnPosition, _localSpawnYaw, true);
			}
			if ((Object)(object)localPlayer != (Object)null)
			{
				yield return GrantStartingLoadout(localPlayer);
			}
			BuildMemberOrder();
			_isHost = SteamMatchmaking.GetLobbyOwner(_lobby) == SteamUser.GetSteamID();
			_localSlot = _members.IndexOf(SteamUser.GetSteamID());
			_ready = true;
			if (_isHost)
			{
				_upgradeEpoch = 0;
				SteamMatchmaking.SetLobbyData(_lobby, "htr_upgrade_epoch", "0");
				ResetScores();
				StartRound(1, AllEligible());
			}
			else
			{
				_upgradeEpoch = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_upgrade_epoch"), 0);
			}
			Plugin.Log.LogInfo((object)(_arenaName + " ready. Local player assigned to spawn " + (spawnIndex + 1) + "."));
		}

		private IEnumerator GrantStartingLoadout(Player player)
		{
			float deadline = Time.unscaledTime + 8f;
			while (((Object)(object)Server.Instance == (Object)null || (Object)(object)player.Inventory == (Object)null || (Object)(object)player.Holding == (Object)null) && Time.unscaledTime < deadline)
			{
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
			if ((Object)(object)Server.Instance == (Object)null || (Object)(object)player.Inventory == (Object)null || (Object)(object)player.Holding == (Object)null)
			{
				Plugin.Log.LogError((object)"Could not grant the starting loadout because the player network objects were not ready.");
				yield break;
			}
			Item spawnable = GameInfo.GetSpawnable("knife");
			Item pistolPrefab = GameInfo.GetSpawnable("pistol");
			if ((Object)(object)spawnable == (Object)null || (Object)(object)pistolPrefab == (Object)null)
			{
				Plugin.Log.LogError((object)("Could not find the vanilla Knife or Pistol prefabs (knife=" + ((Object)(object)spawnable != (Object)null) + ", pistol=" + ((Object)(object)pistolPrefab != (Object)null) + ")."));
				yield break;
			}
			Vector3 itemPosition = _localSpawnPosition + Vector3.up;
			Item heldItem = player.Holding.HeldItem;
			Server.Instance.BuyItem(spawnable.ID, player, heldItem, itemPosition, Quaternion.identity, true);
			deadline = Time.unscaledTime + 5f;
			while (!IsKnife(player.Holding.HeldItem) && Time.unscaledTime < deadline)
			{
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
			Item heldItem2 = player.Holding.HeldItem;
			if (!IsKnife(heldItem2))
			{
				Plugin.Log.LogError((object)"The server did not equip the free starting Knife in time.");
				yield break;
			}
			Server.Instance.BuyItem(pistolPrefab.ID, player, heldItem2, itemPosition, Quaternion.identity, true);
			deadline = Time.unscaledTime + 5f;
			while (!IsPistol(player.Holding.HeldItem) && Time.unscaledTime < deadline)
			{
				yield return (object)new WaitForSecondsRealtime(0.1f);
			}
			if (!IsPistol(player.Holding.HeldItem))
			{
				Plugin.Log.LogError((object)"The server did not equip the free starting Pistol in time.");
			}
			else
			{
				Plugin.Log.LogInfo((object)"Starting loadout granted: Pistol equipped and Knife stored in the inventory.");
			}
		}

		private static bool IsKnife(Item item)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)item.Melee != (Object)null)
			{
				return ((Object)item).name.IndexOf("knife", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static bool IsPistol(Item item)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)item.Weapon != (Object)null)
			{
				return ((Object)item).name.IndexOf("pistol", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private bool LoadArena(string requestedArenaId)
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			string text = NormalizeArenaId(requestedArenaId);
			if ((Object)(object)_arena != (Object)null && (Object)(object)_bundle != (Object)null && text == _arenaId)
			{
				return true;
			}
			try
			{
				string text2 = Path.GetDirectoryName(((BaseUnityPlugin)_plugin).Info.Location);
				string path = "howtorounds_" + text;
				if (text2 == null)
				{
					text2 = string.Empty;
				}
				string text3 = Path.Combine(text2, path);
				if (!File.Exists(text3))
				{
					Plugin.Log.LogError((object)("Arena bundle was not found: " + text3));
					return false;
				}
				AssetBundle val = AssetBundle.LoadFromFile(text3);
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogError((object)("Unity could not load the " + DisplayName(text) + " AssetBundle."));
					return false;
				}
				GameObject val2 = val.LoadAsset<GameObject>("assets/howtorounds/prefabs/" + text + ".prefab");
				if ((Object)(object)val2 == (Object)null)
				{
					string[] allAssetNames = val.GetAllAssetNames();
					foreach (string text4 in allAssetNames)
					{
						val2 = val.LoadAsset<GameObject>(text4);
						if ((Object)(object)val2 != (Object)null)
						{
							break;
						}
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogError((object)(DisplayName(text) + " prefab was not present in the AssetBundle."));
					val.Unload(true);
					return false;
				}
				GameObject val3 = Object.Instantiate<GameObject>(val2, ArenaOrigin, Quaternion.identity);
				if ((Object)(object)val3 == (Object)null)
				{
					Plugin.Log.LogError((object)(DisplayName(text) + " could not be instantiated."));
					val.Unload(true);
					return false;
				}
				GameObject arena = _arena;
				AssetBundle bundle = _bundle;
				_arenaId = text;
				_arenaName = DisplayName(text);
				_arena = val3;
				_bundle = val;
				((Object)_arena).name = "HowToRounds_" + _arenaName + "_Runtime";
				Object.DontDestroyOnLoad((Object)(object)_arena);
				ConfigureLevelSurfaces();
				ResolveArenaMarkers();
				if ((Object)(object)arena != (Object)null)
				{
					Object.Destroy((Object)(object)arena);
				}
				if ((Object)(object)bundle != (Object)null)
				{
					bundle.Unload(false);
				}
				Plugin.Log.LogInfo((object)("Loaded " + _arenaName + " for round " + CurrentRoundNumber() + "."));
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)(_arenaName + " loading failed: " + ex));
				return false;
			}
		}

		private void ConfigureLevelSurfaces()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_00f4: 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)
			LayerMask val = GameInfo.LevelLayer;
			int value = ((LayerMask)(ref val)).value;
			int num = FirstLayerInMask(value);
			if (num < 0)
			{
				Plugin.Log.LogWarning((object)"GameInfo.LevelLayer is empty; arena surfaces could not be marked as jumpable.");
				return;
			}
			int num2 = 0;
			Collider[] componentsInChildren = _arena.GetComponentsInChildren<Collider>(true);
			foreach (Collider val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null) && !val2.isTrigger)
				{
					GameObject gameObject = ((Component)val2).gameObject;
					gameObject.layer = num;
					try
					{
						gameObject.tag = "Level";
					}
					catch (UnityException ex)
					{
						UnityException ex2 = ex;
						Plugin.Log.LogWarning((object)("Could not tag arena surface as Level: " + ((Exception)(object)ex2).Message));
					}
					num2++;
				}
			}
			ManualLogSource log = Plugin.Log;
			string[] obj = new string[9]
			{
				"Configured ",
				num2.ToString(),
				" arena colliders on Level layer ",
				num.ToString(),
				" (LevelMask=",
				value.ToString(),
				", CanJumpOnLayers=",
				null,
				null
			};
			val = GameInfo.CanJumpOnLayers;
			obj[7] = ((LayerMask)(ref val)).value.ToString();
			obj[8] = ").";
			log.LogInfo((object)string.Concat(obj));
		}

		private static int FirstLayerInMask(int mask)
		{
			for (int i = 0; i < 32; i++)
			{
				if ((mask & (1 << i)) != 0)
				{
					return i;
				}
			}
			return -1;
		}

		private void ResolveArenaMarkers()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			_killVolume = null;
			List<Transform> list = new List<Transform>(4);
			Transform[] componentsInChildren = _arena.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name.StartsWith("HTR_Spawn_", StringComparison.Ordinal))
				{
					list.Add(val);
				}
				else if (((Object)val).name == "HTR_KillVolume")
				{
					_killVolume = ((Component)val).GetComponent<Collider>();
				}
			}
			list.Sort((Transform left, Transform right) => string.CompareOrdinal(((Object)left).name, ((Object)right).name));
			_spawns = list.ToArray();
			if ((Object)(object)_killVolume != (Object)null)
			{
				Bounds bounds = _killVolume.bounds;
				_killPlaneY = ((Bounds)(ref bounds)).max.y;
			}
			else
			{
				_killPlaneY = ArenaOrigin.y - 20f;
				Plugin.Log.LogWarning((object)(_arenaName + " has no collider named HTR_KillVolume; only the fallback height check will work."));
			}
		}

		private int UpdateLocalSpawn()
		{
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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)
			int num = ResolveLocalSpawnIndex(_spawns.Length);
			Transform val = _spawns[num];
			_localSpawnPosition = val.position + Vector3.up * 0.15f;
			_localSpawnYaw = val.eulerAngles.y;
			return num;
		}

		private static string NormalizeArenaId(string arenaId)
		{
			if (!TryNormalizeArenaId(arenaId, out var normalized))
			{
				return "arena03";
			}
			return normalized;
		}

		internal static string DisplayName(string arenaId)
		{
			string text = NormalizeArenaId(arenaId);
			return "Arena" + text.Substring(5);
		}

		private static bool TryNormalizeArenaId(string arenaId, out string normalized)
		{
			normalized = null;
			if (string.IsNullOrEmpty(arenaId))
			{
				return false;
			}
			string text = arenaId.Trim().ToLowerInvariant();
			if (!text.StartsWith("arena", StringComparison.Ordinal) || text.Length < 7)
			{
				return false;
			}
			for (int i = 5; i < text.Length; i++)
			{
				if (!char.IsDigit(text[i]))
				{
					return false;
				}
			}
			if (!int.TryParse(text.Substring(5), out var result) || result < 3)
			{
				return false;
			}
			normalized = "arena" + result.ToString("D2");
			return true;
		}

		internal static List<string> FindInstalledArenas(string pluginDirectory)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(pluginDirectory) || !Directory.Exists(pluginDirectory))
			{
				return list;
			}
			string[] files = Directory.GetFiles(pluginDirectory, "howtorounds_arena*");
			for (int i = 0; i < files.Length; i++)
			{
				if (TryNormalizeArenaId(Path.GetFileName(files[i]).Substring("howtorounds_".Length), out var normalized) && !list.Contains(normalized))
				{
					list.Add(normalized);
				}
			}
			list.Sort((string left, string right) => int.Parse(left.Substring(5)).CompareTo(int.Parse(right.Substring(5))));
			return list;
		}

		private int ResolveLocalSpawnIndex(int spawnCount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0042: 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_004c: 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)
			try
			{
				CSteamID steamID = SteamUser.GetSteamID();
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(_lobby);
				if (steamID == lobbyOwner)
				{
					return 0;
				}
				int num = 1;
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_lobby);
				for (int i = 0; i < numLobbyMembers; i++)
				{
					CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(_lobby, i);
					if (!(lobbyMemberByIndex == lobbyOwner))
					{
						if (lobbyMemberByIndex == steamID)
						{
							return num % spawnCount;
						}
						num++;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not resolve the Steam spawn slot: " + ex.Message));
			}
			return 0;
		}

		private void BuildMemberOrder()
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			_members.Clear();
			CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(_lobby);
			if (lobbyOwner.m_SteamID != 0L)
			{
				_members.Add(lobbyOwner);
			}
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(_lobby, i);
				if (lobbyMemberByIndex != lobbyOwner)
				{
					_members.Add(lobbyMemberByIndex);
				}
			}
		}

		private bool[] AllEligible()
		{
			bool[] array = new bool[_members.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = true;
			}
			return array;
		}

		private void StartRound(int number, bool[] eligible)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			string text = (string.IsNullOrEmpty(_roundId) ? _arenaId : SelectArenaForNextRound());
			string text2 = text + ":" + number + "-" + SteamUtils.GetServerRealTime() + "-" + Random.Range(100, 999);
			SteamMatchmaking.SetLobbyData(_lobby, "htr_arena", text);
			SteamMatchmaking.SetLobbyData(_lobby, "htr_round_number", number.ToString());
			SteamMatchmaking.SetLobbyData(_lobby, "htr_round_eligible", EncodeEligible(eligible));
			SteamMatchmaking.SetLobbyData(_lobby, "htr_round_winner", "-1");
			SteamMatchmaking.SetLobbyData(_lobby, "htr_round_id", text2);
			SteamMatchmaking.SetLobbyData(_lobby, "htr_round_state", "draft");
			ObserveNewRound(text2, eligible);
		}

		private void RefreshRoundState()
		{
			//IL_0001: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			int num = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_upgrade_epoch"), 0);
			if (num != _upgradeEpoch)
			{
				_upgradeEpoch = num;
				RoundUpgradeEffects.ResetAllUpgrades();
			}
			string lobbyData = SteamMatchmaking.GetLobbyData(_lobby, "htr_round_id");
			string lobbyData2 = SteamMatchmaking.GetLobbyData(_lobby, "htr_round_state");
			if (!string.IsNullOrEmpty(lobbyData) && lobbyData != _roundId)
			{
				ObserveNewRound(lobbyData, DecodeEligible(SteamMatchmaking.GetLobbyData(_lobby, "htr_round_eligible")));
			}
			if (!(lobbyData2 == _roundState))
			{
				_roundState = lobbyData2;
				switch (lobbyData2)
				{
				case "combat":
					StartCombatLocally();
					break;
				case "over":
					ShowRoundResult();
					break;
				case "match_over":
					ShowMatchResult();
					break;
				}
			}
		}

		private void ObserveNewRound(string id, bool[] eligible)
		{
			_roundId = id;
			_roundState = "draft";
			_draft = null;
			_draftFinished = false;
			_combatStarted = false;
			_localEliminated = false;
			_lastAliveSlot = -1;
			_preparingRound = true;
			RoundUpgradeEffects.LocalEliminated = false;
			StopSpectating();
			RoundUpgradeEffects.ResetProjectileTracking();
			if ((Object)(object)_resultUi != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_resultUi).gameObject);
			}
			if ((Object)(object)_matchUi != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_matchUi).gameObject);
			}
			string roundArenaId = ArenaIdFromRoundId(id);
			((MonoBehaviour)_plugin).StartCoroutine(PrepareRound(eligible, roundArenaId));
		}

		private IEnumerator PrepareRound(bool[] eligible, string roundArenaId)
		{
			Player local = Player.LocalPlayer;
			RoundUpgradeEffects.SelectionActive = true;
			RoundUpgradeEffects.AllowRoundRespawn = true;
			if ((Object)(object)local != (Object)null && (Object)(object)local.Rigidbody != (Object)null)
			{
				local.Rigidbody.linearVelocity = Vector3.zero;
				local.Rigidbody.constraints = (RigidbodyConstraints)126;
			}
			if (!LoadArena(roundArenaId))
			{
				RoundUpgradeEffects.AllowRoundRespawn = false;
				_preparingRound = false;
				yield break;
			}
			if (_spawns.Length == 0)
			{
				Plugin.Log.LogError((object)(_arenaName + " contains no HTR_Spawn_1-4 markers."));
				RoundUpgradeEffects.AllowRoundRespawn = false;
				_preparingRound = false;
				yield break;
			}
			UpdateLocalSpawn();
			if ((Object)(object)local != (Object)null && (Object)(object)local.Dying != (Object)null && local.Dying.IsDead && (Object)(object)Server.Instance != (Object)null)
			{
				Server.Instance.RespawnPlayer(local, _localSpawnPosition, Quaternion.Euler(0f, _localSpawnYaw, 0f));
				float deadline = Time.unscaledTime + 6f;
				while (local.Dying.IsDead && Time.unscaledTime < deadline)
				{
					yield return (object)new WaitForSecondsRealtime(0.1f);
				}
			}
			RoundUpgradeEffects.AllowRoundRespawn = false;
			local = Player.LocalPlayer;
			if ((Object)(object)local != (Object)null)
			{
				local.LocalTeleport(_localSpawnPosition, _localSpawnYaw, true);
				if ((Object)(object)local.Rigidbody != (Object)null)
				{
					local.Rigidbody.linearVelocity = Vector3.zero;
					local.Rigidbody.constraints = (RigidbodyConstraints)126;
				}
				if (!IsPistol(((Object)(object)local.Holding != (Object)null) ? local.Holding.HeldItem : null))
				{
					yield return GrantStartingLoadout(local);
				}
			}
			_draft = new UpgradeDraft(_lobby, eligible);
			_draft.Begin();
			_preparingRound = false;
			SteamMatchmaking.SetLobbyMemberData(_lobby, "htr_life", _roundId + ":alive");
		}

		private string SelectArenaForNextRound()
		{
			List<string> list = FindInstalledArenas(Path.GetDirectoryName(((BaseUnityPlugin)_plugin).Info.Location) ?? string.Empty);
			if (list.Count == 0)
			{
				return _arenaId;
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			list.Remove(_arenaId);
			return list[Random.Range(0, list.Count)];
		}

		private string ArenaIdFromRoundId(string roundId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			int num = (string.IsNullOrEmpty(roundId) ? (-1) : roundId.IndexOf(':'));
			if (num > 0)
			{
				return NormalizeArenaId(roundId.Substring(0, num));
			}
			return NormalizeArenaId(SteamMatchmaking.GetLobbyData(_lobby, "htr_arena"));
		}

		private void StartCombatLocally()
		{
			//IL_0079: 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)
			if (_combatStarted || _preparingRound)
			{
				return;
			}
			_combatStarted = true;
			_roundState = "combat";
			_localEliminated = false;
			RoundUpgradeEffects.SelectionActive = false;
			RoundUpgradeEffects.LocalEliminated = false;
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				localPlayer.LocalTeleport(_localSpawnPosition, _localSpawnYaw, true);
				if ((Object)(object)localPlayer.Rigidbody != (Object)null)
				{
					localPlayer.Rigidbody.constraints = (RigidbodyConstraints)112;
				}
			}
			RoundUpgradeEffects.RefillLocalPistol();
			SteamMatchmaking.SetLobbyMemberData(_lobby, "htr_life", _roundId + ":alive");
			if (_isHost)
			{
				RefillVitals(includeHealth: true);
			}
		}

		private void CheckLocalElimination()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (_localEliminated)
			{
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			bool flag = (Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead;
			bool flag2 = GetPhysicalPosition(localPlayer).y < _killPlaneY;
			if (flag || flag2)
			{
				if (flag2 && !flag && (Object)(object)Server.Instance != (Object)null)
				{
					Vector3 physicalPosition = GetPhysicalPosition(localPlayer);
					Server.Instance.HitPlayer(localPlayer, 10000, Vector3.down * 10f, physicalPosition, (byte)0, (Player)null);
				}
				_localEliminated = true;
				RoundUpgradeEffects.LocalEliminated = true;
				BeginSpectating();
				SteamMatchmaking.SetLobbyMemberData(_lobby, "htr_life", _roundId + ":dead");
				if ((Object)(object)localPlayer.Rigidbody != (Object)null)
				{
					localPlayer.Rigidbody.linearVelocity = Vector3.zero;
					localPlayer.Rigidbody.constraints = (RigidbodyConstraints)126;
				}
				Plugin.Log.LogInfo((object)("Local player eliminated from round " + CurrentRoundNumber() + "."));
			}
		}

		private void EvaluateWinner()
		{
			//IL_000a: 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_009e: 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)
			int num = 0;
			int num2 = -1;
			for (int i = 0; i < _members.Count; i++)
			{
				if (!(SteamMatchmaking.GetLobbyMemberData(_lobby, _members[i], "htr_life") == _roundId + ":dead"))
				{
					num++;
					num2 = i;
				}
			}
			if (num == 1)
			{
				_lastAliveSlot = num2;
			}
			if (_members.Count >= 2 && num <= 1)
			{
				int num3 = ((num == 1) ? num2 : _lastAliveSlot);
				if (num3 < 0)
				{
					num3 = 0;
				}
				int num4 = GetWins(num3) + 1;
				SetWins(num3, num4);
				SteamMatchmaking.SetLobbyData(_lobby, "htr_round_winner", num3.ToString());
				string text = ((num4 >= 10) ? "match_over" : "over");
				SteamMatchmaking.SetLobbyData(_lobby, "htr_round_state", text);
				_roundState = text;
				_roundOverAt = Time.unscaledTime;
				if (text == "match_over")
				{
					ShowMatchResult();
				}
				else
				{
					ShowRoundResult();
				}
			}
		}

		private void ShowRoundResult()
		{
			//IL_0018: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			_roundOverAt = Time.unscaledTime;
			RoundUpgradeEffects.SelectionActive = true;
			StopSpectating();
			int num = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_round_winner"), -1);
			string winner = ((num >= 0 && num < _members.Count) ? SteamFriends.GetFriendPersonaName(_members[num]) : "PLAYER");
			if (num >= 0 && num < _members.Count && _members[num] == SteamUser.GetSteamID())
			{
				winner = SteamFriends.GetPersonaName();
			}
			GameObject val = new GameObject("HowToRounds_RoundResult");
			Object.DontDestroyOnLoad((Object)(object)val);
			_resultUi = val.AddComponent<RoundResultUi>();
			_resultUi.Build(winner, CurrentRoundNumber(), GetWins(num), 10);
		}

		private void ShowMatchResult()
		{
			//IL_0056: 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_007f: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			RoundUpgradeEffects.SelectionActive = true;
			StopSpectating();
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Rigidbody != (Object)null)
			{
				localPlayer.Rigidbody.linearVelocity = Vector3.zero;
				localPlayer.Rigidbody.constraints = (RigidbodyConstraints)126;
			}
			if (!((Object)(object)_matchUi != (Object)null))
			{
				int slot = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_round_winner"), -1);
				string winner = MemberName(slot);
				GameObject val = new GameObject("HowToRounds_MatchDecision");
				Object.DontDestroyOnLoad((Object)(object)val);
				_matchUi = val.AddComponent<MatchDecisionUi>();
				_matchUi.Build(winner, _isHost, ContinueMatch, RestartMatch);
			}
		}

		private void ContinueMatch()
		{
			if (_isHost && !(_roundState != "match_over"))
			{
				ResetScores();
				StartRound(CurrentRoundNumber() + 1, AllEligible());
			}
		}

		private void RestartMatch()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_isHost && !(_roundState != "match_over"))
			{
				_upgradeEpoch++;
				SteamMatchmaking.SetLobbyData(_lobby, "htr_upgrade_epoch", _upgradeEpoch.ToString());
				RoundUpgradeEffects.ResetAllUpgrades();
				ResetScores();
				StartRound(1, AllEligible());
			}
		}

		private string MemberName(int slot)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			if (slot < 0 || slot >= _members.Count)
			{
				return "PLAYER";
			}
			if (_members[slot] == SteamUser.GetSteamID())
			{
				return SteamFriends.GetPersonaName();
			}
			string friendPersonaName = SteamFriends.GetFriendPersonaName(_members[slot]);
			if (!string.IsNullOrWhiteSpace(friendPersonaName) && !(friendPersonaName == "[unknown]"))
			{
				return friendPersonaName;
			}
			return "PLAYER " + (slot + 1);
		}

		private int GetWins(int slot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_wins_" + slot), 0);
		}

		private void SetWins(int slot, int wins)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SteamMatchmaking.SetLobbyData(_lobby, "htr_wins_" + slot, Mathf.Max(0, wins).ToString());
		}

		private void ResetScores()
		{
			for (int i = 0; i < _members.Count; i++)
			{
				SetWins(i, 0);
			}
		}

		private void BeginSpectating()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_spectator != (Object)null))
			{
				GameObject val = new GameObject("HowToRounds_Spectator");
				Object.DontDestroyOnLoad((Object)(object)val);
				_spectator = val.AddComponent<SpectatorController>();
				_spectator.Begin(ArenaOrigin);
			}
		}

		private void StopSpectating()
		{
			if (!((Object)(object)_spectator == (Object)null))
			{
				Object.Destroy((Object)(object)((Component)_spectator).gameObject);
				_spectator = null;
			}
		}

		private void BeginNextRound()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			int num = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_round_winner"), -1);
			bool[] array = AllEligible();
			if (num >= 0 && num < array.Length)
			{
				array[num] = false;
			}
			StartRound(CurrentRoundNumber() + 1, array);
		}

		private int CurrentRoundNumber()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_round_number"), 1);
		}

		private void RefillVitals(bool includeHealth)
		{
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Vitals == (Object)null))
				{
					if (includeHealth)
					{
						RoundUpgradeEffects.SetHealthToMaximum(val);
					}
					else
					{
						RoundUpgradeEffects.ClampHealthToMaximum(val);
					}
					val.Vitals.RestoreFullness(100);
				}
			}
		}

		private static string EncodeEligible(bool[] eligible)
		{
			char[] array = new char[eligible.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (eligible[i] ? '1' : '0');
			}
			return new string(array);
		}

		private bool[] DecodeEligible(string value)
		{
			bool[] array = new bool[_members.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = i < value.Length && value[i] == '1';
			}
			return array;
		}

		private static int ParseInt(string value, int fallback)
		{
			if (!int.TryParse(value, out var result))
			{
				return fallback;
			}
			return result;
		}

		private static Vector3 GetPhysicalPosition(Player player)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player.Rigidbody != (Object)null))
			{
				return ((Component)player).transform.position;
			}
			return player.Rigidbody.position;
		}
	}
	internal sealed class CrosshairHud : MonoBehaviour
	{
		private GameObject _canvasObject;

		private CanvasGroup _canvasGroup;

		private void Awake()
		{
			Build();
		}

		private void Update()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				bool flag = RoundUpgradeEffects.ModeActive && !RoundUpgradeEffects.SelectionActive && !RoundUpgradeEffects.LocalEliminated && !MainMenuManager.IsInMenu;
				_canvasGroup.alpha = (flag ? 1f : 0f);
			}
		}

		private void Build()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			_canvasObject = new GameObject("HowToRounds_Crosshair");
			_canvasObject.transform.SetParent(((Component)this).transform, false);
			Canvas obj = _canvasObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32060;
			CanvasScaler obj2 = _canvasObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			_canvasGroup = _canvasObject.AddComponent<CanvasGroup>();
			_canvasGroup.interactable = false;
			_canvasGroup.blocksRaycasts = false;
			_canvasGroup.alpha = 0f;
			CreateBar("OutlineHorizontal", new Vector2(22f, 4f), Color.black);
			CreateBar("OutlineVertical", new Vector2(4f, 22f), Color.black);
			CreateBar("Horizontal", new Vector2(18f, 2f), Color.white);
			CreateBar("Vertical", new Vector2(2f, 18f), Color.white);
		}

		private void CreateBar(string name, Vector2 size, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(_canvasObject.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.anchoredPosition = Vector2.zero;
			obj.sizeDelta = size;
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = color;
			((Graphic)obj2).raycastTarget = false;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_canvasObject != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObject);
			}
		}
	}
	internal sealed class PlayerHealthHud : MonoBehaviour
	{
		private sealed class Bar
		{
			internal GameObject Root;

			internal RectTransform Rect;

			internal Image Fill;

			internal TextMeshProUGUI Value;

			internal float Displayed = 1f;
		}

		private readonly Dictionary<Player, Bar> _worldBars = new Dictionary<Player, Bar>();

		private readonly List<Player> _remove = new List<Player>();

		private GameObject _canvasObject;

		private RectTransform _canvasRect;

		private Bar _localBar;

		private TMP_FontAsset _font;

		private VitalsUI _nativeVitals;

		private bool _nativeVitalsWasActive;

		private float _nextPlayerRefresh;

		private void Update()
		{
			if (!RoundUpgradeEffects.ModeActive)
			{
				SetCanvasVisible(visible: false);
				RestoreNativeVitals();
				return;
			}
			HideNativeVitals();
			EnsureCanvas();
			SetCanvasVisible(visible: true);
			UpdateLocalBar();
			if (Time.unscaledTime >= _nextPlayerRefresh)
			{
				_nextPlayerRefresh = Time.unscaledTime + 0.25f;
				RefreshPlayers();
			}
			UpdateWorldBars();
		}

		private void OnDestroy()
		{
			RestoreNativeVitals();
		}

		private void HideNativeVitals()
		{
			if ((Object)(object)_nativeVitals == (Object)null)
			{
				_nativeVitals = Object.FindObjectOfType<VitalsUI>();
				if ((Object)(object)_nativeVitals != (Object)null)
				{
					_nativeVitalsWasActive = ((Component)_nativeVitals).gameObject.activeSelf;
				}
			}
			if ((Object)(object)_nativeVitals != (Object)null && ((Component)_nativeVitals).gameObject.activeSelf)
			{
				((Component)_nativeVitals).gameObject.SetActive(false);
			}
		}

		private void RestoreNativeVitals()
		{
			if (!((Object)(object)_nativeVitals == (Object)null))
			{
				if (_nativeVitalsWasActive && !((Component)_nativeVitals).gameObject.activeSelf)
				{
					((Component)_nativeVitals).gameObject.SetActive(true);
				}
				_nativeVitals = null;
			}
		}

		private void EnsureCanvas()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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)
			if (!((Object)(object)_canvasObject != (Object)null))
			{
				TMP_Text val = Object.FindObjectOfType<TMP_Text>();
				_font = (((Object)(object)val != (Object)null) ? val.font : null);
				_canvasObject = new GameObject("HowToRounds_HealthHud", new Type[1] { typeof(RectTransform) });
				_canvasObject.transform.SetParent(((Component)this).transform, false);
				_canvasRect = _canvasObject.GetComponent<RectTransform>();
				Canvas obj = _canvasObject.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 32055;
				CanvasScaler obj2 = _canvasObject.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1920f, 1080f);
				_localBar = CreateBar((Transform)(object)_canvasRect, "LocalHealth", new Vector2(310f, 78f), local: true);
				RectTransform rect = _localBar.Rect;
				RectTransform rect2 = _localBar.Rect;
				Vector2 val2 = (_localBar.Rect.pivot = Vector2.zero);
				Vector2 anchorMin = (rect2.anchorMax = val2);
				rect.anchorMin = anchorMin;
				_localBar.Rect.anchoredPosition = new Vector2(32f, 42f);
			}
		}

		private void UpdateLocalBar()
		{
			Player localPlayer = Player.LocalPlayer;
			bool flag = (Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Vitals != (Object)null && !RoundUpgradeEffects.LocalEliminated;
			if (_localBar.Root.activeSelf != flag)
			{
				_localBar.Root.SetActive(flag);
			}
			if (flag)
			{
				UpdateBar(_localBar, localPlayer.Vitals.Health, RoundUpgradeEffects.GetMaximumHealth(localPlayer));
			}
		}

		private void RefreshPlayers()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			HashSet<Player> hashSet = new HashSet<Player>();
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)Player.LocalPlayer) && !((Object)(object)val.Vitals == (Object)null))
				{
					hashSet.Add(val);
					if (!_worldBars.ContainsKey(val))
					{
						_worldBars[val] = CreateBar((Transform)(object)_canvasRect, "PlayerHealth", new Vector2(154f, 34f), local: false);
					}
				}
			}
			_remove.Clear();
			foreach (KeyValuePair<Player, Bar> worldBar in _worldBars)
			{
				if ((Object)(object)worldBar.Key == (Object)null || !hashSet.Contains(worldBar.Key))
				{
					_remove.Add(worldBar.Key);
				}
			}
			foreach (Player item in _remove)
			{
				if (_worldBars.TryGetValue(item, out var value) && (Object)(object)value.Root != (Object)null)
				{
					Object.Destroy((Object)(object)value.Root);
				}
				_worldBars.Remove(item);
			}
		}

		private void UpdateWorldBars()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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)
			Camera main = Camera.main;
			foreach (KeyValuePair<Player, Bar> worldBar in _worldBars)
			{
				Player key = worldBar.Key;
				Bar value = worldBar.Value;
				if ((Object)(object)key == (Object)null || (Object)(object)key.Vitals == (Object)null || (Object)(object)main == (Object)null)
				{
					value.Root.SetActive(false);
					continue;
				}
				Vector3 val = (((Object)(object)key.Rigidbody != (Object)null) ? key.Rigidbody.position : ((Component)key).transform.position);
				float num = Mathf.Pow(0.8f, (float)RoundUpgradeEffects.GetLevel(key, RoundUpgrade.Miniature));
				Vector3 val2 = main.WorldToScreenPoint(val + Vector3.up * (2.25f * num));
				bool flag = val2.z > 0f && val2.x >= 0f && val2.x <= (float)Screen.width && val2.y >= 0f && val2.y <= (float)Screen.height;
				if (value.Root.activeSelf != flag)
				{
					value.Root.SetActive(flag);
				}
				if (flag)
				{
					((Transform)value.Rect).position = new Vector3(val2.x, val2.y, 0f);
					UpdateBar(value, key.Vitals.Health, RoundUpgradeEffects.GetMaximumHealth(key));
				}
			}
		}

		private static void UpdateBar(Bar bar, int health, int maximum)
		{
			//IL_005b: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			maximum = Mathf.Max(1, maximum);
			int num = Mathf.Clamp(health, 0, maximum);
			float num2 = (float)num / (float)maximum;
			bar.Displayed = Mathf.MoveTowards(bar.Displayed, num2, Time.unscaledDeltaTime * 2.5f);
			bar.Fill.fillAmount = bar.Displayed;
			((Graphic)bar.Fill).color = Color.Lerp(new Color(0.95f, 0.18f, 0.14f), new Color(0.18f, 0.86f, 0.42f), num2);
			((TMP_Text)bar.Value).text = num + " / " + maximum;
		}

		private Bar CreateBar(Transform parent, string name, Vector2 size, bool local)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0065: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			Bar bar = new Bar();
			bar.Root = new GameObject(name, new Type[1] { typeof(RectTransform) });
			bar.Root.transform.SetParent(parent, false);
			bar.Rect = bar.Root.GetComponent<RectTransform>();
			RectTransform rect = bar.Rect;
			RectTransform rect2 = bar.Rect;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			rect2.anchorMax = val;
			rect.anchorMin = val;
			bar.Rect.sizeDelta = size;
			((Graphic)bar.Root.AddComponent<Image>()).color = new Color(0.08f, 0.13f, 0.22f, local ? 0.94f : 0.88f);
			Outline obj = bar.Root.AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(0.92f, 0.95f, 1f, 0.95f);
			((Shadow)obj).effectDistance = (local ? new Vector2(2f, -2f) : new Vector2(1f, -1f));
			GameObject val2 = new GameObject("Track", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)bar.Rect, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.anchoredPosition = (Vector2)(local ? new Vector2(0f, -12f) : Vector2.zero);
			component.sizeDelta = (local ? new Vector2(270f, 25f) : new Vector2(140f, 20f));
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.025f, 0.04f, 0.07f, 0.98f);
			GameObject val3 = new GameObject("Fill", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent((Transform)(object)component, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			val = (component2.offsetMin = (component2.offsetMax = Vector2.zero));
			bar.Fill = val3.AddComponent<Image>();
			((Graphic)bar.Fill).color = new Color(0.18f, 0.86f, 0.42f);
			bar.Fill.type = (Type)3;
			bar.Fill.fillMethod = (FillMethod)0;
			bar.Fill.fillOrigin = 0;
			bar.Fill.fillAmount = 1f;
			GameObject val5 = new GameObject("Value", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent((Transform)(object)bar.Rect, false);
			RectTransform component3 = val5.GetComponent<RectTransform>();
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component3.anchorMax = val;
			component3.anchorMin = val;
			component3.anchoredPosition = (Vector2)(local ? new Vector2(0f, -12f) : Vector2.zero);
			component3.sizeDelta = (local ? new Vector2(280f, 32f) : new Vector2(150f, 26f));
			bar.Value = val5.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)bar.Value).font = _font;
			}
			((TMP_Text)bar.Value).text = "100 / 100";
			((TMP_Text)bar.Value).fontSize = (local ? 21f : 15f);
			((TMP_Text)bar.Value).fontStyle = (FontStyles)1;
			((TMP_Text)bar.Value).alignment = (TextAlignmentOptions)514;
			((Graphic)bar.Value).color = Color.white;
			((Graphic)bar.Value).raycastTarget = false;
			if (local)
			{
				GameObject val6 = new GameObject("Title", new Type[1] { typeof(RectTransform) });
				val6.transform.SetParent((Transform)(object)bar.Rect, false);
				RectTransform component4 = val6.GetComponent<RectTransform>();
				((Vector2)(ref val))..ctor(0.5f, 0.5f);
				component4.anchorMax = val;
				component4.anchorMin = val;
				component4.anchoredPosition = new Vector2(0f, 23f);
				component4.sizeDelta = new Vector2(280f, 26f);
				TextMeshProUGUI val7 = val6.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)_font != (Object)null)
				{
					((TMP_Text)val7).font = _font;
				}
				((TMP_Text)val7).text = "HEALTH";
				((TMP_Text)val7).fontSize = 18f;
				((TMP_Text)val7).alignment = (TextAlignmentOptions)514;
				((Graphic)val7).color = new Color(0.72f, 0.81f, 0.92f);
				((Graphic)val7).raycastTarget = false;
			}
			return bar;
		}

		private void SetCanvasVisible(bool visible)
		{
			if ((Object)(object)_canvasObject != (Object)null && _canvasObject.activeSelf != visible)
			{
				_canvasObject.SetActive(visible);
			}
		}
	}
	[BepInPlugin("com.reysher.howtofish.howtorounds", "How to ROUNDS", "0.17.6")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal enum LobbyFlow
		{
			None,
			Creating,
			Joining,
			Staging,
			Starting
		}

		internal const string PluginGuid = "com.reysher.howtofish.howtorounds";

		internal const string PluginName = "How to ROUNDS";

		internal const string PluginVersion = "0.17.6";

		internal const string ArenaKey = "htr_arena";

		internal static ManualLogSource Log;

		private RoundsMenuUi _menuUi;

		private Harmony _harmony;

		private CallResult<LobbyMatchList_t> _lobbySearchResult;

		private CSteamID _stagingLobby;

		private string _requestedRoomCode;

		private float _nextMenuProbe;

		private float _nextLobbyRefresh;

		private ArenaRuntime _arenaRuntime;

		private int _joinSearchAttempt;

		internal static Plugin Instance { get; private set; }

		internal LobbyFlow Flow { get; private set; }

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			_harmony = new Harmony("com.reysher.howtofish.howtorounds");
			try
			{
				_harmony.PatchAll();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("One or more gameplay patches could not be applied: " + ex));
			}
			((Component)this).gameObject.AddComponent<AmmoHud>();
			((Component)this).gameObject.AddComponent<PlayerHealthHud>();
			((Component)this).gameObject.AddComponent<CrosshairHud>();
			_lobbySearchResult = CallResult<LobbyMatchList_t>.Create((APIDispatchDelegate<LobbyMatchList_t>)OnLobbySearchCompleted);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"How to ROUNDS staging lobby loaded.");
		}

		private void OnDestroy()
		{
			RoundUpgradeEffects.ModeActive = false;
			RoundUpgradeEffects.SelectionActive = false;
			RoundUpgradeEffects.LocalEliminated = false;
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			if (Time.unscaledTime >= _nextMenuProbe)
			{
				_nextMenuProbe = Time.unscaledTime + 0.3f;
				EnsureMenuUi();
				if ((Object)(object)_menuUi != (Object)null)
				{
					_menuUi.SetMenuVisible(IsAtMainMenu());
				}
			}
			if (Flow == LobbyFlow.Starting && _arenaRuntime != null)
			{
				_arenaRuntime.Tick();
			}
			if (Flow == LobbyFlow.Staging && Time.unscaledTime >= _nextLobbyRefresh)
			{
				_nextLobbyRefresh = Time.unscaledTime + 0.35f;
				RefreshLobby();
			}
		}

		private void EnsureMenuUi()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!((Object)(object)_menuUi != (Object)null) && IsAtMainMenu())
			{
				GameObject val = new GameObject("HowToRounds_MenuUi");
				Object.DontDestroyOnLoad((Object)(object)val);
				_menuUi = val.AddComponent<RoundsMenuUi>();
				_menuUi.Initialize(this);
			}
		}

		private static bool IsAtMainMenu()
		{
			if (MainMenuManager.IsInMenu)
			{
				return (Object)(object)Object.FindObjectOfType<MainMenuManager>() != (Object)null;
			}
			return false;
		}

		internal bool ShouldInterceptLobbyCreated()
		{
			return Flow == LobbyFlow.Creating;
		}

		internal bool IsDuplicateStagingEntry(ulong lobbyId)
		{
			if (Flow == LobbyFlow.Staging)
			{
				return _stagingLobby.m_SteamID == lobbyId;
			}
			return false;
		}

		internal void CreateRoom()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (Flow != LobbyFlow.None)
			{
				return;
			}
			try
			{
				_menuUi.SetBrowserStatus("Creating Steam room...");
				ServerSaveObject curServerSave = SaveManager.CurServerSave;
				if (curServerSave == null)
				{
					SaveManager.CreateServer("How To ROUNDS", true, true, (Difficulty)1);
					curServerSave = SaveManager.CurServerSave;
				}
				if (curServerSave == null)
				{
					throw new InvalidOperationException("Could not prepare the How to ROUNDS world.");
				}
				curServerSave.UseSteam = true;
				curServerSave.IsPublic = true;
				Flow = LobbyFlow.Creating;
				SteamMatchmaking.CreateLobby((ELobbyType)2, GetMaxPlayers());
			}
			catch (Exception ex)
			{
				Flow = LobbyFlow.None;
				Log.LogError((object)ex);
				_menuUi.SetBrowserStatus("Could not create the room. Check the console.", error: true);
			}
		}

		internal void JoinRoom(string code)
		{
			if (Flow != LobbyFlow.None)
			{
				return;
			}
			if (!RoomCode.TryNormalize(code, out var code2))
			{
				_menuUi.SetBrowserStatus("Enter a valid 5-character room code.", error: true);
				return;
			}
			try
			{
				Flow = LobbyFlow.Joining;
				_requestedRoomCode = code2;
				_joinSearchAttempt = 0;
				_menuUi.SetBrowserStatus("Searching for room " + code2 + "...");
				RequestRoomSearch();
			}
			catch (Exception ex)
			{
				Flow = LobbyFlow.None;
				Log.LogError((object)ex);
				_menuUi.SetBrowserStatus("Could not join the room. Check the code.", error: true);
			}
		}

		private void OnLobbySearchCompleted(LobbyMatchList_t callback, bool ioFailure)
		{
			//IL_000d: 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)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			if (Flow != LobbyFlow.Joining)
			{
				return;
			}
			if (ioFailure || callback.m_nLobbiesMatching == 0)
			{
				if (!ioFailure && ++_joinSearchAttempt < 4)
				{
					_menuUi.SetBrowserStatus("Steam is locating room " + _requestedRoomCode + "... attempt " + (_joinSearchAttempt + 1) + "/4");
					((MonoBehaviour)this).StartCoroutine(RetryRoomSearch());
				}
				else
				{
					Flow = LobbyFlow.None;
					_menuUi.SetBrowserStatus(ioFailure ? "Steam could not search for rooms. Try again." : ("Room " + _requestedRoomCode + " is not visible. Make sure the host uses mod 0.17.6."), error: true);
				}
				return;
			}
			CSteamID lobbyByIndex = SteamMatchmaking.GetLobbyByIndex(0);
			if (lobbyByIndex.m_SteamID == 0L)
			{
				Flow = LobbyFlow.None;
				_menuUi.SetBrowserStatus("Steam returned an invalid room.", error: true);
				return;
			}
			string lobbyData = SteamMatchmaking.GetLobbyData(lobbyByIndex, "how_to_rounds");
			if (lobbyData != "0.17.6")
			{
				Flow = LobbyFlow.None;
				_menuUi.SetBrowserStatus("Room found, but versions differ (host " + (string.IsNullOrEmpty(lobbyData) ? "unknown" : lobbyData) + ", you 0.17.6).", error: true);
			}
			else
			{
				_menuUi.SetBrowserStatus("Joining room " + _requestedRoomCode + "...");
				SteamManager.JoinLobby(lobbyByIndex.m_SteamID);
			}
		}

		private void RequestRoomSearch()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			SteamMatchmaking.AddRequestLobbyListStringFilter("htr_code", _requestedRoomCode, (ELobbyComparison)0);
			SteamMatchmaking.AddRequestLobbyListDistanceFilter((ELobbyDistanceFilter)3);
			_lobbySearchResult.Set(SteamMatchmaking.RequestLobbyList(), (APIDispatchDelegate<LobbyMatchList_t>)null);
		}

		private IEnumerator RetryRoomSearch()
		{
			yield return (object)new WaitForSecondsRealtime(1.2f);
			if (Flow == LobbyFlow.Joining)
			{
				RequestRoomSearch();
			}
		}

		internal void OnLobbyCreated(LobbyCreated_t callback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((int)callback.m_eResult != 1 || callback.m_ulSteamIDLobby == 0L)
			{
				Flow = LobbyFlow.None;
				_menuUi.SetBrowserStatus("Steam could not create the room.", error: true);
			}
			else
			{
				EnterStagingLobby(new CSteamID(callback.m_ulSteamIDLobby), createdByLocalPlayer: true);
			}
		}

		internal void OnLobbyEntered(LobbyEnter_t callback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			if (callback.m_EChatRoomEnterResponse != 1 || callback.m_ulSteamIDLobby == 0L)
			{
				Flow = LobbyFlow.None;
				_menuUi.SetBrowserStatus("Steam rejected the room connection.", error: true);
				return;
			}
			CSteamID val = default(CSteamID);
			((CSteamID)(ref val))..ctor(callback.m_ulSteamIDLobby);
			string lobbyData = SteamMatchmaking.GetLobbyData(val, "version");
			string lobbyData2 = SteamMatchmaking.GetLobbyData(val, "how_to_rounds");
			if (lobbyData != Application.version || lobbyData2 != "0.17.6")
			{
				SteamMatchmaking.LeaveLobby(val);
				Flow = LobbyFlow.None;
				_menuUi.SetBrowserStatus("Room version mismatch. Install the same game and mod version.", error: true);
			}
			else
			{
				EnterStagingLobby(val, createdByLocalPlayer: false);
			}
		}

		private void EnterStagingLobby(CSteamID lobby, bool createdByLocalPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			_stagingLobby = lobby;
			SetCurrentLobbyId(lobby);
			Flow = LobbyFlow.Staging;
			if (createdByLocalPlayer)
			{
				_requestedRoomCode = RoomCode.Generate();
				SteamMatchmaking.SetLobbyData(lobby, "how_to_rounds", "0.17.6");
				SteamMatchmaking.SetLobbyData(lobby, "htr_state", "waiting");
				SteamMatchmaking.SetLobbyData(lobby, "htr_arena", "arena03");
				SteamMatchmaking.SetLobbyData(lobby, "htr_code", _requestedRoomCode);
				SteamMatchmaking.SetLobbyData(lobby, "name", SteamFriends.GetPersonaName() + "'s How to ROUNDS lobby");
				SteamMatchmaking.SetLobbyData(lobby, "version", Application.version);
				SteamMatchmaking.SetLobbyType(lobby, (ELobbyType)2);
				SteamMatchmaking.SetLobbyJoinable(lobby, true);
			}
			string code = (GUIUtility.systemCopyBuffer = (createdByLocalPlayer ? _requestedRoomCode : SteamMatchmaking.GetLobbyData(lobby, "htr_code")));
			_menuUi.ShowLobby(code, IsLocalLobbyOwner());
			RefreshLobby();
		}

		private void RefreshLobby()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			if (_stagingLobby.m_SteamID == 0L)
			{
				return;
			}
			try
			{
				int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_stagingLobby);
				List<string> list = new List<string>(Math.Max(1, numLobbyMembers));
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(_stagingLobby);
				if (lobbyOwner.m_SteamID != 0L)
				{
					list.Add(GetPersonaName(lobbyOwner));
				}
				for (int i = 0; i < numLobbyMembers; i++)
				{
					CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(_stagingLobby, i);
					if (lobbyMemberByIndex != lobbyOwner)
					{
						list.Add(GetPersonaName(lobbyMemberByIndex));
					}
				}
				bool flag = IsLocalLobbyOwner();
				_menuUi.UpdateLobbyMembers(list, flag);
				if (!flag && SteamMatchmaking.GetLobbyData(_stagingLobby, "htr_state") == "starting")
				{
					BeginClientStart();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Lobby refresh failed: " + ex.Message));
			}
		}

		private bool IsLocalLobbyOwner()
		{
			//IL_000e: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			if (_stagingLobby.m_SteamID != 0L)
			{
				return SteamMatchmaking.GetLobbyOwner(_stagingLobby) == SteamUser.GetSteamID();
			}
			return false;
		}

		private static string GetPersonaName(CSteamID player)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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)
			string text = ((player == SteamUser.GetSteamID()) ? SteamFriends.GetPersonaName() : SteamFriends.GetFriendPersonaName(player));
			if (!string.IsNullOrWhiteSpace(text) && !(text == "[unknown]"))
			{
				return text;
			}
			return "Steam player";
		}

		internal void StartMatch()
		{
			//IL_0021: 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)
			if (Flow == LobbyFlow.Staging && IsLocalLobbyOwner())
			{
				Flow = LobbyFlow.Starting;
				string text = SelectArenaForMatch();
				SteamMatchmaking.SetLobbyData(_stagingLobby, "htr_arena", text);
				SteamMatchmaking.SetLobbyData(_stagingLobby, "htr_state", "starting");
				_menuUi.SetLobbyStatus("Starting " + ArenaRuntime.DisplayName(text) + "...");
				((MonoBehaviour)this).StartCoroutine(StartHostAfterSignal());
			}
		}

		private string SelectArenaForMatch()
		{
			List<string> list = ArenaRuntime.FindInstalledArenas(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? string.Empty);
			if (list.Count == 0)
			{
				Log.LogWarning((object)"No howtorounds_arenaNN bundles were found beside the plugin.");
				return "arena03";
			}
			string text = list[Random.Range(0, list.Count)];
			Log.LogInfo((object)("Host selected " + ArenaRuntime.DisplayName(text) + " from " + list.Count + " installed arena(s)."));
			return text;
		}

		private IEnumerator StartHostAfterSignal()
		{
			yield return (object)new WaitForSecondsRealtime(0.55f);
			if (!((Object)(object)ConnectionManager.Instance != (Object)null) || !ConnectionManager.Instance.CreateOnlineLobby(GetMaxPlayers()))
			{
				Flow = LobbyFlow.Staging;
				SteamMatchmaking.SetLobbyData(_stagingLobby, "htr_state", "waiting");
				_menuUi.SetLobbyStatus("Could not start the host.", error: true);
				yield break;
			}
			yield return (object)new WaitForSecondsRealtime(0.25f);
			if (!((Object)(object)ConnectionManager.Instance != (Object)null) || !ConnectionManager.Instance.JoinOnlineLobby(_stagingLobby))
			{
				Flow = LobbyFlow.Staging;
				SteamMatchmaking.SetLobbyData(_stagingLobby, "htr_state", "waiting");
				_menuUi.SetLobbyStatus("Host server started, but the local player could not connect.", error: true);
			}
			else
			{
				BeginArenaDeployment();
			}
		}

		private void BeginClientStart()
		{
			if (Flow == LobbyFlow.Staging)
			{
				Flow = LobbyFlow.Starting;
				_menuUi.SetLobbyStatus("Host is starting the match...");
				((MonoBehaviour)this).StartCoroutine(StartClientAfterHost());
			}
		}

		private IEnumerator StartClientAfterHost()
		{
			yield return (object)new WaitForSecondsRealtime(1.1f);
			if (!((Object)(object)ConnectionManager.Instance != (Object)null) || !ConnectionManager.Instance.JoinOnlineLobby(_stagingLobby))
			{
				Flow = LobbyFlow.Staging;
				_menuUi.SetLobbyStatus("Could not connect to the host.", error: true);
			}
			else
			{
				BeginArenaDeployment();
			}
		}

		private void BeginArenaDeployment()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_arenaRuntime == null)
			{
				_arenaRuntime = new ArenaRuntime(this);
			}
			_arenaRuntime.Begin(_stagingLobby);
		}

		internal void LeaveStagingLobby()
		{
			//IL_001e: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (_stagingLobby.m_SteamID != 0L)
			{
				SteamMatchmaking.LeaveLobby(_stagingLobby);
			}
			_stagingLobby = default(CSteamID);
			_requestedRoomCode = null;
			SetCurrentLobbyId(default(CSteamID));
			Flow = LobbyFlow.None;
			_menuUi.HideLobby();
		}

		private static void SetCurrentLobbyId(CSteamID lobby)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			AccessTools.Field(typeof(SteamManager), "<CurrentLobbyID>k__BackingField")?.SetValue(null, lobby);
		}

		private static int GetMaxPlayers()
		{
			if (!(AccessTools.Field(typeof(SteamManager), "MaxPlayers")?.GetValue(null) is int num) || num <= 0)
			{
				return 4;
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(SteamManager), "OnLobbyCreated")]
	internal static class StagingLobbyCreatedPatch
	{
		private static bool Prefix(LobbyCreated_t callback)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Plugin instance = Plugin.Instance;
			if ((Object)(object)instance == (Object)null || !instance.ShouldInterceptLobbyCreated())
			{
				return true;
			}
			instance.OnLobbyCreated(callback);
			return false;
		}
	}
	[HarmonyPatch(typeof(SteamManager), "OnLobbyEntered")]
	internal static class StagingLobbyEnteredPatch
	{
		private static bool Prefix(LobbyEnter_t callback)
		{
			//IL_0024: 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)
			Plugin instance = Plugin.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (instance.Flow == Plugin.LobbyFlow.Joining)
			{
				instance.OnLobbyEntered(callback);
				return false;
			}
			return !instance.IsDuplicateStagingEntry(callback.m_ulSteamIDLobby);
		}
	}
	internal static class RoomCode
	{
		private const string Alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";

		internal static string Generate()
		{
			byte[] array = Guid.NewGuid().ToByteArray();
			StringBuilder stringBuilder = new StringBuilder(5);
			for (int i = 0; i < 5; i++)
			{
				stringBuilder.Append("ABCDEFGHJKLMNPQRSTUVWXYZ23456789"[array[i] % "ABCDEFGHJKLMNPQRSTUVWXYZ23456789".Length]);
			}
			return stringBuilder.ToString();
		}

		internal static bool TryNormalize(string input, out string code)
		{
			code = (string.IsNullOrWhiteSpace(input) ? string.Empty : input.Trim().Replace("-", string.Empty).Replace(" ", string.Empty)
				.ToUpperInvariant());
			if (code.Length != 5)
			{
				return false;
			}
			string text = code;
			foreach (char value in text)
			{
				if ("ABCDEFGHJKLMNPQRSTUVWXYZ23456789".IndexOf(value) < 0)
				{
					return false;
				}
			}
			return true;
		}
	}
	internal sealed class RoundsMenuUi : MonoBehaviour
	{
		private static readonly Color VanillaPanel = new Color(0.1f, 0.2f, 0.34f, 0.94f);

		private static readonly Color VanillaRow = new Color(0.13f, 0.25f, 0.4f, 0.92f);

		private static readonly Color White = new Color(0.97f, 0.98f, 1f, 1f);

		private static readonly Color Muted = new Color(0.76f, 0.82f, 0.88f, 1f);

		private static readonly Color Error = new Color(1f, 0.48f, 0.38f, 1f);

		private Plugin _plugin;

		private Canvas _canvas;

		private GameObject _menuButton;

		private GameObject _modal;

		private GameObject _browserPanel;

		private GameObject _lobbyPanel;

		private TMP_InputField _codeInput;

		private TMP_Text _browserStatus;

		private TMP_Text _lobbyCode;

		private TMP_Text _lobbyStatus;

		private TMP_Text _hostHint;

		private readonly List<TMP_Text> _memberRows = new List<TMP_Text>();

		private GameObject _startButton;

		private TMP_FontAsset _font;

		private Sprite _buttonSprite;

		private Color _buttonColor = new Color(0.12f, 0.25f, 0.42f, 0.92f);

		private bool _modalOpen;

		internal void Initialize(Plugin plugin)
		{
			_plugin = plugin;
			TryAttachVanillaButton();
			BuildModal();
			if ((Object)(object)_menuButton == (Object)null)
			{
				CreateFallbackMenuButton();
			}
		}

		internal void SetMenuVisible(bool visible)
		{
			if (visible)
			{
				TryAttachVanillaButton();
			}
			if ((Object)(object)_menuButton != (Object)null)
			{
				_menuButton.SetActive(visible && !_modalOpen);
			}
			if (!visible && (Object)(object)_modal != (Object)null)
			{
				_modal.SetActive(false);
			}
			else if (visible && _modalOpen && (Object)(object)_modal != (Object)null)
			{
				_modal.SetActive(true);
			}
		}

		internal void SetBrowserStatus(string message, bool error = false)
		{
			//IL_002b: 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)
			if (!((Object)(object)_browserStatus == (Object)null))
			{
				_browserStatus.text = message;
				((Graphic)_browserStatus).color = (error ? Error : Muted);
			}
		}

		internal void ShowLobby(string code, bool isHost)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			_modalOpen = true;
			_modal.SetActive(true);
			_browserPanel.SetActive(false);
			_lobbyPanel.SetActive(true);
			if ((Object)(object)_menuButton != (Object)null)
			{
				_menuButton.SetActive(false);
			}
			_lobbyCode.text = "ROOM CODE:  " + code;
			_lobbyStatus.text = "Waiting for players...";
			((Graphic)_lobbyStatus).color = Muted;
			SetHostControls(isHost);
		}

		internal void UpdateLobbyMembers(IReadOnlyList<string> members, bool isHost)
		{
			//IL_00b3: 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)
			for (int i = 0; i < _memberRows.Count; i++)
			{
				if (i < members.Count)
				{
					_memberRows[i].text = i + 1 + ".  " + members[i] + ((i == 0) ? "   HOST" : string.Empty);
				}
				else
				{
					_memberRows[i].text = i + 1 + ".  Waiting for player...";
				}
				((Graphic)_memberRows[i]).color = (Color)((i < members.Count) ? White : new Color(Muted.r, Muted.g, Muted.b, 0.55f));
			}
			SetHostControls(isHost);
		}

		internal void SetLobbyStatus(string message, bool error = false)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_lobbyStatus.text = message;
			((Graphic)_lobbyStatus).color = (error ? Error : Muted);
		}

		internal void HideLobby()
		{
			_modalOpen = false;
			_modal.SetActive(false);
			_browserPanel.SetActive(true);
			_lobbyPanel.SetActive(false);
			if ((Object)(object)_menuButton != (Object)null)
			{
				_menuButton.SetActive(true);
			}
		}

		private void TryAttachVanillaButton()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_menuButton != (Object)null)
			{
				return;
			}
			Button val = FindCreateGameButton();
			if (!((Object)(object)val == (Object)null))
			{
				TMP_Text componentInChildren = ((Component)val).GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					_font = componentInChildren.font;
				}
				Image component = ((Component)val).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					_buttonSprite = component.sprite;
					_buttonColor = ((Graphic)component).color;
				}
				_menuButton = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent, false);
				((Object)_menuButton).name = "HowToRounds_VanillaMenuButton";
				Button component2 = _menuButton.GetComponent<Button>();
				component2.onClick = new ButtonClickedEvent();
				((UnityEvent)component2.onClick).AddListener(new UnityAction(OpenBrowser));
				TMP_Text[] componentsInChildren = _menuButton.GetComponentsInChildren<TMP_Text>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].text = "HOW TO ROUNDS";
				}
				_menuButton.AddComponent<VanillaButtonLabelLock>().Initialize("HOW TO ROUNDS");
				RectTransform component3 = ((Component)val).GetComponent<RectTransform>();
				RectTransform component4 = _menuButton.GetComponent<RectTransform>();
				if ((Object)(object)((Component)((Component)val).transform.parent).GetComponent<LayoutGroup>() != (Object)null)
				{
					_menuButton.transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex());
					return;
				}
				Vector2 anchoredPosition = component3.anchoredPosition;
				Rect rect = component3.rect;
				component4.anchoredPosition = anchoredPosition + new Vector2(0f, ((Rect)(ref rect)).height + 10f);
			}
		}

		private static Button FindCreateGameButton()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			Button result = null;
			ButtonManager val = Object.FindObjectOfType<ButtonManager>();
			Button[] array = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponentsInChildren<Button>(true) : Resources.FindObjectsOfTypeAll<Button>());
			foreach (Button val2 in array)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Scene scene = ((Component)val2).gameObject.scene;
				if (!((Scene)(ref scene)).IsValid())
				{
					continue;
				}
				for (int j = 0; j < ((UnityEventBase)val2.onClick).GetPersistentEventCount(); j++)
				{
					if (((UnityEventBase)val2.onClick).GetPersistentMethodName(j) == "ToggleCreateServerButton")
					{
						return val2;
					}
				}
				TMP_Text componentInChildren = ((Component)val2).GetComponentInChildren<TMP_Text>(true);
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					string text = componentInChildren.text.ToLowerInvariant();
					if (text.Contains("crear partida") || text.Contains("create game") || text.Contains("create server"))
					{
						result = val2;
					}
				}
			}
			return result;
		}

		private void CreateFallbackMenuButton()
		{
			//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)
			//IL_004f: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_menuButton != (Object)null) && !((Object)(object)_canvas == (Object)null))
			{
				_menuButton = Button(((Component)_canvas).transform, "HOW TO ROUNDS", new Vector2(300f, 60f), new UnityAction(OpenBrowser));
				((Object)_menuButton).name = "HowToRounds_FallbackMenuButton";
				RectTransform component = _menuButton.GetComponent<RectTransform>();
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(0f, 0f);
				component.anchorMax = val;
				component.anchorMin = val;
				component.pivot = new Vector2(0f, 0.5f);
				component.anchoredPosition = new Vector2(40f, 420f);
				Plugin.Log.LogWarning((object)"The vanilla Create Game button was not found; using the standalone How To Rounds menu button.");
			}
		}

		private void BuildModal()
		{
			//IL_007a: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_font == (Object)null)
			{
				TMP_Text val = Object.FindObjectOfType<TMP_Text>();
				if ((Object)(object)val != (Object)null)
				{
					_font = val.font;
				}
			}
			GameObject val2 = UiObject("Canvas", ((Component)this).transform);
			_canvas = val2.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 32000;
			CanvasScaler obj = val2.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.matchWidthOrHeight = 0.5f;
			val2.AddComponent<GraphicRaycaster>();
			_modal = Panel(val2.transform, "RoundsModal", new Vector2(700f, 570f), VanillaPanel, outline: true);
			RectTransform component = _modal.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			component.anchorMax = val3;
			component.anchorMin = val3;
			component.anchoredPosition = new Vector2(115f, 0f);
			Text(_modal.transform, "HOW TO ROUNDS", 42f, (FontStyles)0, White, new Vector2(0f, 238f), new Vector2(620f, 58f), (TextAlignmentOptions)514);
			Text(_modal.transform, "COMPETITIVE FISHING COMBAT", 18f, (FontStyles)0, Muted, new Vector2(0f, 196f), new Vector2(620f, 30f), (TextAlignmentOptions)514);
			_browserPanel = UiObject("BrowserPanel", _modal.transform);
			Stretch(_browserPanel.GetComponent<RectTransform>());
			BuildBrowser();
			_lobbyPanel = UiObject("LobbyPanel", _modal.transform);
			Stretch(_lobbyPanel.GetComponent<RectTransform>());
			BuildLobby();
			_lobbyPanel.SetActive(false);
			_modal.SetActive(false);
		}

		private void BuildBrowser()
		{
			//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_0031: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			Button(_browserPanel.transform, "CREATE ROOM", new Vector2(310f, 62f), (UnityAction)delegate
			{
				_plugin.CreateRoom();
			}).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 115f);
			Text(_browserPanel.transform, "JOIN WITH CODE", 21f, (FontStyles)0, White, new Vector2(0f, 55f), new Vector2(500f, 32f), (TextAlignmentOptions)514);
			_codeInput = Input(_browserPanel.transform, new Vector2(360f, 58f));
			((Component)_codeInput).GetComponent<RectTransform>().anchoredPosition = new Vector2(-92f, 5f);
			Button(_browserPanel.transform, "JOIN", new Vector2(150f, 58f), (UnityAction)delegate
			{
				_plugin.JoinRoom(_codeInput.text);
			}).GetComponent<RectTransform>().anchoredPosition = new Vector2(185f, 5f);
			_browserStatus = (TMP_Text)(object)Text(_browserPanel.transform, "All players need the same mod version.", 17f, (FontStyles)0, Muted, new Vector2(0f, -80f), new Vector2(590f, 55f), (TextAlignmentOptions)514);
			Button(_browserPanel.transform, "BACK", new Vector2(220f, 54f), new UnityAction(CloseBrowser)).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, -190f);
		}

		private void BuildLobby()
		{
			//IL_0018: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00bd: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_022c: 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_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			_lobbyCode = (TMP_Text)(object)Text(_lobbyPanel.transform, "ROOM CODE", 25f, (FontStyles)0, White, new Vector2(0f, 150f), new Vector2(590f, 40f), (TextAlignmentOptions)514);
			Text(_lobbyPanel.transform, "PLAYERS IN ROOM", 20f, (FontStyles)0, Muted, new Vector2(0f, 105f), new Vector2(590f, 32f), (TextAlignmentOptions)514);
			for (int i = 0; i < 4; i++)
			{
				GameObject val = Panel(_lobbyPanel.transform, "PlayerRow" + i, new Vector2(520f, 46f), VanillaRow, outline: false);
				val.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 60f - (float)i * 51f);
				_memberRows.Add((TMP_Text)(object)Text(val.transform, i + 1 + ".  Waiting for player...", 19f, (FontStyles)0, Muted, Vector2.zero, new Vector2(480f, 42f), (TextAlignmentOptions)4097));
			}
			_lobbyStatus = (TMP_Text)(object)Text(_lobbyPanel.transform, "Waiting for players...", 17f, (FontStyles)0, Muted, new Vector2(0f, -160f), new Vector2(590f, 32f), (TextAlignmentOptions)514);
			_startButton = Button(_lobbyPanel.transform, "START", new Vector2(220f, 54f), (UnityAction)delegate
			{
				_plugin.StartMatch();
			});
			_startButton.GetComponent<RectTransform>().anchoredPosition = new Vector2(-125f, -215f);
			Button(_lobbyPanel.transform, "LEAVE", new Vector2(220f, 54f), (UnityAction)delegate
			{
				_plugin.LeaveStagingLobby();
			}).GetComponent<RectTransform>().anchoredPosition = new Vector2(125f, -215f);
			_hostHint = (TMP_Text)(object)Text(_lobbyPanel.transform, "", 16f, (FontStyles)0, Muted, new Vector2(-125f, -252f), new Vector2(240f, 24f), (TextAlignmentOptions)514);
		}

		private void SetHostControls(bool isHost)
		{
			_startButton.SetActive(isHost);
			_hostHint.text = (isHost ? "HOST CONTROLS" : "WAITING FOR HOST");
		}

		private void OpenBrowser()
		{
			_modalOpen = true;
			_modal.SetActive(true);
			_browserPanel.SetActive(true);
			_lobbyPanel.SetActive(false);
			if ((Object)(object)_menuButton != (Object)null)
			{
				_menuButton.SetActive(false);
			}
			SetBrowserStatus("All players need the same mod version.");
		}

		private void CloseBrowser()
		{
			_modalOpen = false;
			_modal.SetActive(false);
			if ((Object)(object)_menuButton != (Object)null)
			{
				_menuButton.SetActive(true);
			}
		}

		private GameObject Button(Transform parent, string label, Vector2 size, UnityAction action)
		{
			//IL_001c: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(parent, label.Replace(" ", string.Empty) + "Button", size, _buttonColor, outline: true);
			Image component = val.GetComponent<Image>();
			if ((Object)(object)_buttonSprite != (Object)null)
			{
				component.sprite = _buttonSprite;
				component.type = (Type)1;
			}
			Button obj = val.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)component;
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.78f, 0.9f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.58f, 0.72f, 0.88f);
			((Selectable)obj).colors = colors;
			((UnityEvent)obj.onClick).AddListener(action);
			Text(val.transform, label, 21f, (FontStyles)0, White, Vector2.zero, size, (TextAlignmentOptions)514);
			return val;
		}

		private TMP_InputField Input(Transform parent, Vector2 size)
		{
			//IL_0007: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			GameObject val = Panel(parent, "RoomCodeInput", size, new Color(0.06f, 0.13f, 0.22f, 0.96f), outline: true);
			GameObject val2 = UiObject("Text Area", val.transform);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(16f, 4f);
			component.offsetMax = new Vector2(-16f, -4f);
			val2.AddComponent<RectMask2D>();
			TMP_Text val3 = (TMP_Text)(object)Text(val2.transform, string.Empty, 21f, (FontStyles)0, White, Vector2.zero, Vector2.zero, (TextAlignmentOptions)514);
			Stretch(val3.rectTransform);
			TMP_Text val4 = (TMP_Text)(object)Text(val2.transform, "A6D5S", 19f, (FontStyles)0, Muted, Vector2.zero, Vector2.zero, (TextAlignmentOptions)514);
			Stretch(val4.rectTransform);
			TMP_InputField obj = val.AddComponent<TMP_InputField>();
			obj.textViewport = component;
			obj.textComponent = (TMP_Text)(TextMeshProUGUI)val3;
			obj.placeholder = (Graphic)(object)val4;
			obj.characterLimit = 5;
			obj.contentType = (ContentType)4;
			obj.lineType = (LineType)0;
			((Selectable)obj).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			return obj;
		}

		private GameObject Panel(Transform parent, string name, Vector2 size, Color color, bool outline)
		{
			//IL_0021: 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_002d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UiObject(name, parent);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.sizeDelta = size;
			((Graphic)val.AddComponent<Image>()).color = color;
			if (outline)
			{
				Outline obj = val.AddComponent<Outline>();
				((Shadow)obj).effectColor = White;
				((Shadow)obj).effectDistance = new Vector2(2f, -2f);
			}
			return val;
		}

		private TextMeshProUGUI Text(Transform parent, string value, float size, FontStyles style, Color color, Vector2 position, Vector2 dimensions, TextAlignmentOptions alignment)
		{
			//IL_0024: 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_0031: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = UiObject("Text", parent);
			RectTransform component = obj.GetComponent<RectTransform>();
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.anchoredPosition = position;
			component.sizeDelta = dimensions;
			TextMeshProUGUI val2 = obj.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val2).font = _font;
			}
			((TMP_Text)val2).text = value;
			((TMP_Text)val2).fontSize = size;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).color = color;
			((TMP_Text)val2).alignment = alignment;
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)1;
			((Graphic)val2).raycastTarget = false;
			return val2;
		}

		private static GameObject UiObject(string name, Transform parent)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			return val;
		}

		private static void Stretch(RectTransform rect)
		{
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}
	}
	internal sealed class VanillaButtonLabelLock : MonoBehaviour
	{
		private string _label;

		private TMP_Text[] _texts;

		internal void Initialize(string label)
		{
			_label = label;
			_texts = ((Component)this).GetComponentsInChildren<TMP_Text>(true);
			Apply();
		}

		private void LateUpdate()
		{
			Apply();
		}

		private void Apply()
		{
			if (_texts == null)
			{
				return;
			}
			TMP_Text[] texts = _texts;
			foreach (TMP_Text val in texts)
			{
				if ((Object)(object)val != (Object)null && val.text != _label)
				{
					val.text = _label;
				}
			}
		}
	}
	internal sealed class SpectatorController : MonoBehaviour
	{
		private Camera _camera;

		private Vector3 _position;

		private float _yaw;

		private float _pitch;

		internal void Begin(Vector3 arenaCenter)
		{
			//IL_0001: 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_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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			_position = arenaCenter + new Vector3(0f, 8f, -12f);
			Vector3 val = arenaCenter - _position;
			Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			_yaw = ((Quaternion)(ref val2)).eulerAngles.y;
			_pitch = ((Quaternion)(ref val2)).eulerAngles.x;
			BuildHint();
		}

		private void LateUpdate()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			ResolveCamera();
			if (!((Object)(object)_camera == (Object)null))
			{
				Cursor.lockState = (CursorLockMode)1;
				Cursor.visible = false;
				_yaw += Input.GetAxisRaw("Mouse X") * 3f;
				_pitch = Mathf.Clamp(_pitch - Input.GetAxisRaw("Mouse Y") * 3f, -85f, 85f);
				Quaternion val = Quaternion.Euler(_pitch, _yaw, 0f);
				float num = (Input.GetKey((KeyCode)304) ? 20f : 10f);
				Vector3 val2 = val * new Vector3(Input.GetAxisRaw("Horizontal"), 0f, Input.GetAxisRaw("Vertical"));
				if (Input.GetKey((KeyCode)32))
				{
					val2 += Vector3.up;
				}
				if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)99))
				{
					val2 -= Vector3.up;
				}
				_position += ((Vector3)(ref val2)).normalized * num * Time.unscaledDeltaTime;
				((Component)_camera).transform.SetPositionAndRotation(_position, val);
			}
		}

		private void ResolveCamera()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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)
			if (!((Object)(object)_camera != (Object)null))
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.DeathCam != (Object)null)
				{
					ref Camera camera = ref _camera;
					object? obj = AccessTools.Field(typeof(PlayerDeathCam), "_deathCam")?.GetValue(localPlayer.DeathCam);
					camera = (Camera)((obj is Camera) ? obj : null);
				}
				if ((Object)(object)_camera == (Object)null)
				{
					_camera = Camera.main;
				}
				if ((Object)(object)_camera != (Object)null)
				{
					_position = ((Component)_camera).transform.position;
					Vector3 eulerAngles = ((Component)_camera).transform.eulerAngles;
					_yaw = eulerAngles.y;
					_pitch = ((eulerAngles.x > 180f) ? (eulerAngles.x - 360f) : eulerAngles.x);
				}
			}
		}

		private void BuildHint()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text val = Object.FindObjectOfType<TMP_Text>();
			GameObject val2 = new GameObject("SpectatorHud", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(((Component)this).transform, false);
			Canvas obj = val2.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32080;
			CanvasScaler obj2 = val2.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			GameObject val3 = new GameObject("Hint", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val2.transform, false);
			RectTransform component = val3.GetComponent<RectTransform>();
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(0.5f, 1f);
			component.anchorMax = val4;
			component.anchorMin = val4;
			component.anchoredPosition = new Vector2(0f, -45f);
			component.sizeDelta = new Vector2(1000f, 55f);
			TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val5).font = val.font;
			}
			((TMP_Text)val5).text = "SPECTATING  •  WASD MOVE  •  MOUSE LOOK  •  SPACE / CTRL UP & DOWN";
			((TMP_Text)val5).fontSize = 23f;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
			((Graphic)val5).color = Color.white;
			((Graphic)val5).raycastTarget = false;
		}
	}
	[HarmonyPatch(typeof(PlayerDeathCam), "LateUpdate")]
	internal static class FreeSpectatorCameraPatch
	{
		private static bool Prefix()
		{
			if (RoundUpgradeEffects.ModeActive)
			{
				return !RoundUpgradeEffects.LocalEliminated;
			}
			return true;
		}
	}
	internal enum RoundUpgrade
	{
		None = -1,
		MoreMore,
		DoubleJump,
		FasterThanMe,
		FasterCharge,
		Ricochet,
		BulletExplosive,
		BigBullets,
		QuickShot,
		GlassCannon,
		Tank,
		Lifesteal,
		HealingReload,
		PoisonBullet,
		Homing,
		Grow,
		Miniature,
		Impulse,
		MoreHeal,
		QuickReload,
		HeavyHitter,
		TightSpread,
		DoubleShot,
		BulletStorm
	}
	internal sealed class UpgradeDraft
	{
		private const string PhaseKey = "htr_draft_phase";

		private const string TurnKey = "htr_draft_turn";

		private const string IdKey = "htr_draft_id";

		private readonly CSteamID _lobby;

		private readonly bool _host;

		private readonly bool[] _eligible;

		private readonly List<CSteamID> _members = new List<CSteamID>();

		private UpgradeDraftUi _ui;

		private string _draftId;

		private int _localSlot = -1;

		private float _nextPoll;

		private float _nextCountdownStep;

		private int _lastHover = -2;

		private RoundUpgrade[] _localOffers;

		internal bool IsComplete { get; private set; }

		internal UpgradeDraft(CSteamID lobby, bool[] eligible)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			_lobby = lobby;
			_host = SteamMatchmaking.GetLobbyOwner(lobby) == SteamUser.GetSteamID();
			_eligible = eligible ?? Array.Empty<bool>();
		}

		internal void Begin()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			BuildMemberOrder();
			_localSlot = _members.IndexOf(SteamUser.GetSteamID());
			if (_host)
			{
				_draftId = SteamUtils.GetServerRealTime() + "-" + Random.Range(1000, 9999);
				SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_id", _draftId);
				SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_turn", FirstEligible().ToString());
				SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_countdown", "3");
				SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_phase", "pick");
			}
			_draftId = SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_id");
			_localOffers = OffersForMember(SteamUser.GetSteamID());
			CreateUi();
			FreezeLocalPlayer(freeze: true);
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}

		internal void Tick()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			if (IsComplete)
			{
				return;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			FreezeLocalPlayer(freeze: true);
			if (Time.unscaledTime < _nextPoll)
			{
				return;
			}
			_nextPoll = Time.unscaledTime + 0.08f;
			string lobbyData = SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_id");
			if (!string.IsNullOrEmpty(lobbyData) && lobbyData != _draftId)
			{
				_draftId = lobbyData;
				_localOffers = OffersForMember(SteamUser.GetSteamID());
			}
			string lobbyData2 = SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_phase");
			int num = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_turn"), 0);
			RoundUpgrade[] array = ReadPicks();
			if (_host && lobbyData2 == "pick" && num >= 0 && num < _members.Count && array[num] != RoundUpgrade.None)
			{
				int num2 = NextEligible(num);
				if (num2 >= 0)
				{
					SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_turn", num2.ToString());
				}
				else
				{
					SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_phase", "countdown");
					SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_countdown", "3");
					_nextCountdownStep = Time.unscaledTime + 1f;
				}
			}
			else if (_host && lobbyData2 == "countdown" && Time.unscaledTime >= _nextCountdownStep)
			{
				int num3 = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_countdown"), 3) - 1;
				SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_countdown", Math.Max(0, num3).ToString());
				_nextCountdownStep = Time.unscaledTime + 1f;
				if (num3 <= 0)
				{
					SteamMatchmaking.SetLobbyData(_lobby, "htr_draft_phase", "combat");
				}
			}
			lobbyData2 = SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_phase");
			num = ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_turn"), 0);
			int hover = ((num >= 0 && num < _members.Count) ? ReadMemberValue(_members[num], "htr_hover") : (-1));
			RoundUpgrade[] offers = ((num >= 0 && num < _members.Count) ? OffersForMember(_members[num]) : _localOffers);
			_ui?.Refresh(GetNames(), array, _eligible, num, hover, lobbyData2, offers, ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_countdown"), 3));
			if (lobbyData2 == "combat")
			{
				Finish(array);
			}
		}

		private void OnHover(int card)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalTurn() && card != _lastHover)
			{
				_lastHover = card;
				SteamMatchmaking.SetLobbyMemberData(_lobby, "htr_hover", _draftId + ":" + card);
			}
		}

		private void OnPick(int card)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalTurn() && card >= 0 && card < _localOffers.Length)
			{
				CSteamID lobby = _lobby;
				string draftId = _draftId;
				int num = (int)_localOffers[card];
				SteamMatchmaking.SetLobbyMemberData(lobby, "htr_pick", draftId + ":" + num);
			}
		}

		private bool IsLocalTurn()
		{
			//IL_0001: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			if (SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_phase") == "pick" && ParseInt(SteamMatchmaking.GetLobbyData(_lobby, "htr_draft_turn"), -1) == _localSlot && IsEligible(_localSlot))
			{
				return ReadMemberValue(SteamUser.GetSteamID(), "htr_pick") < 0;
			}
			return false;
		}

		private void Finish(RoundUpgrade[] picks)
		{
			RoundUpgradeEffects.AddChoices(picks, _eligible, _members);
			FreezeLocalPlayer(freeze: false);
			if ((Object)(object)_ui != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_ui).gameObject);
			}
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
			IsComplete = true;
			Plugin.Log.LogInfo((object)"Upgrade draft complete; combat controls enabled.");
		}

		private void BuildMemberOrder()
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			_members.Clear();
			CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(_lobby);
			if (lobbyOwner.m_SteamID != 0L)
			{
				_members.Add(lobbyOwner);
			}
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_lobby);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(_lobby, i);
				if (lobbyMemberByIndex != lobbyOwner)
				{
					_members.Add(lobbyMemberByIndex);
				}
			}
		}

		private string[] GetNames()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0031: Unknown result type (might be due to invalid IL or missing references)
			string[] array = new string[_members.Count];
			for (int i = 0; i < array.Length; i++)
			{
				CSteamID val = _members[i];
				array[i] = ((val == SteamUser.GetSteamID()) ? SteamFriends.GetPersonaName() : SteamFriends.GetFriendPersonaName(val));
				if (string.IsNullOrWhiteSpace(array[i]) || array[i] == "[unknown]")
				{
					array[i] = "Player " + (i + 1);
				}
			}
			return array;
		}

		private RoundUpgrade[] ReadPicks()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			RoundUpgrade[] array = new RoundUpgrade[_members.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = (IsEligible(i) ? ((RoundUpgrade)ReadMemberValue(_members[i], "htr_pick")) : RoundUpgrade.None);
			}
			return array;
		}

		private int FirstEligible()
		{
			for (int i = 0; i < _members.Count; i++)
			{
				if (IsEligible(i))
				{
					return i;
				}
			}
			return -1;
		}

		private int NextEligible(int current)
		{
			for (int i = current + 1; i < _members.Count; i++)
			{
				if (IsEligible(i))
				{
					return i;
				}
			}
			return -1;
		}

		private bool IsEligible(int slot)
		{
			if (slot >= 0 && slot < _eligible.Length)
			{
				return _eligible[slot];
			}
			return false;
		}

		private int ReadMemberValue(CSteamID member, string key)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			string lobbyMemberData = SteamMatchmaking.GetLobbyMemberData(_lobby, member, key);
			if (string.IsNullOrEmpty(lobbyMemberData) || string.IsNullOrEmpty(_draftId) || !lobbyMemberData.StartsWith(_draftId + ":", StringComparison.Ordinal))
			{
				return -1;
			}
			return ParseInt(lobbyMemberData.Substring(_draftId.Length + 1), -1);
		}

		private void CreateUi()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("HowToRounds_UpgradeDraft");
			Object.DontDestroyOnLoad((Object)(object)val);
			_ui = val.AddComponent<UpgradeDraftUi>();
			_ui.Build(OnHover, OnPick, _localSlot);
		}

		private RoundUpgrade[] OffersForMember(CSteamID member)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			List<RoundUpgrade[]> list = new List<RoundUpgrade[]>();
			RoundUpgrade[] array = new RoundUpgrade[23]
			{
				RoundUpgrade.MoreMore,
				RoundUpgrade.DoubleJump,
				RoundUpgrade.FasterThanMe,
				RoundUpgrade.FasterCharge,
				RoundUpgrade.Ricochet,
				RoundUpgrade.BulletExplosive,
				RoundUpgrade.BigBullets,
				RoundUpgrade.QuickShot,
				RoundUpgrade.GlassCannon,
				RoundUpgrade.Tank,
				RoundUpgrade.Lifesteal,
				RoundUpgrade.HealingReload,
				RoundUpgrade.PoisonBullet,
				RoundUpgrade.Homing,
				RoundUpgrade.Grow,
				RoundUpgrade.Miniature,
				RoundUpgrade.Impulse,
				RoundUpgrade.MoreHeal,
				RoundUpgrade.QuickReload,
				RoundUpgrade.HeavyHitter,
				RoundUpgrade.TightSpread,
				RoundUpgrade.DoubleShot,
				RoundUpgrade.BulletStorm
			};
			for (int i = 0; i < array.Length - 3; i++)
			{
				for (int j = i + 1; j < array.Length - 2; j++)
				{
					for (int k = j + 1; k < array.Length - 1; k++)
					{
						for (int l = k + 1; l < array.Length; l++)
						{
							list.Add(new RoundUpgrade[4]
							{
								array[i],
								array[j],
								array[k],
								array[l]
							});
						}
					}
				}
			}
			uint num = 2166136261u;
			string text = _draftId ?? string.Empty;
			for (int m = 0; m < text.Length; m++)
			{
				num = (num ^ text[m]) * 16777619;
			}
			int num2 = Math.Max(0, _members.IndexOf(member));
			RoundUpgrade[] array2 = (RoundUpgrade[])list[((int)(num % (uint)list.Count) + num2) % list.Count].Clone();
			string text2 = text + ":" + member.m_SteamID;
			for (int n = 0; n < text2.Length; n++)
			{
				num = (num ^ text2[n]) * 16777619;
			}
			Random random = new Random((int)num);
			for (int num3 = array2.Length - 1; num3 > 0; num3--)
			{
				int num4 = random.Next(num3 + 1);
				RoundUpgrade roundUpgrade = array2[num3];
				array2[num3] = array2[num4];
				array2[num4] = roundUpgrade;
			}
			return array2;
		}

		private static void FreezeLocalPlayer(bool freeze)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer.Rigidbody == (Object)null))
			{
				RoundUpgradeEffects.SelectionActive = freeze;
				localPlayer.Rigidbody.constraints = (RigidbodyConstraints)(freeze ? 126 : 112);
				if (freeze)
				{
					localPlayer.Rigidbody.linearVelocity = Vector3.zero;
				}
			}
		}

		private static int ParseInt(string value, int fallback)
		{
			if (!int.TryParse(value, out var result))
			{
				return fallback;
			}
			return result;
		}
	}
	internal sealed class UpgradeDraftUi : MonoBehaviour
	{
		private static readonly string[] Titles = new string[23]
		{
			"MORE MORE", "DOUBLE JUMP", "FASTER THAN ME", "FASTER CHARGE", "RICOCHET", "EXPLOSIVE BULLETS", "BIG BULLETS", "QUICK SHOT", "GLASS CANNON", "TANK",
			"LIFESTEAL", "HEALING RELOAD", "POISON BULLET", "HOMING", "GROW", "MINIATURE", "IMPULSE", "MORE HEALTH", "QUICK RELOAD", "HEAVY HITTER",
			"TIGHT SPREAD", "DOUBLE SHOT", "BULLET STORM"
		};

		private static readonly string[] Descriptions = new string[23]
		{
			"+2 bullets\n+10% projectile speed", "Gain one extra jump\nwhile airborne", "+20% movement speed", "Reload weapons\n50% faster", "Bullets bounce once\nStacks add more bounces", "Bullets explode on impact\n50% weapon damage per stack", "+50% bullet size\n+25% damage\n-20% projectile speed", "+35% fire rate\n-15% bullet damage", "+40% movement speed\n-50% maximum health", "+50 maximum health\n-20% movement speed",
			"Heal 30% of damage dealt", "Heal 20 health\nafter every reload", "Purple poison bullets\n30% projectile damage per second\nfor 3 seconds", "Bullets seek nearby players\nMore stacks track harder\nand farther", "-20% projectile speed\nEach second: +20% damage\nand +25% size", "-20% player size\n+20% movement speed\n-20 maximum health", "+3 projectile knockback\nper stack", "+50 maximum health\nper stack", "Reload weapons\n35% faster", "+30% bullet damage\n+40% weapon spread",
			"-50% weapon spread\nper stack", "+1 projectile per shot\n+1 ammo spent per shot", "+12 bullets\nRapid full-auto fire\n-30% bullet damage"
		};

		private readonly List<Image> _cards = new List<Image>();

		private readonly List<TMP_Text> _cardTitles = new List<TMP_Text>();

		private readonly List<TMP_Text> _cardDescriptions = new List<TMP_Text>();

		private readonly List<TMP_Text> _pickRows = new List<TMP_Text>();

		private RectTransform _hand;

		private TMP_Text _turn;

		private TMP_Text _countdown;

		private int _localSlot;

		private TMP_FontAsset _font;

		private Action<int> _directHover;

		private Action<int> _directPick;

		private int _directHoveredCard = -1;

		internal void Build(Action<int> hover, Action<int> pick, int localSlot)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: 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)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Expected O, but got Unknown
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: 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_0497: Unknown result type (might be due to invalid IL or missing references)
			_localSlot = localSlot;
			_directHover = hover;
			_directPick = pick;
			TMP_Text val = Object.FindObjectOfType<TMP_Text>();
			if ((Object)(object)val != (Object)null)
			{
				_font = val.font;
			}
			Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32100;
			CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			((Component)this).gameObject.AddComponent<GraphicRaycaster>();
			((Graphic)MakeImage(((Component)this).transform, "Shade", new Color(0.025f, 0.06f, 0.11f, 0.72f), new Vector2(1920f, 1080f), Vector2.zero)).raycastTarget = true;
			Text(((Component)this).transform, "CHOOSE YOUR UPGRADE", 48f, Color.white, new Vector2(0f, 450f), new Vector2(1300f, 70f));
			_turn = (TMP_Text)(object)Text(((Component)this).transform, "PLAYER 1 IS CHOOSING", 25f, new Color(0.72f, 0.84f, 0.93f), new Vector2(0f, 398f), new Vector2(1000f, 40f));
			float[] array = new float[4] { -570f, -190f, 190f, 570f };
			Color[] array2 = (Color[])(object)new Color[4]
			{
				new Color(0.2f, 0.82f, 1f),
				new Color(0.94f, 0.56f, 0.2f),
				new Color(0.32f, 0.88f, 0.55f),
				new Color(0.76f, 0.45f, 1f)
			};
			for (int i = 0; i < 4; i++)
			{
				int index = i;
				Image val2 = MakeImage(((Component)this).transform, "Card" + i, new Color(0.1f, 0.2f, 0.34f, 0.98f), new Vector2(330f, 470f), new Vector2(array[i], 90f));
				Outline obj3 = ((Component)val2).gameObject.AddComponent<Outline>();
				((Shadow)obj3).effectColor = Color.white;
				((Shadow)obj3).effectDistance = new Vector2(3f, -3f);
				MakeImage(((Component)val2).transform, "Accent", array2[i], new Vector2(294f, 9f), new Vector2(0f, 190f));
				_cardTitles.Add((TMP_Text)(object)Text(((Component)val2).transform, Titles[i], 30f, Color.white, new Vector2(0f, 118f), new Vector2(290f, 90f)));
				_cardDescriptions.Add((TMP_Text)(object)Text(((Component)val2).transform, Descriptions[i], 22f, new Color(0.8f, 0.87f, 0.93f), new Vector2(0f, -22f), new Vector2(280f, 150f)));
				Text(((Component)val2).transform, "CLICK TO SELECT", 16f, array2[i], new Vector2(0f, -188f), new Vector2(280f, 35f));
				Button obj4 = ((Component)val2).gameObject.AddComponent<Button>();
				((Selectable)obj4).targetGraphic = (Graphic)(object)val2;
				((UnityEvent)obj4.onClick).AddListener((UnityAction)delegate
				{
					pick(index);
				});
				((Component)val2).gameObject.AddComponent<CardHover>().Initialize(index, hover);
				_cards.Add(val2);
			}
			_hand = MakeHand(((Component)this).transform);
			for (int num = 0; num < 4; num++)
			{
				_pickRows.Add((TMP_Text)(object)Text(((Component)this).transform, string.Empty, 18f, Color.white, new Vector2((float)(-560 + num * 375), -405f), new Vector2(350f, 36f)));
			}
			_countdown = (TMP_Text)(object)Text(((Component)this).transform, string.Empty, 130f, Color.white, Vector2.zero, new Vector2(1000f, 180f));
			((Component)_countdown).gameObject.SetActive(false);
		}

		private void LateUpdate()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			int num = -1;
			for (int i = 0; i < _cards.Count; i++)
			{
				Image val = _cards[i];
				if (((Component)val).gameObject.activeInHierarchy && ((Graphic)val).raycastTarget && RectTransformUtility.RectangleContainsScreenPoint(((Graphic)val).rectTransform, Vector2.op_Implicit(Input.mousePosition)))
				{
					num = i;
					break;
				}
			}
			if (num >= 0 && num != _directHoveredCard)
			{
				_directHover?.Invoke(num);
			}
			_directHoveredCard = num;
			if (num >= 0 && Input.GetMouseButtonDown(0))
			{
				_directPick?.Invoke(num);
			}
		}

		internal void Refresh(string[] names, RoundUpgrade[] picks, bool[] eligible, int turn, int hover, string phase, RoundUpgrade[] offers, int countdown)
		{
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			bool flag = phase == "pick";
			string text = ((turn >= 0 && turn < names.Length) ? names[turn] : "Player");
			_turn.text = ((!flag) ? "ALL UPGRADES SELECTED" : ((turn == _localSlot) ? "YOUR TURN — CHOOSE A CARD" : (text.ToUpperInvariant() + " IS CHOOSING")));
			for (int i = 0; i < _cards.Count; i++)
			{
				((Graphic)_cards[i]).raycastTarget = flag && turn == _localSlot;
			}
			for (int j = 0; j < _cards.Count && j < offers.Length; j++)
			{
				_cardTitles[j].text = Title(offers[j]);
				_cardDescriptions[j].text = Descriptions[(int)offers[j]];
			}
			for (int k = 0; k < _pickRows.Count; k++)
			{
				if (k >= names.Length)
				{
					_pickRows[k].text = string.Empty;
					continue;
				}
				string text2 = ((k >= eligible.Length || !eligible[k]) ? "ROUND WINNER — NO CARD" : ((picks[k] == RoundUpgrade.None) ? "CHOOSING..." : Title(picks[k])));
				_pickRows[k].text = k + 1 + ". " + names[k] + "  •  " + text2;
			}
			if ((Object)(object)_hand != (Object)null)
			{
				((Component)_hand).gameObject.SetActive(flag && hover >= 0 && hover < 4);
				if (((Component)_hand).gameObject.activeSelf)
				{
					_hand.anchoredPosition = new Vector2((float)(-570 + hover * 380), -205f);
				}
			}
			bool flag2 = phase == "countdown";
			((Component)_countdown).gameObject.SetActive(flag2);
			if (flag2)
			{
				_countdown.text = ((countdown > 0) ? countdown.ToString() : "FIGHT!");
			}
			foreach (Image card in _cards)
			{
				((Component)card).gameObject.SetActive(!flag2);
			}
		}

		private RectTransform MakeHand(Transform parent)
		{
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PlayerHand", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(90f, 150f);
			MakeImage((Transform)(object)component, "Palm", new Color(0.96f, 0.97f, 1f), new Vector2(65f, 65f), new Vector2(0f, -28f));
			MakeImage((Transform)(object)component, "Finger", new Color(0.96f, 0.97f, 1f), new Vector2(25f, 90f), new Vector2(0f, 35f));
			MakeImage((Transform)(object)component, "Cuff", new Color(0.18f, 0.54f, 0.85f), new Vector2(76f, 28f), new Vector2(0f, -72f));
			return component;
		}

		private Image MakeImage(Transform parent, string name, Color color, Vector2 size, Vector2 pos)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.sizeDelta = size;
			component.anchoredPosition = pos;
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			return obj;
		}

		private TextMeshProUGUI Text(Transform parent, string value, float size, Color color, Vector2 pos, Vector2 dims)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.anchoredPosition = pos;
			component.sizeDelta = dims;
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val3).font = _font;
			}
			((TMP_Text)val3).text = value;
			((TMP_Text)val3).fontSize = size;
			((Graphic)val3).color = color;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			((TMP_Text)val3).enableWordWrapping = true;
			((Graphic)val3).raycastTarget = false;
			return val3;
		}

		private static string Title(RoundUpgrade choice)
		{
			if (choice < RoundUpgrade.MoreMore || choice > RoundUpgrade.BulletStorm)
			{
				return "UNKNOWN";
			}
			return Titles[(int)choice];
		}
	}
	internal sealed class CardHover : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler
	{
		private int _index;

		private Action<int> _callback;

		internal void Initialize(int index, Action<int> callback)
		{
			_index = index;
			_callback = callback;
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_callback?.Invoke(_index);
		}
	}
	internal sealed class RoundResultUi : MonoBehaviour
	{
		internal void Build(string winner, int round, int wins, int target)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			TMP_Text val = Object.FindObjectOfType<TMP_Text>();
			Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32090;
			CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			GameObject val2 = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(((Component)this).transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			component.anchorMax = val3;
			component.anchorMin = val3;
			component.sizeDelta = new Vector2(850f, 245f);
			((Graphic)val2.AddComponent<Image>()).color = new Color(0.1f, 0.18f, 0.3f, 0.96f);
			Outline obj3 = val2.AddComponent<Outline>();
			((Shadow)obj3).effectColor = Color.white;
			((Shadow)obj3).effectDistance = new Vector2(3f, -3f);
			AddText((Transform)(object)component, (winner ?? "PLAYER").ToUpperInvariant() + " WINS ROUND " + round, 46f, Color.white, new Vector2(0f, 45f), ((Object)(object)val != (Object)null) ? val.font : null);
			AddText((Transform)(object)component, "LOSERS CHOOSE ANOTHER UPGRADE", 25f, new Color(0.35f, 0.84f, 1f), new Vector2(0f, -45f), ((Object)(object)val != (Object)null) ? val.font : null);
			AddText((Transform)(object)component, "MATCH SCORE  " + wins + " / " + target, 20f, new Color(0.9f, 0.72f, 0.28f), new Vector2(0f, -88f), ((Object)(object)val != (Object)null) ? val.font : null);
		}

		private static void AddText(Transform parent, string value, float size, Color color, Vector2 position, TMP_FontAsset font)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(790f, 80f);
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val3).font = font;
			}
			((TMP_Text)val3).text = value;
			((TMP_Text)val3).fontSize = size;
			((Graphic)val3).color = color;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			((Graphic)val3).raycastTarget = false;
		}
	}
	internal sealed class MatchDecisionUi : MonoBehaviour
	{
		private RectTransform _continueRect;

		private RectTransform _restartRect;

		private Action _continue;

		private Action _restart;

		private bool _host;

		internal void Build(string winner, bool host, Action continueMatch, Action restartMatch)
		{
			//IL_0067: 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)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			_host = host;
			_continue = continueMatch;
			_restart = restartMatch;
			TMP_Text val = Object.FindObjectOfType<TMP_Text>();
			TMP_FontAsset font = (((Object)(object)val != (Object)null) ? val.font : null);
			Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 32120;
			CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			((Graphic)Image(((Component)this).transform, "Shade", new Color(0.02f, 0.05f, 0.1f, 0.78f), new Vector2(1920f, 1080f), Vector2.zero)).raycastTarget = true;
			Image val2 = Image(((Component)this).transform, "Panel", new Color(0.1f, 0.18f, 0.3f, 0.98f), new Vector2(900f, 430f), Vector2.zero);
			Outline obj3 = ((Component)val2).gameObject.AddComponent<Outline>();
			((Shadow)obj3).effectColor = Color.white;
			((Shadow)obj3).effectDistance = new Vector2(3f, -3f);
			Text(((Component)val2).transform, (winner ?? "PLAYER").ToUpperInvariant() + " WINS THE MATCH", 48f, Color.white, new Vector2(0f, 125f), font);
			Text(((Component)val2).transform, "10 ROUND WINS REACHED", 25f, new Color(0.9f, 0.72f, 0.28f), new Vector2(0f, 65f), font);
			if (host)
			{
				Text(((Component)val2).transform, "CHOOSE WHAT HAPPENS NEXT", 22f, new Color(0.7f, 0.84f, 0.94f), new Vector2(0f, 12f), font);
				_continueRect = Button(((Component)val2).transform, "CONTINUE", new Vector2(-210f, -85f), font, "KEEP UPGRADES\nNEW RACE TO 10");
				_restartRect = Button(((Component)val2).transform, "RESTART", new Vector2(210f, -85f), font, "RESET UPGRADES\nNEW RACE TO 10");
			}
			else
			{
				Text(((Component)val2).transform, "WAITING FOR THE HOST TO CONTINUE OR RESTART...", 22f, new Color(0.7f, 0.84f, 0.94f), new Vector2(0f, -45f), font);
			}
		}

		private void LateUpdate()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			if (_host && Input.GetMouseButtonDown(0))
			{
				Vector2 val = Vector2.op_Implicit(Input.mousePosition);
				if ((Object)(object)_continueRect != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(_continueRect, val))
				{
					_continue?.Invoke();
				}
				else if ((Object)(object)_restartRect != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(_restartRect, val))
				{
					_restart?.Invoke();
				}
			}
		}

		private static RectTransform Button(Transform parent, string title, Vector2 position, TMP_FontAsset font, string subtitle)
		{
			//IL_0016: 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_003c: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			Image obj = Image(parent, title, new Color(0.14f, 0.28f, 0.46f, 1f), new Vector2(350f, 125f), position);
			Outline obj2 = ((Component)obj).gameObject.AddComponent<Outline>();
			((Shadow)obj2).effectColor = Color.white;
			((Shadow)obj2).effectDistance = new Vector2(2f, -2f);
			Text(((Component)obj).transform, title, 29f, Color.white, new Vector2(0f, 22f), font);
			Text(((Component)obj).transform, subtitle, 16f, new Color(0.65f, 0.84f, 0.96f), new Vector2(0f, -27f), font);
			return ((Graphic)obj).rectTransform;
		}

		private static Image Image(Transform parent, string name, Color color, Vector2 size, Vector2 position)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.sizeDelta = size;
			component.anchoredPosition = position;
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			return obj;
		}

		private static void Text(Transform parent, string value, float size, Color color, Vector2 position, TMP_FontAsset font)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(820f, 80f);
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val3).font = font;
			}
			((TMP_Text)val3).text = value;
			((TMP_Text)val3).fontSize = size;
			((Graphic)val3).color = color;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			((Graphic)val3).raycastTarget = false;
		}
	}
	internal static class RoundUpgradeEffects
	{
		private const float RoundsPistolProjectileSpeed = 100f;

		private const float RoundsProjectileGravity = 60f;

		private const float ExplosiveBulletRadius = 2.5f;

		private const float RemoteMuzzleRevealDuration = 0.12f;

		private static readonly Dictionary<ulong, int[]> Levels = new Dictionary<ulong, int[]>();

		private static readonly Dictionary<int, int> AppliedMovementLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedGlassMovementLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedTankMovementLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedMiniatureMovementLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedMiniatureScaleLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedWeaponLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedBigBulletLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedQuickShotLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedTightSpreadLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedHeavyHitterSpreadLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedDoubleShotLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> AppliedBulletStormLevels = new Dictionary<int, int>();

		private static readonly Dictionary<int, bool> OriginalFullAutoStates = new Dictionary<int, bool>();

		private static readonly Dictionary<int, bool> ReloadStates = new Dictionary<int, bool>();

		private static readonly Dictionary<int, int> UsedExtraJumps = new Dictionary<int, int>();

		private static readonly HashSet<int> ConfiguredPistols = new HashSet<int>();

		private static readonly Dictionary<Projectile, int> ProjectileBounces = new Dictionary<Projectile, int>();

		private static readonly HashSet<Projectile> ExplodedProjectiles = new HashSet<Projectile>();

		private static readonly HashSet<Projectile> ConfiguredProjectiles = new HashSet<Projectile>();

		private static readonly Dictionary<Projectile, float> ProjectileSizeMultipliers = new Dictionary<Projectile, float>();

		private static readonly Dictionary<Projectile, float> ProjectileBaseSizes = new Dictionary<Projectile, float>();

		private static readonly Dictionary<Projectile, int> ProjectileBaseDamages = new Dictionary<Projectile, int>();

		private static readonly Dictionary<Projectile, float> ProjectileAges = new Dictionary<Projectile, float>();

		private static readonly Dictionary<Projectile, int> ProjectileGrowthSteps = new Dictionary<Projectile, int>();

		private static readonly Dictionary<Projectile, Vector3> ProjectileVisualOrigins = new Dictionary<Projectile, Vector3>();

		private static readonly Dictionary<Projectile, float> ProjectileVisualSpawnTimes = new Dictionary<Projectile, float>();

		private static readonly Dictionary<Projectile, PoisonProjectileVisual> PoisonVisuals = new Dictionary<Projectile, PoisonProjectileVisual>();

		private static Projectile ActiveProjectileHit;

		internal static bool SelectionActive;

		internal static bool LocalEliminated;

		internal static bool ModeActive;

		internal static bool AllowRoundRespawn;

		internal static bool BlocksCombatInput
		{
			get
			{
				if (!SelectionActive)
				{
					return LocalEliminated;
				}
				return true;
			}
		}

		internal static void AddChoices(RoundUpgrade[] choices, bool[] eligible, IList<CSteamID> members)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < choices.Length; i++)
			{
				if (i >= eligible.Length || i >= members.Count || !eligible[i] || choices[i] == RoundUpgrade.None)
				{
					continue;
				}
				ulong steamID = members[i].m_SteamID;
				if (steamID != 0L)
				{
					if (!Levels.TryGetValue(steamID, out var value))
					{
						value = new int[23];
						Levels[steamID] = value;
					}
					int num = (int)choices[i];
					if (num >= 0 && num < value.Length)
					{
						value[num]++;
					}
				}
			}
			ApplyAll();
		}

		internal static void Tick()
		{
			ApplyAll();
			PlayerMovement[] array = Object.FindObjectsOfType<PlayerMovement>();
			foreach (PlayerMovement val in array)
			{
				if (val.Grounded)
				{
					UsedExtraJumps.Remove(((Object)val).GetInstanceID());
				}
			}
			SpeedActiveReload();
		}

		private static void ApplyAll()
		{
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				int level = GetLevel(val, RoundUpgrade.FasterThanMe);
				if (level > 0 && (Object)(object)val.Movement != (Object)null)
				{
					int instanceID = ((Object)val.Movement).GetInstanceID();
					int j;
					int value;
					for (j = (AppliedMovementLevels.TryGetValue(instanceID, out value) ? value : 0); j < level; j++)
					{
						MultiplyFloat(val.Movement, "_walkSpeed", 1.2f);
						MultiplyFloat(val.Movement, "_sprintSpeed", 1.2f);
					}
					AppliedMovementLevels[instanceID] = j;
				}
				int level2 = GetLevel(val, RoundUpgrade.GlassCannon);
				if (level2 > 0 && (Object)(object)val.Movement != (Object)null)
				{
					int instanceID2 = ((Object)val.Movement).GetInstanceID();
					int k;
					int value2;
					for (k = (AppliedGlassMovementLevels.TryGetValue(instanceID2, out value2) ? value2 : 0); k < level2; k++)
					{
						MultiplyFloat(val.Movement, "_walkSpeed", 1.4f);
						MultiplyFloat(val.Movement, "_sprintSpeed", 1.4f);
					}
					AppliedGlassMovementLevels[instanceID2] = k;
				}
				int level3 = GetLevel(val, RoundUpgrade.Tank);
				if (level3 > 0 && (Object)(object)val.Movement != (Object)null)
				{
					int instanceID3 = ((Object)val.Movement).GetInstanceID();
					int l;
					int value3;
					for (l = (AppliedTankMovementLevels.TryGetValue(instanceID3, out value3) ? value3 : 0); l < level3; l++)
					{
						MultiplyFloat(val.Movement, "_walkSpeed", 0.8f);
						MultiplyFloat(val.Movement, "_sprintSpeed", 0.8f);
					}
					AppliedTankMovementLevels[instanceID3] = l;
				}
				int level4 = GetLevel(val, RoundUpgrade.Miniature);
				if (level4 > 0)
				{
					if ((Object)(object)val.Movement != (Object)null)
					{
						int instanceID4 = ((Object)val.Movement).GetInstanceID();
						int m;
						int value4;
						for (m = (AppliedMiniatureMovementLevels.TryGetValue(instanceID4, out value4) ? value4 : 0); m < level4; m++)
						{
							MultiplyFloat(val.Movement, "_walkSpeed", 1.2f);
							MultiplyFloat(val.Movement, "_sprintSpeed", 1.2f);
						}
						AppliedMiniatureMovementLevels[instanceID4] = m;
					}
					int instanceID5 = ((Object)val).GetInstanceID();
					int n;
					int value5;
					for (n = (AppliedMiniatureScaleLevels.TryGetValue(instanceID5, out value5) ? value5 : 0); n < level4; n++)
					{
						ApplyMiniatureSize(val, 0.8f);
					}
					AppliedMiniatureScaleLevels[instanceID5] = n;
				}
				Weapon val2 = (((Object)(object)val.Holding != (Object)null && (Object)(object)val.Holding.HeldItem != (Object)null) ? val.Holding.HeldItem.Weapon : null);
				if ((Object)(object)val2 != (Object)null && IsPistol(val2))
				{
					ConfigureBasePistol(val2);
				}
				int level5 = GetLevel(val, RoundUpgrade.MoreMore);
				if (level5 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID6 = ((Object)val2).GetInstanceID();
					int num;
					int value6;
					for (num = (AppliedWeaponLevels.TryGetValue(instanceID6, out value6) ? value6 : 0); num < level5; num++)
					{
						Attachments attachments = val2.Attachments;
						if ((Object)(object)attachments != (Object)null)
						{
							AddInt(attachments, "_defaultAmmoPerMag", 2);
							AddInt(attachments, "_extendedAmmoPerMag", 2);
						}
						AddInt(val2, "<Ammo>k__BackingField", 2);
						MultiplyFloat(val2, "_projSpeed", 1.1f);
					}
					AppliedWeaponLevels[instanceID6] = num;
				}
				int level6 = GetLevel(val, RoundUpgrade.BigBullets);
				if (level6 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID7 = ((Object)val2).GetInstanceID();
					int num2;
					int value7;
					for (num2 = (AppliedBigBulletLevels.TryGetValue(instanceID7, out value7) ? value7 : 0); num2 < level6; num2++)
					{
						MultiplyFloat(val2, "_projSpeed", 0.8f);
					}
					AppliedBigBulletLevels[instanceID7] = num2;
				}
				int level7 = GetLevel(val, RoundUpgrade.QuickShot);
				if (level7 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID8 = ((Object)val2).GetInstanceID();
					int num3;
					int value8;
					for (num3 = (AppliedQuickShotLevels.TryGetValue(instanceID8, out value8) ? value8 : 0); num3 < level7; num3++)
					{
						MultiplyFloat(val2, "_timeBetweenShots", 20f / 27f);
					}
					AppliedQuickShotLevels[instanceID8] = num3;
				}
				int level8 = GetLevel(val, RoundUpgrade.TightSpread);
				if (level8 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID9 = ((Object)val2).GetInstanceID();
					int num4;
					int value9;
					for (num4 = (AppliedTightSpreadLevels.TryGetValue(instanceID9, out value9) ? value9 : 0); num4 < level8; num4++)
					{
						MultiplyFloat(val2, "_spread", 0.5f);
					}
					AppliedTightSpreadLevels[instanceID9] = num4;
				}
				int level9 = GetLevel(val, RoundUpgrade.HeavyHitter);
				if (level9 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID10 = ((Object)val2).GetInstanceID();
					int num5;
					int value10;
					for (num5 = (AppliedHeavyHitterSpreadLevels.TryGetValue(instanceID10, out value10) ? value10 : 0); num5 < level9; num5++)
					{
						MultiplyFloat(val2, "_spread", 1.4f);
					}
					AppliedHeavyHitterSpreadLevels[instanceID10] = num5;
				}
				int level10 = GetLevel(val, RoundUpgrade.DoubleShot);
				if (level10 > 0 && (Object)(object)val2 != (Object)null)
				{
					int instanceID11 = ((Object)val2).GetInstanceID();
					int num6;
					int value11;
					for (num6 = (AppliedDoubleShotLevels.TryGetValue(instanceID11, out value11) ? value11 : 0); num6 < level10; num6++)
					{
						AddInt(val2, "_projectileCountPerShot", 1);
					}
					AppliedDoubleShotLevels[instanceID11] = num6;
				}
				int level11 = GetLevel(val, RoundUpgrade.BulletStorm);
				if (level11 <= 0 || !((Object)(object)val2 != (Object)null))
				{
					continue;
				}
				int instanceID12 = ((Object)val2).GetInstanceID();
				int num7;
				int value12;
				for (num7 = (AppliedBulletStormLevels.TryGetValue(instanceID12, out value12) ? value12 : 0); num7 < level11; num7++)
				{
					if ((Object)(object)val2.Attachments != (Object)null)
					{
						AddInt(val2.Attachments, "_defaultAmmoPerMag", 12);
						AddInt(val2.Attachments, "_extendedAmmoPerMag", 12);
					}
					AddInt(val2, "<Ammo>k__BackingField", 12);
					MultiplyFloat(val2, "_timeBetweenShots", 0.3f);
				}
				SetBool(val2, "_fullAuto", value: true);
				AppliedBulletStormLevels[instanceID12] = num7;
			}
		}

		private static void SpeedActiveReload()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			Weapon[] array = Object.FindObjectsOfType<Weapon>();
			foreach (Weapon val in array)
			{
				if ((Object)(object)((Item)val).Holder == (Object)null)
				{
					continue;
				}
				bool flag = (bool)(AccessTools.Field(typeof(Weapon), "_isReloading")?.GetValue(val) ?? ((object)false));
				int instanceID = ((Object)val).GetInstanceID();
				bool value;
				bool num = ReloadStates.TryGetValue(instanceID, out value) && value;
				ReloadStates[instanceID] = flag;
				int level = GetLevel(((Item)val).Holder, RoundUpgrade.HealingReload);
				if (num && !flag && level > 0 && (Object)(object)((Item)val).Holder == (Object)(object)Player.LocalPlayer && (Object)(object)Server.Instance != (Object)null)
				{
					Server.Instance.HitPlayer(((Item)val).Holder, -20 * level, Vector3.zero, Vector3.zero, (byte)0, ((Item)val).Holder);
				}
				int level2 = GetLevel(((Item)val).Holder, RoundUpgrade.FasterCharge);
				int level3 = GetLevel(((Item)val).Holder, RoundUpgrade.QuickReload);
				if (level2 > 0 || level3 > 0)
				{
					object obj = AccessTools.Field(typeof(Tool), "_anim")?.GetValue(val);
					string text = AccessTools.Field(typeof(Weapon), "_activeReloadAnimName")?.GetValue(val) as string;
					if (obj != null && !string.IsNullOrEmpty(text))
					{
						object obj2 = obj.GetType().GetProperty("Item")?.GetValue(obj, new object[1] { text });
						float num2 = Mathf.Pow(2f, (float)level2) * Mathf.Pow(1.35f, (float)level3);
						obj2?.GetType().GetProperty("speed")?.SetValue(obj2, flag ? num2 : 1f, null);
					}
				}
			}
		}

		internal static bool TryDoubleJump(PlayerMovement movement)
		{
			if (BlocksCombatInput || (Object)(object)movement == (Object)null || movement.Grounded)
			{
				return false;
			}
			object? obj = AccessTools.Field(typeof(PlayerMovement), "_player")?.GetValue(movement);
			object? obj2 = ((obj is Player) ? obj : null);
			int level = GetLevel((Player)obj2, RoundUpgrade.DoubleJump);
			if ((Object)obj2 != (Object)(object)Player.LocalPlayer || level <= 0)
			{
				return false;
			}
			int instanceID = ((Object)movement).GetInstanceID();
			int value;
			int num = (UsedExtraJumps.TryGetValue(instanceID, out value) ? value : 0);
			if (num >= level)
			{
				return false;
			}
			UsedExtraJumps[instanceID] = num + 1;
			movement.Jump();
			return true;
		}

		internal static int GetLevel(Player player, RoundUpgrade choice)
		{
			ulong num = (((Object)(object)player != (Object)null) ? player.SteamID : 0);
			if (num == 0L || choice < RoundUpgrade.MoreMore || !Levels.TryGetValue(num, out var value) || (int)choice >= value.Length)
			{
				return 0;
			}
			return value[(int)choice];
		}

		internal static int GetMaximumHealth(Player player)
		{
			int level = GetLevel(player, RoundUpgrade.Tank);
			int level2 = GetLevel(player, RoundUpgrade.GlassCannon);
			int level3 = GetLevel(player, RoundUpgrade.Miniature);
			int level4 = GetLevel(player, RoundUpgrade.MoreHeal);
			return Mathf.Max(1, Mathf.RoundToInt((100f + 50f * (float)level + 50f * (float)level4 - 20f * (float)level3) * Mathf.Pow(0.5f, (float)level2)));
		}

		internal static void ClampHealthToMaximum(Player player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player.Vitals == (Object)null))
			{
				int maximumHealth = GetMaximumHealth(player);
				if (player.Vitals.Health > maximumHealth)
				{
					object obj = AccessTools.Field(typeof(PlayerVitals), "_syncedHealth")?.GetValue(player.Vitals);
					obj?.GetType().GetProperty("Value")?.SetValue(obj, maximumHealth, null);
				}
			}
		}

		internal static void SetHealthToMaximum(Player player)
		{
			SetSyncedHealth(player, GetMaximumHealth(player));
		}

		internal static void HealUpToMaximum(Player player, int amount)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player.Vitals == (Object)null) && amount > 0)
			{
				SetSyncedHealth(player, Mathf.Min(GetMaximumHealth(player), player.Vitals.Health + amount));
			}
		}

		internal static void AddImpulse(Player attacker, bool rangedHit, Vector3 direction, ref Vector3 force)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (ModeActive && rangedHit && !((Object)(object)attacker == (Object)null) && ActiveProjectileHit != null && !((Object)(object)ActiveProjectileHit.Owner != (Object)(object)attacker))
			{
				float projectileSize = GetProjectileSize(ActiveProjectileHit);
				force *= Mathf.Sqrt(Mathf.Max(1f, projectileSize));
				int level = GetLevel(attacker, RoundUpgrade.Impulse);
				if (level > 0 && ((Vector3)(ref direction)).sqrMagnitude >= 0.001f)
				{
					force += ((Vector3)(ref direction)).normalized * (3f * (float)level);
				}
			}
		}

		internal static void BeginProjectileHit(Projectile projectile)
		{
			ActiveProjectileHit = projectile;
		}

		internal static void EndProjectileHit()
		{
			ActiveProjectileHit = null;
		}

		private static void SetSyncedHealth(Player player, int value)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player.Vitals == (Object)null))
			{
				object obj = AccessTools.Field(typeof(PlayerVitals), "_syncedHealth")?.GetValue(player.Vitals);
				obj?.GetType().GetProperty("Value")?.SetValue(obj, Mathf.Max(0, value), null);
			}
		}

		internal static void ConfigureProjectile(Projectile projectile)
		{
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			if (ModeActive && projectile != null && !((Object)(object)projectile.Owner == (Object)null) && ConfiguredProjectiles.Add(projectile))
			{
				if (!projectile.IsLocal)
				{
					Weapon val = (((Object)(object)projectile.Owner.Holding != (Object)null && (Object)(object)projectile.Owner.Holding.HeldItem != (Object)null) ? projectile.Owner.Holding.HeldItem.Weapon : null);
					Transform val2 = (((Object)(object)val != (Object)null && (Object)(object)val.Attachments != (Object)null) ? val.Attachments.FirePoint : null);
					ProjectileVisualOrigins[projectile] = (((Object)(object)val2 != (Object)null) ? val2.position : projectile.SpawnPos);
					ProjectileVisualSpawnTimes[projectile] = Time.unscaledTime;
				}
				projectile.GravityForce = 0f;
				int level = GetLevel(projectile.Owner, RoundUpgrade.BigBullets);
				int level2 = GetLevel(projectile.Owner, RoundUpgrade.QuickShot);
				int level3 = GetLevel(projectile.Owner, RoundUpgrade.HeavyHitter);
				int level4 = GetLevel(projectile.Owner, RoundUpgrade.BulletStorm);
				float num = Mathf.Pow(1.25f, (float)level) * Mathf.Pow(0.85f, (float)level2) * Mathf.Pow(1.3f, (float)level3) * Mathf.Pow(0.7f, (float)level4);
				projectile.Damage = Mathf.Max(1, Mathf.RoundToInt((float)projectile.Damage * num));
				float num2 = Mathf.Pow(1.5f, (float)level);
				ProjectileBaseDamages[projectile] = projectile.Damage;
				ProjectileBaseSizes[projectile] = num2;
				ProjectileSizeMultipliers[projectile] = num2 * GetDamageSizeMultiplier(projectile.Damage);
				ProjectileAges[projectile] = 0f;
				ProjectileGrowthSteps[projectile] = 0;
				int level5 = GetLevel(projectile.Owner, RoundUpgrade.Grow);
				if (level5 > 0)
				{
					float num3 = Mathf.Pow(0.8f, (float)level5);
					projectile.Velocity *= num3;
					projectile.PreviousVelocity *= num3;
				}
				if (GetLevel(projectile.Owner, RoundUpgrade.PoisonBullet) > 0)
				{
					PoisonVisuals[projectile] = PoisonProjectileVisual.Create(projectile, ProjectileSizeMultipliers[projectile]);
				}
			}
		}

		internal static void UpdateProjectileFlight(Projectile projectile)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (!ModeActive || projectile == null || (Object)(object)projectile.Owner == (Object)null)
			{
				return;
			}
			ConfigureProjectile(projectile);
			float value;
			float num = (ProjectileAges.TryGetValue(projectile, out value) ? value : 0f) + Time.fixedDeltaTime;
			ProjectileAges[projectile] = num;
			int level = GetLevel(projectile.Owner, RoundUpgrade.Grow);
			if (level > 0)
			{
				int num2 = Mathf.FloorToInt(num);
				int value2;
				int num3 = (ProjectileGrowthSteps.TryGetValue(projectile, out value2) ? value2 : 0);
				if (num2 > num3)
				{
					ProjectileGrowthSteps[projectile] = num2;
					int value3;
					int num4 = (ProjectileBaseDamages.TryGetValue(projectile, out value3) ? value3 : Mathf.Max(1, projectile.Damage));
					float value4;
					float num5 = (ProjectileBaseSizes.TryGetValue(projectile, out value4) ? value4 : 1f);
					projectile.Damage = Mathf.Clamp(Mathf.RoundToInt((float)num4 * Mathf.Pow(1.2f, (float)(num2 * level))), 1, 100000);
					float num6 = Mathf.Pow(1.25f, (float)(num2 * level));
					ProjectileSizeMultipliers[projectile] = num5 * num6 * GetDamageSizeMultiplier(projectile.Damage);
				}
			}
			projectile.Velocity += Vector3.down * (60f * Time.fixedDeltaTime);
			ApplyHoming(projectile);
		}

		private static void ApplyHoming(Projectile projectile)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00d2: 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_00dc: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			int level = GetLevel(projectile.Owner, RoundUpgrade.Homing);
			if (level <= 0 || ((Vector3)(ref projectile.Velocity)).sqrMagnitude < 0.001f)
			{
				return;
			}
			float num = 18f + 8f * (float)(level - 1);
			float num2 = num * num;
			Vector3 position = projectile.Position;
			Vector3 val = Vector3.zero;
			bool flag = false;
			Player[] array = Object.FindObjectsOfType<Player>();
			Vector3 val4;
			foreach (Player val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)projectile.Owner) && !((Object)(object)val2.Vitals == (Object)null) && !((Object)(object)val2.Dying == (Object)null) && !val2.Dying.IsDead)
				{
					Vector3 val3 = (((Object)(object)val2.Rigidbody != (Object)null) ? val2.Rigidbody.position : ((Component)val2).transform.position) + Vector3.up;
					val4 = val3 - position;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (!(sqrMagnitude >= num2))
					{
						num2 = sqrMagnitude;
						val = val3;
						flag = true;
					}
				}
			}
			if (flag)
			{
				float magnitude = ((Vector3)(ref projectile.Velocity)).magnitude;
				val4 = val - position;
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				float num3 = 0.61086524f * (float)level * Time.fixedDeltaTime;
				projectile.Velocity = Vector3.RotateTowards(((Vector3)(ref projectile.Velocity)).normalized, normalized, num3, 0f) * magnitude;
			}
		}

		internal static float GetProjectileSize(Projectile projectile)
		{
			if (projectile == null || !ProjectileSizeMultipliers.TryGetValue(projectile, out var value))
			{
				return 1f;
			}
			return Mathf.Max(0.2f, value);
		}

		internal static Vector3 GetProjectileRenderPosition(Projectile projectile, float interpolationFactor)
		{
			//IL_0001: 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_000d: 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_0039: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.Lerp(projectile.PreviousPosition, projectile.Position, interpolationFactor);
			if (projectile.IsLocal || !ProjectileVisualOrigins.TryGetValue(projectile, out var value) || !ProjectileVisualSpawnTimes.TryGetValue(projectile, out var value2))
			{
				return val;
			}
			float num = Mathf.Clamp01((Time.unscaledTime - value2) / 0.12f);
			return Vector3.Lerp(value, val, Mathf.SmoothStep(0f, 1f, num));
		}

		private static float GetDamageSizeMultiplier(int damage)
		{
			if (damage < 50)
			{
				return 1f;
			}
			if (damage < 100)
			{
				return 2.5f;
			}
			if (damage < 200)
			{
				return 5f;
			}
			if (damage < 400)
			{
				return 12f;
			}
			if (damage < 800)
			{
				return 25f;
			}
			float num = 60f;
			int num2 = 1600;
			while (damage >= num2 && num2 > 0)
			{
				num *= 2.4f;
				if (num2 > 1073741823)
				{
					break;
				}
				num2 *= 2;
			}
			return num;
		}

		internal static void AlignProjectileWithCrosshair(Player owner, bool isLocal, ref Vector3 velocity)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			if (ModeActive && isLocal && !((Object)(object)owner == (Object)null) && !((Object)(object)owner != (Object)(object)Player.LocalPlayer) && !((Object)(object)owner.Camera == (Object)null) && !((Object)(object)owner.Camera.CamTransform == (Object)null) && !(((Vector3)(ref velocity)).sqrMagnitude < 0.001f))
			{
				Weapon val = (((Object)(object)owner.Holding != (Object)null && (Object)(object)owner.Holding.HeldItem != (Object)null) ? owner.Holding.HeldItem.Weapon : null);
				Transform val2 = (((Object)(object)val != (Object)null && (Object)(object)val.Attachments != (Object)null) ? val.Attachments.FirePoint : null);
				Quaternion val3 = Quaternion.FromToRotation(((Object)(object)val2 != (Object)null) ? val2.forward : ((Vector3)(ref velocity)).normalized, owner.Camera.CamTransform.forward);
				velocity = val3 * velocity;
			}
		}

		internal static void AlignProjectilesWithCrosshair(Player owner, bool isLocal, Vector3[] velocities)
		{
			if (velocities != null)
			{
				for (int i = 0; i < velocities.Length; i++)
				{
					AlignProjectileWithCrosshair(owner, isLocal, ref velocities[i]);
				}
			}
		}

		private static bool IsPistol(Weapon weapon)
		{
			if ((Object)(object)weapon != (Object)null)
			{
				return ((Object)weapon).name.IndexOf("pistol", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static void ConfigureBasePistol(Weapon weapon)
		{
			int instanceID = ((Object)weapon).GetInstanceID();
			if (ConfiguredPistols.Add(instanceID))
			{
				OriginalFullAutoStates[instanceID] = GetBool(weapon, "_fullAuto");
				Attachments attachments = weapon.Attachments;
				if ((Object)(object)attachments != (Object)null)
				{
					SetInt(attachments, "_defaultAmmoPerMag", 3);
					SetInt(attachments, "_extendedAmmoPerMag", 3);
				}
				SetInt(weapon, "<Ammo>k__BackingField", 3);
				SetFloat(weapon, "_projSpeed", 100f);
				AppliedWeaponLevels[instanceID] = 0;
			}
		}

		internal static bool TryBounce(Projectile projectile, ProjectileType type, RaycastHit hit)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if (!ModeActive || projectile == null || (Object)(object)projectile.Owner == (Object)null || (Object)(object)((RaycastHit)(ref hit)).transform == (Object)null)
			{
				return false;
			}
			bool flag;
			try
			{
				flag = ((Component)((RaycastHit)(ref hit)).transform).CompareTag("Level") || ((Component)((RaycastHit)(ref hit)).transform).CompareTag("Boat");
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				return false;
			}
			int level = GetLevel(projectile.Owner, RoundUpgrade.Ricochet);
			int value;
			int num = (ProjectileBounces.TryGetValue(projectile, out value) ? value : 0);
			if (num >= level)
			{
				return false;
			}
			ProjectileBounces[projectile] = num + 1;
			Vector3 val = Vector3.Reflect(projectile.Velocity, ((RaycastHit)(ref hit)).normal);
			projectile.PreviousPosition = (projectile.Position = ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * Mathf.Max(0.04f, type.WidthRadius + 0.02f));
			projectile.Velocity = val;
			projectile.PreviousVelocity = val;
			return true;
		}

		internal static void ExplodeProjectile(Projectile projectile, RaycastHit hit)
		{
			//IL_003a: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			if (!ModeActive || projectile == null || (Object)(object)projectile.Owner == (Object)null || !ExplodedProjectiles.Add(projectile))
			{
				return;
			}
			int level = GetLevel(projectile.Owner, RoundUpgrade.BulletExplosive);
			if (level <= 0)
			{
				return;
			}
			VanillaExplosionEffects.Play(((RaycastHit)(ref hit)).point, 0.3f);
			if (!projectile.IsLocal)
			{
				return;
			}
			int num = Mathf.Max(1, Mathf.RoundToInt((float)projectile.Damage * 0.5f * (float)level));
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.Vitals == (Object)null || (Object)(object)val.Dying == (Object)null || val.Dying.IsDead)
				{
					continue;
				}
				Vector3 val2 = (((Object)(object)val.Rigidbody != (Object)null) ? val.Rigidbody.position : ((Component)val).transform.position);
				Vector3 val3 = val2 - ((RaycastHit)(ref hit)).point;
				float num2 = ((Vector3)(ref val3)).sqrMagnitude;
				Collider[] componentsInChildren = ((Component)val).GetComponentsInChildren<Collider>();
				foreach (Collider val4 in componentsInChildren)
				{
					if (!((Object)(object)val4 == (Object)null) && val4.enabled)
					{
						Vector3 val5 = val4.ClosestPoint(((RaycastHit)(ref hit)).point);
						val3 = val5 - ((RaycastHit)(ref hit)).point;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						if (!(sqrMagnitude >= num2))
						{
							num2 = sqrMagnitude;
						}
					}
				}
				if (!(num2 > 6.25f))
				{
					Vector3 val6 = val2 - ((RaycastHit)(ref hit)).point;
					Vector3 val7 = ((((Vector3)(ref val6)).sqrMagnitude > 0.001f) ? ((Vector3)(ref val6)).normalized : Vector3.up);
					float num3 = Mathf.Clamp01(Mathf.Sqrt(num2) / 2.5f);
					float num4 = 1f - num3;
					float num5 = (0.35f + 0.65f * num4) * (float)level;
					val.Vitals.LocalHit(((RaycastHit)(ref hit)).point, val7, projectile.Owner, num, true, val7 * GameInfo.PlayerKillForce * num5, false);
				}
			}
		}

		internal static void ApplyPoison(Projectile projectile, RaycastHit hit)
		{
			if (!ModeActive || projectile == null || (Object)(object)projectile.Owner == (Object)null || !projectile.IsLocal)
			{
				return;
			}
			int level = GetLevel(projectile.Owner, RoundUpgrade.PoisonBullet);
			if (level > 0 && !((Object)(object)((RaycastHit)(ref hit)).transform == (Object)null) && !((Object)(object)Plugin.Instance == (Object)null))
			{
				Player playerFromBodyPart = PlayerManager.GetPlayerFromBodyPart(((RaycastHit)(ref hit)).transform);
				if (!((Object)(object)playerFromBodyPart == (Object)null) && !((Object)(object)playerFromBodyPart == (Object)(object)projectile.Owner) && !((Object)(object)playerFromBodyPart.Vitals == (Object)null))
				{
					int damagePerSecond = Mathf.Max(1, Mathf.RoundToInt((float)projectile.Damage * 0.3f * (float)level));
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PoisonRoutine(playerFromBodyPart, projectile.Owner, damagePerSecond));
				}
			}
		}

		private static IEnumerator PoisonRoutine(Player target, Player owner, int damagePerSecond)
		{
			for (int tick = 0; tick < 3; tick++)
			{
				yield return (object)new WaitForSeconds(1f);
				if (!ModeActive || SelectionActive || (Object)(object)target == (Object)null || (Object)(object)target.Vitals == (Object)null || (Object)(object)owner == (Object)null || (Object)(object)target.Dying == (Object)null || target.Dying.IsDead)
				{
					break;
				}
				Vector3 val = (((Object)(object)target.Rigidbody != (Object)null) ? target.Rigidbody.position : ((Component)target).transform.position);
				target.Vitals.LocalHit(val, Vector3.up, owner, damagePerSecond, true, Vector3.zero, false);
			}
		}

		internal static void RemoveProjectileTracking(Projectile projectile)
		{
			if (projectile != null)
			{
				if (PoisonVisuals.TryGetValue(projectile, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				PoisonVisuals.Remove(projectile);
				ProjectileSizeMultipliers.Remove(projectile);
				ProjectileBaseSizes.Remove(projectile);
				ProjectileBaseDamages.Remove(projectile);
				ProjectileAges.Remove(projectile);
				ProjectileGrowthSteps.Remove(projectile);
				ProjectileVisualOrigins.Remove(projectile);
				ProjectileVisualSpawnTimes.Remove(projectile);
				ProjectileBounces.Remove(projectile);
				ExplodedProjectiles.Remove(projectile);
				ConfiguredProjectiles.Remove(projectile);
			}
		}

		internal static void ResetProjectileTracking()
		{
			foreach (PoisonProjectileVisual value in PoisonVisuals.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			PoisonVisuals.Clear();
			ProjectileSizeMultipliers.Clear();
			ProjectileBaseSizes.Clear();
			ProjectileBaseDamages.Clear();
			ProjectileAges.Clear();
			ProjectileGrowthSteps.Clear();
			ProjectileVisualOrigins.Clear();
			ProjectileVisualSpawnTimes.Clear();
			ProjectileBounces.Clear();
			ExplodedProjectiles.Clear();
			ConfiguredProjectiles.Clear();
			ActiveProjectileHit = null;
		}

		internal static void ResetAllUpgrades()
		{
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if ((Object)(object)val.Movement != (Object)null)
				{
					int instanceID = ((Object)val.Movement).GetInstanceID();
					int value;
					int num = (AppliedMovementLevels.TryGetValue(instanceID, out value) ? value : 0);
					int value2;
					int num2 = (AppliedGlassMovementLevels.TryGetValue(instanceID, out value2) ? value2 : 0);
					int value3;
					int num3 = (AppliedTankMovementLevels.TryGetValue(instanceID, out value3) ? value3 : 0);
					int value4;
					int num4 = (AppliedMiniatureMovementLevels.TryGetValue(instanceID, out value4) ? value4 : 0);
					float multiplier = 1f / (Mathf.Pow(1.2f, (float)num) * Mathf.Pow(1.4f, (float)num2) * Mathf.Pow(0.8f, (float)num3) * Mathf.Pow(1.2f, (float)num4));
					MultiplyFloat(val.Movement, "_walkSpeed", multiplier);
					MultiplyFloat(val.Movement, "_sprintSpeed", multiplier);
				}
				int instanceID2 = ((Object)val).GetInstanceID();
				int value5;
				int num5 = (AppliedMiniatureScaleLevels.TryGetValue(instanceID2, out value5) ? value5 : 0);
				for (int j = 0; j < num5; j++)
				{
					ApplyMiniatureSize(val, 1.25f);
				}
				Weapon val2 = (((Object)(object)val.Holding != (Object)null && (Object)(object)val.Holding.HeldItem != (Object)null) ? val.Holding.HeldItem.Weapon : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					int instanceID3 = ((Object)val2).GetInstanceID();
					int value6;
					int num6 = (AppliedWeaponLevels.TryGetValue(instanceID3, out value6) ? value6 : 0);
					int value7;
					int num7 = (AppliedQuickShotLevels.TryGetValue(instanceID3, out value7) ? value7 : 0);
					int value8;
					int num8 = (AppliedTightSpreadLevels.TryGetValue(instanceID3, out value8) ? value8 : 0);
					int value9;
					int num9 = (AppliedHeavyHitterSpreadLevels.TryGetValue(instanceID3, out value9) ? value9 : 0);
					int value10;
					int num10 = (AppliedDoubleShotLevels.TryGetValue(instanceID3, out value10) ? value10 : 0);
					int value11;
					int num11 = (AppliedBulletStormLevels.TryGetValue(instanceID3, out value11) ? value11 : 0);
					if ((Object)(object)val2.Attachments != (Object)null)
					{
						AddInt(val2.Attachments, "_defaultAmmoPerMag", -2 * num6 - 12 * num11);
						AddInt(val2.Attachments, "_extendedAmmoPerMag", -2 * num6 - 12 * num11);
					}
					SetInt(val2, "<Ammo>k__BackingField", 3);
					SetFloat(val2, "_projSpeed", 100f);
					if (num7 > 0 || num11 > 0)
					{
						MultiplyFloat(val2, "_timeBetweenShots", Mathf.Pow(1.35f, (float)num7) * Mathf.Pow(3.3333333f, (float)num11));
					}
					if (num8 > 0 || num9 > 0)
					{
						MultiplyFloat(val2, "_spread", Mathf.Pow(2f, (float)num8) * Mathf.Pow(0.71428573f, (float)num9));
					}
					if (num10 > 0)
					{
						AddInt(val2, "_projectileCountPerShot", -num10);
					}
					if (OriginalFullAutoStates.TryGetValue(instanceID3, out var value12))
					{
						SetBool(val2, "_fullAuto", value12);
					}
				}
			}
			Levels.Clear();
			AppliedMovementLevels.Clear();
			AppliedGlassMovementLevels.Clear();
			AppliedTankMovementLevels.Clear();
			AppliedMiniatureMovementLevels.Clear();
			AppliedMiniatureScaleLevels.Clear();
			AppliedWeaponLevels.Clear();
			AppliedBigBulletLevels.Clear();
			AppliedQuickShotLevels.Clear();
			AppliedTightSpreadLevels.Clear();
			AppliedHeavyHitterSpreadLevels.Clear();
			AppliedDoubleShotLevels.Clear();
			AppliedBulletStormLevels.Clear();
			OriginalFullAutoStates.Clear();
			ReloadStates.Clear();
			UsedExtraJumps.Clear();
			ConfiguredPistols.Clear();
			ResetProjectileTracking();
		}

		internal static void RefillLocalPistol()
		{
			ApplyAll();
			Player localPlayer = Player.LocalPlayer;
			Weapon val = (((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Holding != (Object)null && (Object)(object)localPlayer.Holding.HeldItem != (Object)null) ? localPlayer.Holding.HeldItem.Weapon : null);
			if (!((Object)(object)val == (Object)null) && IsPistol(val))
			{
				SetInt(val, "<Ammo>k__BackingField", 3 + 2 * GetLevel(localPlayer, RoundUpgrade.MoreMore) + 12 * GetLevel(localPlayer, RoundUpgrade.BulletStorm));
			}
		}

		internal static bool CanBeginShot(Weapon weapon, out int ammoBeforeShot)
		{
			ammoBeforeShot = (((Object)(object)weapon != (Object)null) ? weapon.Ammo : 0);
			if (!ModeActive || (Object)(object)weapon == (Object)null || (Object)(object)((Item)weapon).Holder == (Object)null)
			{
				return true;
			}
			if (BlocksCombatInput)
			{
				return false;
			}
			int num = 1 + GetLevel(((Item)weapon).Holder, RoundUpgrade.DoubleShot);
			if (ammoBeforeShot >= num)
			{
				return true;
			}
			SetBool(weapon, "_queueReload", value: true);
			return false;
		}

		internal static void CompleteShotAmmoCost(Weapon weapon, int ammoBeforeShot)
		{
			if (!ModeActive || (Object)(object)weapon == (Object)null || (Object)(object)((Item)weapon).Holder == (Object)null)
			{
				return;
			}
			int num = 1 + GetLevel(((Item)weapon).Holder, RoundUpgrade.DoubleShot);
			int ammo = weapon.Ammo;
			if (num > 1 && ammo == ammoBeforeShot - 1)
			{
				int num2 = Mathf.Max(0, ammo - (num - 1));
				SetInt(weapon, "<Ammo>k__BackingField", num2);
				if (num2 == 0)
				{
					SetBool(weapon, "_queueReload", value: true);
				}
			}
		}

		private static void MultiplyFloat(object target, string fieldName, float multiplier)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(target, Convert.ToSingle(fieldInfo.GetValue(target)) * multiplier);
			}
		}

		private static void ApplyMiniatureSize(Player player, float multiplier)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if ((Object)(object)player.Body != (Object)null)
			{
				ScaleBodyObject(player.Body, "_newCharacter", multiplier);
				ScaleBodyObject(player.Body, "_oldCharacter", multiplier);
			}
			if ((Object)(object)player.Movement != (Object)null)
			{
				object? obj = AccessTools.Field(typeof(PlayerMovement), "_col")?.GetValue(player.Movement);
				CapsuleCollider val = (CapsuleCollider)((obj is CapsuleCollider) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					val.height *= multiplier;
					val.radius *= multiplier;
					val.center *= multiplier;
				}
				object? obj2 = AccessTools.Field(typeof(PlayerMovement), "_footCol")?.GetValue(player.Movement);
				SphereCollider val2 = (SphereCollider)((obj2 is SphereCollider) ? obj2 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.radius *= multiplier;
					val2.center *= multiplier;
				}
				MultiplyFloat(player.Movement, "_origColHeight", multiplier);
			}
			if ((Object)(object)player.Camera != (Object)null)
			{
				MultiplyFloat(player.Camera, "<CamHeight>k__BackingField", multiplier);
			}
		}

		private static void ScaleBodyObject(PlayerBody body, string fieldName, float multiplier)
		{
			//IL_0033: 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)
			object? obj = AccessTools.Field(typeof(PlayerBody), fieldName)?.GetValue(body);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform transform = val.transform;
				transform.localScale *= multiplier;
			}
		}

		private static void AddInt(object target, string fieldName, int amount)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(target, Convert.ToInt32(fieldInfo.GetValue(target)) + amount);
			}
		}

		private static void SetInt(object target, string fieldName, int value)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(target, value);
			}
		}

		private static void SetFloat(object target, string fieldName, float value)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(target, value);
			}
		}

		private static bool GetBool(object target, string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (fieldInfo != null)
			{
				return Convert.ToBoolean(fieldInfo.GetValue(target));
			}
			return false;
		}

		private static void SetBool(object target, string fieldName, bool value)
		{
			FieldInfo fieldInfo = AccessTools.Field(target.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				fieldInfo.SetValue(target, value);
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "Hit")]
	internal static class RoundsProjectileHitPatch
	{
		private static bool Prefix(Projectile projectile, ProjectileType type, RaycastHit hit, ref bool __state)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			__state = !RoundUpgradeEffects.TryBounce(projectile, type, hit);
			if (__state)
			{
				RoundUpgradeEffects.BeginProjectileHit(projectile);
			}
			return __state;
		}

		private static void Postfix(Projectile projectile, RaycastHit hit, bool __state)
		{
			//IL_000a: 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)
			if (__state)
			{
				RoundUpgradeEffects.EndProjectileHit();
				RoundUpgradeEffects.ExplodeProjectile(projectile, hit);
				RoundUpgradeEffects.ApplyPoison(projectile, hit);
				RoundUpgradeEffects.RemoveProjectileTracking(projectile);
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "AddProjectile")]
	internal static class RoundsCrosshairProjectilePatch
	{
		private static void Prefix(Player owner, bool isLocal, ref Vector3 velocity)
		{
			RoundUpgradeEffects.AlignProjectileWithCrosshair(owner, isLocal, ref velocity);
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "AddProjectiles")]
	internal static class RoundsCrosshairProjectilesPatch
	{
		private static void Prefix(Player owner, bool isLocal, Vector3[] velocities)
		{
			RoundUpgradeEffects.AlignProjectilesWithCrosshair(owner, isLocal, velocities);
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "UpdateProjectileScan")]
	internal static class RoundsProjectileStatsPatch
	{
		private static void Prefix(Projectile projectile, ProjectileType type, ref float __state)
		{
			RoundUpgradeEffects.UpdateProjectileFlight(projectile);
			__state = type?.WidthRadius ?? 0f;
			if (type != null && projectile != null && !((Object)(object)projectile.Owner == (Object)null))
			{
				type.WidthRadius = __state * RoundUpgradeEffects.GetProjectileSize(projectile);
			}
		}

		private static void Postfix(ProjectileType type, float __state)
		{
			if (type != null)
			{
				type.WidthRadius = __state;
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileManager), "MatrixFromProjectile")]
	internal static class RoundsBigBulletVisualPatch
	{
		private static void Postfix(Projectile projectile, float interpolationFactor, ref Matrix4x4 __result)
		{
			//IL_0021: 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_0028: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (RoundUpgradeEffects.ModeActive && projectile != null && !((Object)(object)projectile.Owner == (Object)null))
			{
				RoundUpgradeEffects.ConfigureProjectile(projectile);
				Vector3 projectileRenderPosition = RoundUpgradeEffects.GetProjectileRenderPosition(projectile, interpolationFactor);
				__result = Matrix4x4.TRS(projectileRenderPosition, ((Matrix4x4)(ref __result)).rotation, ((Matrix4x4)(ref __result)).lossyScale);
				if (RoundUpgradeEffects.GetLevel(projectile.Owner, RoundUpgrade.PoisonBullet) > 0)
				{
					__result *= Matrix4x4.Scale(Vector3.zero);
				}
				else
				{
					__result *= Matrix4x4.Scale(Vector3.one * RoundUpgradeEffects.GetProjectileSize(projectile));
				}
			}
		}
	}
	internal sealed class PoisonProjectileVisual : MonoBehaviour
	{
		private Projectile _projectile;

		private Material _material;

		private float _expiresAt;

		internal static PoisonProjectileVisual Create(Projectile projectile, float size)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)obj).name = "HowToRounds_PoisonBullet";
			Object.DontDestroyOnLoad((Object)(object)obj);
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			PoisonProjectileVisual poisonProjectileVisual = obj.AddComponent<PoisonProjectileVisual>();
			poisonProjectileVisual._projectile = projectile;
			poisonProjectileVisual._expiresAt = Time.time + 12f;
			obj.transform.localScale = new Vector3(0.16f, 0.16f, 0.45f) * Mathf.Max(0.2f, size);
			Renderer component2 = obj.GetComponent<Renderer>();
			Shader val = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Sprites/Default");
			if ((Object)(object)component2 != (Object)null && (Object)(object)val != (Object)null)
			{
				poisonProjectileVisual._material = new Material(val);
				poisonProjectileVisual._material.color = new Color(0.72f, 0.12f, 1f, 1f);
				component2.material = poisonProjectileVisual._material;
			}
			poisonProjectileVisual.UpdateTransform();
			return poisonProjectileVisual;
		}

		private void LateUpdate()
		{
			if (_projectile == null || !RoundUpgradeEffects.ModeActive || Time.time >= _expiresAt)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				UpdateTransform();
			}
		}

		private void UpdateTransform()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = _projectile.Position;
			float projectileSize = RoundUpgradeEffects.GetProjectileSize(_projectile);
			((Component)this).transform.localScale = new Vector3(0.16f, 0.16f, 0.45f) * Mathf.Max(0.2f, projectileSize);
			if (((Vector3)(ref _projectile.Velocity)).sqrMagnitude > 0.001f)
			{
				((Component)this).transform.rotation = Quaternion.LookRotation(((Vector3)(ref _projectile.Velocity)).normalized);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_material != (Object)null)
			{
				Object.Destroy((Object)(object)_material);
			}
		}
	}
	[HarmonyPatch(typeof(Server), "RpcLogic___HitPlayer___2449261505")]
	internal static class RoundsHealingAndLifestealPatch
	{
		private static bool Prefix(object[] __args, ref int __state)
		{
			__state = 0;
			if (!RoundUpgradeEffects.ModeActive || __args == null || __args.Length < 6)
			{
				return true;
			}
			object obj = __args[0];
			Player val = (Player)((obj is Player) ? obj : null);
			int num = (int)__args[1];
			if ((Object)(object)val == (Object)null || (Object)(object)val.Vitals == (Object)null)
			{
				return true;
			}
			if (num < 0)
			{
				RoundUpgradeEffects.HealUpToMaximum(val, -num);
				return false;
			}
			__state = val.Vitals.Health;
			return true;
		}

		private static void Postfix(object[] __args, int __state)
		{
			if (!RoundUpgradeEffects.ModeActive || __args == null || __args.Length < 6 || (int)__args[1] <= 0)
			{
				return;
			}
			object obj = __args[0];
			Player val = (Player)((obj is Player) ? obj : null);
			object obj2 = __args[5];
			Player val2 = (Player)((obj2 is Player) ? obj2 : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Vitals == (Object)null) && !((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)val))
			{
				int num = Mathf.Max(0, __state - val.Vitals.Health);
				int level = RoundUpgradeEffects.GetLevel(val2, RoundUpgrade.Lifesteal);
				if (num > 0 && level > 0)
				{
					RoundUpgradeEffects.HealUpToMaximum(val2, Mathf.Max(1, Mathf.RoundToInt((float)num * 0.3f * (float)level)));
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerVitals), "LocalHit")]
	internal static class RoundsImpulsePatch
	{
		private static void Prefix(Vector3 dir, Player playerWhoHit, bool rangedHit, ref Vector3 force)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			RoundUpgradeEffects.AddImpulse(playerWhoHit, rangedHit, dir, ref force);
		}
	}
	internal static class VanillaExplosionEffects
	{
		private static ExplosionInfo _info;

		private static MethodInfo _playMethod;

		internal static void Play(Vector3 position, float visualScale)
		{
			//IL_00d0: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			HashSet<int> hashSet = new HashSet<int>();
			Transform[] array = Object.FindObjectsOfType<Transform>();
			foreach (Transform val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					hashSet.Add(((Object)val).GetInstanceID());
				}
			}
			try
			{
				if (_info == null)
				{
					_info = FindVanillaInfo();
				}
				if (_playMethod == null)
				{
					_playMethod = AccessTools.Method(typeof(ExplosionManager), "ExplodeEffects", (Type[])null, (Type[])null);
				}
				if (_info != null && _playMethod != null)
				{
					_playMethod.Invoke(null, new object[2] { position, _info });
					ScaleNewEffects(position, visualScale, hashSet);
					return;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not play the vanilla explosion effect: " + ex.Message));
			}
			BossManager.BossExplosion(position, false);
			ScaleNewEffects(position, visualScale, hashSet);
		}

		private static void ScaleNewEffects(Vector3 position, float scale, HashSet<int> existingTransforms)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			HashSet<int> hashSet = new HashSet<int>();
			Transform[] array = Object.FindObjectsOfType<Transform>();
			foreach (Transform val in array)
			{
				if ((Object)(object)val == (Object)null || existingTransforms.Contains(((Object)val).GetInstanceID()))
				{
					continue;
				}
				Vector3 val2 = val.position - position;
				if (!(((Vector3)(ref val2)).sqrMagnitude > 1f))
				{
					Transform val3 = val;
					while ((Object)(object)val3.parent != (Object)null && !existingTransforms.Contains(((Object)val3.parent).GetInstanceID()))
					{
						val3 = val3.parent;
					}
					if (hashSet.Add(((Object)val3).GetInstanceID()))
					{
						Transform obj = val3;
						obj.localScale *= Mathf.Clamp(scale, 0.1f, 1f);
					}
				}
			}
		}

		private static ExplosionInfo FindVanillaInfo()
		{
			ExplosionInfo val = null;
			Explosive[] array = Resources.FindObjectsOfTypeAll<Explosive>();
			foreach (Explosive val2 in array)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				ExplosionInfo explosionInfo = ((Item)val2).GetExplosionInfo();
				if (explosionInfo != null)
				{
					if (val == null)
					{
						val = explosionInfo;
					}
					if (((Object)val2).name.IndexOf("dynamite", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return explosionInfo;
					}
				}
			}
			return val;
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "JumpInput")]
	internal static class DoubleJumpPatch
	{
		private static bool Prefix(PlayerMovement __instance)
		{
			if (RoundUpgradeEffects.BlocksCombatInput)
			{
				return false;
			}
			return !RoundUpgradeEffects.TryDoubleJump(__instance);
		}
	}
	[HarmonyPatch(typeof(Weapon), "PrimaryInput")]
	internal static class DraftWeaponInputPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.BlocksCombatInput;
		}
	}
	[HarmonyPatch(typeof(Weapon), "Shoot")]
	internal static class RoundsPerShotAmmoPatch
	{
		private static bool Prefix(Weapon __instance, ref int __state)
		{
			return RoundUpgradeEffects.CanBeginShot(__instance, out __state);
		}

		private static void Postfix(Weapon __instance, int __state)
		{
			RoundUpgradeEffects.CompleteShotAmmoCost(__instance, __state);
		}
	}
	[HarmonyPatch(typeof(Melee), "PrimaryInput")]
	internal static class DraftMeleeInputPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.BlocksCombatInput;
		}
	}
	[HarmonyPatch(typeof(PlayerVitals), "LowerFullnessTick")]
	internal static class DisableRoundsHungerPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.ModeActive;
		}
	}
	[HarmonyPatch(typeof(PlayerVitals), "DamageFromFullness")]
	internal static class DisableRoundsStarvationDamagePatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.ModeActive;
		}
	}
	[HarmonyPatch(typeof(PlayerVitals), "Regenerate")]
	internal static class DisableRoundsFoodRegenerationPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.ModeActive;
		}
	}
	[HarmonyPatch(typeof(PlayerDying), "MouseClick")]
	internal static class DisableRoundsGiveUpPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.ModeActive;
		}
	}
	[HarmonyPatch(typeof(Server), "ResurrectPlayer")]
	internal static class DisableRoundsManualResurrectionPatch
	{
		private static bool Prefix()
		{
			if (RoundUpgradeEffects.ModeActive)
			{
				return RoundUpgradeEffects.AllowRoundRespawn;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Server), "RespawnPlayer")]
	internal static class DisableRoundsEarlyRespawnPatch
	{
		private static bool Prefix()
		{
			if (RoundUpgradeEffects.ModeActive)
			{
				return RoundUpgradeEffects.AllowRoundRespawn;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerInventory), "ServerDropAll")]
	internal static class KeepRoundsInventoryOnRespawnPatch
	{
		private static bool Prefix()
		{
			return !RoundUpgradeEffects.ModeActive;
		}
	}
	[HarmonyPatch(typeof(PlayerDying), "ServerDie")]
	internal static class KeepRoundsHeldWeaponServerPatch
	{
		private static void Prefix(PlayerDying __instance, ref Item __state)
		{
			if (RoundUpgradeEffects.ModeActive)
			{
				object? obj = AccessTools.Field(typeof(PlayerDying), "_player")?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Holding == (Object)null))
				{
					__state = val.Holding.HeldItem;
					AccessTools.Field(typeof(PlayerHolding), "_heldItem")?.SetValue(val.Holding, null);
				}
			}
		}

		private static void Postfix(PlayerDying __instance, Item __state)
		{
			if (!((Object)(object)__state == (Object)null))
			{
				object? obj = AccessTools.Field(typeof(PlayerDying), "_player")?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.Holding != (Object)null)
				{
					AccessTools.Field(typeof(PlayerHolding), "_heldItem")?.SetValue(val.Holding, __state);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerDying), "LocalDie")]
	internal static class KeepRoundsHeldWeaponLocalPatch
	{
		private static void Prefix(PlayerDying __instance, ref Item __state)
		{
			if (RoundUpgradeEffects.ModeActive)
			{
				object? obj = AccessTools.Field(typeof(PlayerDying), "_player")?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Holding == (Object)null))
				{
					__state = val.Holding.HeldItem;
					AccessTools.Field(typeof(PlayerHolding), "_heldItem")?.SetValue(val.Holding, null);
				}
			}
		}

		private static void Postfix(PlayerDying __instance, Item __state)
		{
			if (!((Object)(object)__state == (Object)null))
			{
				object? obj = AccessTools.Field(typeof(PlayerDying), "_player")?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.Holding != (Object)null)
				{
					AccessTools.Field(typeof(PlayerHolding), "_heldItem")?.SetValue(val.Holding, __state);
				}
			}
		}
	}
}