using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Keybound.Cards;
using Keybound.Compat;
using Keybound.Core;
using Keybound.Effects;
using Keybound.UI;
using Microsoft.CodeAnalysis;
using TMPro;
using UnboundLib.Cards;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("Keybound")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+146ac727a7fc6b83f382d57f53cce40478349c58")]
[assembly: AssemblyProduct("Keybound Mod for ROUNDS")]
[assembly: AssemblyTitle("Keybound")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Keybound
{
	internal static class KLog
	{
		private static ManualLogSource Logger => Plugin.Logger;

		internal static void Section(string title)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"=====================");
			}
			ManualLogSource logger2 = Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)("[Keybound] " + title));
			}
			ManualLogSource logger3 = Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)"=====================");
			}
		}

		internal static void Line(string message)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogInfo((object)("[Keybound] " + message));
			}
		}

		internal static void Warn(string message)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogWarning((object)("[Keybound] " + message));
			}
		}

		internal static void Error(string message)
		{
			ManualLogSource logger = Logger;
			if (logger != null)
			{
				logger.LogError((object)("[Keybound] " + message));
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Keybound", "Keybound Mod for ROUNDS", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static string PluginDirectory { get; private set; }

		private void Awake()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			PluginDirectory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? "";
			KLog.Section("Plugin Awake");
			KLog.Line("PluginDirectory = " + PluginDirectory);
			new Harmony("Keybound").PatchAll();
			((Component)this).gameObject.AddComponent<EffectStackManager>();
			GameObject val = new GameObject("KB_UIRoot");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<KeybindModalUI>();
			val.AddComponent<EffectStackOverlay>();
			KLog.Line("Plugin Keybound loaded.");
		}

		private void Start()
		{
			KeyboundCardRegistrar.RegisterAll();
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Keybound";

		public const string PLUGIN_NAME = "Keybound Mod for ROUNDS";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace Keybound.UI
{
	public class EffectStackOverlay : MonoBehaviour
	{
		private sealed class PlayerEffectRow
		{
			internal GameObject Root;

			private RectTransform _slotRow;

			private readonly List<EffectSlotView> _slots = new List<EffectSlotView>();

			private Action<KeyboundBinding, Vector3> _onHover;

			private Action _onHoverExit;

			internal static PlayerEffectRow Create(Transform parent, int playerID, Action<KeyboundBinding, Vector3> onHover, Action onHoverExit)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				GameObject val = new GameObject($"EffectRow_P{playerID}");
				val.transform.SetParent(parent, false);
				val.AddComponent<RectTransform>();
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredHeight = 35f;
				obj.minHeight = 35f;
				HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj2).spacing = 6f;
				((LayoutGroup)obj2).childAlignment = (TextAnchor)5;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
				return new PlayerEffectRow
				{
					Root = val,
					_slotRow = val.GetComponent<RectTransform>(),
					_onHover = onHover,
					_onHoverExit = onHoverExit
				};
			}

			internal void Refresh(IReadOnlyList<KeyboundBinding> bindings)
			{
				Root.SetActive(true);
				EnsureSlotCount(bindings.Count);
				for (int i = 0; i < bindings.Count; i++)
				{
					_slots[i].Bind(bindings[i]);
				}
				for (int j = bindings.Count; j < _slots.Count; j++)
				{
					_slots[j].Root.SetActive(false);
				}
			}

			private void EnsureSlotCount(int count)
			{
				while (_slots.Count < count)
				{
					EffectSlotView item = EffectSlotView.Create((Transform)(object)_slotRow, _onHover, _onHoverExit);
					_slots.Add(item);
				}
			}
		}

		private sealed class EffectSlotView : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			internal GameObject Root;

			private Image _bg;

			private TextMeshProUGUI _label;

			private static readonly Color CooldownRed = new Color(0.55f, 0.12f, 0.12f, 0.95f);

			private static readonly Color ReadyGreen = new Color(0.12f, 0.55f, 0.18f, 0.95f);

			private static readonly Color BorderRed = new Color(0.95f, 0.2f, 0.2f, 1f);

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

			private KeyboundBinding _binding;

			private Action<KeyboundBinding, Vector3> _onHover;

			private Action _onHoverExit;

			internal static EffectSlotView Create(Transform parent, Action<KeyboundBinding, Vector3> onHover, Action onHoverExit)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Expected O, but got Unknown
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("EffectSlot");
				val.transform.SetParent(parent, false);
				val.AddComponent<RectTransform>().sizeDelta = new Vector2(35f, 35f);
				LayoutElement obj = val.AddComponent<LayoutElement>();
				obj.preferredWidth = 35f;
				obj.preferredHeight = 35f;
				EffectSlotView effectSlotView = val.AddComponent<EffectSlotView>();
				effectSlotView._onHover = onHover;
				effectSlotView._onHoverExit = onHoverExit;
				effectSlotView.Root = val;
				effectSlotView.Build();
				return effectSlotView;
			}

			private void Build()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				_bg = ((Component)this).gameObject.AddComponent<Image>();
				((Graphic)_bg).color = CooldownRed;
				Outline obj = ((Component)_bg).gameObject.AddComponent<Outline>();
				((Shadow)obj).effectColor = BorderRed;
				((Shadow)obj).effectDistance = new Vector2(3f, -3f);
				_label = UIHelper.CreateText(((Component)this).transform, "Abbr", "—", 12, (TextAlignmentOptions)514);
			}

			internal void Bind(KeyboundBinding binding)
			{
				_binding = binding;
				((TMP_Text)_label).text = Abbreviate(binding.CardName);
				RefreshVisual();
			}

			private void Update()
			{
				if (_binding != null)
				{
					RefreshVisual();
				}
			}

			private void RefreshVisual()
			{
				//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_0023: 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_005a: 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)
				float num = 1f - _binding.CooldownFill();
				((Graphic)_bg).color = Color.Lerp(CooldownRed, ReadyGreen, num);
				Outline obj = ((Component)_bg).GetComponent<Outline>() ?? ((Component)_bg).gameObject.AddComponent<Outline>();
				((Shadow)obj).effectColor = (_binding.IsReady() ? BorderGreen : BorderRed);
				((Shadow)obj).effectDistance = new Vector2(3f, -3f);
			}

			public void OnPointerEnter(PointerEventData _)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				if (_binding != null)
				{
					_onHover?.Invoke(_binding, ((Component)this).transform.position);
				}
			}

			public void OnPointerExit(PointerEventData _)
			{
				_onHoverExit?.Invoke();
			}

			private static string Abbreviate(string name)
			{
				if (string.IsNullOrEmpty(name))
				{
					return "?";
				}
				if (name.Length == 1)
				{
					return name.ToUpper();
				}
				return char.ToUpper(name[0]) + name.Substring(1, 1).ToLower();
			}
		}

		public static EffectStackOverlay instance;

		private const float RowHeight = 35f;

		private const float RowSpacing = 4f;

		private const float SlotSize = 35f;

		private Canvas _canvas;

		private RectTransform _container;

		private readonly Dictionary<int, PlayerEffectRow> _playerRows = new Dictionary<int, PlayerEffectRow>();

		private GameObject _hoverCard;

		private void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			BuildUI();
			((Component)_canvas).gameObject.SetActive(false);
		}

		private void BuildUI()
		{
			//IL_002d: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			_canvas = UIHelper.CreateFullscreenCanvas("KB_EffectStack", 45);
			_container = UIHelper.CreatePanel(((Component)_canvas).transform, "EffectContainer", new Vector2(0.55f, 0.02f), new Vector2(0.98f, 0.3f));
			VerticalLayoutGroup obj = ((Component)_container).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)8;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 4f;
			((LayoutGroup)obj).padding = new RectOffset(0, 4, 4, 0);
		}

		public void RefreshAll()
		{
			if ((Object)(object)EffectStackManager.instance == (Object)null)
			{
				HideAll();
				return;
			}
			bool flag = false;
			HashSet<int> hashSet = new HashSet<int>();
			foreach (KeyValuePair<int, IReadOnlyList<KeyboundBinding>> allBinding in EffectStackManager.instance.GetAllBindings())
			{
				hashSet.Add(allBinding.Key);
				GetOrCreateRow(allBinding.Key).Refresh(allBinding.Value);
				flag = true;
			}
			foreach (KeyValuePair<int, PlayerEffectRow> playerRow in _playerRows)
			{
				if (!hashSet.Contains(playerRow.Key))
				{
					playerRow.Value.Root.SetActive(false);
				}
			}
			if (!flag)
			{
				HideAll();
			}
			else
			{
				((Component)_canvas).gameObject.SetActive(true);
			}
		}

		public void Refresh(int playerID)
		{
			RefreshAll();
		}

		public void HideAll()
		{
			ClearHover();
			foreach (PlayerEffectRow value in _playerRows.Values)
			{
				value.Root.SetActive(false);
			}
			if ((Object)(object)_canvas != (Object)null)
			{
				((Component)_canvas).gameObject.SetActive(false);
			}
		}

		private void Update()
		{
			if (!((Object)(object)_canvas == (Object)null) && ((Component)_canvas).gameObject.activeSelf && !IsGameActive())
			{
				HideAll();
			}
		}

		private PlayerEffectRow GetOrCreateRow(int playerID)
		{
			if (_playerRows.TryGetValue(playerID, out var value))
			{
				return value;
			}
			value = PlayerEffectRow.Create((Transform)(object)_container, playerID, OnSlotHover, OnSlotHoverExit);
			_playerRows[playerID] = value;
			return value;
		}

		private void OnSlotHover(KeyboundBinding binding, Vector3 worldPos)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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)
			ClearHover();
			if ((Object)(object)CardChoice.instance == (Object)null)
			{
				return;
			}
			CardInfo val = binding.Card ?? FindCardTemplate(binding.CardName);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			_hoverCard = CardChoice.instance.AddCardVisual(val, worldPos);
			if (!((Object)(object)_hoverCard == (Object)null))
			{
				Collider2D[] componentsInChildren = ((Component)_hoverCard.transform.root).GetComponentsInChildren<Collider2D>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Behaviour)componentsInChildren[i]).enabled = false;
				}
				Canvas componentInChildren = _hoverCard.GetComponentInChildren<Canvas>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.sortingLayerName = "MostFront";
				}
				RectTransform component = ((Component)UIHelper.CreateText(_hoverCard.transform, "KeyLabel", "Bound to " + KeybindModalUI.FormatKey(binding.Key), 18, (TextAlignmentOptions)1026, (Color?)new Color(0.75f, 0.9f, 1f))).GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 0f);
				component.anchorMax = new Vector2(1f, 0.18f);
				Vector2 offsetMin = (component.offsetMax = Vector2.zero);
				component.offsetMin = offsetMin;
			}
		}

		private void OnSlotHoverExit()
		{
			ClearHover();
		}

		private void ClearHover()
		{
			if ((Object)(object)_hoverCard != (Object)null)
			{
				Object.Destroy((Object)(object)_hoverCard);
				_hoverCard = null;
			}
		}

		private static CardInfo FindCardTemplate(string cardName)
		{
			if (CardChoice.instance?.cards == null)
			{
				return null;
			}
			CardInfo[] cards = CardChoice.instance.cards;
			foreach (CardInfo val in cards)
			{
				if ((Object)(object)val != (Object)null && val.cardName == cardName)
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsGameActive()
		{
			if ((Object)(object)GameManager.instance == (Object)null)
			{
				return false;
			}
			if (!GameManager.instance.isPlaying)
			{
				return false;
			}
			if (PlayerManager.instance?.players == null || PlayerManager.instance.players.Count == 0)
			{
				return false;
			}
			return true;
		}
	}
	public class KeybindModalUI : MonoBehaviour
	{
		public static KeybindModalUI instance;

		private const int KeyA = 97;

		private const int KeyZ = 122;

		private const int KeyAlpha0 = 48;

		private const int KeyAlpha9 = 57;

		private Canvas _canvas;

		private TextMeshProUGUI _messageText;

		private Button _bindButton;

		private Image _bindImage;

		private TextMeshProUGUI _bindLabel;

		private Action<int> _onConfirm;

		private Action _onCancel;

		private int _pickerID;

		private CardInfo _card;

		private int? _pendingKey;

		private static readonly Color PanelBg = new Color(0.04f, 0.06f, 0.12f, 1f);

		private static readonly Color CancelBg = new Color(0.4f, 0.1f, 0.1f, 0.95f);

		private static readonly Color BindReadyBg = new Color(0.1f, 0.45f, 0.12f, 0.95f);

		private static readonly Color BindGrayBg = new Color(0.18f, 0.18f, 0.18f, 0.55f);

		private void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			BuildUI();
			((Component)_canvas).gameObject.SetActive(false);
		}

		private void BuildUI()
		{
			//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_0043: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: 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_019a: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: 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_02f3: Unknown result type (might be due to invalid IL or missing references)
			_canvas = UIHelper.CreateFullscreenCanvas("KB_KeybindModal", 190);
			UIHelper.CreatePanel(((Component)_canvas).transform, "Dim", Vector2.zero, Vector2.one, (Color?)new Color(0f, 0f, 0f, 0.55f));
			RectTransform val = UIHelper.CreatePanel(((Component)_canvas).transform, "Panel", new Vector2(0.25f, 0.35f), new Vector2(0.75f, 0.65f), PanelBg);
			UIHelper.CreateText((Transform)(object)val, "Title", "Bind Key", 28, (TextAlignmentOptions)258, (Color?)new Color(0.9f, 0.93f, 1f));
			_messageText = UIHelper.CreateText((Transform)(object)val, "Message", "Press a key to bind this effect.", 22, (TextAlignmentOptions)4098, (Color?)new Color(0.88f, 0.92f, 1f));
			RectTransform component = ((Component)_messageText).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.05f, 0.35f);
			component.anchorMax = new Vector2(0.95f, 0.75f);
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
			((UnityEvent)UIHelper.CreateButton((Transform)(object)val, "CancelBtn", "[Cancel]", new Vector2(0.08f, 0.1f), new Vector2(0.42f, 0.28f), 20, CancelBg).onClick).AddListener(new UnityAction(OnCancelClicked));
			GameObject val2 = new GameObject("BindBtn");
			val2.transform.SetParent((Transform)(object)val, false);
			RectTransform obj = val2.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.58f, 0.1f);
			obj.anchorMax = new Vector2(0.92f, 0.28f);
			offsetMin = (obj.offsetMax = Vector2.zero);
			obj.offsetMin = offsetMin;
			_bindImage = val2.AddComponent<Image>();
			((Graphic)_bindImage).color = BindGrayBg;
			_bindButton = val2.AddComponent<Button>();
			((Selectable)_bindButton).targetGraphic = (Graphic)(object)_bindImage;
			((Selectable)_bindButton).interactable = false;
			((UnityEvent)_bindButton.onClick).AddListener(new UnityAction(OnBindClicked));
			GameObject val3 = new GameObject("Label");
			val3.transform.SetParent(val2.transform, false);
			RectTransform obj2 = val3.AddComponent<RectTransform>();
			obj2.anchorMin = Vector2.zero;
			obj2.anchorMax = Vector2.one;
			offsetMin = (obj2.offsetMax = Vector2.zero);
			obj2.offsetMin = offsetMin;
			_bindLabel = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_bindLabel).text = "[Bind Key]";
			((TMP_Text)_bindLabel).fontSize = 20f;
			((TMP_Text)_bindLabel).alignment = (TextAlignmentOptions)514;
			((Graphic)_bindLabel).color = new Color(0.45f, 0.45f, 0.45f);
		}

		public void Show(int pickerID, CardInfo card, Action<int> onConfirm, Action onCancel)
		{
			_pickerID = pickerID;
			_card = card;
			_onConfirm = onConfirm;
			_onCancel = onCancel;
			_pendingKey = null;
			((TMP_Text)_messageText).text = "Press a key to bind <b>" + card.cardName + "</b>.";
			RefreshBindButton();
			((Component)_canvas).gameObject.SetActive(true);
			KLog.Line($"Keybind modal shown for '{card.cardName}' (picker={pickerID}).");
		}

		public void Hide()
		{
			((Component)_canvas).gameObject.SetActive(false);
			_onConfirm = null;
			_onCancel = null;
			_card = null;
			_pendingKey = null;
		}

		private void Update()
		{
			if (!((Component)_canvas).gameObject.activeSelf || (Object)(object)_card == (Object)null)
			{
				return;
			}
			if (InputCompat.GetKeyDown(27))
			{
				OnCancelClicked();
				return;
			}
			int[] bindableKeys = GetBindableKeys();
			foreach (int num in bindableKeys)
			{
				if (InputCompat.GetKeyDown(num))
				{
					EffectStackManager effectStackManager = EffectStackManager.instance;
					if (effectStackManager != null && effectStackManager.IsKeyTaken(_pickerID, num))
					{
						((TMP_Text)_messageText).text = "<color=#ff8888>" + FormatKey(num) + " is already bound.</color>";
						_pendingKey = null;
						RefreshBindButton();
						break;
					}
					_pendingKey = num;
					((TMP_Text)_messageText).text = "Bind <b>" + _card.cardName + "</b> to <b>" + FormatKey(num) + "</b>?";
					RefreshBindButton();
					break;
				}
			}
		}

		private void RefreshBindButton()
		{
			//IL_0028: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			bool hasValue = _pendingKey.HasValue;
			((Selectable)_bindButton).interactable = hasValue;
			((Graphic)_bindImage).color = (hasValue ? BindReadyBg : BindGrayBg);
			((Graphic)_bindLabel).color = (Color)(hasValue ? Color.white : new Color(0.45f, 0.45f, 0.45f));
		}

		private void OnBindClicked()
		{
			if (_pendingKey.HasValue)
			{
				int value = _pendingKey.Value;
				Action<int> onConfirm = _onConfirm;
				Hide();
				onConfirm?.Invoke(value);
			}
		}

		private void OnCancelClicked()
		{
			Action onCancel = _onCancel;
			Hide();
			onCancel?.Invoke();
		}

		private static int[] GetBindableKeys()
		{
			int[] array = new int[36];
			int num = 0;
			for (int i = 97; i <= 122; i++)
			{
				array[num++] = i;
			}
			for (int j = 48; j <= 57; j++)
			{
				array[num++] = j;
			}
			return array;
		}

		internal static string FormatKey(int key)
		{
			if (key >= 48 && key <= 57)
			{
				return (key - 48).ToString();
			}
			if (key >= 97 && key <= 122)
			{
				return ((char)key).ToString().ToUpper();
			}
			return key.ToString();
		}
	}
	internal static class UIHelper
	{
		public static Canvas CreateFullscreenCanvas(string name, int sortOrder = 100)
		{
			//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_000c: Expected O, but got Unknown
			//IL_000c: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			Object.DontDestroyOnLoad((Object)val);
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = sortOrder;
			CanvasScaler obj = val.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			val.AddComponent<GraphicRaycaster>();
			return val2;
		}

		public static RectTransform CreatePanel(Transform parent, string name, Vector2 anchorMin, Vector2 anchorMax, Color? bg = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001b: 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_002a: 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_0030: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = anchorMin;
			obj.anchorMax = anchorMax;
			Vector2 offsetMin = (obj.offsetMax = Vector2.zero);
			obj.offsetMin = offsetMin;
			if (bg.HasValue)
			{
				((Graphic)val.AddComponent<Image>()).color = bg.Value;
			}
			return obj;
		}

		public static TextMeshProUGUI CreateText(Transform parent, string name, string text, int fontSize = 24, TextAlignmentOptions alignment = 514, Color? color = null)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0036: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			Vector2 offsetMin = (obj.offsetMax = Vector2.zero);
			obj.offsetMin = offsetMin;
			TextMeshProUGUI obj2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = text;
			((TMP_Text)obj2).fontSize = fontSize;
			((TMP_Text)obj2).alignment = alignment;
			((Graphic)obj2).color = (Color)(((??)color) ?? Color.white);
			return obj2;
		}

		public static Button CreateButton(Transform parent, string name, string label, Vector2 anchorMin, Vector2 anchorMax, int fontSize = 20, Color? bgColor = null, Color? textColor = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001b: 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_002a: 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_0030: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00ff: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = anchorMin;
			obj.anchorMax = anchorMax;
			Vector2 offsetMin = (obj.offsetMax = Vector2.zero);
			obj.offsetMin = offsetMin;
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = (Color)(((??)bgColor) ?? new Color(0.2f, 0.2f, 0.2f, 0.9f));
			Button obj2 = val.AddComponent<Button>();
			((Selectable)obj2).targetGraphic = (Graphic)(object)val2;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.15f, 1.15f, 1.15f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.8f, 0.8f, 0.8f);
			((ColorBlock)(ref colors)).disabledColor = Color.white;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)obj2).colors = colors;
			GameObject val3 = new GameObject("Label");
			val3.transform.SetParent(val.transform, false);
			RectTransform obj3 = val3.AddComponent<RectTransform>();
			obj3.anchorMin = Vector2.zero;
			obj3.anchorMax = Vector2.one;
			offsetMin = (obj3.offsetMax = Vector2.zero);
			obj3.offsetMin = offsetMin;
			TextMeshProUGUI obj4 = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).text = label;
			((TMP_Text)obj4).fontSize = fontSize;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)514;
			((Graphic)obj4).color = (Color)(((??)textColor) ?? Color.white);
			return obj2;
		}
	}
}
namespace Keybound.Patches
{
	[HarmonyPatch]
	internal static class DeckPickCompatPatch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("DeckBuilder.GameIntegration.DeckPickPatch");
			if (!(type == null))
			{
				return AccessTools.Method(type, "ApplyStats_Postfix", (Type[])null, (Type[])null);
			}
			return null;
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SuppressDeckConsume(ApplyCardStats __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			CardInfo componentInParent = ((Component)__instance).GetComponentInParent<CardInfo>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			if (!KeyboundCardRegistry.IsKeybound(componentInParent.cardName))
			{
				return true;
			}
			KLog.Line("Suppressed DeckPickPatch consume for keybound card '" + componentInParent.cardName + "'.");
			return false;
		}
	}
	[HarmonyPatch]
	internal static class KeyboundPickPatches
	{
		internal static bool IsBindFlowActive;

		private static int _pickerID = -1;

		private static CardInfo _pendingCard;

		[HarmonyPatch(typeof(ApplyCardStats), "ApplyStats")]
		[HarmonyPrefix]
		private static bool ApplyStats_Prefix(ApplyCardStats __instance)
		{
			if ((Object)(object)CardChoice.instance == (Object)null || !CardChoice.instance.IsPicking)
			{
				return true;
			}
			CardInfo componentInParent = ((Component)__instance).GetComponentInParent<CardInfo>();
			if ((Object)(object)componentInParent == (Object)null || !KeyboundCardRegistry.IsKeybound(componentInParent.cardName))
			{
				return true;
			}
			int pickrID = CardChoice.instance.pickrID;
			if (!IsLocalPicker(pickrID))
			{
				return true;
			}
			KLog.Section("Keybind flow started — '" + componentInParent.cardName + "'");
			StartBindFlow(pickrID, componentInParent);
			return false;
		}

		[HarmonyPatch(typeof(CardChoice), "RPCA_DoEndPick")]
		[HarmonyPrefix]
		private static bool RPCA_DoEndPick_Prefix()
		{
			if (!IsBindFlowActive)
			{
				return true;
			}
			KLog.Line("RPCA_DoEndPick suppressed (keybind modal open).");
			return false;
		}

		[HarmonyPatch(typeof(CardBarHandler), "AddCard")]
		[HarmonyPrefix]
		private static bool CardBarHandler_AddCard_Prefix(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return true;
			}
			if (!KeyboundCardRegistry.IsKeybound(card.cardName))
			{
				return true;
			}
			KLog.Line("Blocked card-bar add for keybound card '" + card.cardName + "'.");
			return false;
		}

		private static void StartBindFlow(int pickerID, CardInfo card)
		{
			_pickerID = pickerID;
			_pendingCard = card;
			IsBindFlowActive = true;
			KeybindModalUI.instance?.Show(pickerID, card, OnConfirm, OnCancel);
		}

		private static void OnConfirm(int key)
		{
			KLog.Section($"Keybind confirmed — {_pendingCard?.cardName} -> {key}");
			IsBindFlowActive = false;
			if ((Object)(object)_pendingCard != (Object)null)
			{
				EffectStackManager.instance?.AddBinding(_pickerID, _pendingCard, key);
				DeckBuilderBridge.ConsumeCard(_pickerID, _pendingCard);
			}
			PickPhaseHelper.EndPickPhase();
			_pendingCard = null;
		}

		private static void OnCancel()
		{
			KLog.Section("Keybind cancelled");
			IsBindFlowActive = false;
			PickPhaseHelper.RestorePickState(_pickerID, _pendingCard);
			_pendingCard = null;
		}

		private static bool IsLocalPicker(int pickerID)
		{
			Player val = PlayerManager.instance?.players?.Find((Player p) => p.playerID == pickerID);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			object obj = AccessTools.Field(typeof(CharacterData), "view")?.GetValue(val.data);
			if (obj == null)
			{
				return true;
			}
			PropertyInfo propertyInfo = AccessTools.Property(obj.GetType(), "IsMine");
			if (propertyInfo == null)
			{
				return true;
			}
			return (bool)propertyInfo.GetValue(obj, null);
		}
	}
}
namespace Keybound.Effects
{
	internal static class TeleportEffect
	{
		internal const string CardName = "Teleport";

		internal const float InitialDelay = 10f;

		internal const float Cooldown = 15f;

		internal static readonly KeyboundEffectDef Def = new KeyboundEffectDef
		{
			CardName = "Teleport",
			InitialDelay = 10f,
			Cooldown = 15f,
			Activate = TryTeleport
		};

		private static bool TryTeleport(Player player)
		{
			//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_0043: 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_00cb: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player?.data == (Object)null || (Object)(object)MainCam.instance?.cam == (Object)null)
			{
				return false;
			}
			Vector3 val = MainCam.instance.cam.ScreenToWorldPoint(InputCompat.MousePosition);
			val.z = 0f;
			PlayerCollision componentInParent = ((Component)player).GetComponentInParent<PlayerCollision>();
			if (componentInParent != null)
			{
				componentInParent.IgnoreWallForFrames(2);
			}
			((Component)player).transform.position = val;
			if ((Object)(object)player.data.playerVel != (Object)null)
			{
				Traverse.Create((object)player.data.playerVel).Field("velocity").SetValue((object)Vector2.zero);
			}
			player.data.sinceGrounded = 0f;
			KLog.Line($"Teleport activated for player {player.playerID} -> ({val.x:F1}, {val.y:F1}).");
			return true;
		}
	}
}
namespace Keybound.Core
{
	public class EffectStackManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <GetAllBindings>d__4 : IEnumerable<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>>, IEnumerable, IEnumerator<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private KeyValuePair<int, IReadOnlyList<KeyboundBinding>> <>2__current;

			private int <>l__initialThreadId;

			public EffectStackManager <>4__this;

			private Dictionary<int, List<KeyboundBinding>>.Enumerator <>7__wrap1;

			KeyValuePair<int, IReadOnlyList<KeyboundBinding>> IEnumerator<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			public <GetAllBindings>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(Dictionary<int, List<KeyboundBinding>>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					EffectStackManager effectStackManager = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = effectStackManager._bindings.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						KeyValuePair<int, List<KeyboundBinding>> current = <>7__wrap1.Current;
						if (current.Value != null && current.Value.Count > 0)
						{
							<>2__current = new KeyValuePair<int, IReadOnlyList<KeyboundBinding>>(current.Key, current.Value);
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = default(Dictionary<int, List<KeyboundBinding>>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>> IEnumerable<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>>.GetEnumerator()
			{
				<GetAllBindings>d__4 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetAllBindings>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>>)this).GetEnumerator();
			}
		}

		public static EffectStackManager instance;

		private readonly Dictionary<int, List<KeyboundBinding>> _bindings = new Dictionary<int, List<KeyboundBinding>>();

		private bool _wasGameActive;

		private void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		internal IReadOnlyList<KeyboundBinding> GetBindings(int playerID)
		{
			if (!_bindings.TryGetValue(playerID, out var value))
			{
				return Array.Empty<KeyboundBinding>();
			}
			return value;
		}

		[IteratorStateMachine(typeof(<GetAllBindings>d__4))]
		internal IEnumerable<KeyValuePair<int, IReadOnlyList<KeyboundBinding>>> GetAllBindings()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllBindings>d__4(-2)
			{
				<>4__this = this
			};
		}

		internal bool IsKeyTaken(int playerID, int key)
		{
			return GetBindings(playerID).Any((KeyboundBinding b) => b.Key == key);
		}

		internal void AddBinding(int playerID, CardInfo card, int key)
		{
			if ((Object)(object)card == (Object)null || !KeyboundCardRegistry.TryGet(card.cardName, out var def))
			{
				KLog.Warn("AddBinding failed — '" + (card?.cardName ?? "null") + "' is not keybound.");
				return;
			}
			if (!_bindings.TryGetValue(playerID, out var value))
			{
				value = new List<KeyboundBinding>();
				_bindings[playerID] = value;
			}
			KeyboundBinding keyboundBinding = new KeyboundBinding
			{
				PlayerID = playerID,
				CardName = card.cardName,
				Card = card,
				Key = key,
				Def = def
			};
			keyboundBinding.ArmInitialDelay();
			value.Add(keyboundBinding);
			KLog.Line($"Bound '{card.cardName}' to {key} for player {playerID}.");
			EffectStackOverlay.instance?.RefreshAll();
		}

		internal void ClearAll()
		{
			_bindings.Clear();
			EffectStackOverlay.instance?.HideAll();
		}

		private void Update()
		{
			bool flag = IsGameActive();
			if (_wasGameActive && !flag)
			{
				ClearAll();
			}
			_wasGameActive = flag;
			if (!flag)
			{
				return;
			}
			Player localHumanPlayer = GetLocalHumanPlayer();
			if ((Object)(object)localHumanPlayer == (Object)null)
			{
				return;
			}
			foreach (KeyboundBinding binding in GetBindings(localHumanPlayer.playerID))
			{
				if (binding.IsReady() && InputCompat.GetKeyDown(binding.Key) && binding.Def.Activate(localHumanPlayer))
				{
					binding.ArmCooldown();
				}
			}
			EffectStackOverlay.instance?.RefreshAll();
		}

		private static bool IsGameActive()
		{
			if ((Object)(object)GameManager.instance == (Object)null)
			{
				return false;
			}
			if (!GameManager.instance.isPlaying)
			{
				return false;
			}
			if (PlayerManager.instance?.players == null || PlayerManager.instance.players.Count == 0)
			{
				return false;
			}
			return true;
		}

		internal static Player GetLocalHumanPlayer()
		{
			if ((Object)(object)PlayerManager.instance == (Object)null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player == (Object)null)
				{
					continue;
				}
				PlayerAPI component = ((Component)player).GetComponent<PlayerAPI>();
				if (component == null || !((Behaviour)component).enabled)
				{
					object obj = AccessTools.Field(typeof(CharacterData), "view")?.GetValue(player.data);
					if (obj == null)
					{
						return player;
					}
					PropertyInfo propertyInfo = AccessTools.Property(obj.GetType(), "IsMine");
					if (propertyInfo == null)
					{
						return player;
					}
					if ((bool)propertyInfo.GetValue(obj, null))
					{
						return player;
					}
				}
			}
			return null;
		}
	}
	internal static class InputCompat
	{
		internal const int KeyEscape = 27;

		private static Type _keyCodeType;

		private static MethodInfo _getKeyDown;

		private static PropertyInfo _mousePosition;

		private static bool _resolved;

		private static bool _available;

		internal static Vector3 MousePosition
		{
			get
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: 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_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)
				Resolve();
				if (!_available)
				{
					return Vector3.zero;
				}
				try
				{
					return (Vector3)_mousePosition.GetValue(null, null);
				}
				catch (Exception ex)
				{
					KLog.Warn("InputCompat.MousePosition failed: " + ex.Message);
					return Vector3.zero;
				}
			}
		}

		internal static bool GetKeyDown(int keyCode)
		{
			Resolve();
			if (!_available)
			{
				return false;
			}
			try
			{
				object obj = Enum.ToObject(_keyCodeType, keyCode);
				return (bool)_getKeyDown.Invoke(null, new object[1] { obj });
			}
			catch (Exception ex)
			{
				KLog.Warn("InputCompat.GetKeyDown failed: " + ex.Message);
				return false;
			}
		}

		private static void Resolve()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			try
			{
				_keyCodeType = Type.GetType("UnityEngine.KeyCode, UnityEngine.CoreModule") ?? Type.GetType("UnityEngine.KeyCode, UnityEngine");
				Type type = Type.GetType("UnityEngine.Input, UnityEngine.CoreModule") ?? Type.GetType("UnityEngine.Input, UnityEngine");
				if (_keyCodeType == null || type == null)
				{
					KLog.Warn("InputCompat: UnityEngine.Input/KeyCode not found in CoreModule.");
					return;
				}
				_getKeyDown = type.GetMethod("GetKeyDown", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { _keyCodeType }, null);
				_mousePosition = type.GetProperty("mousePosition", BindingFlags.Static | BindingFlags.Public);
				_available = _getKeyDown != null && _mousePosition != null;
				if (_available)
				{
					KLog.Line("InputCompat resolved against UnityEngine.CoreModule.");
				}
				else
				{
					KLog.Warn("InputCompat: GetKeyDown or mousePosition not found.");
				}
			}
			catch (Exception ex)
			{
				KLog.Warn("InputCompat resolve failed: " + ex.Message);
			}
		}
	}
	internal sealed class KeyboundBinding
	{
		public int PlayerID;

		public string CardName;

		public CardInfo Card;

		public int Key;

		public KeyboundEffectDef Def;

		public float ReadyAt;

		public float LockoutDuration;

		public bool IsReady()
		{
			return Time.time >= ReadyAt;
		}

		public float CooldownFill()
		{
			if (IsReady())
			{
				return 0f;
			}
			float num = ReadyAt - Time.time;
			if (LockoutDuration <= 0f)
			{
				return 1f;
			}
			return Mathf.Clamp01(num / LockoutDuration);
		}

		public void ArmInitialDelay()
		{
			LockoutDuration = Def.InitialDelay;
			ReadyAt = Time.time + Def.InitialDelay;
		}

		public void ArmCooldown()
		{
			LockoutDuration = Def.Cooldown;
			ReadyAt = Time.time + Def.Cooldown;
		}
	}
	internal static class KeyboundCardRegistry
	{
		private static readonly Dictionary<string, KeyboundEffectDef> Effects = new Dictionary<string, KeyboundEffectDef>();

		internal static void Register(KeyboundEffectDef def)
		{
			Effects[def.CardName] = def;
			KLog.Line($"Registered keybound effect '{def.CardName}' (delay={def.InitialDelay}s, cd={def.Cooldown}s).");
		}

		internal static bool IsKeybound(string cardName)
		{
			if (!string.IsNullOrEmpty(cardName))
			{
				return Effects.ContainsKey(cardName);
			}
			return false;
		}

		internal static bool TryGet(string cardName, out KeyboundEffectDef def)
		{
			return Effects.TryGetValue(cardName, out def);
		}

		internal static void RegisterBuiltInEffects()
		{
			Register(TeleportEffect.Def);
		}
	}
	internal sealed class KeyboundEffectDef
	{
		public string CardName;

		public float InitialDelay;

		public float Cooldown;

		public Func<Player, bool> Activate;
	}
	internal static class PickPhaseHelper
	{
		private static readonly FieldInfo s_isPlayingField = AccessTools.Field(typeof(CardChoice), "isPlaying");

		private static readonly FieldInfo s_picksField = AccessTools.Field(typeof(CardChoice), "picks");

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

		private static readonly MethodInfo s_rpca_donePicking = AccessTools.Method(typeof(CardChoice), "RPCA_DonePicking", (Type[])null, (Type[])null);

		internal static void EndPickPhase()
		{
			KLog.Section("EndPickPhase");
			CardChoice instance = CardChoice.instance;
			if ((Object)(object)instance == (Object)null)
			{
				KLog.Error("CardChoice.instance is null.");
				return;
			}
			((MonoBehaviour)instance).StopAllCoroutines();
			CleanupSpawnedDraftCards(instance);
			if (s_isPlayingField != null)
			{
				s_isPlayingField.SetValue(instance, false);
			}
			if (s_picksField != null)
			{
				s_picksField.SetValue(instance, 0);
			}
			if (s_rpca_donePicking == null)
			{
				instance.IsPicking = false;
			}
			else
			{
				try
				{
					s_rpca_donePicking.Invoke(instance, null);
				}
				catch (Exception ex)
				{
					KLog.Error("RPCA_DonePicking failed: " + ex.Message);
					instance.IsPicking = false;
				}
			}
			KLog.Line($"Pick ended. IsPicking={instance.IsPicking}");
		}

		internal static void RestorePickState(int pickerID, CardInfo card)
		{
			CardChoice instance = CardChoice.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				((MonoBehaviour)instance).StopAllCoroutines();
				instance.pickrID = pickerID;
				if (s_isPlayingField != null)
				{
					s_isPlayingField.SetValue(instance, false);
				}
				instance.IsPicking = true;
				if ((Object)(object)card != (Object)null)
				{
					ApplyCardStats componentInChildren = ((Component)card).GetComponentInChildren<ApplyCardStats>();
					AccessTools.Field(typeof(ApplyCardStats), "done")?.SetValue(componentInChildren, false);
				}
				ResetSpawnedDoneFlags(instance);
				KLog.Line($"Restored pick state for picker {pickerID}.");
			}
		}

		private static void ResetSpawnedDoneFlags(CardChoice cc)
		{
			if (!(s_spawnedCardsField?.GetValue(cc) is IList list))
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(ApplyCardStats), "done");
			foreach (object item in list)
			{
				GameObject val = (GameObject)((item is GameObject) ? item : null);
				if (val != null)
				{
					ApplyCardStats componentInChildren = val.GetComponentInChildren<ApplyCardStats>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						fieldInfo?.SetValue(componentInChildren, false);
					}
				}
			}
		}

		private static void CleanupSpawnedDraftCards(CardChoice cc)
		{
			if (!(s_spawnedCardsField?.GetValue(cc) is IList list))
			{
				return;
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				object? obj = list[num];
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
			list.Clear();
		}
	}
}
namespace Keybound.Compat
{
	internal static class DeckBuilderBridge
	{
		private static Type _deckManagerType;

		private static MethodInfo _consumeCard;

		private static MethodInfo _getRemaining;

		private static Type _networkSyncType;

		private static MethodInfo _broadcastRemaining;

		private static bool _resolved;

		internal static bool IsAvailable
		{
			get
			{
				Resolve();
				return _consumeCard != null;
			}
		}

		internal static void ConsumeCard(int playerID, CardInfo card)
		{
			Resolve();
			if (_consumeCard == null || (Object)(object)card == (Object)null)
			{
				return;
			}
			try
			{
				_consumeCard.Invoke(null, new object[2] { playerID, card });
				KLog.Line($"Consumed '{card.cardName}' from runtime deck (player {playerID}).");
				BroadcastRemaining(playerID);
			}
			catch (Exception ex)
			{
				KLog.Warn("DeckBuilder ConsumeCard failed: " + ex.Message);
			}
		}

		private static void BroadcastRemaining(int playerID)
		{
			if (_broadcastRemaining == null || _getRemaining == null)
			{
				return;
			}
			try
			{
				int num = (int)_getRemaining.Invoke(null, new object[1] { playerID });
				if (num >= 0)
				{
					_broadcastRemaining.Invoke(null, new object[2] { playerID, num });
				}
			}
			catch (Exception ex)
			{
				KLog.Warn("DeckBuilder broadcast failed: " + ex.Message);
			}
		}

		private static void Resolve()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "DeckBuilder");
				if (assembly == null)
				{
					KLog.Line("DeckBuilder not installed — runtime deck consumption skipped.");
					return;
				}
				_deckManagerType = assembly.GetType("DeckBuilder.Data.DeckManager");
				if (!(_deckManagerType == null))
				{
					_consumeCard = _deckManagerType.GetMethod("ConsumeCard", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
					{
						typeof(int),
						typeof(CardInfo)
					}, null);
					_getRemaining = _deckManagerType.GetMethod("GetRemainingCount", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
					_networkSyncType = assembly.GetType("DeckBuilder.Networking.DeckNetworkSync");
					_broadcastRemaining = _networkSyncType?.GetMethod("BroadcastRemainingCount", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
					{
						typeof(int),
						typeof(int)
					}, null);
				}
			}
			catch (Exception ex)
			{
				KLog.Warn("DeckBuilder bridge resolve failed: " + ex.Message);
			}
		}
	}
}
namespace Keybound.Cards
{
	internal static class CardArtLoader
	{
		private static readonly Dictionary<string, GameObject> Cache = new Dictionary<string, GameObject>();

		private static string AssetsDirectory => Path.Combine(Plugin.PluginDirectory, "assets");

		internal static GameObject Load(string fileName)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010f: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			if (Cache.TryGetValue(fileName, out var value) && (Object)(object)value != (Object)null)
			{
				KLog.Line("CardArtLoader: Returning cached art for '" + fileName + "'.");
				return value;
			}
			string text = Path.Combine(AssetsDirectory, fileName);
			KLog.Line("CardArtLoader: Loading '" + fileName + "' from " + text);
			if (!File.Exists(text))
			{
				KLog.Warn("CardArtLoader: Card art not found: " + text);
				return null;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array))
			{
				KLog.Warn("CardArtLoader: Failed to decode card art: " + text);
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Sprite sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			GameObject val2 = new GameObject("KeyboundCardArt_" + fileName);
			Object.DontDestroyOnLoad((Object)(object)val2);
			RectTransform obj = val2.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			((Transform)obj).localPosition = Vector3.up * 10000f;
			Image obj2 = val2.AddComponent<Image>();
			obj2.sprite = sprite;
			obj2.preserveAspect = true;
			((Graphic)obj2).raycastTarget = false;
			Cache[fileName] = val2;
			KLog.Line($"CardArtLoader: Loaded {((Texture)val).width}x{((Texture)val).height} from {text}");
			return val2;
		}
	}
	internal static class KeyboundCardRegistrar
	{
		internal static void RegisterAll()
		{
			KLog.Section("KeyboundCardRegistrar — RegisterAll");
			KeyboundCardRegistry.RegisterBuiltInEffects();
			CustomCard.BuildCard<TeleportCard>((Action<CardInfo>)delegate(CardInfo ci)
			{
				KLog.Line("Registered keybound card: " + ci.cardName);
			});
		}
	}
	public class TeleportCard : CustomCard
	{
		public const string CardDisplayName = "Teleport";

		protected override string GetTitle()
		{
			return "Teleport";
		}

		protected override string GetDescription()
		{
			return "[Keybound] Press your bound key to teleport to your cursor.\nBecomes available 10s after the round starts. Cooldown: 15s.";
		}

		protected override CardInfoStat[] GetStats()
		{
			return Array.Empty<CardInfoStat>();
		}

		protected override Rarity GetRarity()
		{
			return (Rarity)2;
		}

		protected override GameObject GetCardArt()
		{
			return CardArtLoader.Load("Teleport.png");
		}

		protected override CardThemeColorType GetTheme()
		{
			return (CardThemeColorType)2;
		}

		public override string GetModName()
		{
			return "Keybound";
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
		}
	}
}