using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Agents;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using ChainedPuzzles;
using Enemies;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using KainRogueProtocol.Core;
using KainRogueProtocol.Corruption;
using KainRogueProtocol.Data;
using KainRogueProtocol.Effects;
using KainRogueProtocol.Events;
using KainRogueProtocol.Modifiers;
using KainRogueProtocol.Networking;
using KainRogueProtocol.Patches;
using KainRogueProtocol.Runtime;
using KainRogueProtocol.Triggers;
using KainRogueProtocol.UI;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace KainRogueProtocol.UI
{
	public sealed class BuffBar
	{
		private readonly GameObject _panel;

		private readonly Text _text;

		private readonly Image _accent;

		public BuffBar(Transform parent)
		{
			//IL_0017: 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_0035: 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_0064: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			_panel = UiFactory.CreatePanel("BuffBar", parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(680f, 38f), new Vector2(0f, -42f));
			_accent = UiFactory.CreateImage("BuffAccent", _panel.transform, UiFactory.MutedTextColor);
			UiFactory.SetRect((Component)(object)_accent, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(4f, 24f), new Vector2(18f, 0f));
			_text = UiFactory.CreateText("BuffBarText", _panel.transform, "KRP / NO ACTIVE CARDS", 16, (TextAnchor)4, UiFactory.MutedTextColor);
			UiFactory.Stretch((Component)(object)_text, 30f, 4f, 12f, 4f);
		}

		public void Refresh(RogueState state)
		{
			//IL_0044: 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_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)
			if (state.SelectedCards.Count == 0)
			{
				((Graphic)_accent).color = UiFactory.MutedTextColor;
				((Graphic)_text).color = UiFactory.MutedTextColor;
				_text.text = "KRP / NO ACTIVE CARDS";
				return;
			}
			((Graphic)_accent).color = UiFactory.AccentColor;
			((Graphic)_text).color = UiFactory.TextColor;
			_text.text = "KRP / " + string.Join("  +  ", state.SelectedCards.Select((RogueCard card) => card.Name.ToUpperInvariant()));
		}

		public void SetVisible(bool visible)
		{
			_panel.SetActive(visible);
		}
	}
	public sealed class CardPoolPanel
	{
		private readonly GameObject _panel;

		private readonly Transform _gridRoot;

		private readonly Text _headerText;

		private readonly Text _promptText;

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

		private RogueCard[] _cards = Array.Empty<RogueCard>();

		private Action<RogueCard>? _onSelected;

		private bool _isVisible;

		public bool IsVisible => _isVisible;

		public CardPoolPanel(Transform parent)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0065: 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_00b1: 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_00cf: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01b1: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: 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_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: 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_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: 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)
			_panel = UiFactory.CreateRect("DevelopmentCardPoolPanel", parent, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			UiFactory.Stretch((Component)(object)UiFactory.CreateImage("CardPoolDimmer", _panel.transform, new Color(0f, 0.005f, 0.006f, 0.9f)), 0f, 0f, 0f, 0f);
			GameObject val = UiFactory.CreatePanel("CardPoolFrame", _panel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(1540f, 840f), new Vector2(0f, -20f));
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.72f);
			_headerText = UiFactory.CreateText("CardPoolHeader", val.transform, "<color=#8FDCFF>Kain</color> ROGUE PROTOCOL / DEV CARD POOL", 27, (TextAnchor)3, UiFactory.AccentColor);
			_headerText.fontStyle = (FontStyle)1;
			UiFactory.SetRect((Component)(object)_headerText, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-80f, 48f), new Vector2(40f, -44f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("CardPoolRule", val.transform, UiFactory.LineColor), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-80f, 2f), new Vector2(40f, -78f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("CardPoolSub", val.transform, "开发测试工具：点击任意卡牌立即加入当前运行状态。按 ESC 关闭。", 15, (TextAnchor)3, UiFactory.MutedTextColor), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-80f, 28f), new Vector2(40f, -105f));
			GameObject val2 = UiFactory.CreateRect("CardPoolGrid", val.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(1440f, 610f), new Vector2(0f, -42f));
			_gridRoot = val2.transform;
			_promptText = UiFactory.CreateText("CardPoolPrompt", val.transform, "快捷键 ~ 打开本面板 / F8 常驻 UI / F7 随机三选一", 14, (TextAnchor)4, UiFactory.TextColor);
			UiFactory.SetRect((Component)(object)_promptText, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(-80f, 34f), new Vector2(40f, 34f));
			_panel.SetActive(false);
		}

		public void Show(RogueCard[] cards, Action<RogueCard> onSelected)
		{
			_cards = cards;
			_onSelected = onSelected;
			RebuildEntries();
			_panel.SetActive(true);
			_isVisible = true;
		}

		public void Tick()
		{
			if (_isVisible && Input.GetKeyDown((KeyCode)27))
			{
				Close();
			}
		}

		private void RebuildEntries()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject entry in _entries)
			{
				Object.Destroy((Object)(object)entry);
			}
			_entries.Clear();
			int num = Mathf.Min(_cards.Length, 24);
			for (int i = 0; i < num; i++)
			{
				RogueCard card = _cards[i];
				int num2 = i % 4;
				int num3 = i / 4;
				float num4 = -516f + (float)num2 * 344f;
				float num5 = 204f - (float)num3 * 184f;
				CreateEntry(card, i, new Vector2(num4, num5));
			}
			_promptText.text = ((_cards.Length > 24) ? $"显示前 24 张 / 总计 {_cards.Length} 张。按 ESC 关闭。" : $"已载入 {_cards.Length} 张卡。点击任意卡牌立即选择，按 ESC 关闭。");
		}

		private void CreateEntry(RogueCard card, int index, Vector2 position)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_010d: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: 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_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: 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_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			RogueCard card2 = card;
			GameObject entry = UiFactory.CreateCard($"CardPoolEntry_{index + 1}", _gridRoot);
			UiFactory.SetRect((Component)(object)entry.GetComponent<RectTransform>(), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(320f, 156f), position);
			((Graphic)entry.GetComponent<Image>()).color = new Color(0.024f, 0.038f, 0.035f, 0.95f);
			_entries.Add(entry);
			Color color = RogueUiAssetLibrary.RarityPrimaryColor(card2.Rarity);
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("Accent", entry.transform, color), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 4f), new Vector2(0f, -2f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("Index", entry.transform, $"{index + 1:00}", 14, (TextAnchor)3, UiFactory.AccentColor), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(44f, 24f), new Vector2(34f, -24f));
			RogueUiAssetLibrary.BindRarityModule(UiFactory.CreateRect("RarityModuleSlot", entry.transform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(46f, 46f), new Vector2(-42f, -40f)).transform, card2.Rarity, out Image baseImage, out Image rarityGlow, out Image rarityAccent);
			UiFactory.Stretch((Component)(object)baseImage, 0f, 0f, 0f, 0f);
			UiFactory.Stretch((Component)(object)rarityGlow, -6f, -6f, -6f, -6f);
			UiFactory.Stretch((Component)(object)rarityAccent, 0f, 0f, 0f, 0f);
			Text obj = UiFactory.CreateText("Title", entry.transform, card2.Name, 18, (TextAnchor)3, UiFactory.TextColor);
			obj.resizeTextForBestFit = true;
			obj.resizeTextMinSize = 12;
			obj.resizeTextMaxSize = 18;
			UiFactory.SetRect((Component)(object)obj, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-112f, 28f), new Vector2(84f, -24f));
			Text obj2 = UiFactory.CreateText("Description", entry.transform, card2.Description, 12, (TextAnchor)0, UiFactory.TextColor);
			obj2.resizeTextForBestFit = true;
			obj2.resizeTextMinSize = 9;
			obj2.resizeTextMaxSize = 12;
			UiFactory.SetRect((Component)(object)obj2, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-34f, 58f), new Vector2(17f, -88f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("Tags", entry.transform, (card2.Tags.Count == 0) ? "无标签" : string.Join(" / ", card2.Tags.Take(3)), 10, (TextAnchor)3, UiFactory.MutedTextColor), new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(-34f, 22f), new Vector2(17f, 18f));
			((UnityEvent)entry.AddComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				Select(card2);
			}));
			EventTrigger trigger = entry.AddComponent<EventTrigger>();
			AddTrigger(trigger, (EventTriggerType)0, delegate
			{
				//IL_000b: 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)
				entry.transform.localScale = Vector3.one * 1.018f;
				RogueUiAssetLibrary.SetRarityModuleState(rarityGlow, rarityAccent, highlighted: true, selected: false);
			});
			AddTrigger(trigger, (EventTriggerType)1, delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				entry.transform.localScale = Vector3.one;
				RogueUiAssetLibrary.SetRarityModuleState(rarityGlow, rarityAccent, highlighted: false, selected: false);
			});
		}

		private void Select(RogueCard card)
		{
			Close();
			_onSelected?.Invoke(card);
		}

		private void Close()
		{
			_panel.SetActive(false);
			_isVisible = false;
		}

		private static void AddTrigger(EventTrigger trigger, EventTriggerType type, Action<BaseEventData> callback)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Entry val = new Entry
			{
				eventID = type
			};
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener(UnityAction<BaseEventData>.op_Implicit(callback));
			trigger.triggers.Add(val);
		}

		private static string DisplayRarity(string rarity)
		{
			return rarity.ToLowerInvariant() switch
			{
				"common" => "普通", 
				"uncommon" => "优秀", 
				"rare" => "稀有", 
				"epic" => "史诗", 
				"legendary" => "传说", 
				"curse" => "腐化", 
				"corrupted" => "腐化", 
				_ => rarity, 
			};
		}
	}
	public sealed class CorruptionIntroPanel
	{
		private readonly GameObject _panel;

		private readonly Text _title;

		private readonly Text _body;

		private readonly Text _footer;

		private bool _isVisible;

		private float _hideAt = -1f;

		public CorruptionIntroPanel(Transform parent)
		{
			//IL_0022: 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_0040: 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_0077: 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_00a5: 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_00c3: 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_00f1: 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_010f: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			_panel = UiFactory.CreatePanel("CorruptionIntroPanel", parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(860f, 420f), new Vector2(0f, -40f));
			_title = UiFactory.CreateText("CorruptionTitle", _panel.transform, "本局异变已确认", 28, (TextAnchor)3, UiFactory.DangerColor);
			UiFactory.SetRect((Component)(object)_title, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-80f, 42f), new Vector2(42f, -42f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("CorruptionRule", _panel.transform, UiFactory.LineColor), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(780f, 2f), new Vector2(0f, -76f));
			_body = UiFactory.CreateText("CorruptionBody", _panel.transform, string.Empty, 18, (TextAnchor)0, UiFactory.TextColor);
			_body.resizeTextForBestFit = true;
			_body.resizeTextMinSize = 13;
			_body.resizeTextMaxSize = 18;
			UiFactory.SetRect((Component)(object)_body, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(-84f, 260f), new Vector2(42f, -220f));
			_footer = UiFactory.CreateText("CorruptionFooter", _panel.transform, "F4 查看 / 隐藏当前异变", 14, (TextAnchor)5, UiFactory.MutedTextColor);
			UiFactory.SetRect((Component)(object)_footer, new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(-84f, 32f), new Vector2(42f, 34f));
			_panel.SetActive(false);
		}

		public void Show(CorruptionCard[] cards, float durationSeconds)
		{
			_body.text = ((cards.Length == 0) ? "暂无已激活异变。" : string.Join(Environment.NewLine + Environment.NewLine, cards.Select((CorruptionCard card) => "[" + card.Name + "]\n" + card.Description)));
			_hideAt = ((durationSeconds > 0f) ? (Time.time + durationSeconds) : (-1f));
			_panel.SetActive(true);
			_isVisible = true;
		}

		public void Toggle(CorruptionCard[] cards)
		{
			if (_isVisible)
			{
				Hide();
			}
			else
			{
				Show(cards, 0f);
			}
		}

		public void Tick()
		{
			if (_isVisible && !(_hideAt < 0f) && !(Time.time < _hideAt))
			{
				Hide();
			}
		}

		private void Hide()
		{
			_panel.SetActive(false);
			_isVisible = false;
			_hideAt = -1f;
		}
	}
	public sealed class DebugOverlay
	{
		private readonly GameObject _panel;

		private readonly Text _text;

		private RogueState? _state;

		public DebugOverlay(Transform parent, bool enabled)
		{
			//IL_0017: 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_0035: 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_0063: 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_0086: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			_panel = UiFactory.CreatePanel("DebugOverlay", parent, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(360f, 112f), new Vector2(218f, -78f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("DebugAccent", _panel.transform, UiFactory.DangerColor), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 2f), new Vector2(0f, -1f));
			_text = UiFactory.CreateText("DebugText", _panel.transform, string.Empty, 13, (TextAnchor)0, UiFactory.TextColor);
			UiFactory.Stretch((Component)(object)_text, 14f, 8f, 12f, 8f);
			_panel.SetActive(enabled);
		}

		public void Refresh(RogueState state)
		{
			_state = state;
			Tick();
		}

		public void Tick()
		{
			if (_state != null)
			{
				_text.text = "KAIN ROGUE PROTOCOL / PHASE 0\n" + $"SEED      {_state.Seed}\n" + $"VERSION   {_state.Version}\n" + $"CARDS     {_state.SelectedCards.Count}";
			}
		}

		public void SetVisible(bool visible)
		{
			_panel.SetActive(visible);
		}
	}
	public sealed class RewardChoicePanel
	{
		private const float ReferenceCardWidth = 768f;

		private const float ReferenceCardHeight = 1024f;

		private const float CardAspect = 0.75f;

		private const float GapRatio = 0.32f;

		private readonly GameObject _panel;

		private readonly GameObject[] _cards = (GameObject[])(object)new GameObject[3];

		private readonly RectTransform[] _cardRects = (RectTransform[])(object)new RectTransform[3];

		private readonly RectTransform[] _contentRoots = (RectTransform[])(object)new RectTransform[3];

		private readonly Button[] _buttons = (Button[])(object)new Button[3];

		private readonly Image[] _cardBodies = (Image[])(object)new Image[3];

		private readonly Image[] _outerBorders = (Image[])(object)new Image[3];

		private readonly Image[] _innerBorders = (Image[])(object)new Image[3];

		private readonly Image[] _backgroundArts = (Image[])(object)new Image[3];

		private readonly Image[] _glows = (Image[])(object)new Image[3];

		private readonly Image[] _accentBars = (Image[])(object)new Image[3];

		private readonly Image[] _rarityBaseImages = (Image[])(object)new Image[3];

		private readonly Image[] _rarityGlowImages = (Image[])(object)new Image[3];

		private readonly Image[] _rarityAccentImages = (Image[])(object)new Image[3];

		private readonly Image[] _scanLines = (Image[])(object)new Image[3];

		private readonly RectTransform[] _scanRects = (RectTransform[])(object)new RectTransform[3];

		private readonly TextMeshProUGUI[] _keyTexts = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private readonly TextMeshProUGUI[] _titleTexts = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private readonly TextMeshProUGUI[] _descriptionTexts = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private readonly TextMeshProUGUI[] _tagTexts = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private readonly TextMeshProUGUI[] _footerTexts = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private readonly GameObject[][] _debugRects = new GameObject[3][];

		private readonly Text _protocolStatsText;

		private readonly Text _centerStatusText;

		private readonly Text _mainTitle;

		private readonly Text _glitchTitle;

		private readonly Text _bottomPromptText;

		private RogueCard[] _activeCards = Array.Empty<RogueCard>();

		private Action<RogueCard>? _onSelected;

		private bool _isVisible;

		private int _hoverIndex = 1;

		private float _nextGlitchAt;

		private float _glitchUntil;

		private int _selectedIndex = -1;

		private bool _layoutDebugVisible;

		public bool IsVisible => _isVisible;

		public RewardChoicePanel(Transform parent)
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			_panel = UiFactory.CreateRect("RewardChoicePanel.VersionA", parent, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			CreateBackground();
			CreateTopStatusBar(out _protocolStatsText, out _centerStatusText);
			CreateHeader(out _mainTitle, out _glitchTitle);
			CreateSideDecor();
			CreateBottomPrompt(out _bottomPromptText);
			GameObject val = UiFactory.CreateRect("RewardCardsRow", _panel.transform, Vector2.zero, Vector2.one, Vector2.zero, new Vector2(0f, -36f));
			for (int i = 0; i < 3; i++)
			{
				CreateCard(val.transform, i);
			}
			_panel.SetActive(false);
			_isVisible = false;
			_nextGlitchAt = Time.time + 4f;
		}

		public void RefreshState(RogueState state)
		{
			_protocolStatsText.text = $"KAIN ROGUE PROTOCOL\nSEED {state.Seed}\nVERSION {state.Version}\nCARDS {state.SelectedCards.Count}";
			_centerStatusText.text = ((state.SelectedCards.Count == 0) ? "KRP / NO ACTIVE CARDS" : ("KRP / ACTIVE CARDS " + state.SelectedCards.Count));
		}

		public void Show(RogueCard[] cards, Action<RogueCard> onSelected)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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)
			_activeCards = cards;
			_onSelected = onSelected;
			_hoverIndex = ((cards.Length > 1) ? 1 : 0);
			_selectedIndex = -1;
			_panel.SetActive(true);
			_isVisible = true;
			LayoutRewardCards();
			for (int i = 0; i < _cards.Length; i++)
			{
				bool flag = i < cards.Length;
				_cards[i].SetActive(flag);
				if (flag)
				{
					RogueCard rogueCard = cards[i];
					RogueUiAssetLibrary.RarityPrimaryColor(rogueCard.Rarity);
					Sprite cardBackground = RogueUiAssetLibrary.GetCardBackground(rogueCard);
					_backgroundArts[i].sprite = cardBackground;
					((Graphic)_backgroundArts[i]).color = (Color)(((Object)(object)cardBackground == (Object)null) ? new Color(0f, 0f, 0f, 0f) : Color.white);
					RogueUiAssetLibrary.SetRarityModuleSprites(_rarityBaseImages[i], _rarityGlowImages[i], _rarityAccentImages[i], rogueCard.Rarity);
					((Graphic)_accentBars[i]).color = new Color(0f, 0f, 0f, 0f);
					((TMP_Text)_keyTexts[i]).text = $"[{i + 1}]";
					((TMP_Text)_titleTexts[i]).text = rogueCard.Name;
					((TMP_Text)_descriptionTexts[i]).text = rogueCard.Description;
					((TMP_Text)_tagTexts[i]).text = ((rogueCard.Tags.Count == 0) ? "未分类" : string.Join("  /  ", rogueCard.Tags.Take(4)));
					((TMP_Text)_footerTexts[i]).text = $"PRESS [{i + 1}] TO SELECT";
					SetCardVisual(i, i == _hoverIndex, selected: false);
				}
			}
			_bottomPromptText.text = "数字键 1-3 或鼠标点击选择奖励  /  REWARD SELECTION REQUIRED";
			_panel.SetActive(true);
			_isVisible = true;
		}

		public void Tick()
		{
			if (_isVisible)
			{
				if (Input.GetKeyDown((KeyCode)49) || Input.GetKeyDown((KeyCode)257))
				{
					Select(0);
				}
				else if (Input.GetKeyDown((KeyCode)50) || Input.GetKeyDown((KeyCode)258))
				{
					Select(1);
				}
				else if (Input.GetKeyDown((KeyCode)51) || Input.GetKeyDown((KeyCode)259))
				{
					Select(2);
				}
				else if (Input.GetKeyDown((KeyCode)27))
				{
					_bottomPromptText.text = "REWARD SELECTION REQUIRED";
				}
				else if (Input.GetKeyDown((KeyCode)291))
				{
					SetLayoutDebugVisible(!_layoutDebugVisible);
				}
				LayoutRewardCards();
				TickCards();
				TickGlitchTitle();
			}
		}

		private void CreateBackground()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00c6: 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_011e: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: 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_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			UiFactory.Stretch((Component)(object)UiFactory.CreateImage("DimmerFullScreen", _panel.transform, new Color(0f, 0.006f, 0.007f, 0.82f)), 0f, 0f, 0f, 0f);
			for (int i = 0; i < 28; i++)
			{
				int num = -520 + i * 40;
				UiFactory.SetRect((Component)(object)UiFactory.CreateImage($"HorizontalScanline_{i:00}", _panel.transform, new Color(0.58f, 0.9f, 0.86f, (i % 3 == 0) ? 0.045f : 0.018f)), new Vector2(0f, 0.5f), new Vector2(1f, 0.5f), new Vector2(0f, 1f), new Vector2(0f, (float)num));
			}
			for (int j = 0; j < 9; j++)
			{
				UiFactory.SetRect((Component)(object)UiFactory.CreateImage($"RedWarningMark_{j:00}", _panel.transform, new Color(0.9f, 0.03f, 0.02f, 0.24f)), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2((float)(120 + j * 11), 3f), new Vector2((float)(110 + j * 175), (float)(-94 - j % 3 * 22)));
			}
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("BottomVignette", _panel.transform, new Color(0f, 0f, 0f, 0.44f)), new Vector2(0f, 0f), new Vector2(1f, 0f), new Vector2(0f, 170f), new Vector2(0f, 74f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("TopVignette", _panel.transform, new Color(0f, 0f, 0f, 0.35f)), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 160f), new Vector2(0f, -80f));
		}

		private void CreateTopStatusBar(out Text protocolStatsText, out Text centerStatusText)
		{
			//IL_001a: 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_0038: 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_006c: 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_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_00c7: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: 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_0144: 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_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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: 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_01d7: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UiFactory.CreatePanel("TopStatusBar", _panel.transform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 100f), new Vector2(0f, -50f));
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.72f);
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("TopRedRule", val.transform, new Color(0.93f, 0.03f, 0.02f, 0.82f)), new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 2f), new Vector2(0f, -8f));
			protocolStatsText = UiFactory.CreateText("ProtocolStats", val.transform, "KAIN ROGUE PROTOCOL\nSEED 0\nVERSION 0\nCARDS 0", 13, (TextAnchor)0, Color.white);
			protocolStatsText.lineSpacing = 0.9f;
			UiFactory.SetRect((Component)(object)protocolStatsText, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(330f, 72f), new Vector2(198f, -8f));
			centerStatusText = UiFactory.CreateText("CenterStatusText", val.transform, "KRP / NO ACTIVE CARDS", 18, (TextAnchor)4, UiFactory.MutedTextColor);
			UiFactory.SetRect((Component)(object)centerStatusText, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(640f, 38f), new Vector2(0f, -4f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("ExitTerminal", val.transform, "退出", 23, (TextAnchor)4, Color.white), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(170f, 42f), new Vector2(-118f, -2f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("ExitFrame", val.transform, new Color(1f, 1f, 1f, 0.12f)), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(180f, 2f), new Vector2(-118f, -29f));
		}

		private void CreateHeader(out Text mainTitle, out Text glitchTitle)
		{
			//IL_0019: 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_0047: 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_0065: 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_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_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_010a: 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_013c: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			mainTitle = UiFactory.CreateText("MainTitle", _panel.transform, "<color=#8FDCFF>Kain</color> ROGUE PROTOCOL", 34, (TextAnchor)4, UiFactory.AccentColor);
			mainTitle.fontStyle = (FontStyle)1;
			UiFactory.SetRect((Component)(object)mainTitle, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(740f, 48f), new Vector2(0f, -175f));
			glitchTitle = UiFactory.CreateText("MainTitleGlitchRed", _panel.transform, "<color=#8FDCFF>Kain</color> ROGUE PROTOCOL", 34, (TextAnchor)4, new Color(0.9f, 0.04f, 0.02f, 0f));
			glitchTitle.fontStyle = (FontStyle)1;
			UiFactory.SetRect((Component)(object)glitchTitle, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(740f, 48f), new Vector2(0f, -175f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("SubtitleCN", _panel.transform, "多线程入侵协议 · 卡牌奖励选择", 16, (TextAnchor)4, UiFactory.TextColor), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(680f, 24f), new Vector2(0f, -214f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateText("SubtitleEN", _panel.transform, "SELECT ONE REWARD TO ADD TO YOUR PROTOCOL", 13, (TextAnchor)4, UiFactory.MutedTextColor), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(680f, 22f), new Vector2(0f, -238f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("HeaderRuleLeft", _panel.transform, UiFactory.LineColor), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(380f, 1f), new Vector2(-530f, -220f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("HeaderRuleRight", _panel.transform, UiFactory.LineColor), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(380f, 1f), new Vector2(530f, -220f));
		}

		private void CreateSideDecor()
		{
			//IL_001a: 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_0038: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00e5: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UiFactory.CreatePanel("SideMenuLeft", _panel.transform, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(210f, 420f), new Vector2(124f, -78f));
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.34f);
			Text obj = UiFactory.CreateText("SideMenuText", val.transform, "REWARD\nSELECTION\n\n01  CARD POOL\n02  ACTIVE BUFFS\n03  CORRUPTION\n04  EXIT LOCKED", 12, (TextAnchor)0, UiFactory.MutedTextColor);
			obj.lineSpacing = 1.15f;
			UiFactory.Stretch((Component)(object)obj, 22f, 20f, 18f, 20f);
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("SideMenuAccent", val.transform, UiFactory.AccentColor), new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(3f, 82f), new Vector2(14f, -58f));
		}

		private void CreateBottomPrompt(out Text prompt)
		{
			//IL_001a: 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_0038: 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_006c: 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)
			GameObject val = UiFactory.CreatePanel("BottomPromptBar", _panel.transform, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(980f, 54f), new Vector2(0f, 58f));
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.58f);
			prompt = UiFactory.CreateText("BottomPromptText", val.transform, "数字键 1-3 或鼠标点击选择奖励", 15, (TextAnchor)4, UiFactory.TextColor);
			UiFactory.Stretch((Component)(object)prompt, 24f, 6f, 24f, 6f);
		}

		private void CreateCard(Transform parent, int index)
		{
			//IL_0054: 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_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)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_060d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_075b: 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)
			_cards[index] = UiFactory.CreateCard($"RewardCard_{index + 1}", parent);
			_cardRects[index] = _cards[index].GetComponent<RectTransform>();
			UiFactory.SetRect((Component)(object)_cardRects[index], new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(384f, 512f), Vector2.zero);
			Outline component = _cards[index].GetComponent<Outline>();
			if ((Object)(object)component != (Object)null)
			{
				((Shadow)component).effectColor = new Color(0f, 0f, 0f, 0f);
			}
			_cardBodies[index] = _cards[index].GetComponent<Image>();
			((Graphic)_cardBodies[index]).color = new Color(0f, 0f, 0f, 0f);
			_buttons[index] = _cards[index].AddComponent<Button>();
			int capturedIndex = index;
			((UnityEvent)_buttons[index].onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				Select(capturedIndex);
			}));
			AddPointerCallbacks(_cards[index], capturedIndex);
			_backgroundArts[index] = UiFactory.CreateImage("CardBackgroundArt", _cards[index].transform, Color.white);
			UiFactory.Stretch((Component)(object)_backgroundArts[index], 0f, 0f, 0f, 0f);
			((Graphic)_backgroundArts[index]).raycastTarget = false;
			GameObject val = UiFactory.CreateRect("CardContentRoot", _cards[index].transform, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			_contentRoots[index] = val.GetComponent<RectTransform>();
			_glows[index] = UiFactory.CreateImage("RarityGlow", _cards[index].transform, new Color(1f, 1f, 1f, 0.08f));
			UiFactory.Stretch((Component)(object)_glows[index], -8f, -8f, -8f, -8f);
			_outerBorders[index] = UiFactory.CreateImage("CardBorderOuter", _cards[index].transform, new Color(0f, 0f, 0f, 0f));
			UiFactory.SetRect((Component)(object)_outerBorders[index], new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 4f), new Vector2(0f, -2f));
			_innerBorders[index] = UiFactory.CreateImage("CardBorderInner", _cards[index].transform, new Color(0f, 0f, 0f, 0f));
			UiFactory.Stretch((Component)(object)_innerBorders[index], 12f, 12f, 12f, 12f);
			_accentBars[index] = UiFactory.CreateImage("RarityAccentBar", _cards[index].transform, new Color(0f, 0f, 0f, 0f));
			UiFactory.SetRect((Component)(object)_accentBars[index], new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0f, 5f), new Vector2(0f, -2f));
			GameObject obj = UiFactory.CreateRect("CardRarityModuleSlot", val.transform, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			ApplyTopLeftNormalizedRect(obj.GetComponent<RectTransform>(), new Rect(0.088f, 0.06f, 0.15f, 0.125f));
			RogueUiAssetLibrary.BindRarityModule(obj.transform, "common", out _rarityBaseImages[index], out _rarityGlowImages[index], out _rarityAccentImages[index]);
			UiFactory.Stretch((Component)(object)_rarityBaseImages[index], 0f, 0f, 0f, 0f);
			UiFactory.Stretch((Component)(object)_rarityGlowImages[index], -8f, -8f, -8f, -8f);
			UiFactory.Stretch((Component)(object)_rarityAccentImages[index], 0f, 0f, 0f, 0f);
			_keyTexts[index] = UiFactory.CreateTmpText("KeyText", val.transform, $"[{index + 1}]", 24f, (TextAlignmentOptions)514, UiFactory.AccentColor);
			((TMP_Text)_keyTexts[index]).fontStyle = (FontStyles)1;
			ConfigureTmp(_keyTexts[index], wrap: false, 18f, 28f);
			ApplyTopLeftNormalizedRect(((TMP_Text)_keyTexts[index]).rectTransform, new Rect(0.07f, 0.855f, 0.09f, 0.045f));
			_titleTexts[index] = UiFactory.CreateTmpText("CardName", val.transform, string.Empty, 34f, (TextAlignmentOptions)514, UiFactory.TextColor);
			((TMP_Text)_titleTexts[index]).fontStyle = (FontStyles)1;
			ConfigureTmp(_titleTexts[index], wrap: false, 24f, 36f);
			ApplyTopLeftNormalizedRect(((TMP_Text)_titleTexts[index]).rectTransform, new Rect(0.225f, 0.078f, 0.68f, 0.105f));
			_descriptionTexts[index] = UiFactory.CreateTmpText("DescriptionText", val.transform, string.Empty, 20f, (TextAlignmentOptions)514, UiFactory.TextColor);
			ConfigureTmp(_descriptionTexts[index], wrap: true, 14f, 22f);
			((TMP_Text)_descriptionTexts[index]).lineSpacing = -8f;
			ApplyTopLeftNormalizedRect(((TMP_Text)_descriptionTexts[index]).rectTransform, new Rect(0.13f, 0.68f, 0.74f, 0.13f));
			_tagTexts[index] = UiFactory.CreateTmpText("TagRow", val.transform, string.Empty, 16f, (TextAlignmentOptions)514, UiFactory.MutedTextColor);
			ConfigureTmp(_tagTexts[index], wrap: false, 11f, 18f);
			ApplyTopLeftNormalizedRect(((TMP_Text)_tagTexts[index]).rectTransform, new Rect(0.17f, 0.832f, 0.66f, 0.055f));
			_footerTexts[index] = UiFactory.CreateTmpText("FooterPrompt", val.transform, $"PRESS [{index + 1}] TO SELECT", 16f, (TextAlignmentOptions)514, UiFactory.MutedTextColor);
			ConfigureTmp(_footerTexts[index], wrap: false, 11f, 18f);
			ApplyTopLeftNormalizedRect(((TMP_Text)_footerTexts[index]).rectTransform, new Rect(0.245f, 0.923f, 0.51f, 0.045f));
			CreateLayoutDebugRects(index, val.transform);
			_scanLines[index] = UiFactory.CreateImage("HoverScanline", _cards[index].transform, new Color(1f, 1f, 1f, 0f));
			UiFactory.SetRect((Component)(object)_scanLines[index], new Vector2(0f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-36f, 34f), new Vector2(18f, 0f));
			_scanRects[index] = ((Component)_scanLines[index]).GetComponent<RectTransform>();
		}

		private void AddPointerCallbacks(GameObject target, int index)
		{
			EventTrigger trigger = target.AddComponent<EventTrigger>();
			AddTrigger(trigger, (EventTriggerType)0, delegate
			{
				_hoverIndex = index;
			});
			AddTrigger(trigger, (EventTriggerType)1, delegate
			{
				if (_hoverIndex == index)
				{
					_hoverIndex = -1;
				}
			});
		}

		private static void AddTrigger(EventTrigger trigger, EventTriggerType type, Action<BaseEventData> callback)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Entry val = new Entry
			{
				eventID = type
			};
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener(UnityAction<BaseEventData>.op_Implicit(callback));
			trigger.triggers.Add(val);
		}

		private void TickCards()
		{
			//IL_0052: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _activeCards.Length && i < _cards.Length; i++)
			{
				bool flag = i == _hoverIndex || _selectedIndex == i;
				SetCardVisual(i, flag, _selectedIndex == i);
				UpdateCardTypography(i);
				float num = (flag ? 145f : 58f);
				Rect rect = _cardRects[i].rect;
				float num2 = Mathf.Max(1f, ((Rect)(ref rect)).height);
				float num3 = Mathf.Repeat(Time.time * num + (float)i * 80f, num2) - num2 * 0.5f;
				_scanRects[i].anchoredPosition = new Vector2(18f, num3);
			}
		}

		private void TickGlitchTitle()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			if (time >= _nextGlitchAt)
			{
				_glitchUntil = time + 0.12f;
				_nextGlitchAt = time + Random.Range(3.5f, 6.5f);
			}
			if (time < _glitchUntil)
			{
				((Graphic)_glitchTitle).color = new Color(0.95f, 0.03f, 0.02f, 0.45f);
				((Graphic)_glitchTitle).rectTransform.anchoredPosition = new Vector2(Random.Range(-4f, 4f), -175f);
			}
			else
			{
				((Graphic)_glitchTitle).color = new Color(0.95f, 0.03f, 0.02f, 0f);
				((Graphic)_glitchTitle).rectTransform.anchoredPosition = new Vector2(0f, -175f);
			}
		}

		private void SetCardVisual(int index, bool highlighted, bool selected)
		{
			//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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00ba: 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_00d4: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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)
			if (index >= 0 && index < _activeCards.Length)
			{
				Color color = RogueUiAssetLibrary.RarityPrimaryColor(_activeCards[index].Rarity);
				Mathf.Sin(Time.time * 3.2f + (float)index);
				float num = 0f;
				float alpha = 0f;
				if (selected)
				{
					num = 0f;
					alpha = 0f;
				}
				((Graphic)_cardBodies[index]).color = new Color(0f, 0f, 0f, 0f);
				((Graphic)_accentBars[index]).color = new Color(0f, 0f, 0f, 0f);
				((Graphic)_outerBorders[index]).color = WithAlpha(color, num);
				((Graphic)_innerBorders[index]).color = WithAlpha(color, num * 0.32f);
				((Graphic)_glows[index]).color = WithAlpha(color, alpha);
				RogueUiAssetLibrary.SetRarityModuleState(_rarityGlowImages[index], _rarityAccentImages[index], highlighted, selected);
				((Graphic)_scanLines[index]).color = new Color(1f, 1f, 1f, 0f);
				_cards[index].transform.localScale = Vector3.one * (highlighted ? 1.025f : 1f);
			}
		}

		private void LayoutRewardCards()
		{
			//IL_0012: 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_0031: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = _panel.GetComponent<RectTransform>();
			Rect rect = component.rect;
			float num = Mathf.Max(1280f, ((Rect)(ref rect)).width);
			rect = component.rect;
			float num2 = Mathf.Max(720f, ((Rect)(ref rect)).height);
			float num3 = num * 0.86f;
			float num4 = num2 * 0.78f;
			float num5 = Mathf.Min(num3 / 3.6399999f / 0.75f, num4);
			float num6 = num5 * 0.75f;
			float num7 = num6 * 0.32f;
			float num8 = (0f - (3f * num6 + 2f * num7)) * 0.5f + num6 * 0.5f;
			float num9 = (0f - num2) * 0.075f;
			for (int i = 0; i < _cardRects.Length; i++)
			{
				RectTransform obj = _cardRects[i];
				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.SetSizeWithCurrentAnchors((Axis)0, num6);
				obj.SetSizeWithCurrentAnchors((Axis)1, num5);
				obj.anchoredPosition = new Vector2(num8 + (float)i * (num6 + num7), num9);
				UpdateCardTypography(i);
			}
		}

		private void UpdateCardTypography(int index)
		{
			//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)
			Rect rect = _cardRects[index].rect;
			float scale = Mathf.Max(0.25f, ((Rect)(ref rect)).height / 1024f);
			ApplyFontScale(_titleTexts[index], 34f, 24f, 36f, scale);
			ApplyFontScale(_tagTexts[index], 16f, 11f, 18f, scale);
			ApplyFontScale(_descriptionTexts[index], 20f, 14f, 22f, scale);
			ApplyFontScale(_footerTexts[index], 16f, 11f, 18f, scale);
			ApplyFontScale(_keyTexts[index], 24f, 18f, 28f, scale);
		}

		private static void ApplyFontScale(TextMeshProUGUI text, float size, float min, float max, float scale)
		{
			((TMP_Text)text).fontSize = size * scale;
			((TMP_Text)text).fontSizeMin = min * scale;
			((TMP_Text)text).fontSizeMax = max * scale;
		}

		private static void ConfigureTmp(TextMeshProUGUI text, bool wrap, float minSize, float maxSize)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)text).enableAutoSizing = true;
			((TMP_Text)text).fontSizeMin = minSize;
			((TMP_Text)text).fontSizeMax = maxSize;
			((TMP_Text)text).enableWordWrapping = wrap;
			((TMP_Text)text).overflowMode = (TextOverflowModes)1;
			((TMP_Text)text).alignment = (TextAlignmentOptions)514;
			((TMP_Text)text).margin = Vector4.zero;
		}

		private static void ApplyTopLeftNormalizedRect(RectTransform target, Rect normalized)
		{
			//IL_001d: 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_004f: 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_006f: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			target.anchorMin = new Vector2(((Rect)(ref normalized)).x, 1f - ((Rect)(ref normalized)).y - ((Rect)(ref normalized)).height);
			target.anchorMax = new Vector2(((Rect)(ref normalized)).x + ((Rect)(ref normalized)).width, 1f - ((Rect)(ref normalized)).y);
			target.offsetMin = Vector2.zero;
			target.offsetMax = Vector2.zero;
			target.pivot = new Vector2(0.5f, 0.5f);
			target.anchoredPosition = Vector2.zero;
			target.sizeDelta = Vector2.zero;
		}

		private void CreateLayoutDebugRects(int index, Transform contentRoot)
		{
			//IL_0022: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] array = (GameObject[])(object)new GameObject[6]
			{
				CreateDebugRect("DebugRarity", contentRoot, new Rect(0.088f, 0.06f, 0.15f, 0.125f), new Color(1f, 0.62f, 0f, 0.22f)),
				CreateDebugRect("DebugTitle", contentRoot, new Rect(0.225f, 0.078f, 0.68f, 0.105f), new Color(1f, 0.05f, 0.05f, 0.2f)),
				CreateDebugRect("DebugTags", contentRoot, new Rect(0.17f, 0.832f, 0.66f, 0.055f), new Color(0.25f, 1f, 0.05f, 0.2f)),
				CreateDebugRect("DebugDescription", contentRoot, new Rect(0.13f, 0.68f, 0.74f, 0.13f), new Color(1f, 0.25f, 0.25f, 0.18f)),
				CreateDebugRect("DebugSelect", contentRoot, new Rect(0.245f, 0.923f, 0.51f, 0.045f), new Color(1f, 1f, 1f, 0.2f)),
				CreateDebugRect("DebugKey", contentRoot, new Rect(0.07f, 0.855f, 0.09f, 0.045f), new Color(1f, 1f, 1f, 0.2f))
			};
			_debugRects[index] = array;
			GameObject[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i].SetActive(_layoutDebugVisible);
			}
		}

		private static GameObject CreateDebugRect(string name, Transform parent, Rect normalized, Color color)
		{
			//IL_0002: 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)
			Image obj = UiFactory.CreateImage(name, parent, color);
			((Graphic)obj).raycastTarget = false;
			ApplyTopLeftNormalizedRect(((Graphic)obj).rectTransform, normalized);
			return ((Component)obj).gameObject;
		}

		private void SetLayoutDebugVisible(bool visible)
		{
			_layoutDebugVisible = visible;
			GameObject[][] debugRects = _debugRects;
			foreach (GameObject[] array in debugRects)
			{
				if (array != null)
				{
					GameObject[] array2 = array;
					for (int j = 0; j < array2.Length; j++)
					{
						array2[j].SetActive(visible);
					}
				}
			}
		}

		private void Select(int index)
		{
			if (index >= 0 && index < _activeCards.Length && _onSelected != null && _selectedIndex < 0)
			{
				_selectedIndex = index;
				RogueCard obj = _activeCards[index];
				_panel.SetActive(false);
				_isVisible = false;
				_onSelected(obj);
			}
		}

		private static Color WithAlpha(Color color, float alpha)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			color.a = alpha;
			return color;
		}

		private static string DisplayRarity(string rarity)
		{
			return rarity.ToLowerInvariant() switch
			{
				"common" => "普通", 
				"uncommon" => "优秀", 
				"rare" => "稀有", 
				"epic" => "史诗", 
				"legendary" => "传说", 
				"curse" => "腐化", 
				"corrupted" => "腐化", 
				_ => rarity, 
			};
		}
	}
	public sealed class RogueHudRoot
	{
		private readonly bool _debugEnabled;

		private readonly bool _persistentUiDefault;

		private RewardChoicePanel? _rewardPanel;

		private CardPoolPanel? _cardPoolPanel;

		private CorruptionIntroPanel? _corruptionPanel;

		private BuffBar? _buffBar;

		private RuntimeStatusPanel? _runtimeStatusPanel;

		private DebugOverlay? _debugOverlay;

		private GameObject? _root;

		private bool _persistentUiVisible;

		private bool _hasCursorCapture;

		private bool _previousCursorVisible;

		private CursorLockMode _previousCursorLockState;

		public RogueHudRoot(bool debugEnabled, bool persistentUiDefault)
		{
			_debugEnabled = debugEnabled;
			_persistentUiDefault = persistentUiDefault;
			_persistentUiVisible = persistentUiDefault;
		}

		public void Create()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			_root = new GameObject("KainRogueProtocol.HudRoot");
			Object.DontDestroyOnLoad((Object)(object)_root);
			Canvas obj = _root.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 30000;
			CanvasScaler obj2 = _root.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			_root.AddComponent<GraphicRaycaster>();
			EnsureEventSystem();
			_rewardPanel = new RewardChoicePanel(_root.transform);
			_cardPoolPanel = new CardPoolPanel(_root.transform);
			_corruptionPanel = new CorruptionIntroPanel(_root.transform);
			_buffBar = new BuffBar(_root.transform);
			_runtimeStatusPanel = new RuntimeStatusPanel(_root.transform);
			_debugOverlay = new DebugOverlay(_root.transform, _debugEnabled);
			SetPersistentUiVisible(_persistentUiDefault);
			RogueLogger.Info("Created Phase 0 UI root.");
		}

		public void ShowRewards(RogueCard[] cards, Action<RogueCard> onSelected)
		{
			_rewardPanel?.Show(cards, onSelected);
		}

		public void ShowCardPool(RogueCard[] cards, Action<RogueCard> onSelected)
		{
			_cardPoolPanel?.Show(cards, onSelected);
		}

		public void ShowCorruptions(CorruptionCard[] cards, float durationSeconds)
		{
			_corruptionPanel?.Show(cards, durationSeconds);
		}

		public void ToggleCorruptions(CorruptionCard[] cards)
		{
			_corruptionPanel?.Toggle(cards);
		}

		public void RefreshState(RogueState state)
		{
			_rewardPanel?.RefreshState(state);
			_buffBar?.Refresh(state);
			_debugOverlay?.Refresh(state);
		}

		public void Tick()
		{
			_rewardPanel?.Tick();
			_cardPoolPanel?.Tick();
			_corruptionPanel?.Tick();
			_runtimeStatusPanel?.Tick();
			_debugOverlay?.Tick();
			UpdateCursorCapture();
		}

		public void LateTick()
		{
			UpdateCursorCapture();
		}

		public void ReleaseCursorCapture()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (_hasCursorCapture)
			{
				Cursor.visible = _previousCursorVisible;
				Cursor.lockState = _previousCursorLockState;
				_hasCursorCapture = false;
			}
		}

		public void TogglePersistentUi()
		{
			SetPersistentUiVisible(!_persistentUiVisible);
		}

		private void SetPersistentUiVisible(bool visible)
		{
			_persistentUiVisible = visible;
			_buffBar?.SetVisible(visible);
			_runtimeStatusPanel?.SetVisible(visible);
			_debugOverlay?.SetVisible(visible && _debugEnabled);
		}

		private void UpdateCursorCapture()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			RewardChoicePanel? rewardPanel = _rewardPanel;
			bool num = (rewardPanel != null && rewardPanel.IsVisible) || (_cardPoolPanel?.IsVisible ?? false);
			RogueInputBlocker.BlockGameplayInput = num;
			RogueModalCursorGuard.SetModalActive(num);
			if (num)
			{
				if (!_hasCursorCapture)
				{
					_previousCursorVisible = Cursor.visible;
					_previousCursorLockState = Cursor.lockState;
					_hasCursorCapture = true;
					RogueLogger.Info($"KRP modal UI captured cursor. PreviousVisible={_previousCursorVisible}, PreviousLock={_previousCursorLockState}.");
				}
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			else
			{
				ReleaseCursorCapture();
			}
		}

		private static void EnsureEventSystem()
		{
			//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)
			//IL_004b: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			EventSystem val = Object.FindObjectOfType<EventSystem>();
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)((Component)val).GetComponent<StandaloneInputModule>() == (Object)null)
				{
					((Component)val).gameObject.AddComponent<StandaloneInputModule>();
					RogueLogger.Info("Attached StandaloneInputModule to existing EventSystem.");
				}
				((Behaviour)val).enabled = true;
			}
			else
			{
				GameObject val2 = new GameObject("KainRogueProtocol.EventSystem");
				Object.DontDestroyOnLoad((Object)val2);
				val2.AddComponent<EventSystem>();
				val2.AddComponent<StandaloneInputModule>();
			}
		}
	}
	internal static class RogueUiAssetLibrary
	{
		private static readonly Dictionary<string, Sprite?> SpriteCache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		public static Sprite? GetCardBackground(RogueCard card)
		{
			string cardBackgroundPath = GetCardBackgroundPath(card);
			if (!string.IsNullOrWhiteSpace(cardBackgroundPath))
			{
				return LoadSprite(cardBackgroundPath);
			}
			return null;
		}

		public static void BindRarityModule(Transform parent, string rarity, out Image baseImage, out Image glowImage, out Image accentImage)
		{
			//IL_0007: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			baseImage = UiFactory.CreateImage("RarityBaseImage", parent, Color.white);
			glowImage = UiFactory.CreateImage("RarityGlowImage", parent, Color.white);
			accentImage = UiFactory.CreateImage("RarityAccentImage", parent, Color.white);
			SetRarityModuleSprites(baseImage, glowImage, accentImage, rarity);
			baseImage.preserveAspect = true;
			glowImage.preserveAspect = true;
			accentImage.preserveAspect = true;
			((Graphic)baseImage).raycastTarget = false;
			((Graphic)glowImage).raycastTarget = false;
			((Graphic)accentImage).raycastTarget = false;
			SetRarityModuleState(glowImage, accentImage, highlighted: false, selected: false);
		}

		public static void SetRarityModuleSprites(Image? baseImage, Image? glowImage, Image? accentImage, string rarity)
		{
			string text = NormalizeRarity(rarity);
			if ((Object)(object)baseImage != (Object)null)
			{
				baseImage.sprite = LoadSprite("Custom/KainRogueProtocol/UI/rarity_modules/" + text + "/png256/rarity_module_" + text + "_base_256.png");
				SetImageAlpha(baseImage, 1f);
			}
			if ((Object)(object)glowImage != (Object)null)
			{
				glowImage.sprite = LoadSprite("Custom/KainRogueProtocol/UI/rarity_modules/" + text + "/png256/rarity_module_" + text + "_glow_256.png");
			}
			if ((Object)(object)accentImage != (Object)null)
			{
				accentImage.sprite = LoadSprite("Custom/KainRogueProtocol/UI/rarity_modules/" + text + "/png256/rarity_module_" + text + "_accent_256.png");
			}
		}

		public static void SetRarityModuleState(Image? glowImage, Image? accentImage, bool highlighted, bool selected)
		{
			float num = 0.5f + Mathf.Sin(Time.time * 2.25f) * 0.5f;
			float alpha = (selected ? 1f : (highlighted ? (0.64f + num * 0.12f) : 0.35f));
			float alpha2 = (selected ? 0.85f : (highlighted ? (0.4f + num * 0.1f) : 0.18f));
			SetImageAlpha(glowImage, alpha);
			SetImageAlpha(accentImage, alpha2);
		}

		public static Color RarityPrimaryColor(string rarity)
		{
			//IL_0044: 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_009e: 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_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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(NormalizeRarity(rarity) switch
			{
				"rare" => new Color(0f, 0.83f, 1f, 1f), 
				"epic" => new Color(1f, 0.71f, 0.18f, 1f), 
				"legendary" => new Color(1f, 0.2f, 0.2f, 1f), 
				_ => new Color(0.9f, 0.9f, 0.9f, 1f), 
			});
		}

		private static string NormalizeRarity(string rarity)
		{
			return rarity.ToLowerInvariant() switch
			{
				"rare" => "rare", 
				"epic" => "epic", 
				"legendary" => "legendary", 
				_ => "common", 
			};
		}

		private static string? GetCardBackgroundPath(RogueCard card)
		{
			string text = card.PersistentID switch
			{
				100301 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch02_1086x1448/cold_blade_rhythm_background.png", 
				100302 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch02_1086x1448/stable_formation_background.png", 
				100303 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch02_1086x1448/defense_calibration_background.png", 
				100304 => "Custom/KainRogueProtocol/UI/card_backgrounds/runtime_768x1024/chamber_prime_background.png", 
				100305 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch02_1086x1448/bullet_tax_background.png", 
				100312 => "Custom/KainRogueProtocol/UI/card_backgrounds/runtime_768x1024/backstab_protocol_background.png", 
				100313 => "Custom/KainRogueProtocol/UI/card_backgrounds/runtime_768x1024/precision_recycle_background.png", 
				100316 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch01_1086x1448/StressResponse.png", 
				100317 => "Custom/KainRogueProtocol/UI/card_backgrounds/batch01_1086x1448/MutualSupply.png", 
				_ => null, 
			};
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			if (card.Effects.Any((RogueCardEffect effect) => string.Equals(effect.Type, "CoordinatedHeavyStrike", StringComparison.OrdinalIgnoreCase)))
			{
				return "Custom/KainRogueProtocol/UI/card_backgrounds/batch01_1086x1448/CoordinatedHeavyStrike.png";
			}
			return null;
		}

		private static Sprite? LoadSprite(string relativePath)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_008a: 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)
			if (SpriteCache.TryGetValue(relativePath, out Sprite value))
			{
				return value;
			}
			try
			{
				string path = ResolvePluginPath(relativePath);
				if (!File.Exists(path))
				{
					SpriteCache[relativePath] = null;
					return null;
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(File.ReadAllBytes(path)), false))
				{
					Object.Destroy((Object)(object)val);
					SpriteCache[relativePath] = null;
					return null;
				}
				((Texture)val).wrapMode = (TextureWrapMode)1;
				Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				SpriteCache[relativePath] = val2;
				return val2;
			}
			catch
			{
				SpriteCache[relativePath] = null;
				return null;
			}
		}

		private static string ResolvePluginPath(string relativePath)
		{
			string location = typeof(RogueUiAssetLibrary).Assembly.Location;
			return Path.GetFullPath(Path.Combine(string.IsNullOrWhiteSpace(location) ? Paths.PluginPath : (Path.GetDirectoryName(location) ?? Paths.PluginPath), relativePath.Replace('/', Path.DirectorySeparatorChar)));
		}

		private static void SetImageAlpha(Image? image, float alpha)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				Color color = ((Graphic)image).color;
				color.a = alpha;
				((Graphic)image).color = color;
			}
		}
	}
	public sealed class RuntimeStatusPanel
	{
		private readonly GameObject _panel;

		private readonly Text _text;

		public RuntimeStatusPanel(Transform parent)
		{
			//IL_0017: 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_0035: 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_0063: 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_0086: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			_panel = UiFactory.CreatePanel("RuntimeStatusPanel", parent, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(680f, 30f), new Vector2(0f, -83f));
			UiFactory.SetRect((Component)(object)UiFactory.CreateImage("RuntimeStatusAccent", _panel.transform, UiFactory.AccentColor), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(4f, 18f), new Vector2(18f, 0f));
			_text = UiFactory.CreateText("RuntimeStatusText", _panel.transform, string.Empty, 13, (TextAnchor)4, UiFactory.TextColor);
			_text.resizeTextForBestFit = true;
			_text.resizeTextMinSize = 10;
			_text.resizeTextMaxSize = 13;
			UiFactory.Stretch((Component)(object)_text, 30f, 3f, 12f, 3f);
		}

		public void Tick()
		{
			_text.text = RogueGameplayRuntime.GetRuntimeStatusText(Time.time);
		}

		public void SetVisible(bool visible)
		{
			_panel.SetActive(visible);
		}
	}
	public static class UiFactory
	{
		public static readonly Color PanelColor = new Color(0.015f, 0.018f, 0.016f, 0.88f);

		public static readonly Color CardColor = new Color(0.035f, 0.052f, 0.048f, 0.94f);

		public static readonly Color CardInnerColor = new Color(0.055f, 0.075f, 0.068f, 0.62f);

		public static readonly Color AccentColor = new Color(0.95f, 0.62f, 0.12f, 1f);

		public static readonly Color DangerColor = new Color(0.82f, 0.08f, 0.05f, 1f);

		public static readonly Color TextColor = new Color(0.86f, 0.94f, 0.88f, 1f);

		public static readonly Color MutedTextColor = new Color(0.46f, 0.62f, 0.57f, 1f);

		public static readonly Color LineColor = new Color(0.75f, 0.92f, 0.82f, 0.22f);

		public static GameObject CreatePanel(string name, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta, Vector2 anchoredPosition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateRect(name, parent, anchorMin, anchorMax, sizeDelta, anchoredPosition);
			((Graphic)obj.AddComponent<Image>()).color = PanelColor;
			return obj;
		}

		public static GameObject CreateRect(string name, Transform parent, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta, Vector2 anchoredPosition)
		{
			//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_0021: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = anchorMin;
			obj.anchorMax = anchorMax;
			obj.sizeDelta = sizeDelta;
			obj.anchoredPosition = anchoredPosition;
			return val;
		}

		public static Image CreateImage(string name, Transform parent, 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_0019: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			return obj;
		}

		public static Text CreateText(string name, Transform parent, string value, int fontSize, TextAnchor alignment)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return CreateText(name, parent, value, fontSize, alignment, TextColor);
		}

		public static Text CreateText(string name, Transform parent, string value, int fontSize, TextAnchor alignment, 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_0037: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Text obj = val.AddComponent<Text>();
			obj.text = value;
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = fontSize;
			obj.alignment = alignment;
			((Graphic)obj).color = color;
			obj.horizontalOverflow = (HorizontalWrapMode)0;
			obj.verticalOverflow = (VerticalWrapMode)0;
			obj.supportRichText = true;
			return obj;
		}

		public static TextMeshProUGUI CreateTmpText(string name, Transform parent, string value, float fontSize, TextAlignmentOptions alignment, 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_0027: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).text = value;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).alignment = alignment;
			((Graphic)obj).color = color;
			((TMP_Text)obj).richText = true;
			((TMP_Text)obj).enableWordWrapping = true;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static GameObject CreateCard(string name, Transform parent)
		{
			//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_0019: 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_002a: 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_0049: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = CardColor;
			Outline obj = val.AddComponent<Outline>();
			((Shadow)obj).effectColor = LineColor;
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
			return val;
		}

		public static void SetRect(Component component, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta, Vector2 anchoredPosition)
		{
			//IL_0007: 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)
			//IL_0015: 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)
			RectTransform component2 = component.GetComponent<RectTransform>();
			component2.anchorMin = anchorMin;
			component2.anchorMax = anchorMax;
			component2.sizeDelta = sizeDelta;
			component2.anchoredPosition = anchoredPosition;
		}

		public static void Stretch(Component component, float left, float bottom, float right, float top)
		{
			//IL_0007: 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_001f: 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)
			RectTransform component2 = component.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(left, bottom);
			component2.offsetMax = new Vector2(0f - right, 0f - top);
		}

		public static Color RarityColor(string rarity)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d9: 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)
			return (Color)(rarity.ToLowerInvariant() switch
			{
				"common" => new Color(0.72f, 0.78f, 0.72f, 1f), 
				"rare" => new Color(0.36f, 0.84f, 0.78f, 1f), 
				"epic" => new Color(0.72f, 0.46f, 0.96f, 1f), 
				"legendary" => new Color(1f, 0.66f, 0.16f, 1f), 
				"curse" => new Color(0.92f, 0.12f, 0.08f, 1f), 
				_ => MutedTextColor, 
			});
		}
	}
}
namespace KainRogueProtocol.Triggers
{
	public sealed class TriggerRegistry
	{
		private readonly RogueEventDispatcher _events;

		public TriggerRegistry(RogueEventDispatcher events)
		{
			_events = events;
		}

		public void OnEnemyDamaged(EnemyDamagedContext context)
		{
			_events.OnEnemyDamaged(context);
		}

		public void OnEnemyKilled(EnemyKilledContext context)
		{
			_events.OnEnemyKilled(context);
		}

		public void OnMeleeHit(MeleeHitContext context)
		{
			_events.OnMeleeHit(context);
		}

		public void OnResourcePackUsed(ResourcePackUsedContext context)
		{
			_events.OnResourcePackUsed(context);
		}

		public void OnHealthChanged(HealthChangedContext context)
		{
			_events.OnHealthChanged(context);
		}
	}
}
namespace KainRogueProtocol.Runtime
{
	public static class RogueGameplayRuntime
	{
		private readonly struct PlayerDamageStamp
		{
			public ulong PlayerId { get; }

			public PlayerAgent Player { get; }

			public float Timestamp { get; }

			public bool IsMelee { get; }

			public bool IsWeakspot { get; }

			public bool WasSleepingTarget { get; }

			public PlayerDamageStamp(ulong playerId, PlayerAgent player, float timestamp, bool isMelee, bool isWeakspot, bool wasSleepingTarget = false)
			{
				PlayerId = playerId;
				Player = player;
				Timestamp = timestamp;
				IsMelee = isMelee;
				IsWeakspot = isWeakspot;
				WasSleepingTarget = wasSleepingTarget;
			}
		}

		private readonly struct LastFullChargeHit
		{
			public ulong PlayerId { get; }

			public float Timestamp { get; }

			public LastFullChargeHit(ulong playerId, float timestamp)
			{
				PlayerId = playerId;
				Timestamp = timestamp;
			}
		}

		private readonly struct RecentMeleeHit
		{
			public ulong EnemyInstanceId { get; }

			public float Timestamp { get; }

			public bool IsWeakspot { get; }

			public bool WasSleepingTarget { get; }

			public RecentMeleeHit(ulong enemyInstanceId, float timestamp, bool isWeakspot, bool wasSleepingTarget)
			{
				EnemyInstanceId = enemyInstanceId;
				Timestamp = timestamp;
				IsWeakspot = isWeakspot;
				WasSleepingTarget = wasSleepingTarget;
			}
		}

		private readonly struct ScanPresence
		{
			public int PlayerCount { get; }

			public Vector3 Position { get; }

			public float ExpiresAt { get; }

			public ScanPresence(int playerCount, Vector3 position, float expiresAt)
			{
				//IL_0008: 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)
				PlayerCount = playerCount;
				Position = position;
				ExpiresAt = expiresAt;
			}
		}

		private readonly struct StressResponseRuntimeStatus
		{
			public ulong PlayerId { get; }

			public int Stacks { get; }

			public float ExpiresAt { get; }

			public float DamagePercent { get; }

			public float MovePercent { get; }

			public StressResponseRuntimeStatus(ulong playerId, int stacks, float expiresAt, float damagePercent, float movePercent)
			{
				PlayerId = playerId;
				Stacks = stacks;
				ExpiresAt = expiresAt;
				DamagePercent = damagePercent;
				MovePercent = movePercent;
			}
		}

		private static readonly Dictionary<ulong, PlayerAgent> KnownPlayers = new Dictionary<ulong, PlayerAgent>();

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

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

		private static readonly HashSet<ulong> LoggedKnownPlayers = new HashSet<ulong>();

		private static readonly Dictionary<ulong, List<PlayerDamageStamp>> RecentEnemyDamage = new Dictionary<ulong, List<PlayerDamageStamp>>();

		private static readonly Dictionary<ulong, LastFullChargeHit> LastFullChargeHits = new Dictionary<ulong, LastFullChargeHit>();

		private static readonly Dictionary<ulong, float> CoordinatedStrikeCooldowns = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, float> ChamberNextReadyAt = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, float> ChamberShotExpiresAt = new Dictionary<ulong, float>();

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

		private static readonly Dictionary<ulong, RecentMeleeHit> LastMeleeHitsByPlayer = new Dictionary<ulong, RecentMeleeHit>();

		private static readonly Dictionary<ulong, float> AppliedMoveSpeedBonuses = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, StressResponseRuntimeStatus> StressResponseStatuses = new Dictionary<ulong, StressResponseRuntimeStatus>();

		private static readonly Dictionary<ulong, ScanPresence> ActiveScanPlayers = new Dictionary<ulong, ScanPresence>();

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

		private static readonly Dictionary<ulong, bool> SettlementReloadReady = new Dictionary<ulong, bool>();

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

		private static readonly Dictionary<ulong, BulletWeapon> LastBulletWeaponsByPlayer = new Dictionary<ulong, BulletWeapon>();

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

		private static readonly Dictionary<ulong, float> PrecisionRecycleReadyAt = new Dictionary<ulong, float>();

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

		private static readonly Dictionary<ulong, float> FieldMedicRescuerNormalizeUntil = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, float> FieldMedicForcedSlowUntil = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, Dictionary<ulong, float>> RecentAttackersByEnemy = new Dictionary<ulong, Dictionary<ulong, float>>();

		private static readonly Dictionary<ulong, float> CrossfireReadyAt = new Dictionary<ulong, float>();

		private static readonly RogueProcessedEventRegistry ProcessedEvents = new RogueProcessedEventRegistry();

		private static readonly RogueTriggerGuard TriggerGuard = new RogueTriggerGuard();

		private static bool _mirroringResource;

		private static float _nextBloodDebtBleedAt;

		private static PlayerDataBlock? _playerDataBlock;

		private static float _baseWalkMoveSpeed;

		private static float _baseRunMoveSpeed;

		private static float _baseCrouchMoveSpeed;

		private static float _baseAirMoveSpeed;

		private static float _appliedPlayerDataMoveMultiplier = 1f;

		private static int _unresolvedDamageSourceLogCount;

		private static int _singlePlayerFallbackLogCount;

		private static int _soulSiphonTraceLogCount;

		public static RogueEventDispatcher? Events { get; private set; }

		public static RogueModifierRegistry? Modifiers { get; private set; }

		public static bool MutualSupplyActive { get; set; }

		public static bool CoordinatedHeavyStrikeActive { get; set; }

		public static bool StressResponseActive { get; set; }

		public static bool BloodDebtActive { get; set; }

		public static bool ExplosiveHeadActive { get; set; }

		public static bool GiantRegenerationActive { get; set; }

		public static bool ChamberActive { get; set; }

		public static float ChamberDamageMultiplier { get; set; } = 3f;


		public static float ChamberReadySeconds { get; set; } = 3f;


		public static bool SoulSiphonStrikeActive { get; set; }

		public static float SoulSiphonMeleeDamagePercent { get; set; } = 0.02f;


		public static int SoulSiphonMaxStacks { get; set; } = 25;


		public static bool BulletTaxActive { get; set; }

		public static float BulletTaxAmmoStandardRel { get; set; } = 0.05f;


		public static float BulletTaxAmmoSpecialRel { get; set; } = 0.05f;


		public static HashSet<uint> BulletTaxLargeEnemyIds { get; set; } = new HashSet<uint>();


		public static float BulletTaxLargeEnemyHealthThreshold { get; set; } = 40f;


		public static bool ColdBladeRhythmActive { get; set; }

		public static float ColdBladeChargeSpeedPercent { get; set; } = 0.25f;


		public static float ColdBladeNextChargeSpeedPercent { get; set; } = 0.25f;


		public static float ColdBladeNextChargeDuration { get; set; } = 8f;


		public static bool StableFormationActive { get; set; }

		public static float StableFormationDamageReductionPerExtraPlayer { get; set; } = 0.1f;


		public static bool DefenseCalibrationActive { get; set; }

		public static float DefenseCalibrationLockSpeedPercent { get; set; } = 0.2f;


		public static float DefenseCalibrationAmmoCostPercent { get; set; } = -0.3f;


		public static bool SettlementProtocolActive { get; set; }

		public static int SettlementKillsRequired { get; set; } = 3;


		public static float SettlementReloadSpeedPercent { get; set; } = 0.75f;


		public static bool RapidHardeningActive { get; set; }

		public static float RapidHardeningFoamDurationMultiplier { get; set; } = 2f;


		public static bool DoorSealExpertActive { get; set; }

		public static float DoorSealExpertDurabilityPercent { get; set; } = 0.5f;


		public static bool TrackingCalibrationActive { get; set; }

		public static float TrackingCalibrationDamagePercent { get; set; } = 0.1f;


		public static bool FieldMedicActive { get; set; }

		public static float FieldMedicReviveSpeedPercent { get; set; } = 10f;


		public static float FieldMedicRevivedMoveSpeedPercent { get; set; } = -0.99f;


		public static float FieldMedicDebuffSeconds { get; set; } = 10f;


		public static bool BackstabProtocolActive { get; set; }

		public static float BackstabProtocolBackDamagePercent { get; set; } = 0.5f;


		public static float BackstabProtocolFrontDamagePercent { get; set; } = -0.25f;


		public static bool PrecisionRecycleActive { get; set; }

		public static float PrecisionRecycleCooldownSeconds { get; set; } = 0.5f;


		public static bool DataBackflowActive { get; set; }

		public static float DataBackflowToolChance { get; set; } = 0.1f;


		public static float DataBackflowToolRel { get; set; } = 0.1f;


		public static float DataBackflowAmmoChance { get; set; } = 0.15f;


		public static float DataBackflowAmmoRel { get; set; } = 0.05f;


		public static bool CrossfireActive { get; set; }

		public static float CrossfireWindowSeconds { get; set; } = 3f;


		public static float CrossfireCooldownSeconds { get; set; } = 3f;


		public static float CrossfireMaxHealthDamagePercent { get; set; } = 0.1f;


		public static IReadOnlyCollection<PlayerAgent> Players => KnownPlayers.Values;

		public static void Initialize(RogueEventDispatcher events, RogueModifierRegistry modifiers)
		{
			Events = events;
			Modifiers = modifiers;
			ResetFlags();
		}

		public static void ResetFlags()
		{
			MutualSupplyActive = false;
			CoordinatedHeavyStrikeActive = false;
			StressResponseActive = false;
			BloodDebtActive = false;
			ExplosiveHeadActive = false;
			GiantRegenerationActive = false;
			ChamberActive = false;
			ChamberDamageMultiplier = 3f;
			ChamberReadySeconds = 3f;
			SoulSiphonStrikeActive = false;
			SoulSiphonMeleeDamagePercent = 0.02f;
			SoulSiphonMaxStacks = 25;
			BulletTaxActive = false;
			BulletTaxAmmoStandardRel = 0.05f;
			BulletTaxAmmoSpecialRel = 0.05f;
			BulletTaxLargeEnemyIds = new HashSet<uint>();
			BulletTaxLargeEnemyHealthThreshold = 40f;
			ColdBladeRhythmActive = false;
			ColdBladeChargeSpeedPercent = 0.25f;
			ColdBladeNextChargeSpeedPercent = 0.25f;
			ColdBladeNextChargeDuration = 8f;
			StableFormationActive = false;
			StableFormationDamageReductionPerExtraPlayer = 0.1f;
			DefenseCalibrationActive = false;
			DefenseCalibrationLockSpeedPercent = 0.2f;
			DefenseCalibrationAmmoCostPercent = -0.3f;
			SettlementProtocolActive = false;
			SettlementKillsRequired = 3;
			SettlementReloadSpeedPercent = 0.75f;
			RapidHardeningActive = false;
			RapidHardeningFoamDurationMultiplier = 2f;
			DoorSealExpertActive = false;
			DoorSealExpertDurabilityPercent = 0.5f;
			TrackingCalibrationActive = false;
			TrackingCalibrationDamagePercent = 0.1f;
			FieldMedicActive = false;
			FieldMedicReviveSpeedPercent = 10f;
			FieldMedicRevivedMoveSpeedPercent = -0.99f;
			FieldMedicDebuffSeconds = 10f;
			BackstabProtocolActive = false;
			BackstabProtocolBackDamagePercent = 0.5f;
			BackstabProtocolFrontDamagePercent = -0.25f;
			PrecisionRecycleActive = false;
			PrecisionRecycleCooldownSeconds = 0.5f;
			DataBackflowActive = false;
			DataBackflowToolChance = 0.1f;
			DataBackflowToolRel = 0.1f;
			DataBackflowAmmoChance = 0.15f;
			DataBackflowAmmoRel = 0.05f;
			CrossfireActive = false;
			CrossfireWindowSeconds = 3f;
			CrossfireCooldownSeconds = 3f;
			CrossfireMaxHealthDamagePercent = 0.1f;
			RestoreRuntimeMoveSpeedBonuses();
			StressResponseStatuses.Clear();
			ActiveScanPlayers.Clear();
			RecentEnemyDamage.Clear();
			LastFullChargeHits.Clear();
			CoordinatedStrikeCooldowns.Clear();
			ChamberNextReadyAt.Clear();
			ChamberShotExpiresAt.Clear();
			SoulSiphonStacks.Clear();
			LastMeleeHitsByPlayer.Clear();
			MagazineKillCounts.Clear();
			SettlementReloadReady.Clear();
			ReloadingLastFrame.Clear();
			LastBulletWeaponsByPlayer.Clear();
			WeakspotStreaksByPlayer.Clear();
			PrecisionRecycleReadyAt.Clear();
			ReviveTargetsByInteraction.Clear();
			FieldMedicRescuerNormalizeUntil.Clear();
			FieldMedicForcedSlowUntil.Clear();
			RecentAttackersByEnemy.Clear();
			CrossfireReadyAt.Clear();
			ProcessedEvents.Clear();
			TriggerGuard.Clear();
			_nextBloodDebtBleedAt = 0f;
			_unresolvedDamageSourceLogCount = 0;
			_singlePlayerFallbackLogCount = 0;
			_soulSiphonTraceLogCount = 0;
		}

		public static void RegisterPlayer(PlayerAgent? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				ulong playerId = GetPlayerId(player);
				KnownPlayers[playerId] = player;
				if (((Agent)player).GameObjectID > 0)
				{
					KnownPlayersByAgentId[((Agent)player).GameObjectID] = player;
				}
				int instanceID = ((Object)player).GetInstanceID();
				if (instanceID != 0)
				{
					KnownPlayersByUnityId[instanceID] = player;
				}
				if (LoggedKnownPlayers.Add(playerId))
				{
					RogueLogger.Info($"Registered player for rogue runtime. PlayerId={playerId} Slot={player.PlayerSlotIndex} AgentId={((Agent)player).GameObjectID} UnityId={instanceID}");
				}
			}
		}

		public static void Tick(float now)
		{
			ApplyPlayerRuntimeModifiers(now);
			if (BloodDebtActive && !(now < _nextBloodDebtBleedAt))
			{
				_nextBloodDebtBleedAt = now + 2f;
				ApplyBloodDebtDrain();
			}
		}

		public static void OnGiveHealth(PlayerAgent receiver, PlayerAgent? giver, float amountRel)
		{
			PlayerAgent giver2 = giver;
			RegisterPlayer(receiver);
			RegisterPlayer(giver2);
			DispatchHealthChanged(receiver, amountRel * 100f, "GiveHealth");
			if (MutualSupplyActive && !_mirroringResource && !((Object)(object)giver2 == (Object)null) && !IsSamePlayer(receiver, giver2))
			{
				MirrorResource(delegate
				{
					giver2.GiveHealth(giver2, amountRel * 0.5f);
				});
				DispatchResourcePackUsed(giver2, receiver, "Health", amountRel);
			}
		}

		public static void OnGiveDisinfection(PlayerAgent receiver, PlayerAgent? giver, float amountRel)
		{
			PlayerAgent giver2 = giver;
			RegisterPlayer(receiver);
			RegisterPlayer(giver2);
			if (MutualSupplyActive && !_mirroringResource && !((Object)(object)giver2 == (Object)null) && !IsSamePlayer(receiver, giver2))
			{
				MirrorResource(delegate
				{
					giver2.GiveDisinfection(giver2, amountRel * 0.5f);
				});
				DispatchResourcePackUsed(giver2, receiver, "Disinfection", amountRel);
			}
		}

		public static void OnGiveAmmo(PlayerAgent receiver, PlayerAgent? giver, float ammoStandardRel, float ammoSpecialRel, float ammoClassRel)
		{
			PlayerAgent giver2 = giver;
			RegisterPlayer(receiver);
			RegisterPlayer(giver2);
			if (MutualSupplyActive && !_mirroringResource && !((Object)(object)giver2 == (Object)null) && !IsSamePlayer(receiver, giver2))
			{
				MirrorResource(delegate
				{
					giver2.GiveAmmoRel(giver2, ammoStandardRel * 0.5f, ammoSpecialRel * 0.5f, ammoClassRel * 0.5f);
				});
				DispatchResourcePackUsed(giver2, receiver, "AmmoOrTool", ammoStandardRel + ammoSpecialRel + ammoClassRel);
			}
		}

		public static void OnPlayerDamage(PlayerAgent? player, float damage, string reason)
		{
			if (!((Object)(object)player == (Object)null))
			{
				RegisterPlayer(player);
				DispatchHealthChanged(player, 0f - Mathf.Abs(damage), reason);
			}
		}

		public static void OnEnemyDamage(Dam_EnemyDamageBase damageBase, Agent? sourceAgent, ref float damage, bool isWeakspot, bool isMelee, bool wasSleepingTarget = false)
		{
			PlayerAgent val = TryGetPlayer(sourceAgent);
			if ((Object)(object)val == (Object)null)
			{
				if (BloodDebtActive)
				{
					LogUnresolvedDamageSource(sourceAgent);
				}
				return;
			}
			RegisterPlayer(val);
			ulong playerId = GetPlayerId(val);
			float num = Modifiers?.GetTotalPercentForSourcePrefix(RogueModifierKind.WeaponDamage, $"card:StressResponse:{playerId}:", Time.time) ?? 0f;
			if (num > 0f)
			{
				damage *= 1f + num;
			}
			if (isMelee)
			{
				LastMeleeHitsByPlayer[playerId] = new RecentMeleeHit(0uL, Time.time, isWeakspot, wasSleepingTarget);
				float num2 = Modifiers?.GetTotalPercentForSourcePrefix(RogueModifierKind.MeleeDamage, $"card:SoulSiphonStrike:{playerId}:", Time.time) ?? 0f;
				if (num2 > 0f)
				{
					damage *= 1f + num2;
				}
				if (SoulSiphonStrikeActive && _soulSiphonTraceLogCount < 12)
				{
					_soulSiphonTraceLogCount++;
					RogueLogger.Info($"[SoulSiphonStrike] Saw melee damage. Player={playerId} Weakspot={isWeakspot} Damage={damage:0.##}");
				}
			}
			else if (ChamberActive && TryConsumeChamberShot(playerId))
			{
				damage *= Mathf.Max(1f, ChamberDamageMultiplier);
				RogueLogger.Info($"[Chamber] Player {playerId} consumed chambered shot. Damage multiplier x{ChamberDamageMultiplier:0.#}.");
			}
			if (TrackingCalibrationActive && IsEnemyTagged(GetEnemyFromDamageBase(damageBase)))
			{
				damage *= 1f + TrackingCalibrationDamagePercent;
				RogueLogger.Info($"[TrackingCalibration] Tagged enemy damage +{TrackingCalibrationDamagePercent:P0}. Enemy={GetEnemyInstanceId(GetEnemyFromDamageBase(damageBase), damageBase)}");
			}
			EnemyAgent enemyFromDamageBase = GetEnemyFromDamageBase(damageBase);
			ulong enemyInstanceId = GetEnemyInstanceId(enemyFromDamageBase, damageBase);
			uint enemyDataId = ((enemyFromDamageBase != null) ? enemyFromDamageBase.EnemyDataID : 0u);
			if (isMelee && BackstabProtocolActive)
			{
				ApplyBackstabProtocol(val, enemyFromDamageBase, ref damage);
			}
			if (!isMelee && PrecisionRecycleActive)
			{
				UpdatePrecisionRecycle(playerId, isWeakspot);
			}
			if (CrossfireActive)
			{
				TryApplyCrossfire(playerId, enemyFromDamageBase, enemyInstanceId, ref damage);
			}
			if (isMelee)
			{
				LastMeleeHitsByPlayer[playerId] = new RecentMeleeHit(enemyInstanceId, Time.time, isWeakspot, wasSleepingTarget);
			}
			TrackEnemyDamage(enemyInstanceId, val, Time.time, isMelee, isWeakspot, wasSleepingTarget);
			Events?.OnEnemyDamaged(new EnemyDamagedContext
			{
				AttackerPlayerId = playerId,
				EnemyInstanceId = enemyInstanceId,
				EnemyDataId = enemyDataId,
				Damage = damage,
				IsWeakspot = isWeakspot,
				IsMelee = isMelee,
				Timestamp = Time.time
			});
			if (isMelee && CoordinatedHeavyStrikeActive && damage >= 20f && TryApplyCoordinatedHeavyStrike(playerId, enemyInstanceId, ref damage))
			{
				Events?.OnMeleeHit(new MeleeHitContext
				{
					AttackerPlayerId = playerId,
					EnemyInstanceId = enemyInstanceId,
					EnemyDataId = enemyDataId,
					ChargeValue = 1f,
					Timestamp = Time.time
				});
			}
		}

		public static void OnEnemyAgentTakeDamage(EnemyAgent enemy, float damage, Agent? sourceAgent, bool isWeakspot)
		{
			PlayerAgent val = TryGetPlayer(sourceAgent);
			if ((Object)(object)val == (Object)null)
			{
				if (BloodDebtActive)
				{
					LogUnresolvedDamageSource(sourceAgent);
				}
				return;
			}
			RegisterPlayer(val);
			ulong enemyInstanceId = GetEnemyInstanceId(enemy, null);
			TrackEnemyDamage(enemyInstanceId, val, Time.time, isMelee: false, isWeakspot, wasSleepingTarget: false);
			Events?.OnEnemyDamaged(new EnemyDamagedContext
			{
				AttackerPlayerId = GetPlayerId(val),
				EnemyInstanceId = enemyInstanceId,
				EnemyDataId = enemy.EnemyDataID,
				Damage = damage,
				IsWeakspot = isWeakspot,
				IsMelee = false,
				Timestamp = Time.time
			});
		}

		public static void OnEnemyDead(EnemyAgent enemy)
		{
			ulong enemyInstanceId = GetEnemyInstanceId(enemy, null);
			uint enemyDataID = enemy.EnemyDataID;
			if (!ProcessedEvents.TryMarkEnemy(enemyInstanceId, "EnemyDead"))
			{
				RecentEnemyDamage.Remove(enemyInstanceId);
				RogueLogger.Info($"[Runtime] Ignored duplicate enemy death event. EnemyKey={enemyInstanceId}");
				return;
			}
			PlayerDamageStamp? playerDamageStamp = TryGetRecentKillerStamp(enemyInstanceId, enemy.LastDamageInflictor);
			Events?.OnEnemyKilled(new EnemyKilledContext
			{
				KillerPlayerId = (playerDamageStamp?.PlayerId ?? 0),
				EnemyInstanceId = enemyInstanceId,
				EnemyDataId = enemyDataID,
				LastHitWasMelee = (playerDamageStamp?.IsMelee ?? false),
				LastHitWasWeakspot = (playerDamageStamp?.IsWeakspot ?? false),
				Timestamp = Time.time
			});
			if (BloodDebtActive)
			{
				if (!RecentEnemyDamage.TryGetValue(enemyInstanceId, out List<PlayerDamageStamp> value))
				{
					value = new List<PlayerDamageStamp>();
				}
				PlayerAgent val = TryGetPlayer(enemy.LastDamageInflictor);
				if (val != null)
				{
					RegisterPlayer(val);
					value.Add(new PlayerDamageStamp(GetPlayerId(val), val, Time.time, playerDamageStamp?.IsMelee ?? false, playerDamageStamp?.IsWeakspot ?? false, playerDamageStamp?.WasSleepingTarget ?? false));
				}
				Dictionary<ulong, PlayerAgent> dictionary = new Dictionary<ulong, PlayerAgent>();
				foreach (PlayerDamageStamp item in value)
				{
					if (Time.time - item.Timestamp <= 5f)
					{
						dictionary[item.PlayerId] = item.Player;
					}
				}
				if (dictionary.Count == 0)
				{
					PlayerAgent val2 = TryGetSingleKnownPlayerFallback("kill heal");
					if (val2 != null)
					{
						dictionary[GetPlayerId(val2)] = val2;
					}
				}
				foreach (PlayerAgent value2 in dictionary.Values)
				{
					ApplyBloodDebtHeal(value2);
				}
				RogueLogger.Info($"[BloodDebt] Restored 3% health to {dictionary.Count} participants. EnemyKey={enemyInstanceId}");
			}
			if (SoulSiphonStrikeActive && TryGetSoulSiphonKillPlayer(enemyInstanceId, playerDamageStamp, out var playerId))
			{
				ApplySoulSiphonStrikeStack(playerId);
			}
			if (SettlementProtocolActive && playerDamageStamp.HasValue && !playerDamageStamp.GetValueOrDefault().IsMelee)
			{
				IncrementSettlementMagazineKills(playerDamageStamp.Value.PlayerId);
			}
			if (ColdBladeRhythmActive && playerDamageStamp.HasValue)
			{
				PlayerDamageStamp valueOrDefault = playerDamageStamp.GetValueOrDefault();
				if (valueOrDefault.IsMelee && valueOrDefault.WasSleepingTarget)
				{
					ApplyColdBladeNextChargeBuff(playerDamageStamp.Value.PlayerId);
				}
			}
			if (BulletTaxActive && IsBulletTaxEligibleLargeEnemy(enemy))
			{
				ApplyBulletTaxRefund(enemyDataID);
			}
			if (DataBackflowActive && IsEnemyTagged(enemy))
			{
				ApplyDataBackflow(enemyDataID);
			}
			if (ExplosiveHeadActive)
			{
				RogueLogger.Info($"[ExplosiveHead] Enemy {enemyInstanceId} died. Explosion damage is pending until a safe explosion spawn API is selected.");
			}
			RecentEnemyDamage.Remove(enemyInstanceId);
			RecentAttackersByEnemy.Remove(enemyInstanceId);
			CrossfireReadyAt.Remove(enemyInstanceId);
		}

		public static ulong GetPlayerId(PlayerAgent player)
		{
			if (player.PlayerSlotIndex >= 0)
			{
				return (ulong)(player.PlayerSlotIndex + 1);
			}
			if (((Agent)player).GameObjectID > 0)
			{
				return 1000000uL + (ulong)((Agent)player).GameObjectID;
			}
			int instanceID = ((Object)player).GetInstanceID();
			return 2000000uL + (ulong)Math.Abs(instanceID);
		}

		private static void DispatchHealthChanged(PlayerAgent player, float delta, string reason)
		{
			if (StressResponseActive || Events != null)
			{
				Events?.OnHealthChanged(new HealthChangedContext
				{
					PlayerId = GetPlayerId(player),
					OldHealth = 0f,
					NewHealth = delta,
					Reason = reason,
					Timestamp = Time.time
				});
			}
		}

		private static void DispatchResourcePackUsed(PlayerAgent user, PlayerAgent target, string resourceType, float amount)
		{
			Events?.OnResourcePackUsed(new ResourcePackUsedContext
			{
				UserPlayerId = GetPlayerId(user),
				TargetPlayerId = GetPlayerId(target),
				ResourceType = resourceType,
				Amount = amount,
				Timestamp = Time.time
			});
		}

		private static void TrackEnemyDamage(ulong enemyInstanceId, PlayerAgent player, float timestamp, bool isMelee, bool isWeakspot, bool wasSleepingTarget)
		{
			if (!RecentEnemyDamage.TryGetValue(enemyInstanceId, out List<PlayerDamageStamp> value))
			{
				value = new List<PlayerDamageStamp>();
				RecentEnemyDamage[enemyInstanceId] = value;
			}
			value.RemoveAll((PlayerDamageStamp stamp) => timestamp - stamp.Timestamp > 5f);
			ulong playerId = GetPlayerId(player);
			if (value.Count > 0)
			{
				int index = value.Count - 1;
				PlayerDamageStamp playerDamageStamp = value[index];
				if (playerDamageStamp.PlayerId == playerId && timestamp - playerDamageStamp.Timestamp <= 0.2f)
				{
					value[index] = new PlayerDamageStamp(playerId, player, timestamp, playerDamageStamp.IsMelee || isMelee, playerDamageStamp.IsWeakspot || isWeakspot, playerDamageStamp.WasSleepingTarget || wasSleepingTarget);
					return;
				}
			}
			value.Add(new PlayerDamageStamp(playerId, player, timestamp, isMelee, isWeakspot, wasSleepingTarget));
		}

		private static bool TryConsumeChamberShot(ulong playerId)
		{
			float time = Time.time;
			if (ChamberShotExpiresAt.TryGetValue(playerId, out var value))
			{
				ChamberShotExpiresAt.Remove(playerId);
				if (time <= value)
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryGetSoulSiphonKillPlayer(ulong enemyInstanceId, PlayerDamageStamp? killerStamp, out ulong playerId)
		{
			if (killerStamp.HasValue)
			{
				PlayerDamageStamp valueOrDefault = killerStamp.GetValueOrDefault();
				if (valueOrDefault.IsMelee && valueOrDefault.IsWeakspot)
				{
					playerId = killerStamp.Value.PlayerId;
					return true;
				}
			}
			foreach (KeyValuePair<ulong, RecentMeleeHit> item in LastMeleeHitsByPlayer)
			{
				RecentMeleeHit value = item.Value;
				if (!(Time.time - value.Timestamp > 2f) && (value.EnemyInstanceId == 0L || value.EnemyInstanceId == enemyInstanceId) && value.IsWeakspot)
				{
					playerId = item.Key;
					RogueLogger.Info($"[SoulSiphonStrike] Using recent melee fallback for kill attribution. Player={playerId} Enemy={enemyInstanceId} Weakspot={value.IsWeakspot}");
					return true;
				}
			}
			playerId = 0uL;
			return false;
		}

		private static PlayerDamageStamp? TryGetRecentKillerStamp(ulong enemyInstanceId, Agent? lastDamageInflictor)
		{
			if (RecentEnemyDamage.TryGetValue(enemyInstanceId, out List<PlayerDamageStamp> value))
			{
				for (int num = value.Count - 1; num >= 0; num--)
				{
					PlayerDamageStamp value2 = value[num];
					if (Time.time - value2.Timestamp <= 5f)
					{
						return value2;
					}
				}
			}
			if (TryGetRecentGlobalDamageStamp(out var stamp))
			{
				RogueLogger.Info($"[Runtime] Using recent global damage fallback for kill attribution. Player={stamp.PlayerId} EnemyKey={enemyInstanceId} Melee={stamp.IsMelee} Weakspot={stamp.IsWeakspot}");
				return stamp;
			}
			PlayerAgent val = TryGetPlayer(lastDamageInflictor);
			if (val != null)
			{
				RegisterPlayer(val);
				return new PlayerDamageStamp(GetPlayerId(val), val, Time.time, isMelee: false, isWeakspot: false);
			}
			return null;
		}

		private static bool TryGetRecentGlobalDamageStamp(out PlayerDamageStamp stamp)
		{
			float time = Time.time;
			PlayerDamageStamp? playerDamageStamp = null;
			foreach (KeyValuePair<ulong, List<PlayerDamageStamp>> item in RecentEnemyDamage)
			{
				foreach (PlayerDamageStamp item2 in item.Value)
				{
					if (!(time - item2.Timestamp > 1.5f) && (!playerDamageStamp.HasValue || item2.Timestamp > playerDamageStamp.Value.Timestamp))
					{
						playerDamageStamp = item2;
					}
				}
			}
			if (playerDamageStamp.HasValue)
			{
				stamp = playerDamageStamp.Value;
				return true;
			}
			stamp = default(PlayerDamageStamp);
			return false;
		}

		private static void ApplySoulSiphonStrikeStack(ulong playerId)
		{
			int num = 1;
			if (SoulSiphonStacks.TryGetValue(playerId, out var value))
			{
				num = Mathf.Min(value + 1, Mathf.Max(1, SoulSiphonMaxStacks));
			}
			SoulSiphonStacks[playerId] = num;
			Modifiers?.AddOrReplace(new RogueModifier
			{
				SourceId = $"card:SoulSiphonStrike:{playerId}:melee",
				Kind = RogueModifierKind.MeleeDamage,
				Percent = SoulSiphonMeleeDamagePercent,
				Stacks = num
			});
			RogueLogger.Info($"[SoulSiphonStrike] Player {playerId} melee damage stacks={num}, total +{(float)num * SoulSiphonMeleeDamagePercent:P0}.");
		}

		private static bool IsBulletTaxEligibleLargeEnemy(EnemyAgent enemy)
		{
			if (BulletTaxLargeEnemyIds.Count == 0)
			{
				EnemyBalancingDataBlock enemyBalancingData = enemy.EnemyBalancingData;
				float? obj;
				if (enemyBalancingData == null)
				{
					obj = null;
				}
				else
				{
					HealthData health = enemyBalancingData.Health;
					obj = ((health != null) ? new float?(health.HealthMax) : null);
				}
				float? num = obj;
				float valueOrDefault = num.GetValueOrDefault();
				float num2 = Mathf.Max(40f, BulletTaxLargeEnemyHealthThreshold);
				bool flag = valueOrDefault >= num2;
				RogueLogger.Info($"[BulletTax] EnemyDataID={enemy.EnemyDataID} HealthMax={valueOrDefault:0.#} Threshold={num2:0.#} Eligible={flag}.");
				return flag;
			}
			return BulletTaxLargeEnemyIds.Contains(enemy.EnemyDataID);
		}

		private static void ApplyBulletTaxRefund(uint enemyDataId)
		{
			int num = 0;
			foreach (PlayerAgent value in KnownPlayers.Values)
			{
				if (!((Object)(object)value == (Object)null) && ((Agent)value).Alive)
				{
					value.GiveAmmoRel(value, BulletTaxAmmoStandardRel, BulletTaxAmmoSpecialRel, 0f);
					num++;
				}
			}
			RogueLogger.Info($"[BulletTax] EnemyDataID={enemyDataId} refunded ammo to {num} players.");
		}

		private static void ApplyDataBackflow(uint enemyDataId)
		{
			float value = Random.value;
			float value2 = Random.value;
			bool flag = value <= DataBackflowAmmoChance;
			bool flag2 = value2 <= DataBackflowToolChance;
			if (!flag && !flag2)
			{
				RogueLogger.Info($"[DataBackflow] Tagged kill rolled no refund. EnemyDataID={enemyDataId} AmmoRoll={value:0.00} ToolRoll={value2:0.00}");
				return;
			}
			int num = 0;
			foreach (PlayerAgent value3 in KnownPlayers.Values)
			{
				if (!((Object)(object)value3 == (Object)null) && ((Agent)value3).Alive)
				{
					if (flag)
					{
						value3.GiveAmmoRel(value3, DataBackflowAmmoRel, DataBackflowAmmoRel, 0f);
					}
					if (flag2)
					{
						value3.GiveAmmoRel(value3, 0f, 0f, DataBackflowToolRel);
					}
					num++;
				}
			}
			RogueLogger.Info($"[DataBackflow] Tagged kill refunded resources to {num} players. EnemyDataID={enemyDataId} Ammo={flag} Tool={flag2}");
		}

		private static void ApplyBackstabProtocol(PlayerAgent player, EnemyAgent? enemy, ref float damage)
		{
			//IL_000c: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)enemy == (Object)null)
			{
				return;
			}
			try
			{
				Vector3 val = ((Agent)player).Position - enemy.Position;
				if (!(((Vector3)(ref val)).sqrMagnitude <= 0.001f))
				{
					float num = Vector3.Dot(((Component)enemy).transform.forward, ((Vector3)(ref val)).normalized);
					if (num <= -0.25f)
					{
						damage *= 1f + Mathf.Max(0f, BackstabProtocolBackDamagePercent);
						RogueLogger.Info($"[BackstabProtocol] Back melee hit. Enemy={GetEnemyInstanceId(enemy, null)} Dot={num:0.00} Damage+{BackstabProtocolBackDamagePercent:P0}");
					}
					else
					{
						damage *= Mathf.Max(0.01f, 1f + BackstabProtocolFrontDamagePercent);
						RogueLogger.Info($"[BackstabProtocol] Front/side melee hit. Enemy={GetEnemyInstanceId(enemy, null)} Dot={num:0.00} Damage{BackstabProtocolFrontDamagePercent:P0}");
					}
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[BackstabProtocol] Failed to evaluate melee position.", ex);
			}
		}

		private static void UpdatePrecisionRecycle(ulong playerId, bool isWeakspot)
		{
			if (!isWeakspot)
			{
				return;
			}
			float time = Time.time;
			if (!PrecisionRecycleReadyAt.TryGetValue(playerId, out var value) || !(time < value))
			{
				PrecisionRecycleReadyAt[playerId] = time + Mathf.Max(0.01f, PrecisionRecycleCooldownSeconds);
				if (TryRefundOneCurrentWeaponRound(playerId, accountForPendingShot: true))
				{
					RogueLogger.Info($"[PrecisionRecycle] Player {playerId} weakspot hit reloaded 1 round into the current magazine.");
				}
			}
		}

		private static void ApplyBloodDebtHeal(PlayerAgent participant)
		{
			if ((Object)(object)participant == (Object)null)
			{
				return;
			}
			try
			{
				RegisterPlayer(participant);
				if ((Object)(object)participant.Damage == (Object)null)
				{
					participant.GiveHealth(participant, 0.03f);
					return;
				}
				float health = ((Dam_SyncedDamageBase)participant.Damage).Health;
				float num = Mathf.Max(1f, ((Dam_SyncedDamageBase)participant.Damage).HealthMax);
				float num2 = Mathf.Min(num, health + num * 0.03f);
				if (!(num2 <= health))
				{
					((Dam_SyncedDamageBase)participant.Damage).SendSetHealth(num2);
					float delta = (num2 - health) / num * 100f;
					DispatchHealthChanged(participant, delta, "BloodDebtKillHeal");
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[BloodDebt] Direct kill-heal failed, falling back to GiveHealth.", ex);
				try
				{
					participant.GiveHealth(participant, 0.03f);
				}
				catch (Exception ex2)
				{
					RogueLogger.Error("[BloodDebt] GiveHealth fallback failed.", ex2);
				}
			}
		}

		private static bool TryRefundOneCurrentWeaponRound(ulong playerId, bool accountForPendingShot)
		{
			if (!LastBulletWeaponsByPlayer.TryGetValue(playerId, out BulletWeapon value) || (Object)(object)value == (Object)null)
			{
				return false;
			}
			try
			{
				int currentClip = ((ItemEquippable)value).GetCurrentClip();
				int maxClip = ((ItemEquippable)value).GetMaxClip();
				if (maxClip <= 0)
				{
					return false;
				}
				int num = (accountForPendingShot ? 1 : 0);
				int num2 = Mathf.Clamp(currentClip + 1, num, maxClip + num);
				if (num2 == currentClip)
				{
					return false;
				}
				((ItemEquippable)value).SetCurrentClip(num2);
				return true;
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[PrecisionRecycle] Failed to refund current-weapon round.", ex);
				return false;
			}
		}

		private static void TryApplyCrossfire(ulong playerId, EnemyAgent? enemy, ulong enemyInstanceId, ref float damage)
		{
			if ((Object)(object)enemy == (Object)null || enemyInstanceId == 0L)
			{
				return;
			}
			float time = Time.time;
			if (!RecentAttackersByEnemy.TryGetValue(enemyInstanceId, out Dictionary<ulong, float> value))
			{
				value = new Dictionary<ulong, float>();
				RecentAttackersByEnemy[enemyInstanceId] = value;
			}
			bool flag = false;
			List<ulong> list = new List<ulong>();
			foreach (KeyValuePair<ulong, float> item in value)
			{
				if (time - item.Value > CrossfireWindowSeconds)
				{
					list.Add(item.Key);
				}
				else if (item.Key != playerId)
				{
					flag = true;
				}
			}
			foreach (ulong item2 in list)
			{
				value.Remove(item2);
			}
			value[playerId] = time;
			if (flag && (!CrossfireReadyAt.TryGetValue(enemyInstanceId, out var value2) || !(time < value2)))
			{
				EnemyBalancingDataBlock enemyBalancingData = enemy.EnemyBalancingData;
				float? obj;
				if (enemyBalancingData == null)
				{
					obj = null;
				}
				else
				{
					HealthData health = enemyBalancingData.Health;
					obj = ((health != null) ? new float?(health.HealthMax) : null);
				}
				float? num = obj;
				float valueOrDefault = num.GetValueOrDefault();
				if (!(valueOrDefault <= 0f))
				{
					float num2 = valueOrDefault * Mathf.Max(0f, CrossfireMaxHealthDamagePercent);
					damage += num2;
					CrossfireReadyAt[enemyInstanceId] = time + Mathf.Max(0.01f, CrossfireCooldownSeconds);
					RogueLogger.Info($"[Crossfire] Enemy={enemyInstanceId} received +{num2:0.#} damage from coordinated attackers.");
				}
			}
		}

		private static bool TryApplyCoordinatedHeavyStrike(ulong playerId, ulong enemyInstanceId, ref float damage)
		{
			float time = Time.time;
			bool result = false;
			if (LastFullChargeHits.TryGetValue(enemyInstanceId, out var value) && value.PlayerId != playerId && time - value.Timestamp <= 3f && (!CoordinatedStrikeCooldowns.TryGetValue(enemyInstanceId, out var value2) || time >= value2))
			{
				damage += Mathf.Max(5f, damage * 0.2f);
				CoordinatedStrikeCooldowns[enemyInstanceId] = time + 8f;
				result = true;
				RogueLogger.Info($"[CoordinatedHeavyStrike] Added bonus melee damage to enemy {enemyInstanceId}.");
			}
			LastFullChargeHits[enemyInstanceId] = new LastFullChargeHit(playerId, time);
			return result;
		}

		private static void ApplyPlayerRuntimeModifiers(float now)
		{
			RemoveExpiredScanPlayers(now);
			RemoveExpiredFieldMedicForcedSlows(now);
			foreach (KeyValuePair<ulong, PlayerAgent> knownPlayer in KnownPlayers)
			{
				ulong key = knownPlayer.Key;
				PlayerAgent value = knownPlayer.Value;
				float playerMovementPercent = GetPlayerMovementPercent(key, now);
				ApplyMoveSpeedBonus(key, value, playerMovementPercent);
			}
		}

		public static float GetMoveSpeedMultiplier(PlayerAgent? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				return GetMoveSpeedMultiplier(GetPlayerId(player));
			}
			return 1f;
		}

		public static float GetMoveSpeedMultiplier(PlayerLocomotion? locomotion)
		{
			if (!((Object)(object)locomotion == (Object)null))
			{
				return GetMoveSpeedMultiplier(locomotion.m_owner);
			}
			return 1f;
		}

		public static float GetMoveSpeedMultiplier(ulong playerId)
		{
			float playerMovementPercent = GetPlayerMovementPercent(playerId, Time.time);
			return Mathf.Max(0.01f, 1f + playerMovementPercent);
		}

		public static float GetColdBladeMeleeSpeedMultiplier(PlayerAgent? player)
		{
			if (!ColdBladeRhythmActive || (Object)(object)player == (Object)null)
			{
				return 1f;
			}
			ulong playerId = GetPlayerId(player);
			float coldBladeChargeSpeedPercent = ColdBladeChargeSpeedPercent;
			coldBladeChargeSpeedPercent += Modifiers?.GetTotalPercentForSourcePrefix(RogueModifierKind.MeleeChargeSpeed, $"card:ColdBladeRhythm:{playerId}:", Time.time) ?? 0f;
			return Mathf.Max(0.05f, 1f + coldBladeChargeSpeedPercent);
		}

		public static void OnBioscanUpdated(CP_Bioscan_Core? core)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)core == (Object)null || (!StableFormationActive && !DefenseCalibrationActive))
			{
				return;
			}
			try
			{
				List<PlayerAgent> playersOnScan = core.PlayersOnScan;
				if (playersOnScan == null || playersOnScan.Count <= 0)
				{
					return;
				}
				int count = playersOnScan.Count;
				float expiresAt = Time.time + 0.25f;
				for (int i = 0; i < playersOnScan.Count; i++)
				{
					PlayerAgent val = playersOnScan[i];
					if (!((Object)(object)val == (Object)null))
					{
						RegisterPlayer(val);
						ActiveScanPlayers[GetPlayerId(val)] = new ScanPresence(count, ((Agent)val).Position, expiresAt);
					}
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[Bioscan] Failed to update scan presence.", ex);
			}
		}

		public static void ModifyIncomingDamage(PlayerAgent? player, ref pBulletDamageData data)
		{
			float damage = ((UFloat16)(ref data.damage)).Get(100f);
			if (TryModifyIncomingDamage(player, ref damage))
			{
				((UFloat16)(ref data.damage)).Set(damage, 100f);
			}
		}

		public static void ModifyIncomingDamage(PlayerAgent? player, ref pFullDamageData data)
		{
			float damage = ((UFloat16)(ref data.damage)).Get(100f);
			if (TryModifyIncomingDamage(player, ref damage))
			{
				((UFloat16)(ref data.damage)).Set(damage, 100f);
			}
		}

		public static void ModifyIncomingDamage(PlayerAgent? player, ref pExplosionDamageData data)
		{
			float damage = ((UFloat16)(ref data.damage)).Get(100f);
			if (TryModifyIncomingDamage(player, ref damage))
			{
				((UFloat16)(ref data.damage)).Set(damage, 100f);
			}
		}

		public static void ModifyIncomingDamage(PlayerAgent? player, ref pSmallDamageData data)
		{
			float damage = ((UFloat16)(ref data.damage)).Get(100f);
			if (TryModifyIncomingDamage(player, ref damage))
			{
				((UFloat16)(ref data.damage)).Set(damage, 100f);
			}
		}

		public static void OnBulletWeaponFire(BulletWeapon? weapon)
		{
			if ((Object)(object)weapon == (Object)null || (Object)(object)((Item)weapon).Owner == (Object)null)
			{
				return;
			}
			RegisterPlayer(((Item)weapon).Owner);
			ulong playerId = GetPlayerId(((Item)weapon).Owner);
			LastBulletWeaponsByPlayer[playerId] = weapon;
			if (ChamberActive)
			{
				if (((ItemEquippable)weapon).GetCurrentClip() >= ((ItemEquippable)weapon).GetMaxClip())
				{
					ChamberShotExpiresAt[playerId] = Time.time + Mathf.Max(0.05f, ChamberReadySeconds);
					RogueLogger.Info($"[Chamber] Player {playerId} fired first bullet in magazine. Next hit for this shot is armed.");
				}
				else
				{
					ChamberShotExpiresAt.Remove(playerId);
				}
			}
		}

		public static void OnBulletWeaponWield(BulletWeapon? weapon)
		{
			if (!((Object)(object)((weapon != null) ? ((Item)weapon).Owner : null) == (Object)null))
			{
				MagazineKillCounts[GetPlayerId(((Item)weapon).Owner)] = 0;
			}
		}

		public static void OnBulletWeaponReloadState(BulletWeapon? weapon)
		{
			if ((Object)(object)((weapon != null) ? ((Item)weapon).Owner : null) == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)weapon).GetInstanceID();
			bool isReloading = ((ItemEquippable)weapon).IsReloading;
			ReloadingLastFrame.TryGetValue(instanceID, out var value);
			ReloadingLastFrame[instanceID] = isReloading;
			if (!(!value || isReloading))
			{
				ulong playerId = GetPlayerId(((Item)weapon).Owner);
				MagazineKillCounts[playerId] = 0;
				if (SettlementReloadReady.Remove(playerId))
				{
					RogueLogger.Info($"[SettlementProtocol] Player {playerId} completed empowered reload. Buff consumed.");
				}
			}
		}

		public static float ModifyReloadTime(PlayerAgent? player, float reloadTime)
		{
			if (!SettlementProtocolActive || (Object)(object)player == (Object)null)
			{
				return reloadTime;
			}
			ulong playerId = GetPlayerId(player);
			if (!SettlementReloadReady.ContainsKey(playerId))
			{
				return reloadTime;
			}
			float num = 1f + Mathf.Max(0f, SettlementReloadSpeedPercent);
			return reloadTime / num;
		}

		public static void OnSentryDetectionUpdate(SentryGunInstance_Detection? detection)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (DefenseCalibrationActive && !((Object)(object)detection == (Object)null) && IsNearActiveScan(((Component)detection).transform.position))
			{
				float scanningTimer = detection.m_scanningTimer;
				if (scanningTimer > 0f)
				{
					detection.m_scanningTimer = Mathf.Max(0f, scanningTimer - Time.deltaTime * DefenseCalibrationLockSpeedPercent);
				}
			}
		}

		public static void ModifySentryBulletCost(SentryGunInstance? sentry, ref float cost)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (DefenseCalibrationActive && !((Object)(object)sentry == (Object)null) && IsNearActiveScan(((Component)sentry).transform.position))
			{
				cost *= Mathf.Max(0.01f, 1f + DefenseCalibrationAmmoCostPercent);
			}
		}

		public static void ModifyEnemyGlueFadeOutTime(ref float duration)
		{
			if (RapidHardeningActive)
			{
				duration *= Mathf.Max(1f, RapidHardeningFoamDurationMultiplier);
			}
		}

		public static void OnEnemyGlueVolumeUpdated(Dam_EnemyDamageBase? damageBase)
		{
			if (!RapidHardeningActive || (Object)(object)damageBase == (Object)null)
			{
				return;
			}
			try
			{
				if (!damageBase.IsStuckInGlue)
				{
					return;
				}
				EnemyAgent owner = damageBase.Owner;
				object obj;
				if (owner == null)
				{
					obj = null;
				}
				else
				{
					EnemyLocomotion locomotion = owner.Locomotion;
					obj = ((locomotion != null) ? locomotion.StuckInGlue : null);
				}
				ES_StuckInGlue val = (ES_StuckInGlue)obj;
				EnemyBalancingDataBlock val2 = ((owner != null) ? owner.EnemyBalancingData : null);
				if (val != null && val2 != null)
				{
					float num = Mathf.Max(1f, RapidHardeningFoamDurationMultiplier);
					float num2 = Mathf.Max(0f, val2.GlueFadeOutTime * 0.9f);
					float num4 = (val.m_fadeOutDuration = Mathf.Max(val.m_fadeOutDuration, num2 * num));
					if (val.m_glueFadeOutTriggered)
					{
						val.m_fadeOutTimer = Mathf.Max(val.m_fadeOutTimer, Time.time + num4);
					}
					RogueLogger.Info($"[StrongGlue] Extended stuck glue fade duration to {num4:0.##}s.");
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[StrongGlue] Failed to extend enemy glue fade duration.", ex);
			}
		}

		public static void ModifyGlueOnDoorPacket(ref pSpawnGlueOnDoor data)
		{
			//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_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)
			if (DoorSealExpertActive)
			{
				float num = 1f + Mathf.Max(0f, DoorSealExpertDurabilityPercent);
				GlueVolumeDesc volumeDesc = data.volumeDesc;
				volumeDesc.volume *= num;
				volumeDesc.expandVolume *= num;
				data.volumeDesc = volumeDesc;
			}
		}

		public static void OnReviveSetup(Interact_Revive? interaction, PlayerAgent? owner)
		{
			if (!((Object)(object)interaction == (Object)null) && !((Object)(object)owner == (Object)null))
			{
				RegisterPlayer(owner);
				ReviveTargetsByInteraction[((Object)interaction).GetInstanceID()] = owner;
				RogueLogger.Info($"[FieldMedic] Cached revive target from setup: player {GetPlayerId(owner)}.");
			}
		}

		public static float ModifyReviveSpeed(Interact_Revive? interaction, PlayerAgent? source, float deltaTime)
		{
			if (!FieldMedicActive || (Object)(object)source == (Object)null)
			{
				return deltaTime;
			}
			CacheReviveTarget(interaction, source);
			return deltaTime * (1f + Mathf.Max(0f, FieldMedicReviveSpeedPercent));
		}

		public static void OnReviveCompleted(Interact_Revive? interaction, PlayerAgent? source)
		{
			if (FieldMedicActive && !((Object)(object)interaction == (Object)null))
			{
				PlayerAgent val = ResolveReviveTarget(interaction, source);
				if ((Object)(object)val == (Object)null)
				{
					RestoreFieldMedicRescuerMoveSpeed(source);
					return;
				}
				RegisterPlayer(val);
				ulong playerId = GetPlayerId(val);
				Modifiers?.AddOrReplace(new RogueModifier
				{
					SourceId = $"card:FieldMedic:{playerId}:revived_slow",
					Kind = RogueModifierKind.MovementSpeed,
					Percent = FieldMedicRevivedMoveSpeedPercent,
					Stacks = 1,
					ExpiresAt = Time.time + FieldMedicDebuffSeconds
				});
				FieldMedicForcedSlowUntil[playerId] = Time.time + FieldMedicDebuffSeconds;
				ApplyMoveSpeedBonus(playerId, val, GetPlayerMovementPercent(playerId, Time.time));
				RestoreFieldMedicRescuerMoveSpeed(source);
				RogueLogger.Info($"[FieldMedic] Player {playerId} revived by {FormatPlayerDebug(source)}. Movement {FieldMedicRevivedMoveSpeedPercent:P0} for {FieldMedicDebuffSeconds:0.#}s.");
			}
		}

		private static void CacheReviveTarget(Interact_Revive? interaction, PlayerAgent? source)
		{
			if (!((Object)(object)interaction == (Object)null))
			{
				PlayerAgent interactTargetAgent = ((Interact_Timed)interaction).m_interactTargetAgent;
				if (!((Object)(object)interactTargetAgent == (Object)null) && (!((Object)(object)source != (Object)null) || !IsSamePlayer(interactTargetAgent, source)))
				{
					ReviveTargetsByInteraction[((Object)interaction).GetInstanceID()] = interactTargetAgent;
				}
			}
		}

		private static PlayerAgent? ResolveReviveTarget(Interact_Revive interaction, PlayerAgent? source)
		{
			int instanceID = ((Object)interaction).GetInstanceID();
			if (ReviveTargetsByInteraction.TryGetValue(instanceID, out PlayerAgent value) && (Object)(object)value != (Object)null && ((Object)(object)source == (Object)null || !IsSamePlayer(value, source)))
			{
				ReviveTargetsByInteraction.Remove(instanceID);
				return value;
			}
			PlayerAgent interactTargetAgent = ((Interact_Timed)interaction).m_interactTargetAgent;
			if ((Object)(object)interactTargetAgent != (Object)null && ((Object)(object)source == (Object)null || !IsSamePlayer(interactTargetAgent, source)))
			{
				return interactTargetAgent;
			}
			RogueLogger.Info("[FieldMedic] Revive target resolved to source or null; skipped revived-player slow to avoid slowing the rescuer.");
			return null;
		}

		private static void RestoreFieldMedicRescuerMoveSpeed(PlayerAgent? player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				ulong playerId = GetPlayerId(player);
				Modifiers?.ClearSource($"card:FieldMedic:{playerId}:revived_slow");
				FieldMedicForcedSlowUntil.Remove(playerId);
				FieldMedicRescuerNormalizeUntil[playerId] = Time.time + Mathf.Max(0.5f, FieldMedicDebuffSeconds + 0.25f);
				ForceNormalizePlayerMoveSpeed(playerId, player);
				RogueLogger.Info($"[FieldMedic] Restored rescuer/source player {playerId} move speed to normal for {FieldMedicDebuffSeconds:0.#}s.");
			}
		}

		private static void RemoveExpiredFieldMedicForcedSlows(float now)
		{
			if (FieldMedicForcedSlowUntil.Count == 0)
			{
				return;
			}
			List<ulong> list = new List<ulong>();
			foreach (KeyValuePair<ulong, float> item in FieldMedicForcedSlowUntil)
			{
				if (now > item.Value)
				{
					list.Add(item.Key);
				}
			}
			foreach (ulong item2 in list)
			{
				FieldMedicForcedSlowUntil.Remove(item2);
				Modifiers?.ClearSource($"card:FieldMedic:{item2}:revived_slow");
				if (KnownPlayers.TryGetValue(item2, out PlayerAgent value))
				{
					ApplyMoveSpeedBonus(item2, value, GetPlayerMovementPercent(item2, now));
				}
				RogueLogger.Info($"[FieldMedic] Revived-player slow expired for player {item2}.");
			}
		}

		private static string FormatPlayerDebug(PlayerAgent? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "null";
			}
			return $"{GetPlayerId(player)}(slot={player.PlayerSlotIndex}, agent={((Agent)player).GameObjectID}, unity={((Object)player).GetInstanceID()})";
		}

		public static void SetStressResponseStatus(ulong playerId, int stacks, float expiresAt, float damagePercent, float movePercent)
		{
			StressResponseStatuses[playerId] = new StressResponseRuntimeStatus(playerId, stacks, expiresAt, damagePercent, movePercent);
		}

		public static string GetRuntimeStatusText(float now)
		{
			List<string> list = new List<string>();
			foreach (StressResponseRuntimeStatus value in StressResponseStatuses.Values)
			{
				float num = Mathf.Max(0f, value.ExpiresAt - now);
				if (value.Stacks > 0 && !(num <= 0f))
				{
					list.Add($"P{value.PlayerId} {value.Stacks}层 {num:0.0}s  伤害+{value.DamagePercent * 100f:0}% / 移速+{value.MovePercent * 100f:0}%");
				}
			}
			string soulSiphonStatusText = GetSoulSiphonStatusText();
			if (list.Count > 0)
			{
				return "应激反应  " + string.Join("    ", list) + "    /    " + soulSiphonStatusText;
			}
			return (BloodDebtActive ? "血债循环: 生效中  /  应激反应: 无活动层数" : "应激反应: 无活动层数") + "    /    " + soulSiphonStatusText;
		}

		private static string GetSoulSiphonStatusText()
		{
			if (!SoulSiphonStrikeActive)
			{
				return "汲魂痛击: 未激活";
			}
			if (SoulSiphonStacks.Count == 0)
			{
				return "汲魂痛击: 0 层";
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<ulong, int> soulSiphonStack in SoulSiphonStacks)
			{
				list.Add($"P{soulSiphonStack.Key} {soulSiphonStack.Value}层");
			}
			return "汲魂痛击  " + string.Join("    ", list);
		}

		private static void ApplyMoveSpeedBonus(ulong playerId, PlayerAgent player, float bonus)
		{
			float time = Time.time;
			if (FieldMedicRescuerNormalizeUntil.TryGetValue(playerId, out var value))
			{
				if (time <= value)
				{
					bonus = Mathf.Max(0f, bonus);
				}
				else
				{
					FieldMedicRescuerNormalizeUntil.Remove(playerId);
				}
			}
			AppliedMoveSpeedBonuses.TryGetValue(playerId, out var value2);
			if (Mathf.Abs(value2 - bonus) < 0.0001f)
			{
				if (FieldMedicRescuerNormalizeUntil.ContainsKey(playerId))
				{
					ForceNormalizePlayerMoveSpeed(playerId, player);
				}
				return;
			}
			float num = Mathf.Max(0.01f, 1f + bonus);
			Mathf.Max(0.01f, 1f + value2);
			ApplyPlayerDataMoveSpeedMultiplier((num >= 1f) ? num : 1f);
			AppliedMoveSpeedBonuses[playerId] = bonus;
			try
			{
				player.moveSpeedMult = num;
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[Movement] Failed to apply PlayerAgent moveSpeedMult.", ex);
			}
			RogueLogger.Info($"[StressResponse] Applied PlayerData move speed multiplier x{num:0.00} to player {playerId}.");
		}

		private static void ForceNormalizePlayerMoveSpeed(ulong playerId, PlayerAgent player)
		{
			AppliedMoveSpeedBonuses[playerId] = 0f;
			ApplyPlayerDataMoveSpeedMultiplier(1f);
			try
			{
				player.moveSpeedMult = 1f;
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[FieldMedic] Failed to force-normalize rescuer moveSpeedMult.", ex);
			}
		}

		private static float GetPlayerMovementPercent(ulong playerId, float now)
		{
			return 0f + (Modifiers?.GetTotalPercentForSourcePrefix(RogueModifierKind.MovementSpeed, $"card:StressResponse:{playerId}:", now) ?? 0f) + (Modifiers?.GetTotalPercentForSourcePrefix(RogueModifierKind.MovementSpeed, $"card:FieldMedic:{playerId}:", now) ?? 0f);
		}

		private static bool TryModifyIncomingDamage(PlayerAgent? player, ref float damage)
		{
			if (!StableFormationActive || (Object)(object)player == (Object)null)
			{
				return false;
			}
			RegisterPlayer(player);
			ulong playerId = GetPlayerId(player);
			if (!ActiveScanPlayers.TryGetValue(playerId, out var value) || Time.time > value.ExpiresAt || value.PlayerCount <= 1)
			{
				return false;
			}
			float num = Mathf.Clamp01((float)(value.PlayerCount - 1) * StableFormationDamageReductionPerExtraPlayer);
			damage *= 1f - num;
			RogueLogger.Info($"[StableFormation] Player {playerId} incoming damage reduced by {num:P0}. PlayersInScan={value.PlayerCount}.");
			return true;
		}

		private static bool IsNearActiveScan(Vector3 position)
		{
			//IL_0024: 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)
			RemoveExpiredScanPlayers(Time.time);
			foreach (ScanPresence value in ActiveScanPlayers.Values)
			{
				if (Vector3.Distance(position, value.Position) <= 10f)
				{
					return true;
				}
			}
			return false;
		}

		private static void IncrementSettlementMagazineKills(ulong playerId)
		{
			MagazineKillCounts.TryGetValue(playerId, out var value);
			value++;
			MagazineKillCounts[playerId] = value;
			if (value >= Mathf.Max(1, SettlementKillsRequired))
			{
				SettlementReloadReady[playerId] = true;
				RogueLogger.Info($"[SettlementProtocol] Player {playerId} reached {value} kills in one magazine. Next reload speed +{SettlementReloadSpeedPercent:P0}.");
			}
		}

		private static void ApplyColdBladeNextChargeBuff(ulong playerId)
		{
			Modifiers?.AddOrReplace(new RogueModifier
			{
				SourceId = $"card:ColdBladeRhythm:{playerId}:sleep_kill",
				Kind = RogueModifierKind.MeleeChargeSpeed,
				Percent = ColdBladeNextChargeSpeedPercent,
				Stacks = 1,
				ExpiresAt = Time.time + ColdBladeNextChargeDuration
			});
			RogueLogger.Info($"[ColdBladeRhythm] Player {playerId} killed sleeping enemy. Next charge speed +{ColdBladeNextChargeSpeedPercent:P0} for {ColdBladeNextChargeDuration:0.#}s.");
		}

		private static bool IsEnemyTagged(EnemyAgent? enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return false;
			}
			try
			{
				return enemy.IsTagged || enemy.WasTagged || enemy.EnemyTaggedTimer > 0f;
			}
			catch
			{
				return false;
			}
		}

		private static void RemoveExpiredScanPlayers(float now)
		{
			List<ulong> list = new List<ulong>();
			foreach (KeyValuePair<ulong, ScanPresence> activeScanPlayer in ActiveScanPlayers)
			{
				if (now > activeScanPlayer.Value.ExpiresAt)
				{
					list.Add(activeScanPlayer.Key);
				}
			}
			foreach (ulong item in list)
			{
				ActiveScanPlayers.Remove(item);
			}
		}

		private static void RestoreRuntimeMoveSpeedBonuses()
		{
			ApplyPlayerDataMoveSpeedMultiplier(1f);
			AppliedMoveSpeedBonuses.Clear();
		}

		private static void ApplyPlayerDataMoveSpeedMultiplier(float multiplier)
		{
			try
			{
				if (TryCachePlayerDataBlock())
				{
					multiplier = Mathf.Max(0.01f, multiplier);
					if (!(Mathf.Abs(_appliedPlayerDataMoveMultiplier - multiplier) < 0.0001f) && _playerDataBlock != null)
					{
						_appliedPlayerDataMoveMultiplier = multiplier;
						_playerDataBlock.walkMoveSpeed = _baseWalkMoveSpeed * multiplier;
						_playerDataBlock.runMoveSpeed = _baseRunMoveSpeed * multiplier;
						_playerDataBlock.crouchMoveSpeed = _baseCrouchMoveSpeed * multiplier;
						_playerDataBlock.airMoveSpeed = _baseAirMoveSpeed * multiplier;
					}
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[StressResponse] Failed to apply PlayerData movement speed multiplier.", ex);
			}
		}

		private static bool TryCachePlayerDataBlock()
		{
			if (_playerDataBlock != null)
			{
				return true;
			}
			try
			{
				_playerDataBlock = GameDataBlockBase<PlayerDataBlock>.GetBlock(1u);
				if (_playerDataBlock == null)
				{
					return false;
				}
				_baseWalkMoveSpeed = _playerDataBlock.walkMoveSpeed;
				_baseRunMoveSpeed = _playerDataBlock.runMoveSpeed;
				_baseCrouchMoveSpeed = _playerDataBlock.crouchMoveSpeed;
				_baseAirMoveSpeed = _playerDataBlock.airMoveSpeed;
				RogueLogger.Info($"Cached PlayerData movement speeds. Walk={_baseWalkMoveSpeed:0.00} Run={_baseRunMoveSpeed:0.00} Crouch={_baseCrouchMoveSpeed:0.00} Air={_baseAirMoveSpeed:0.00}");
				return true;
			}
			catch (Exception ex)
			{
				RogueLogger.Error("[StressResponse] Failed to cache PlayerData movement speeds.", ex);
				return false;
			}
		}

		private static void ApplyBloodDebtDrain()
		{
			int num = 0;
			foreach (PlayerAgent value in KnownPlayers.Values)
			{
				if ((Object)(object)value == (Object)null || !((Agent)value).Alive || (Object)(object)value.Damage == (Object)null)
				{
					continue;
				}
				try
				{
					float health = ((Dam_SyncedDamageBase)value.Damage).Health;
					float num2 = Mathf.Max(1f, ((Dam_SyncedDamageBase)value.Damage).HealthMax);
					if (!(health <= 1f))
					{
						float num3 = num2 * 0.01f;
						float num4 = Mathf.Max(1f, health - num3);
						if (!(num4 >= health))
						{
							((Dam_SyncedDamageBase)value.Damage).SendSetHealth(num4);
							float delta = (num4 - health) / num2 * 100f;
							DispatchHealthChanged(value, delta, "BloodDebtDrain");
							num++;
						}
					}
				}
				catch (Exception ex)
				{
					RogueLogger.Error("[BloodDebt] Failed to apply health drain.", ex);
				}
			}
			RogueLogger.Info($"[BloodDebt] Drained 1% max health from {num} living players, clamped above 1 HP.");
		}

		private static PlayerAgent? TryGetPlayer(Agent? agent)
		{
			if ((Object)(object)agent == (Object)null)
			{
				return null;
			}
			PlayerAgent val = (PlayerAgent)(object)((agent is PlayerAgent) ? agent : null);
			if (val != null)
			{
				return val;
			}
			if (agent.GameObjectID > 0 && KnownPlayersByAgentId.TryGetValue(agent.GameObjectID, out PlayerAgent value))
			{
				return value;
			}
			int instanceID = ((Object)agent).GetInstanceID();
			if (instanceID != 0 && KnownPlayersByUnityId.TryGetValue(instanceID, out PlayerAgent value2))
			{
				return value2;
			}
			return TryGetSingleKnownPlayerFallback("damage source");
		}

		private static PlayerAgent? TryGetSingleKnownPlayerFallback(string reason)
		{
			if (KnownPlayers.Count != 1)
			{
				return null;
			}
			using (Dictionary<ulong, PlayerAgent>.ValueCollection.Enumerator enumerator = KnownPlayers.Values.GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					PlayerAgent current = enumerator.Current;
					if (_singlePlayerFallbackLogCount < 4)
					{
						_singlePlayerFallbackLogCount++;
						RogueLogger.Info($"[BloodDebt] Using single known player fallback for {reason}. PlayerId={GetPlayerId(current)} AgentId={((Agent)current).GameObjectID}");
					}
					return current;
				}
			}
			return null;
		}

		private static void LogUnresolvedDamageSource(Agent? sourceAgent)
		{
			if (_unresolvedDamageSourceLogCount < 10)
			{
				_unresolvedDamageSourceLogCount++;
				string text = (((Object)(object)sourceAgent == (Object)null) ? "null" : (((object)sourceAgent).GetType().FullName ?? ((object)sourceAgent).GetType().Name));
				int num = ((sourceAgent != null) ? sourceAgent.GameObjectID : 0);
				int num2 = ((sourceAgent != null) ? ((Object)sourceAgent).GetInstanceID() : 0);
				string text2 = string.Join(",", KnownPlayersByAgentId.Keys);
				RogueLogger.Info($"[BloodDebt] Enemy damage source was not resolved as a player. SourceType={text} SourceAgentId={num} SourceUnityId={num2} KnownPlayerAgentIds=[{text2}] KnownPlayers={KnownPlayers.Count}");
			}
		}

		private static bool IsSamePlayer(PlayerAgent left, PlayerAgent right)
		{
			return GetPlayerId(left) == GetPlayerId(right);
		}

		private static EnemyAgent? GetEnemyFromDamageBase(Dam_EnemyDamageBase damageBase)
		{
			if ((Object)(object)damageBase.Owner != (Object)null)
			{
				return damageBase.Owner;
			}
			Agent baseAgent = ((Dam_SyncedDamageBase)damageBase).GetBaseAgent();
			return (EnemyAgent?)(object)((baseAgent is EnemyAgent) ? baseAgent : null);
		}

		private static ulong GetEnemyInstanceId(EnemyAgent? enemy, Dam_EnemyDamageBase? damageBase)
		{
			if ((Object)(object)enemy != (Object)null)
			{
				return ToStableUnityKey(((Object)enemy).GetInstanceID());
			}
			if ((Object)(object)damageBase != (Object)null)
			{
				Agent baseAgent = ((Dam_SyncedDamageBase)damageBase).GetBaseAgent();
				if ((Object)(object)baseAgent != (Object)null)
				{
					return ToStableUnityKey(((Object)baseAgent).GetInstanceID());
				}
				return ToStableUnityKey(((Object)damageBase).GetInstanceID());
			}
			return 0uL;
		}

		private static ulong ToStableUnityKey(int instanceId)
		{
			if (instanceId != 0)
			{
				return (uint)instanceId;
			}
			return 0uL;
		}

		private static void MirrorResource(Action action)
		{
			try
			{
				_mirroringResource = true;
				action();
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Failed to mirror resource effect.", ex);
			}
			finally
			{
				_mirroringResource = false;
			}
		}
	}
	public static class RogueInputBlocker
	{
		public static bool BlockGameplayInput { get; set; }
	}
	public static class RogueModalCursorGuard
	{
		private static bool _active;

		private static bool _hasCapture;

		private static bool _previousCursorVisible;

		private static CursorLockMode _previousCursorLockState;

		public static void SetModalActive(bool active)
		{
			if (_active == active)
			{
				if (active)
				{
					ForceCursorReleased();
				}
				return;
			}
			_active = active;
			if (_active)
			{
				CaptureIfNeeded();
				ForceCursorReleased();
			}
			else
			{
				Release();
			}
		}

		private static void CaptureIfNeeded()
		{
			//IL_0012: 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)
			if (!_hasCapture)
			{
				_previousCursorVisible = Cursor.visible;
				_previousCursorLockState = Cursor.lockState;
				_hasCapture = true;
			}
		}

		public static void ForceCursorReleased()
		{
			if (_active)
			{
				CaptureIfNeeded();
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}

		private static void Release()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (_hasCapture)
			{
				Cursor.visible = _previousCursorVisible;
				Cursor.lockState = _previousCursorLockState;
				_hasCapture = false;
			}
		}
	}
	public sealed class RogueProcessedEventRegistry
	{
		private readonly Dictionary<string, HashSet<ulong>> _enemyEvents = new Dictionary<string, HashSet<ulong>>();

		private readonly Dictionary<string, HashSet<ulong>> _playerEvents = new Dictionary<string, HashSet<ulong>>();

		public bool TryMarkEnemy(ulong enemyInstanceId, string channel)
		{
			if (enemyInstanceId == 0L || string.IsNullOrWhiteSpace(channel))
			{
				return true;
			}
			return TryMark(_enemyEvents, channel, enemyInstanceId);
		}

		public bool TryMarkPlayer(ulong playerId, string channel)
		{
			if (playerId == 0L || string.IsNullOrWhiteSpace(channel))
			{
				return true;
			}
			return TryMark(_playerEvents, channel, playerId);
		}

		public void Clear()
		{
			_enemyEvents.Clear();
			_playerEvents.Clear();
		}

		public void ClearChannel(string channel)
		{
			_enemyEvents.Remove(channel);
			_playerEvents.Remove(channel);
		}

		private static bool TryMark(Dictionary<string, HashSet<ulong>> registry, string channel, ulong key)
		{
			if (!registry.TryGetValue(channel, out HashSet<ulong> value))
			{
				value = (registry[channel] = new HashSet<ulong>());
			}
			return value.Add(key);
		}
	}
	[Flags]
	public enum RogueTriggerGuardFlags
	{
		None = 0,
		DamageTriggers = 1,
		KillTriggers = 2,
		HealthTriggers = 4,
		ResourceTriggers = 8,
		ExplosionTriggers = 0x10,
		CardTriggers = 0x20,
		CorruptionTriggers = 0x40
	}
	public sealed class RogueTriggerGuard
	{
		private sealed class Scope : IDisposable
		{
			private readonly RogueTriggerGuard _owner;

			private readonly RogueTriggerGuardFlags _flags;

			private bool _disposed;

			public Scope(RogueTriggerGuard owner, RogueTriggerGuardFlags flags)
			{
				_owner = owner;
				_flags = flags;
			}

			public void Dispose()
			{
				if (!_disposed)
				{
					_disposed = true;
					_owner.Remove(_flags);
				}
			}
		}

		private readonly Dictionary<RogueTriggerGuardFlags, int> _counts = new Dictionary<RogueTriggerGuardFlags, int>();

		public bool Allows(RogueTriggerGuardFlags flags)
		{
			if (flags == RogueTriggerGuardFlags.None)
			{
				return true;
			}
			foreach (RogueTriggerGuardFlags value2 in Enum.GetValues(typeof(RogueTriggerGuardFlags)))
			{
				if (value2 != 0 && flags.HasFlag(value2) && _counts.TryGetValue(value2, out var value) && value > 0)
				{
					return false;
				}
			}
			return true;
		}

		public IDisposable Suppress(RogueTriggerGuardFlags flags)
		{
			Add(flags);
			return new Scope(this, flags);
		}

		public void Clear()
		{
			_counts.Clear();
		}

		private void Add(RogueTriggerGuardFlags flags)
		{
			foreach (RogueTriggerGuardFlags value2 in Enum.GetValues(typeof(RogueTriggerGuardFlags)))
			{
				if (value2 != 0 && flags.HasFlag(value2))
				{
					_counts.TryGetValue(value2, out var value);
					_counts[value2] = value + 1;
				}
			}
		}

		private void Remove(RogueTriggerGuardFlags flags)
		{
			foreach (RogueTriggerGuardFlags value2 in Enum.GetValues(typeof(RogueTriggerGuardFlags)))
			{
				if (value2 != 0 && flags.HasFlag(value2) && _counts.TryGetValue(value2, out var value))
				{
					if (value <= 1)
					{
						_counts.Remove(value2);
					}
					else
					{
						_counts[value2] = value - 1;
					}
				}
			}
		}
	}
	public static class RogueWatermarkOverride
	{
		public const string Text = "<color=#00BFFF>Kain</color> <color=#FFCC00>ROGUE PROTOCOL</color> <color=#FFB000>DEV BUILD</color>";

		private static float _nextScanTime;

		private static bool _loggedApply;

		public static void Tick(float now)
		{
			if (!(now < _nextScanTime))
			{
				_nextScanTime = now + 0.5f;
				PUI_Watermark[] array;
				try
				{
					array = Il2CppArrayBase<PUI_Watermark>.op_Implicit(Object.FindObjectsOfType<PUI_Watermark>());
				}
				catch (Exception ex)
				{
					RogueLogger.Warning("Watermark scan failed: " + ex.Message);
					return;
				}
				for (int i = 0; i < array.Length; i++)
				{
					Apply(array[i]);
				}
			}
		}

		public static void Apply(PUI_Watermark instance)
		{
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_watermarkText == (Object)null))
			{
				((TMP_Text)instance.m_watermarkText).SetText("<color=#00BFFF>Kain</color> <color=#FFCC00>ROGUE PROTOCOL</color> <color=#FFB000>DEV BUILD</color>", true);
				if (!_loggedApply)
				{
					_loggedApply = true;
					RogueLogger.Info("KRP watermark override applied.");
				}
			}
		}
	}
}
namespace KainRogueProtocol.Patches
{
	[HarmonyPatch]
	public static class RogueGameplayPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerAgent), "Update")]
		public static void PlayerAgent_Update_Postfix(PlayerAgent __instance)
		{
			PlayerAgent __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.RegisterPlayer(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerAgent), "GiveHealth")]
		public static void PlayerAgent_GiveHealth_Postfix(PlayerAgent __instance, PlayerAgent giverAgent, float amountRel)
		{
			PlayerAgent __instance2 = __instance;
			PlayerAgent giverAgent2 = giverAgent;
			Safe(delegate
			{
				RogueGameplayRuntime.OnGiveHealth(__instance2, giverAgent2, amountRel);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerAgent), "GiveDisinfection")]
		public static void PlayerAgent_GiveDisinfection_Postfix(PlayerAgent __instance, PlayerAgent giverAgent, float amountRel)
		{
			PlayerAgent __instance2 = __instance;
			PlayerAgent giverAgent2 = giverAgent;
			Safe(delegate
			{
				RogueGameplayRuntime.OnGiveDisinfection(__instance2, giverAgent2, amountRel);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerAgent), "GiveAmmoRel")]
		public static void PlayerAgent_GiveAmmoRel_Postfix(PlayerAgent __instance, PlayerAgent giverAgent, float ammoStandardRel, float ammoSpecialRel, float ammoClassRel)
		{
			PlayerAgent __instance2 = __instance;
			PlayerAgent giverAgent2 = giverAgent;
			Safe(delegate
			{
				RogueGameplayRuntime.OnGiveAmmo(__instance2, giverAgent2, ammoStandardRel, ammoSpecialRel, ammoClassRel);
			});
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveBulletDamage")]
		public static void Player_ReceiveBulletDamage_Prefix(Dam_PlayerDamageLocal __instance, ref pBulletDamageData data)
		{
			try
			{
				RogueGameplayRuntime.ModifyIncomingDamage(((Dam_PlayerDamageBase)__instance).Owner, ref data);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue incoming bullet damage patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveMeleeDamage")]
		public static void Player_ReceiveMeleeDamage_Prefix(Dam_PlayerDamageLocal __instance, ref pFullDamageData data)
		{
			try
			{
				RogueGameplayRuntime.ModifyIncomingDamage(((Dam_PlayerDamageBase)__instance).Owner, ref data);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue incoming melee damage patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveExplosionDamage")]
		public static void Player_ReceiveExplosionDamage_Prefix(Dam_PlayerDamageLocal __instance, ref pExplosionDamageData data)
		{
			try
			{
				RogueGameplayRuntime.ModifyIncomingDamage(((Dam_PlayerDamageBase)__instance).Owner, ref data);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue incoming explosion damage patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveFireDamage")]
		public static void Player_ReceiveFireDamage_Prefix(Dam_PlayerDamageLocal __instance, ref pSmallDamageData data)
		{
			try
			{
				RogueGameplayRuntime.ModifyIncomingDamage(((Dam_PlayerDamageBase)__instance).Owner, ref data);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue incoming fire damage patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "BulletDamage")]
		public static void Enemy_BulletDamage_Prefix(Dam_EnemyDamageBase __instance, Agent sourceAgent, ref float dam, int limbID)
		{
			try
			{
				RogueGameplayRuntime.OnEnemyDamage(__instance, sourceAgent, ref dam, IsWeakspotLimb(__instance, limbID), isMelee: false);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue bullet damage patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "MeleeDamage")]
		public static void Enemy_MeleeDamage_Prefix(Dam_EnemyDamageBase __instance, Agent sourceAgent, ref float dam, int limbID, float sleeperMulti)
		{
			try
			{
				RogueGameplayRuntime.OnEnemyDamage(__instance, sourceAgent, ref dam, IsWeakspotLimb(__instance, limbID), isMelee: true, sleeperMulti > 1.01f);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue melee damage patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(EnemyAgent), "OnTakeDamage")]
		public static void EnemyAgent_OnTakeDamage_Postfix(EnemyAgent __instance, float damage, Agent damageSource)
		{
			EnemyAgent __instance2 = __instance;
			Agent damageSource2 = damageSource;
			Safe(delegate
			{
				RogueGameplayRuntime.OnEnemyAgentTakeDamage(__instance2, damage, damageSource2, isWeakspot: false);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(EnemyAgent), "OnDead")]
		public static void EnemyAgent_OnDead_Postfix(EnemyAgent __instance)
		{
			EnemyAgent __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnEnemyDead(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveBulletDamage")]
		public static void Player_ReceiveBulletDamage_Postfix(Dam_PlayerDamageLocal __instance, pBulletDamageData data)
		{
			//IL_000d: 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)
			Dam_PlayerDamageLocal __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnPlayerDamage(((Dam_PlayerDamageBase)__instance2).Owner, ((UFloat16)(ref data.damage)).Get(100f), "BulletDamage");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveMeleeDamage")]
		public static void Player_ReceiveMeleeDamage_Postfix(Dam_PlayerDamageLocal __instance, pFullDamageData data)
		{
			//IL_000d: 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)
			Dam_PlayerDamageLocal __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnPlayerDamage(((Dam_PlayerDamageBase)__instance2).Owner, ((UFloat16)(ref data.damage)).Get(100f), "MeleeDamage");
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveExplosionDamage")]
		public static void Player_ReceiveExplosionDamage_Postfix(Dam_PlayerDamageLocal __instance, pExplosionDamageData data)
		{
			//IL_000d: 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)
			Dam_PlayerDamageLocal __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnPlayerDamage(((Dam_PlayerDamageBase)__instance2).Owner, ((UFloat16)(ref data.damage)).Get(100f), "ExplosionDamage");
			});
		}

		private static void Safe(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue gameplay patch failed.", ex);
			}
		}

		private static bool IsWeakspotLimb(Dam_EnemyDamageBase damageBase, int limbID)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)damageBase == (Object)null || limbID < 0 || damageBase.DamageLimbs == null || limbID >= ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)damageBase.DamageLimbs).Count)
				{
					return false;
				}
				Dam_EnemyDamageLimb val = ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)damageBase.DamageLimbs)[limbID];
				return (Object)(object)val != (Object)null && (int)val.m_type == 1;
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue weakspot limb check failed.", ex);
				return false;
			}
		}
	}
	[HarmonyPatch]
	public static class RogueFirstPhaseGameplayPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(BulletWeapon), "Fire")]
		public static void BulletWeapon_Fire_Prefix(BulletWeapon __instance)
		{
			BulletWeapon __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnBulletWeaponFire(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(BulletWeapon), "Update")]
		public static void BulletWeapon_Update_Postfix(BulletWeapon __instance)
		{
			BulletWeapon __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnBulletWeaponReloadState(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(BulletWeapon), "OnWield")]
		public static void BulletWeapon_OnWield_Postfix(BulletWeapon __instance)
		{
			BulletWeapon __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnBulletWeaponWield(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(BulletWeapon), "get_ReloadTime")]
		public static void BulletWeapon_ReloadTime_Postfix(BulletWeapon __instance, ref float __result)
		{
			try
			{
				__result = RogueGameplayRuntime.ModifyReloadTime(((Item)__instance).Owner, __result);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue reload-time patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MeleeWeaponFirstPerson), "get_MeleeSpeedModifier")]
		public static void MeleeWeapon_SpeedModifier_Postfix(MeleeWeaponFirstPerson __instance, ref float __result)
		{
			try
			{
				__result *= RogueGameplayRuntime.GetColdBladeMeleeSpeedMultiplier(((Item)__instance).Owner);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue melee-speed patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CP_Bioscan_Core), "Update")]
		public static void Bioscan_Update_Postfix(CP_Bioscan_Core __instance)
		{
			CP_Bioscan_Core __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnBioscanUpdated(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance_Detection), "UpdateDetection")]
		public static void SentryDetection_Update_Postfix(SentryGunInstance_Detection __instance)
		{
			SentryGunInstance_Detection __instance2 = __instance;
			Safe(delegate
			{
				RogueGameplayRuntime.OnSentryDetectionUpdate(__instance2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SentryGunInstance), "CalcCostOfBullet")]
		public static void Sentry_CalcCostOfBullet_Postfix(SentryGunInstance __instance, ref float __result)
		{
			try
			{
				RogueGameplayRuntime.ModifySentryBulletCost(__instance, ref __result);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue sentry ammo-cost patch failed.", ex);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ProjectileManager), "DoSpawnGlueOnDoor")]
		public static void ProjectileManager_DoSpawnGlueOnDoor_Prefix(ref pSpawnGlueOnDoor data)
		{
			try
			{
				RogueGameplayRuntime.ModifyGlueOnDoorPacket(ref data);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue glue-on-door patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Dam_EnemyDamageBase), "AddToTotalGlueVolume")]
		public static void EnemyDamageBase_AddToTotalGlueVolume_Postfix(Dam_EnemyDamageBase __instance)
		{
			try
			{
				RogueGameplayRuntime.OnEnemyGlueVolumeUpdated(__instance);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue enemy glue-fade runtime patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Interact_Revive), "Setup")]
		public static void Revive_Setup_Postfix(Interact_Revive __instance, PlayerAgent owner)
		{
			Interact_Revive __instance2 = __instance;
			PlayerAgent owner2 = owner;
			Safe(delegate
			{
				RogueGameplayRuntime.OnReviveSetup(__instance2, owner2);
			});
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Interact_Revive), "ApplySpeedModifier")]
		public static void Revive_ApplySpeedModifier_Postfix(Interact_Revive __instance, PlayerAgent sourceAgent, ref float __result)
		{
			try
			{
				__result = RogueGameplayRuntime.ModifyReviveSpeed(__instance, sourceAgent, __result);
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue revive-speed patch failed.", ex);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Interact_Revive), "TriggerInteractionAction")]
		public static void Revive_TriggerInteractionAction_Postfix(Interact_Revive __instance, PlayerAgent source)
		{
			Interact_Revive __instance2 = __instance;
			PlayerAgent source2 = source;
			Safe(delegate
			{
				RogueGameplayRuntime.OnReviveCompleted(__instance2, source2);
			});
		}

		private static void Safe(Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Rogue first phase gameplay patch failed.", ex);
			}
		}
	}
	[HarmonyPatch]
	public static class RogueInputMapperBooleanPatches
	{
		private static readonly string[] BooleanMethods = new string[12]
		{
			"GetButton", "GetButtonDown", "GetButtonUp", "GetButtonKeyMouse", "GetButtonDownKeyMouse", "GetButtonUpKeyMouse", "GetButtonKeyMouseGamepad", "GetButtonDownKeyMouseGamepad", "GetButtonUpKeyMouseGamepad", "GetButtonPlayerBot",
			"GetButtonDownPlayerBot", "GetButtonUpPlayerBot"
		};

		public static bool Prepare()
		{
			return RogueInputMapperPatchTargets.HasAny(BooleanMethods, typeof(bool));
		}

		public static IEnumerable<MethodBase> TargetMethods()
		{
			foreach (MethodBase item in RogueInputMapperPatchTargets.Find(BooleanMethods, typeof(bool)))
			{
				yield return item;
			}
		}

		public static bool Prefix(ref bool __result)
		{
			if (!RogueInputBlocker.BlockGameplayInput)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch]
	public static class RogueInputMapperFloatPatches
	{
		private static readonly string[] FloatMethods = new string[4] { "GetAxis", "GetAxisKeyMouse", "GetAxisKeyMouseGamepad", "GetAxisPlayerBot" };

		public static bool Prepare()
		{
			return RogueInputMapperPatchTargets.HasAny(FloatMethods, typeof(float));
		}

		public static IEnumerable<MethodBase> TargetMethods()
		{
			foreach (MethodBase item in RogueInputMapperPatchTargets.Find(FloatMethods, typeof(float)))
			{
				yield return item;
			}
		}

		public static bool Prefix(ref float __result)
		{
			if (!RogueInputBlocker.BlockGameplayInput)
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
	[HarmonyPatch]
	public static class RogueInputMapperVector2Patches
	{
		private static readonly string[] Vector2Methods = new string[2] { "GetMouseLook", "GetMouseLookRaw" };

		public static bool Prepare()
		{
			return RogueInputMapperPatchTargets.HasAny(Vector2Methods, typeof(Vector2));
		}

		public static IEnumerable<MethodBase> TargetMethods()
		{
			foreach (MethodBase item in RogueInputMapperPatchTargets.Find(Vector2Methods, typeof(Vector2)))
			{
				yield return item;
			}
		}

		public static bool Prefix(ref Vector2 __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!RogueInputBlocker.BlockGameplayInput)
			{
				return true;
			}
			__result = Vector2.zero;
			return false;
		}
	}
	public static class RogueInputMapperPatchTargets
	{
		public static bool HasAny(string[] methodNames, Type returnType)
		{
			return Find(methodNames, returnType).Any();
		}

		public static IEnumerable<MethodBase> Find(string[] methodNames, Type returnType)
		{
			Type type = AccessTools.TypeByName("InputMapper");
			if (type == null)
			{
				RogueLogger.Warning("Could not find GTFO InputMapper type. KRP UI will not be able to block gameplay input.");
				yield break;
			}
			List<MethodInfo> methods = AccessTools.GetDeclaredMethods(type);
			foreach (string methodName in methodNames)
			{
				foreach (MethodInfo item in methods)
				{
					if (item.Name == methodName && item.ReturnType == returnType)
					{
						yield return item;
					}
				}
			}
		}
	}
}
namespace KainRogueProtocol.Patches.UI
{
	[HarmonyPatch(typeof(PUI_Watermark), "UpdateWatermark")]
	[HarmonyAfter(new string[] { "com.dak.MTFO" })]
	[HarmonyPriority(0)]
	internal static class Patch_PUI_Watermark_UpdateWatermark
	{
		private static void Postfix(PUI_Watermark __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.m_watermarkText == (Object)null))
			{
				((TMP_Text)__instance.m_watermarkText).SetText("<color=#00BFFF>Kain</color> <color=#FFCC00>ROGUE PROTOCOL</color> <color=#FFB000>DEV BUILD</color>", true);
			}
		}
	}
}
namespace KainRogueProtocol.Networking
{
	public sealed class RogueHostAuthority
	{
		public bool IsHost()
		{
			return true;
		}

		public bool TryRunHostOnly(string operationName)
		{
			if (IsHost())
			{
				return true;
			}
			RogueLogger.Warning("Blocked non-host operation: " + operationName);
			return false;
		}

		public bool TryRollCorruptions(CorruptionCardManager corruptions, string expeditionId, string difficulty, int? seed = null)
		{
			if (!TryRunHostOnly("RollCorruptions"))
			{
				return false;
			}
			corruptions.RollForLobby(expeditionId, difficulty, seed);
			corruptions.ApplyPreGeneration();
			return true;
		}
	}
	public enum RoguePacketType
	{
		SyncFullState,
		SyncDeltaState,
		RequestRewardChoice,
		ConfirmRewardChoice,
		RejectRewardChoice,
		OpenRewardPanel,
		CloseRewardPanel,
		ApplyEffect,
		RemoveEffect,
		DebugCommand,
		LateJoinRequest
	}
	public sealed class RogueNetPacket
	{
	}
	public sealed class RogueNetworkSync
	{
		private readonly CorruptionCardManager _corruptions;

		public RogueNetworkSync(CorruptionCardManager corruptions)
		{
			_corruptions = corruptions;
		}

		public CorruptionRunSnapshot CreateCorruptionSnapshot()
		{
			CorruptionRunSnapshot corruptionRunSnapshot = _corruptions.CreateSnapshot();
			RogueLogger.Info(string.Format("Created corruption sync snapshot. Seed={0} Cards={1}", corruptionRunSnapshot.Seed, string.Join(",", corruptionRunSnapshot.ActiveCorruptionIds)));
			return corruptionRunSnapshot;
		}

		public void ApplyCorruptionSnapshot(CorruptionRunSnapshot snapshot)
		{
			_corruptions.ApplySnapshot(snapshot);
			RogueLogger.Info($"Applied corruption sync snapshot. Seed={snapshot.Seed} Cards={snapshot.ActiveCorruptionIds.Count}");
		}

		public string DumpSnapshot(CorruptionRunSnapshot snapshot)
		{
			string text = ((snapshot.ActiveCorruptionIds.Count == 0) ? "(none)" : string.Join(", ", snapshot.ActiveCorruptionIds));
			return $"CorruptionSnapshot Seed={snapshot.Seed} Expedition={snapshot.ExpeditionId} Difficulty={snapshot.Difficulty} PreGenerationReady={snapshot.PreGenerationReady} Revealed={snapshot.HasShownIntroUi} Cards=[{text}]";
		}
	}
}
namespace KainRogueProtocol.Modifiers
{
	public sealed class RogueModifier
	{
		public string SourceId { get; set; } = string.Empty;


		public RogueModifierKind Kind { get; set; }

		public float Percent { get; set; }

		public float ExpiresAt { get; set; } = -1f;


		public int Stacks { get; set; } = 1;


		public bool IsExpired(float now)
		{
			if (ExpiresAt >= 0f)
			{
				return now >= ExpiresAt;
			}
			return false;
		}
	}
	public enum RogueModifierKind
	{
		WeaponDamage,
		MeleeDamage,
		WeakspotDamage,
		MovementSpeed,
		ReloadSpeed,
		ScanSpeed,
		ResourceEfficiency,
		ToolEfficiency,
		IncomingDamage,
		EnemyDamage,
		EnemyRegeneration,
		MeleeChargeSpeed
	}
	public sealed class RogueModifierRegistry
	{
		private readonly List<RogueModifier> _modifiers = new List<RogueModifier>();

		public IReadOnlyList<RogueModifier> Modifiers => _modifiers;

		public void AddOrReplace(RogueModifier modifier)
		{
			RogueModifier modifier2 = modifier;
			_modifiers.RemoveAll((RogueModifier existing) => existing.SourceId == modifier2.SourceId && existing.Kind == modifier2.Kind);
			_modifiers.Add(modifier2);
		}

		public void ClearSource(string sourceId)
		{
			string sourceId2 = sourceId;
			_modifiers.RemoveAll((RogueModifier modifier) => modifier.SourceId == sourceId2);
		}

		public void ClearSourcePrefix(string sourcePrefix)
		{
			string sourcePrefix2 = sourcePrefix;
			_modifiers.RemoveAll((RogueModifier modifier) => modifier.SourceId.StartsWith(sourcePrefix2, StringComparison.OrdinalIgnoreCase));
		}

		public void RemoveExpired(float now)
		{
			_modifiers.RemoveAll((RogueModifier modifier) => modifier.IsExpired(now));
		}

		public float GetTotalPercent(RogueModifierKind kind, float now)
		{
			RemoveExpired(now);
			return _modifiers.Where((RogueModifier modifier) => modifier.Kind == kind).Sum((RogueModifier modifier) => modifier.Percent * (float)modifier.Stacks);
		}

		public float GetTotalPercentForSourcePrefix(RogueModifierKind kind, string sourcePrefix, float now)
		{
			string sourcePrefix2 = sourcePrefix;
			RemoveExpired(now);
			return _modifiers.Where((RogueModifier modifier) => modifier.Kind == kind && modifier.SourceId.StartsWith(sourcePrefix2, StringComparison.OrdinalIgnoreCase)).Sum((RogueModifier modifier) => modifier.Percent * (float)modifier.Stacks);
		}

		public string Dump(float now)
		{
			RemoveExpired(now);
			if (_modifiers.Count != 0)
			{
				return "Modifiers=" + string.Join(", ", _modifiers.Select((RogueModifier modifier) => $"{modifier.SourceId}:{modifier.Kind}:{modifier.Percent:P0}x{modifier.Stacks}"));
			}
			return "Modifiers=(none)";
		}
	}
}
namespace KainRogueProtocol.Integration
{
	public sealed class EECIntegration
	{
	}
	public sealed class ExtraObjectiveIntegration
	{
	}
	public sealed class MTFOIntegration
	{
	}
}
namespace KainRogueProtocol.Events
{
	public sealed class EnemyDamagedContext
	{
		public ulong AttackerPlayerId { get; set; }

		public ulong EnemyInstanceId { get; set; }

		public uint EnemyDataId { get; set; }

		public float Damage { get; set; }

		public bool IsWeakspot { get; set; }

		public bool IsMelee { get; set; }

		public float Timestamp { get; set; }
	}
	public sealed class EnemyKilledContext
	{
		public ulong KillerPlayerId { get; set; }

		public ulong EnemyInstanceId { get; set; }

		public uint EnemyDataId { get; set; }

		public bool LastHitWasMelee { get; set; }

		public bool LastHitWasWeakspot { get; set; }

		public float Timestamp { get; set; }
	}
	public sealed class MeleeHitContext
	{
		public ulong AttackerPlayerId { get; set; }

		public ulong EnemyInstanceId { get; set; }

		public uint EnemyDataId { get; set; }

		public float ChargeValue { get; set; }

		public float Timestamp { get; set; }

		public bool IsFullCharge => ChargeValue >= 0.95f;
	}
	public sealed class ResourcePackUsedContext
	{
		public ulong UserPlayerId { get; set; }

		public ulong TargetPlayerId { get; set; }

		public string ResourceType { get; set; } = string.Empty;


		public float Amount { get; set; }

		public float Timestamp { get; set; }

		public bool UsedOnOtherPlayer => UserPlayerId != TargetPlayerId;
	}
	public sealed class HealthChangedContext
	{
		public ulong PlayerId { get; set; }

		public float OldHealth { get; set; }

		public float NewHealth { get; set; }

		public string Reason { get; set; } = string.Empty;


		public float Timestamp { get; set; }

		public float Delta => NewHealth - OldHealth;
	}
	public sealed class RogueEventDispatcher
	{
		private readonly List<IRogueEventListener> _listeners = new List<IRogueEventListener>();

		public void Register(IRogueEventListener listener)
		{
			if (!_listeners.Contains(listener))
			{
				_listeners.Add(listener);
				RogueLogger.Info("Registered event listener " + listener.GetType().Name + ".");
			}
		}

		public void Clear()
		{
			_listeners.Clear();
		}

		public void OnEnemyDamaged(EnemyDamagedContext context)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IOnEnemyDamaged onEnemyDamaged)
				{
					onEnemyDamaged.OnEnemyDamaged(context);
				}
			}
		}

		public void OnEnemyKilled(EnemyKilledContext context)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IOnEnemyKilled onEnemyKilled)
				{
					onEnemyKilled.OnEnemyKilled(context);
				}
			}
		}

		public void OnMeleeHit(MeleeHitContext context)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IOnMeleeHit onMeleeHit)
				{
					onMeleeHit.OnMeleeHit(context);
				}
			}
		}

		public void OnResourcePackUsed(ResourcePackUsedContext context)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IOnResourcePackUsed onResourcePackUsed)
				{
					onResourcePackUsed.OnResourcePackUsed(context);
				}
			}
		}

		public void OnHealthChanged(HealthChangedContext context)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IOnHealthChanged onHealthChanged)
				{
					onHealthChanged.OnHealthChanged(context);
				}
			}
		}

		public void Tick(float now)
		{
			foreach (IRogueEventListener listener in _listeners)
			{
				if (listener is IRuntimeRuleTick runtimeRuleTick)
				{
					runtimeRuleTick.OnRuntimeTick(now);
				}
			}
		}
	}
	public interface IRogueEventListener
	{
	}
	public interface IOnEnemyDamaged : IRogueEventListener
	{
		void OnEnemyDamaged(EnemyDamagedContext context);
	}
	public interface IOnEnemyKilled : IRogueEventListener
	{
		void OnEnemyKilled(EnemyKilledContext context);
	}
	public interface IOnMeleeHit : IRogueEventListener
	{
		void OnMeleeHit(MeleeHitContext context);
	}
	public interface IOnResourcePackUsed : IRogueEventListener
	{
		void OnResourcePackUsed(ResourcePackUsedContext context);
	}
	public interface IOnHealthChanged : IRogueEventListener
	{
		void OnHealthChanged(HealthChangedContext context);
	}
	public interface IRuntimeRuleTick : IRogueEventListener
	{
		void OnRuntimeTick(float now);
	}
}
namespace KainRogueProtocol.Effects
{
	public sealed class BulletTaxEffect : IRogueEffect
	{
		public string Type => "BulletTax";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.BulletTaxActive = true;
			RogueGameplayRuntime.BulletTaxAmmoStandardRel = GetFloat(effect, "AmmoStandardRel", 0.05f);
			RogueGameplayRuntime.BulletTaxAmmoSpecialRel = GetFloat(effect, "AmmoSpecialRel", 0.05f);
			RogueGameplayRuntime.BulletTaxLargeEnemyHealthThreshold = GetFloat(effect, "LargeEnemyHealthThreshold", 40f);
			RogueGameplayRuntime.BulletTaxLargeEnemyIds = GetUIntSet(effect, "LargeEnemyIds");
			RogueLogger.Info($"[BulletTax] Armed. Configured large enemy ids={RogueGameplayRuntime.BulletTaxLargeEnemyIds.Count}. Health threshold={RogueGameplayRuntime.BulletTaxLargeEnemyHealthThreshold:0.#}. Ammo refund={RogueGameplayRuntime.BulletTaxAmmoStandardRel:P0}/{RogueGameplayRuntime.BulletTaxAmmoSpecialRel:P0}.");
		}

		private static float GetFloat(RogueCardEffect effect, string key, float fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is double num))
			{
				if (!(value is float result))
				{
					if (!(value is long num2))
					{
						if (value is int num3)
						{
							return num3;
						}
						return fallback;
					}
					return num2;
				}
				return result;
			}
			return (float)num;
		}

		private static HashSet<uint> GetUIntSet(RogueCardEffect effect, string key)
		{
			HashSet<uint> hashSet = new HashSet<uint>();
			if (!effect.Parameters.TryGetValue(key, out object value) || !(value is List<object> list))
			{
				return hashSet;
			}
			foreach (object item in list)
			{
				if (!(item is long num))
				{
					if (!(item is double num2))
					{
						if (item is int num3 && num3 > 0)
						{
							hashSet.Add((uint)num3);
						}
					}
					else if (num2 > 0.0)
					{
						hashSet.Add((uint)num2);
					}
				}
				else if (num > 0)
				{
					hashSet.Add((uint)num);
				}
			}
			return hashSet;
		}
	}
	public sealed class CardEffectDispatcher
	{
		private readonly Dictionary<string, IRogueEffect> _effects = new Dictionary<string, IRogueEffect>(StringComparer.OrdinalIgnoreCase);

		private readonly RogueEventDispatcher _events;

		private readonly RogueModifierRegistry _modifiers;

		public CardEffectDispatcher(RogueEventDispatcher events, RogueModifierRegistry modifiers)
		{
			_events = events;
			_modifiers = modifiers;
		}

		public void RegisterDefaults()
		{
			Register(new LogOnlyEffect("LogOnly"));
			Register(new LogOnlyEffect("AddCardToState"));
			Register(new LogOnlyEffect("ModifyMoveSpeed"));
			Register(new LogOnlyEffect("RestoreHealth"));
			Register(new LogOnlyEffect("AddCurrency"));
			Register(new MutualSupplyEffect());
			Register(new CoordinatedHeavyStrikeEffect());
			Register(new StressResponseEffect(_modifiers));
			Register(new ChamberEffect());
			Register(new SoulSiphonStrikeEffect());
			Register(new BulletTaxEffect());
			Register(new ColdBladeRhythmEffect());
			Register(new StableFormationEffect());
			Register(new DefenseCalibrationEffect());
			Register(new SettlementProtocolEffect());
			Register(new RapidHardeningEffect());
			Register(new DoorSealExpertEffect());
			Register(new TrackingCalibrationEffect());
			Register(new FieldMedicEffect());
			Register(new BackstabProtocolEffect());
			Register(new PrecisionRecycleEffect());
			Register(new DataBackflowEffect());
			Register(new CrossfireEffect());
		}

		public void Register(IRogueEffect effect)
		{
			_effects[effect.Type] = effect;
			if (effect is IRogueEventListener listener)
			{
				_events.Register(listener);
			}
		}

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			if (!_effects.TryGetValue(effect.Type, out IRogueEffect value))
			{
				RogueLogger.Warning($"No card effect handler registered for '{effect.Type}' on card {sourceCard.PersistentID}:{sourceCard.Name}.");
			}
			else
			{
				value.Apply(effect, sourceCard, state);
			}
		}
	}
	public sealed class ChamberEffect : IRogueEffect
	{
		public string Type => "Chamber";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.ChamberActive = true;
			RogueGameplayRuntime.ChamberDamageMultiplier = GetFloat(effect, "DamageMultiplier", 3f);
			RogueGameplayRuntime.ChamberReadySeconds = GetFloat(effect, "ReadySeconds", 3f);
			RogueLogger.Info($"[Chamber] Armed. First bullet fired from a full magazine deals x{RogueGameplayRuntime.ChamberDamageMultiplier:0.#} damage on its next hit.");
		}

		private static float GetFloat(RogueCardEffect effect, string key, float fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is double num))
			{
				if (!(value is float result))
				{
					if (!(value is long num2))
					{
						if (value is int num3)
						{
							return num3;
						}
						return fallback;
					}
					return num2;
				}
				return result;
			}
			return (float)num;
		}
	}
	public sealed class CoordinatedHeavyStrikeEffect : IRogueEffect, IOnMeleeHit, IRogueEventListener
	{
		private readonly struct LastFullChargeHit
		{
			public ulong PlayerId { get; }

			public float Timestamp { get; }

			public LastFullChargeHit(ulong playerId, float timestamp)
			{
				PlayerId = playerId;
				Timestamp = timestamp;
			}
		}

		private readonly Dictionary<ulong, LastFullChargeHit> _lastHits = new Dictionary<ulong, LastFullChargeHit>();

		private readonly Dictionary<ulong, float> _enemyCooldowns = new Dictionary<ulong, float>();

		private bool _active;

		public string Type => "CoordinatedHeavyStrike";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			_active = true;
			RogueGameplayRuntime.CoordinatedHeavyStrikeActive = true;
			RogueLogger.Info("[CoordinatedHeavyStrike] Skeleton armed. Full-charge ally melee window=3s cooldown=8s.");
		}

		public void OnMeleeHit(MeleeHitContext context)
		{
			if (_active && context.IsFullCharge)
			{
				if (_lastHits.TryGetValue(context.EnemyInstanceId, out var value) && value.PlayerId != context.AttackerPlayerId && context.Timestamp - value.Timestamp <= 3f && (!_enemyCooldowns.TryGetValue(context.EnemyInstanceId, out var value2) || context.Timestamp >= value2))
				{
					_enemyCooldowns[context.EnemyInstanceId] = context.Timestamp + 8f;
					RogueLogger.Info($"[CoordinatedHeavyStrike] Would deal 20% max-health bonus damage to enemy {context.EnemyInstanceId}.");
				}
				_lastHits[context.EnemyInstanceId] = new LastFullChargeHit(context.AttackerPlayerId, context.Timestamp);
			}
		}
	}
	public sealed class EffectRegistry
	{
		private readonly Dictionary<string, IRogueEffect> _effects = new Dictionary<string, IRogueEffect>(StringComparer.OrdinalIgnoreCase);

		public void RegisterDefaults()
		{
			Register(new LogOnlyEffect("LogOnly"));
			Register(new LogOnlyEffect("AddCardToState"));
			Register(new LogOnlyEffect("ModifyMoveSpeed"));
			Register(new LogOnlyEffect("RestoreHealth"));
			Register(new LogOnlyEffect("AddCurrency"));
		}

		public void Register(IRogueEffect effect)
		{
			_effects[effect.Type] = effect;
		}

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			if (!_effects.TryGetValue(effect.Type, out IRogueEffect value))
			{
				RogueLogger.Warning($"No effect handler registered for '{effect.Type}' on card {sourceCard.PersistentID}:{sourceCard.Name}.");
			}
			else
			{
				value.Apply(effect, sourceCard, state);
			}
		}
	}
	public sealed class ColdBladeRhythmEffect : IRogueEffect
	{
		public string Type => "ColdBladeRhythm";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.ColdBladeRhythmActive = true;
			RogueGameplayRuntime.ColdBladeChargeSpeedPercent = EffectParameters.GetFloat(effect, "ChargeSpeedPercent", 0.25f);
			RogueGameplayRuntime.ColdBladeNextChargeSpeedPercent = EffectParameters.GetFloat(effect, "NextChargeSpeedPercent", 0.25f);
			RogueGameplayRuntime.ColdBladeNextChargeDuration = EffectParameters.GetFloat(effect, "DurationSeconds", 8f);
			RogueLogger.Info($"[ColdBladeRhythm] Armed. Charge +{RogueGameplayRuntime.ColdBladeChargeSpeedPercent:P0}, sleep-kill charge +{RogueGameplayRuntime.ColdBladeNextChargeSpeedPercent:P0} for {RogueGameplayRuntime.ColdBladeNextChargeDuration:0.#}s.");
		}
	}
	public sealed class StableFormationEffect : IRogueEffect
	{
		public string Type => "StableFormation";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.StableFormationActive = true;
			RogueGameplayRuntime.StableFormationDamageReductionPerExtraPlayer = EffectParameters.GetFloat(effect, "DamageReductionPerExtraPlayer", 0.1f);
			RogueLogger.Info($"[StableFormation] Armed. Damage reduction per extra scan player={RogueGameplayRuntime.StableFormationDamageReductionPerExtraPlayer:P0}.");
		}
	}
	public sealed class DefenseCalibrationEffect : IRogueEffect
	{
		public string Type => "DefenseCalibration";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.DefenseCalibrationActive = true;
			RogueGameplayRuntime.DefenseCalibrationLockSpeedPercent = EffectParameters.GetFloat(effect, "LockSpeedPercent", 0.2f);
			RogueGameplayRuntime.DefenseCalibrationAmmoCostPercent = EffectParameters.GetFloat(effect, "AmmoCostPercent", -0.3f);
			RogueLogger.Info($"[DefenseCalibration] Armed. Scan-linked sentry lock +{RogueGameplayRuntime.DefenseCalibrationLockSpeedPercent:P0}, ammo cost {RogueGameplayRuntime.DefenseCalibrationAmmoCostPercent:P0}.");
		}
	}
	public sealed class SettlementProtocolEffect : IRogueEffect
	{
		public string Type => "SettlementProtocol";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.SettlementProtocolActive = true;
			RogueGameplayRuntime.SettlementKillsRequired = EffectParameters.GetInt(effect, "KillsRequired", 3);
			RogueGameplayRuntime.SettlementReloadSpeedPercent = EffectParameters.GetFloat(effect, "ReloadSpeedPercent", 0.75f);
			RogueLogger.Info($"[SettlementProtocol] Armed. Kills required={RogueGameplayRuntime.SettlementKillsRequired}, reload speed +{RogueGameplayRuntime.SettlementReloadSpeedPercent:P0}.");
		}
	}
	public sealed class RapidHardeningEffect : IRogueEffect
	{
		public string Type => "RapidHardening";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.RapidHardeningActive = true;
			RogueGameplayRuntime.RapidHardeningFoamDurationMultiplier = EffectParameters.GetFloat(effect, "FoamDurationMultiplier", 2f);
			RogueLogger.Info($"[StrongGlue] Armed. Enemy glue fade/stuck duration x{RogueGameplayRuntime.RapidHardeningFoamDurationMultiplier:0.##}.");
		}
	}
	public sealed class DoorSealExpertEffect : IRogueEffect
	{
		public string Type => "DoorSealExpert";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.DoorSealExpertActive = true;
			RogueGameplayRuntime.DoorSealExpertDurabilityPercent = EffectParameters.GetFloat(effect, "DoorFoamDurabilityPercent", 0.5f);
			RogueLogger.Info($"[DoorSealExpert] Armed. Door glue durability +{RogueGameplayRuntime.DoorSealExpertDurabilityPercent:P0}.");
		}
	}
	public sealed class TrackingCalibrationEffect : IRogueEffect
	{
		public string Type => "TrackingCalibration";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.TrackingCalibrationActive = true;
			RogueGameplayRuntime.TrackingCalibrationDamagePercent = EffectParameters.GetFloat(effect, "MarkedEnemyDamagePercent", 0.1f);
			RogueLogger.Info($"[TrackingCalibration] Armed. Tagged enemy damage +{RogueGameplayRuntime.TrackingCalibrationDamagePercent:P0}.");
		}
	}
	public sealed class FieldMedicEffect : IRogueEffect
	{
		public string Type => "FieldMedic";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.FieldMedicActive = true;
			RogueGameplayRuntime.FieldMedicReviveSpeedPercent = EffectParameters.GetFloat(effect, "ReviveSpeedPercent", 10f);
			RogueGameplayRuntime.FieldMedicRevivedMoveSpeedPercent = EffectParameters.GetFloat(effect, "RevivedMoveSpeedPercent", -0.99f);
			RogueGameplayRuntime.FieldMedicDebuffSeconds = EffectParameters.GetFloat(effect, "DebuffSeconds", 10f);
			RogueLogger.Info($"[FieldMedic] Armed. Revive speed +{RogueGameplayRuntime.FieldMedicReviveSpeedPercent:P0}, revived move {RogueGameplayRuntime.FieldMedicRevivedMoveSpeedPercent:P0} for {RogueGameplayRuntime.FieldMedicDebuffSeconds:0.#}s.");
		}
	}
	public sealed class BackstabProtocolEffect : IRogueEffect
	{
		public string Type => "BackstabProtocol";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.BackstabProtocolActive = true;
			RogueGameplayRuntime.BackstabProtocolBackDamagePercent = EffectParameters.GetFloat(effect, "BackDamagePercent", 0.5f);
			RogueGameplayRuntime.BackstabProtocolFrontDamagePercent = EffectParameters.GetFloat(effect, "FrontDamagePercent", -0.25f);
			RogueLogger.Info($"[BackstabProtocol] Armed. Back melee +{RogueGameplayRuntime.BackstabProtocolBackDamagePercent:P0}, front melee {RogueGameplayRuntime.BackstabProtocolFrontDamagePercent:P0}.");
		}
	}
	public sealed class PrecisionRecycleEffect : IRogueEffect
	{
		public string Type => "PrecisionRecycle";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.PrecisionRecycleActive = true;
			RogueGameplayRuntime.PrecisionRecycleCooldownSeconds = EffectParameters.GetFloat(effect, "CooldownSeconds", 0.75f);
			RogueLogger.Info($"[PrecisionRecycle] Armed. Weakspot bullets reload 1 round into the current magazine every {RogueGameplayRuntime.PrecisionRecycleCooldownSeconds:0.##}s.");
		}
	}
	public sealed class DataBackflowEffect : IRogueEffect
	{
		public string Type => "DataBackflow";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.DataBackflowActive = true;
			RogueGameplayRuntime.DataBackflowToolChance = EffectParameters.GetFloat(effect, "ToolChance", 0.1f);
			RogueGameplayRuntime.DataBackflowToolRel = EffectParameters.GetFloat(effect, "ToolRel", 0.1f);
			RogueGameplayRuntime.DataBackflowAmmoChance = EffectParameters.GetFloat(effect, "AmmoChance", 0.15f);
			RogueGameplayRuntime.DataBackflowAmmoRel = EffectParameters.GetFloat(effect, "AmmoRel", 0.05f);
			RogueLogger.Info($"[DataBackflow] Armed. Tagged kills roll tool {RogueGameplayRuntime.DataBackflowToolChance:P0}/{RogueGameplayRuntime.DataBackflowToolRel:P0}, ammo {RogueGameplayRuntime.DataBackflowAmmoChance:P0}/{RogueGameplayRuntime.DataBackflowAmmoRel:P0}.");
		}
	}
	public sealed class CrossfireEffect : IRogueEffect
	{
		public string Type => "Crossfire";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.CrossfireActive = true;
			RogueGameplayRuntime.CrossfireWindowSeconds = EffectParameters.GetFloat(effect, "WindowSeconds", 3f);
			RogueGameplayRuntime.CrossfireCooldownSeconds = EffectParameters.GetFloat(effect, "CooldownSeconds", 3f);
			RogueGameplayRuntime.CrossfireMaxHealthDamagePercent = EffectParameters.GetFloat(effect, "MaxHealthDamagePercent", 0.1f);
			RogueLogger.Info($"[Crossfire] Armed. Two-player focus fire deals +{RogueGameplayRuntime.CrossfireMaxHealthDamagePercent:P0} max health, cooldown {RogueGameplayRuntime.CrossfireCooldownSeconds:0.#}s per target.");
		}
	}
	internal static class EffectParameters
	{
		public static float GetFloat(RogueCardEffect effect, string key, float fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is double num))
			{
				if (!(value is float result))
				{
					if (!(value is long num2))
					{
						if (value is int num3)
						{
							return num3;
						}
						return fallback;
					}
					return num2;
				}
				return result;
			}
			return (float)num;
		}

		public static int GetInt(RogueCardEffect effect, string key, int fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is long num))
			{
				if (!(value is double num2))
				{
					if (value is int result)
					{
						return result;
					}
					return fallback;
				}
				return (int)num2;
			}
			return (int)num;
		}
	}
	public sealed class FirstPhaseHookPendingEffect : IRogueEffect
	{
		private readonly string _missingHook;

		public string Type { get; }

		public FirstPhaseHookPendingEffect(string type, string missingHook)
		{
			Type = type;
			_missingHook = missingHook;
		}

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueLogger.Warning("[" + Type + "] Card '" + sourceCard.Name + "' is selectable and recorded, but gameplay is waiting for hook: " + _missingHook + ".");
		}
	}
	public interface IRogueEffect
	{
		string Type { get; }

		void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state);
	}
	public sealed class LogOnlyEffect : IRogueEffect
	{
		public string Type { get; }

		public LogOnlyEffect(string type)
		{
			Type = type;
		}

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueLogger.Info($"[Phase0] Would apply effect '{effect.Type}' from card {sourceCard.PersistentID}:{sourceCard.Name}. StateVersion={state.Version}");
		}
	}
	public sealed class MutualSupplyEffect : IRogueEffect, IOnResourcePackUsed, IRogueEventListener
	{
		private bool _active;

		public string Type => "MutualSupply";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			_active = true;
			RogueGameplayRuntime.MutualSupplyActive = true;
			RogueLogger.Info("[MutualSupply] Armed. Runtime resource hooks mirror 50% to the user when target is an ally.");
		}

		public void OnResourcePackUsed(ResourcePackUsedContext context)
		{
			if (_active && context.UsedOnOtherPlayer)
			{
				RogueLogger.Info($"[MutualSupply] Runtime mirror observed for player {context.UserPlayerId}: {context.Amount * 0.5f:0.##} {context.ResourceType} from ally use.");
			}
		}
	}
	public sealed class SoulSiphonStrikeEffect : IRogueEffect
	{
		public string Type => "SoulSiphonStrike";

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			RogueGameplayRuntime.SoulSiphonStrikeActive = true;
			RogueGameplayRuntime.SoulSiphonMeleeDamagePercent = GetFloat(effect, "MeleeDamagePercentPerStack", 0.02f);
			RogueGameplayRuntime.SoulSiphonMaxStacks = GetInt(effect, "MaxStacks", 25);
			RogueLogger.Info($"[SoulSiphonStrike] Armed. Melee weakspot kills grant +{RogueGameplayRuntime.SoulSiphonMeleeDamagePercent:P0} melee damage, max {RogueGameplayRuntime.SoulSiphonMaxStacks} stacks.");
		}

		private static float GetFloat(RogueCardEffect effect, string key, float fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is double num))
			{
				if (!(value is float result))
				{
					if (!(value is long num2))
					{
						if (value is int num3)
						{
							return num3;
						}
						return fallback;
					}
					return num2;
				}
				return result;
			}
			return (float)num;
		}

		private static int GetInt(RogueCardEffect effect, string key, int fallback)
		{
			if (!effect.Parameters.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is long num))
			{
				if (!(value is double num2))
				{
					if (value is int result)
					{
						return result;
					}
					return fallback;
				}
				return (int)num2;
			}
			return (int)num;
		}
	}
	public sealed class StressResponseEffect : IRogueEffect, IOnHealthChanged, IRogueEventListener
	{
		private sealed class PlayerStressState
		{
			public int Stacks { get; set; }

			public float NextReadyAt { get; set; }
		}

		private readonly RogueModifierRegistry _modifiers;

		private readonly Dictionary<ulong, PlayerStressState> _states = new Dictionary<ulong, PlayerStressState>();

		private bool _active;

		private int _maxStacks = 10;

		private float _damagePercentPerStack = 0.2f;

		private float _movePercentPerStack = 0.05f;

		private float _durationSeconds = 10f;

		private float _cooldownSeconds = 0.75f;

		public string Type => "StressResponse";

		public StressResponseEffect(RogueModifierRegistry modifiers)
		{
			_modifiers = modifiers;
		}

		public void Apply(RogueCardEffect effect, RogueCard sourceCard, RogueState state)
		{
			_active = true;
			_states.Clear();
			_damagePercentPerStack = EffectParameters.GetFloat(effect, "DamagePercentPerStack", 0.2f);
			_movePercentPerStack = EffectParameters.GetFloat(effect, "MovePercentPerStack", 0.05f);
			_maxStacks = EffectParameters.GetInt(effect, "MaxStacks", 10);
			_durationSeconds = EffectParameters.GetFloat(effect, "DurationSeconds", 10f);
			_cooldownSeconds = EffectParameters.GetFloat(effect, "CooldownSeconds", 0.75f);
			RogueGameplayRuntime.StressResponseActive = true;
			RogueLogger.Info($"[StressResponse] Armed. Health changes add stacks with {_cooldownSeconds:0.##}s cooldown. +{_damagePercentPerStack:P0} damage and +{_movePercentPerStack:P0} move speed per stack, max {_maxStacks} stacks.");
		}

		public void OnHealthChanged(HealthChangedContext context)
		{
			if (_active && !(Mathf.Abs(context.Delta) < 1f))
			{
				if (!_states.TryGetValue(context.PlayerId, out PlayerStressState value))
				{
					value = new PlayerStressState();
					_states[context.PlayerId] = value;
				}
				if (!(context.Timestamp < value.NextReadyAt))
				{
					value.NextReadyAt = context.Timestamp + Mathf.Max(0.01f, _cooldownSeconds);
					value.Stacks = Mathf.Min(value.Stacks + 1, Mathf.Max(1, _maxStacks));
					float expiresAt = context.Timestamp + Mathf.Max(0.01f, _durationSeconds);
					_modifiers.AddOrReplace(new RogueModifier
					{
						SourceId = $"card:StressResponse:{context.PlayerId}:damage",
						Kind = RogueModifierKind.WeaponDamage,
						Percent = _damagePercentPerStack,
						Stacks = value.Stacks,
						ExpiresAt = expiresAt
					});
					_modifiers.AddOrReplace(new RogueModifier
					{
						SourceId = $"card:StressResponse:{context.PlayerId}:move",
						Kind = RogueModifierKind.MovementSpeed,
						Percent = _movePercentPerStack,
						Stacks = value.Stacks,
						ExpiresAt = expiresAt
					});
					RogueGameplayRuntime.SetStressResponseStatus(context.PlayerId, value.Stacks, expiresAt, (float)value.Stacks * _damagePercentPerStack, (float)value.Stacks * _movePercentPerStack);
					RogueLogger.Info($"[StressResponse] Player {context.PlayerId} stress stacks={value.Stacks}. Damage=+{(float)value.Stacks * _damagePercentPerStack:P0} Move=+{(float)value.Stacks * _movePercentPerStack:P0}");
				}
			}
		}
	}
}
namespace KainRogueProtocol.Data
{
	public sealed class RogueCard
	{
		public int PersistentID { get; set; }

		public string Name { get; set; } = string.Empty;


		public string Name_zh { get; set; } = string.Empty;


		public string Description { get; set; } = string.Empty;


		public string Rarity { get; set; } = "Common";


		public List<string> Tags { get; set; } = new List<string>();


		public int MaxStacks { get; set; } = 1;


		public List<RogueCardEffect> Effects { get; set; } = new List<RogueCardEffect>();

	}
	public sealed class RogueCardDatabase
	{
		private readonly string _pluginDirectory;

		private readonly string _relativeCardDirectory;

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

		public IReadOnlyList<RogueCard> Cards => _cards;

		public RogueCardDatabase(string pluginDirectory, string relativeCardDirectory)
		{
			_pluginDirectory = pluginDirectory;
			_relativeCardDirectory = relativeCardDirectory;
		}

		public void Load()
		{
			_cards.Clear();
			string text = ResolveCardDirectory();
			if (!Directory.Exists(text))
			{
				RogueLogger.Warning("Card directory does not exist: " + text);
				return;
			}
			foreach (string item in Directory.EnumerateFiles(text, "*.json", SearchOption.AllDirectories))
			{
				LoadFile(item);
			}
			if (_cards.Count == 0)
			{
				RogueLogger.Warning("No valid JSON cards were loaded. Adding built-in Phase 0 fallback cards.");
				_cards.AddRange(CreateFallbackCards());
			}
			RogueLogger.Info($"Loaded {_cards.Count} rogue cards from {text}");
		}

		public RogueCard[] PickRandom(int count, Random random)
		{
			Random random2 = random;
			if (_cards.Count == 0)
			{
				return Array.Empty<RogueCard>();
			}
			return _cards.OrderBy((RogueCard _) => random2.Next()).Take(Math.Min(count, _cards.Count)).ToArray();
		}

		private string ResolveCardDirectory()
		{
			if (Path.IsPathRooted(_relativeCardDirectory))
			{
				return _relativeCardDirectory;
			}
			return Path.GetFullPath(Path.Combine(_pluginDirectory, _relativeCardDirectory.Replace('/', Path.DirectorySeparatorChar)));
		}

		private void LoadFile(string file)
		{
			try
			{
				if (!(SimpleJson.Parse(File.ReadAllText(file)) is List<object> list))
				{
					RogueLogger.Warning("Card JSON did not contain an array: " + file);
					return;
				}
				foreach (object item in list)
				{
					if (!(item is Dictionary<string, object> raw))
					{
						RogueLogger.Warning("Skipping non-object card entry in " + file);
						continue;
					}
					RogueCard rogueCard = ToCard(raw);
					if (IsValid(rogueCard))
					{
						_cards.Add(rogueCard);
					}
				}
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Failed to load card JSON: " + file, ex);
			}
		}

		private static bool IsValid(RogueCard card)
		{
			if (card.PersistentID <= 0)
			{
				RogueLogger.Warning("Skipping card with invalid PersistentID: " + card.Name);
				return false;
			}
			if (string.IsNullOrWhiteSpace(card.Name))
			{
				RogueLogger.Warning($"Skipping card {card.PersistentID} because Name is empty.");
				return false;
			}
			return true;
		}

		private static RogueCard ToCard(Dictionary<string, object?> raw)
		{
			return new RogueCard
			{
				PersistentID = GetInt(raw, "PersistentID"),
				Name = GetString(raw, "Name"),
				Name_zh = GetString(raw, "Name_zh"),
				Description = GetString(raw, "Description"),
				Rarity = GetString(raw, "Rarity", "Common"),
				MaxStacks = GetInt(raw, "MaxStacks", 1),
				Tags = GetStringList(raw, "Tags"),
				Effects = GetEffects(raw, "Effects")
			};
		}

		private static List<RogueCardEffect> GetEffects(Dictionary<string, object?> raw, string key)
		{
			List<RogueCardEffect> list = new List<RogueCardEffect>();
			if (!raw.TryGetValue(key, out object value) || !(value is List<object> list2))
			{
				return list;
			}
			foreach (object item in list2)
			{
				if (item is Dictionary<string, object> dictionary)
				{
					RogueCardEffect rogueCardEffect = new RogueCardEffect
					{
						Type = GetString(dictionary, "Type", "LogOnly")
					};
					if (dictionary.TryGetValue("Parameters", out var value2) && value2 is Dictionary<string, object> parameters)
					{
						rogueCardEffect.Parameters = parameters;
					}
					list.Add(rogueCardEffect);
				}
			}
			return list;
		}

		private static List<string> GetStringList(Dictionary<string, object?> raw, string key)
		{
			List<string> list = new List<string>();
			if (!raw.TryGetValue(key, out object value) || !(value is List<object> list2))
			{
				return list;
			}
			foreach (object item2 in list2)
			{
				if (item2 is string item)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static string GetString(Dictionary<string, object?> raw, string key, string fallback = "")
		{
			if (!raw.TryGetValue(key, out object value) || !(value is string result))
			{
				return fallback;
			}
			return result;
		}

		private static int GetInt(Dictionary<string, object?> raw, string key, int fallback = 0)
		{
			if (!raw.TryGetValue(key, out object value))
			{
				return fallback;
			}
			if (!(value is long num))
			{
				if (!(value is double num2))
				{
					if (value is int result)
					{
						return result;
					}
					return fallback;
				}
				return (int)num2;
			}
			return (int)num;
		}

		private static IEnumerable<RogueCard> CreateFallbackCards()
		{
			return new RogueCard[3]
			{
				new RogueCard
				{
					PersistentID = 900001,
					Name = "备用协议 Alpha",
					Name_zh = "备用协议 Alpha",
					Description = "内置 Phase 0 备用词条。JSON 读取失败时用于继续测试 UI。",
					Rarity = "Common",
					Tags = new List<string> { "调试" },
					MaxStacks = 1,
					Effects = new List<RogueCardEffect>
					{
						new RogueCardEffect
						{
							Type = "LogOnly"
						}
					}
				},
				new RogueCard
				{
					PersistentID = 900002,
					Name = "备用协议 Beta",
					Name_zh = "备用协议 Beta",
					Description = "内置 Phase 0 备用词条。",
					Rarity = "Rare",
					Tags = new List<string> { "调试" },
					MaxStacks = 1,
					Effects = new List<RogueCardEffect>
					{
						new RogueCardEffect
						{
							Type = "LogOnly"
						}
					}
				},
				new RogueCard
				{
					PersistentID = 900003,
					Name = "备用协议 Gamma",
					Name_zh = "备用协议 Gamma",
					Description = "内置 Phase 0 备用词条。",
					Rarity = "Epic",
					Tags = new List<string> { "调试" },
					MaxStacks = 1,
					Effects = new List<RogueCardEffect>
					{
						new RogueCardEffect
						{
							Type = "LogOnly"
						}
					}
				}
			};
		}
	}
	public sealed class RogueCardEffect
	{
		public string Type { get; set; } = "LogOnly";


		public Dictionary<string, object?> Parameters { get; set; } = new Dictionary<string, object>();

	}
	public sealed class RogueRewardPool
	{
	}
	internal sealed class SimpleJson
	{
		private readonly string _json;

		private int _index;

		private SimpleJson(string json)
		{
			_json = json;
		}

		public static object? Parse(string json)
		{
			SimpleJson simpleJson = new SimpleJson(json);
			object result = simpleJson.ParseValue();
			simpleJson.SkipWhitespace();
			return result;
		}

		private object? ParseValue()
		{
			SkipWhitespace();
			if (_index >= _json.Length)
			{
				throw new FormatException("Unexpected end of JSON.");
			}
			return _json[_index] switch
			{
				'{' => ParseObject(), 
				'[' => ParseArray(), 
				'"' => ParseString(), 
				't' => ParseLiteral("true", true), 
				'f' => ParseLiteral("false", false), 
				'n' => ParseLiteral("null", null), 
				_ => ParseNumber(), 
			};
		}

		private Dictionary<string, object?> ParseObject()
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
			Expect('{');
			SkipWhitespace();
			if (TryConsume('}'))
			{
				return dictionary;
			}
			while (true)
			{
				string key = ParseString();
				SkipWhitespace();
				Expect(':');
				dictionary[key] = ParseValue();
				SkipWhitespace();
				if (TryConsume('}'))
				{
					break;
				}
				Expect(',');
			}
			return dictionary;
		}

		private List<object?> ParseArray()
		{
			List<object> list = new List<object>();
			Expect('[');
			SkipWhitespace();
			if (TryConsume(']'))
			{
				return list;
			}
			while (true)
			{
				list.Add(ParseValue());
				SkipWhitespace();
				if (TryConsume(']'))
				{
					break;
				}
				Expect(',');
			}
			return list;
		}

		private string ParseString()
		{
			Expect('"');
			List<char> list = new List<char>();
			while (_index < _json.Length)
			{
				char c = _json[_index++];
				switch (c)
				{
				case '"':
					return new string(list.ToArray());
				default:
					list.Add(c);
					break;
				case '\\':
				{
					if (_index >= _json.Length)
					{
						throw new FormatException("Unexpected end of JSON escape sequence.");
					}
					char c2 = _json[_index++];
					List<char> list2 = list;
					list2.Add(c2 switch
					{
						'"' => '"', 
						'\\' => '\\', 
						'/' => '/', 
						'b' => '\b', 
						'f' => '\f', 
						'n' => '\n', 
						'r' => '\r', 
						't' => '\t', 
						'u' => ParseUnicodeEscape(), 
						_ => throw new FormatException($"Unsupported JSON escape: \\{c2}"), 
					});
					break;
				}
				}
			}
			throw new FormatException("Unterminated JSON string.");
		}

		private char ParseUnicodeEscape()
		{
			if (_index + 4 > _json.Length)
			{
				throw new FormatException("Incomplete unicode escape.");
			}
			string s = _json.Substring(_index, 4);
			_index += 4;
			return (char)int.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
		}

		private object ParseNumber()
		{
			int index = _index;
			while (_index < _json.Length && "-+0123456789.eE".IndexOf(_json[_index]) >= 0)
			{
				_index++;
			}
			string text = _json.Substring(index, _index - index);
			if (text.IndexOf('.') < 0 && text.IndexOf('e') < 0 && text.IndexOf('E') < 0 && long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return result2;
			}
			throw new FormatException("Invalid JSON number: " + text);
		}

		private object? ParseLiteral(string literal, object? value)
		{
			if (_index + literal.Length > _json.Length || string.CompareOrdinal(_json, _index, literal, 0, literal.Length) != 0)
			{
				throw new FormatException($"Invalid JSON literal near index {_index}.");
			}
			_index += literal.Length;
			return value;
		}

		private bool TryConsume(char expected)
		{
			SkipWhitespace();
			if (_index >= _json.Length || _json[_index] != expected)
			{
				return false;
			}
			_index++;
			return true;
		}

		private void Expect(char expected)
		{
			SkipWhitespace();
			if (_index >= _json.Length || _json[_index] != expected)
			{
				throw new FormatException($"Expected '{expected}' near index {_index}.");
			}
			_index++;
		}

		private void SkipWhitespace()
		{
			while (_index < _json.Length && char.IsWhiteSpace(_json[_index]))
			{
				_index++;
			}
		}
	}
}
namespace KainRogueProtocol.Corruption
{
	public sealed class BloodDebtCorruptionEffect : ICorruptionEffect
	{
		public string CorruptionId => "corruption_blood_debt";

		public void Activate(CorruptionCard card, RogueRunState state, RogueEventDispatcher events, RogueModifierRegistry modifiers)
		{
			RogueGameplayRuntime.BloodDebtActive = true;
			RogueLogger.Info("Activated Blood Debt: runtime bleed and participant kill-heal are handled by RogueGameplayRuntime.");
		}
	}
	public enum CorruptionApplyPhase
	{
		PreGeneration,
		PreSpawn,
		Runtime,
		Event
	}
	public sealed class CorruptionCard
	{
		public string Id { get; set; } = string.Empty;


		public string Name { get; set; } = string.Empty;


		public string Description { get; set; } = string.Empty;


		public string Tier { get; set; } = "Minor";


		public int ThreatScore { get; set; } = 1;


		public List<CorruptionApplyPhase> ApplyPhases { get; set; } = new List<CorruptionApplyPhase>();


		public List<EnemyReplacementEntry> EnemyReplacementMap { get; set; } = new List<EnemyReplacementEntry>();


		public bool HasPhase(CorruptionApplyPhase phase)
		{
			return ApplyPhases.Contains(phase);
		}
	}
	public sealed class CorruptionCardManager
	{
		private readonly RogueRunState _state;

		private readonly CorruptionEnemyReplacementSystem _enemyReplacements;

		private readonly RogueModifierRegistry _modifiers;

		private readonly RogueEventDispatcher _events;

		private readonly List<CorruptionCard> _cardPool;

		private readonly Dictionary<string, ICorruptionEffect> _effects = new Dictionary<string, ICorruptionEffect>(StringComparer.OrdinalIgnoreCase);

		public RogueRunState State => _state;

		public IReadOnlyList<CorruptionCard> CardPool => _cardPool;

		public CorruptionCardManager(RogueRunState state, CorruptionEnemyReplacementSystem enemyReplacements, RogueModifierRegistry modifiers, RogueEventDispatcher events)
		{
			_state = state;
			_enemyReplacements = enemyReplacements;
			_modifiers = modifiers;
			_events = events;
			_cardPool = CreateDefaultPool().ToList();
			RegisterDefaultEffects();
		}

		public void RollForLobby(string expeditionId, string difficulty, int? seed = null, int count = 2)
		{
			int valueOrDefault = seed.GetValueOrDefault(Environment.TickCount);
			_state.BeginLobbySelection(expeditionId, difficulty, valueOrDefault);
			Random random = new Random(valueOrDefault);
			CorruptionCard[] rolled = _cardPool.OrderBy((CorruptionCard _) => random.Next()).Take(Math.Min(count, _cardPool.Count)).ToArray();
			_state.SetRolled(rolled);
			RogueLogger.Info($"Rolled {_state.ActiveCorruptions.Count} corruption cards for {expeditionId}. Seed={valueOrDefault}");
		}

		public void ApplyPreGeneration()
		{
			if (_state.Phase != CorruptionRunPhase.Rolled && _state.Phase != CorruptionRunPhase.LobbySelected)
			{
				RogueLogger.Warning($"PreGeneration apply requested from unexpected phase: {_state.Phase}");
			}
			_enemyReplacements.Clear();
			_modifiers.ClearSourcePrefix("corruption:");
			foreach (CorruptionCard activeCorruption in _state.ActiveCorruptions)
			{
				if (activeCorruption.HasPhase(CorruptionApplyPhase.PreGeneration) && activeCorruption.EnemyReplacementMap.Count > 0)
				{
					_enemyReplacements.Register(new StaticEnemyReplacementRule(activeCorruption.Id, activeCorruption.EnemyReplacementMap));
				}
				if (_effects.TryGetValue(activeCorruption.Id, out ICorruptionEffect value))
				{
					value.Activate(activeCorruption, _state, _events, _modifiers);
				}
			}
			_state.MarkPreGenerationApplied();
			RogueLogger.Info("Applied corruption PreGeneration skeleton.");
		}

		public void MarkLevelLoading()
		{
			_state.MarkLevelLoading();
		}

		public void MarkExpeditionStarted()
		{
			_state.MarkExpeditionStarted();
		}

		public bool TryReveal(out CorruptionCard[] cards)
		{
			cards = Array.Empty<CorruptionCard>();
			if (_state.HasShownIntroUi || _state.ActiveCorruptions.Count == 0)
			{
				return false;
			}
			if (_state.Phase != CorruptionRunPhase.ExpeditionStarted && _state.Phase != CorruptionRunPhase.PreGenerationApplied)
			{
				return false;
			}
			cards = _state.ActiveCorruptions.ToArray();
			_state.MarkRevealed();
			return true;
		}

		public CorruptionRunSnapshot CreateSnapshot()
		{
			return new CorruptionRunSnapshot
			{
				Seed = _state.Seed,
				ExpeditionId = _state.ExpeditionId,
				Difficulty = _state.Difficulty,
				ActiveCorruptionIds = _state.ActiveCorruptions.Select((CorruptionCard card) => card.Id).ToList(),
				PreGenerationReady = _state.PreGenerationReady,
				HasShownIntroUi = _state.HasShownIntroUi
			};
		}

		public void ApplySnapshot(CorruptionRunSnapshot snapshot)
		{
			_state.BeginLobbySelection(snapshot.ExpeditionId, snapshot.Difficulty, snapshot.Seed);
			_state.SetRolled(snapshot.ActiveCorruptionIds.Select(FindById).OfType<CorruptionCard>());
			if (snapshot.PreGenerationReady)
			{
				_state.MarkPreGenerationApplied();
			}
			if (snapshot.HasShownIntroUi)
			{
				_state.MarkRevealed();
			}
		}

		public void Reset()
		{
			_state.Reset();
			_enemyReplacements.Clear();
			_modifiers.ClearSourcePrefix("corruption:");
		}

		private CorruptionCard? FindById(string id)
		{
			string id2 = id;
			return _cardPool.FirstOrDefault((CorruptionCard card) => string.Equals(card.Id, id2, StringComparison.OrdinalIgnoreCase));
		}

		private void RegisterDefaultEffects()
		{
			Register(new BloodDebtCorruptionEffect());
			Register(new ExplosiveHeadCorruptionEffect());
			Register(new GiantRegenerationCorruptionEffect());
		}

		private void Register(ICorruptionEffect effect)
		{
			_effects[effect.CorruptionId] = effect;
			if (effect is IRogueEventListener listener)
			{
				_events.Register(listener);
			}
		}

		private static IEnumerable<CorruptionCard> CreateDefaultPool()
		{
			yield return new CorruptionCard
			{
				Id = "corruption_blood_debt",
				Name = "血债循环",
				Description = "所有玩家持续流失生命，参与击杀可恢复生命。",
				Tier = "Major",
				ThreatScore = 2,
				ApplyPhases = new List<CorruptionApplyPhase>
				{
					CorruptionApplyPhase.Runtime,
					CorruptionApplyPhase.Event
				}
			};
			yield return new CorruptionCard
			{
				Id = "corruption_explosive_head",
				Name = "爆颅孢囊",
				Description = "普通小型敌人替换为头部膨胀变体，死亡后延迟爆炸。",
				Tier = "Major",
				ThreatScore = 2,
				ApplyPhases = new List<CorruptionApplyPhase>
				{
					CorruptionApplyPhase.PreGeneration,
					CorruptionApplyPhase.Event
				},
				EnemyReplacementMap = new List<EnemyReplacementEntry>
				{
					new EnemyReplacementEntry
					{
						FromEnemyId = 24u,
						ToEnemyId = 1024u,
						Category = "SmallStriker"
					},
					new EnemyReplacementEntry
					{
						FromEnemyId = 26u,
						ToEnemyId = 1026u,
						Category = "SmallShooter"
					},
					new EnemyReplacementEntry
					{
						FromEnemyId = 28u,
						ToEnemyId = 1028u,
						Category = "SmallCharger"
					},
					new EnemyReplacementEntry
					{
						FromEnemyId = 30u,
						ToEnemyId = 1030u,
						Category = "SmallShadow"
					}
				}
			};
			yield return new CorruptionCard
			{
				Id = "corruption_giant_regeneration",
				Name = "巨物再生",
				Description = "普通大型敌人脱战后恢复生命，弱点伤害会暂停再生。",
				Tier = "Major",
				ThreatScore = 2,
				ApplyPhases = new List<CorruptionApplyPhase>
				{
					CorruptionApplyPhase.Runtime,
					CorruptionApplyPhase.Event
				}
			};
		}
	}
	public sealed class CorruptionEnemyReplacementSystem
	{
		private readonly List<IEnemyReplacementRule> _rules = new List<IEnemyReplacementRule>();

		public IReadOnlyList<IEnemyReplacementRule> Rules => _rules;

		public void Register(IEnemyReplacementRule rule)
		{
			IEnemyReplacementRule rule2 = rule;
			_rules.RemoveAll((IEnemyReplacementRule existing) => existing.SourceId == rule2.SourceId);
			_rules.Add(rule2);
			RogueLogger.Info("Registered enemy replacement rule from " + rule2.SourceId + ".");
		}

		public void ClearForSource(string sourceId)
		{
			string sourceId2 = sourceId;
			_rules.RemoveAll((IEnemyReplacementRule rule) => rule.SourceId == sourceId2);
		}

		public void Clear()
		{
			_rules.Clear();
		}

		public uint Resolve(EnemySpawnContext context, uint originalEnemyId)
		{
			foreach (IEnemyReplacementRule rule in _rules)
			{
				if (rule.ShouldReplace(context, originalEnemyId))
				{
					return rule.GetReplacementId(context, originalEnemyId);
				}
			}
			return originalEnemyId;
		}

		public string Dump()
		{
			if (_rules.Count != 0)
			{
				return "EnemyReplacementRules=" + string.Join(", ", _rules.Select((IEnemyReplacementRule rule) => rule.SourceId));
			}
			return "EnemyReplacementRules=(none)";
		}
	}
	public enum CorruptionRunPhase
	{
		None,
		LobbySelected,
		Rolled,
		PreGenerationApplied,
		LevelLoading,
		ExpeditionStarted,
		Revealed
	}
	public sealed class CorruptionRunSnapshot
	{
		public int Seed { get; set; }

		public string ExpeditionId { get; set; } = string.Empty;


		public string Difficulty { get; set; } = string.Empty;


		public List<string> ActiveCorruptionIds { get; set; } = new List<string>();


		public bool PreGenerationReady { get; set; }

		public bool HasShownIntroUi { get; set; }
	}
	public sealed class EnemyReplacementEntry
	{
		public uint FromEnemyId { get; set; }

		public uint ToEnemyId { get; set; }

		public string Category { get; set; } = string.Empty;

	}
	public sealed class EnemySpawnContext
	{
		public string Source { get; set; } = string.Empty;


		public string ZoneAlias { get; set; } = string.Empty;


		public bool IsAlarmWave { get; set; }

		public bool IsObjectiveEnemy { get; set; }
	}
	public sealed class ExplosiveHeadCorruptionEffect : ICorruptionEffect, IOnEnemyKilled, IRogueEventListener
	{
		private readonly HashSet<uint> _variantEnemyIds = new HashSet<uint>();

		private bool _active;

		public string CorruptionId => "corruption_explosive_head";

		public void Activate(CorruptionCard card, RogueRunState state, RogueEventDispatcher events, RogueModifierRegistry modifiers)
		{
			_active = true;
			RogueGameplayRuntime.ExplosiveHeadActive = true;
			_variantEnemyIds.Clear();
			foreach (uint item in card.EnemyReplacementMap.Select((EnemyReplacementEntry entry) => entry.ToEnemyId))
			{
				_variantEnemyIds.Add(item);
			}
			RogueLogger.Info("Activated Explosive Head skeleton. VariantIds=" + string.Join(",", _variantEnemyIds));
		}

		public void OnEnemyKilled(EnemyKilledContext context)
		{
			if (_active && _variantEnemyIds.Contains(context.EnemyDataId))
			{
				RogueLogger.Info($"[ExplosiveHead] Would spawn delayed explosion at enemy {context.EnemyInstanceId}. Delay=0.4 Radius=4 Damage=16");
			}
		}
	}
	public sealed class GiantRegenerationCorruptionEffect : ICorruptionEffect, IOnEnemyDamaged, IRogueEventListener, IRuntimeRuleTick
	{
		private sealed class EnemyRegenState
		{
			public float LastDamageAt { get; set; }

			public float LastWeakspotAt { get; set; }
		}

		private readonly Dictionary<ulong, EnemyRegenState> _trackedEnemies = new Dictionary<ulong, EnemyRegenState>();

		private bool _active;

		private float _nextTick;

		public string CorruptionId => "corruption_giant_regeneration";

		public void Activate(CorruptionCard card, RogueRunState state, RogueEventDispatcher events, RogueModifierRegistry modifiers)
		{
			_active = true;
			RogueGameplayRuntime.GiantRegenerationActive = true;
			RogueLogger.Info("Activated Giant Regeneration skeleton: damage timestamps and regen ticks are registered.");
		}

		public void OnEnemyDamaged(EnemyDamagedContext context)
		{
			if (_active)
			{
				_trackedEnemies[context.EnemyInstanceId] = new EnemyRegenState
				{
					LastDamageAt = context.Timestamp,
					LastWeakspotAt = (context.IsWeakspot ? context.Timestamp : 0f)
				};
			}
		}

		public void OnRuntimeTick(float now)
		{
			if (_active && !(now < _nextTick))
			{
				_nextTick = now + 1f;
				RogueLogger.Info($"[GiantRegen] Would tick regeneration checks for {_trackedEnemies.Count} damaged large enemies.");
			}
		}
	}
	public interface ICorruptionEffect
	{
		string CorruptionId { get; }

		void Activate(CorruptionCard card, RogueRunState state, RogueEventDispatcher events, RogueModifierRegistry modifiers);
	}
	public interface IEnemyReplacementRule
	{
		string SourceId { get; }

		bool ShouldReplace(EnemySpawnContext context, uint originalEnemyId);

		uint GetReplacementId(EnemySpawnContext context, uint originalEnemyId);
	}
	public sealed class RogueRunState
	{
		private readonly List<CorruptionCard> _activeCorruptions = new List<CorruptionCard>();

		public int Seed { get; private set; }

		public string ExpeditionId { get; private set; } = string.Empty;


		public string Difficulty { get; private set; } = string.Empty;


		public CorruptionRunPhase Phase { get; private set; }

		public bool PreGenerationReady { get; private set; }

		public bool HasShownIntroUi { get; private set; }

		public IReadOnlyList<CorruptionCard> ActiveCorruptions => _activeCorruptions;

		public void BeginLobbySelection(string expeditionId, string difficulty, int seed)
		{
			ExpeditionId = expeditionId;
			Difficulty = difficulty;
			Seed = seed;
			Phase = CorruptionRunPhase.LobbySelected;
			PreGenerationReady = false;
			HasShownIntroUi = false;
			_activeCorruptions.Clear();
		}

		public void SetRolled(IEnumerable<CorruptionCard> cards)
		{
			_activeCorruptions.Clear();
			_activeCorruptions.AddRange(cards);
			Phase = CorruptionRunPhase.Rolled;
		}

		public void MarkPreGenerationApplied()
		{
			PreGenerationReady = true;
			Phase = CorruptionRunPhase.PreGenerationApplied;
		}

		public void MarkLevelLoading()
		{
			Phase = CorruptionRunPhase.LevelLoading;
		}

		public void MarkExpeditionStarted()
		{
			Phase = CorruptionRunPhase.ExpeditionStarted;
		}

		public void MarkRevealed()
		{
			HasShownIntroUi = true;
			Phase = CorruptionRunPhase.Revealed;
		}

		public void Reset()
		{
			Seed = 0;
			ExpeditionId = string.Empty;
			Difficulty = string.Empty;
			Phase = CorruptionRunPhase.None;
			PreGenerationReady = false;
			HasShownIntroUi = false;
			_activeCorruptions.Clear();
		}

		public bool HasCorruption(string id)
		{
			string id2 = id;
			return _activeCorruptions.Any((CorruptionCard card) => card.Id == id2);
		}

		public string Dump()
		{
			string text = ((_activeCorruptions.Count == 0) ? "(none)" : string.Join(", ", _activeCorruptions.Select((CorruptionCard card) => card.Id + ":" + card.Name)));
			return $"RogueRunState Seed={Seed} Expedition={ExpeditionId} Difficulty={Difficulty} Phase={Phase} PreGenerationReady={PreGenerationReady} Revealed={HasShownIntroUi} ActiveCorruptions=[{text}]";
		}
	}
	public sealed class StaticEnemyReplacementRule : IEnemyReplacementRule
	{
		private readonly Dictionary<uint, uint> _map;

		private readonly HashSet<uint> _excludedEnemyIds;

		public string SourceId { get; }

		public StaticEnemyReplacementRule(string sourceId, IEnumerable<EnemyReplacementEntry> entries, IEnumerable<uint>? excludedEnemyIds = null)
		{
			SourceId = sourceId;
			_map = entries.ToDictionary((EnemyReplacementEntry entry) => entry.FromEnemyId, (EnemyReplacementEntry entry) => entry.ToEnemyId);
			_excludedEnemyIds = ((excludedEnemyIds == null) ? new HashSet<uint>() : new HashSet<uint>(excludedEnemyIds));
		}

		public bool ShouldReplace(EnemySpawnContext context, uint originalEnemyId)
		{
			if (context.IsObjectiveEnemy || _excludedEnemyIds.Contains(originalEnemyId))
			{
				return false;
			}
			return _map.ContainsKey(originalEnemyId);
		}

		public uint GetReplacementId(EnemySpawnContext context, uint originalEnemyId)
		{
			if (!ShouldReplace(context, originalEnemyId))
			{
				return originalEnemyId;
			}
			return _map[originalEnemyId];
		}
	}
}
namespace KainRogueProtocol.Core
{
	public static class PluginInfo
	{
		public const string Guid = "kain.gtfo.rogueprotocol";

		public const string Name = "KainRogueProtocol";

		public const string Version = "0.1.0";
	}
	public sealed class RogueConfig
	{
		private readonly ConfigFile _config;

		public ConfigEntry<bool> DebugOverlayEnabled { get; }

		public ConfigEntry<bool> PersistentUiEnabled { get; }

		public ConfigEntry<KeyCode> TogglePersistentUiHotkey { get; }

		public ConfigEntry<KeyCode> ToggleCorruptionUiHotkey { get; }

		public ConfigEntry<KeyCode> DebugRollCorruptionHotkey { get; }

		public ConfigEntry<KeyCode> RewardHotkey { get; }

		public ConfigEntry<KeyCode> CardPoolHotkey { get; }

		public ConfigEntry<KeyCode> ReloadHotkey { get; }

		public ConfigEntry<KeyCode> DumpStateHotkey { get; }

		public ConfigEntry<KeyCode> ResetStateHotkey { get; }

		public ConfigEntry<string> CardDirectory { get; }

		public RogueConfig(ConfigFile config)
		{
			_config = config;
			DebugOverlayEnabled = _config.Bind<bool>("Debug", "DebugOverlayEnabled", true, "Show Phase 0 debug state overlay.");
			PersistentUiEnabled = _config.Bind<bool>("UI", "PersistentUiEnabled", true, "Show persistent Phase 0 BuffBar and debug overlay.");
			TogglePersistentUiHotkey = _config.Bind<KeyCode>("UI", "TogglePersistentUiHotkey", (KeyCode)289, "Toggle persistent Phase 0 UI visibility.");
			ToggleCorruptionUiHotkey = _config.Bind<KeyCode>("UI", "ToggleCorruptionUiHotkey", (KeyCode)285, "Toggle the active corruption card panel.");
			DebugRollCorruptionHotkey = _config.Bind<KeyCode>("Debug", "DebugRollCorruptionHotkey", (KeyCode)286, "Debug-roll corruption cards and apply the PreGeneration skeleton.");
			RewardHotkey = _config.Bind<KeyCode>("Debug", "RewardHotkey", (KeyCode)288, "Open the Phase 0 reward choice panel.");
			CardPoolHotkey = _config.Bind<KeyCode>("Debug", "CardPoolHotkey", (KeyCode)96, "Open the development card pool with all loaded card options.");
			ReloadHotkey = _config.Bind<KeyCode>("Debug", "ReloadHotkey", (KeyCode)292, "Reload card JSON files.");
			DumpStateHotkey = _config.Bind<KeyCode>("Debug", "DumpStateHotkey", (KeyCode)290, "Dump RogueState to the BepInEx log.");
			ResetStateHotkey = _config.Bind<KeyCode>("Debug", "ResetStateHotkey", (KeyCode)291, "Reset Phase 0 runtime state.");
			CardDirectory = _config.Bind<string>("Data", "CardDirectory", "Custom/KainRogueProtocol/Cards", "Card JSON directory relative to the plugin folder.");
			MigrateHotkeys();
		}

		private void MigrateHotkeys()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if ((int)TogglePersistentUiHotkey.Value == 287)
			{
				TogglePersistentUiHotkey.Value = (KeyCode)289;
			}
			if ((int)ReloadHotkey.Value == 289)
			{
				ReloadHotkey.Value = (KeyCode)292;
			}
		}
	}
	public static class RogueLogger
	{
		private static ManualLogSource? _log;

		public static void Bind(ManualLogSource log)
		{
			_log = log;
		}

		public static void Info(string message)
		{
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogInfo((object)message);
			}
		}

		public static void Warning(string message)
		{
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogWarning((object)message);
			}
		}

		public static void Error(string message)
		{
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogError((object)message);
			}
		}

		public static void Error(string message, Exception ex)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			ManualLogSource log = _log;
			if (log != null)
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(message);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				log.LogError(val);
			}
		}
	}
	[BepInPlugin("kain.gtfo.rogueprotocol", "KainRogueProtocol", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class RoguePlugin : BasePlugin
	{
		private RogueConfig? _config;

		private RogueCardDatabase? _cards;

		private RogueSession? _session;

		private RogueRunState? _runState;

		private CorruptionCardManager? _corruptions;

		private RogueEventDispatcher? _events;

		private RogueModifierRegistry? _modifiers;

		private CorruptionEnemyReplacementSystem? _enemyReplacements;

		private RogueHostAuthority? _hostAuthority;

		private RogueNetworkSync? _networkSync;

		private TriggerRegistry? _triggers;

		private RogueHudRoot? _hud;

		private Harmony? _harmony;

		private bool _runtimeUpdateSeen;

		private bool _runtimeFaulted;

		public override void Load()
		{
			RogueLogger.Bind(((BasePlugin)this).Log);
			RogueLogger.Info("KainRogueProtocol 0.1.0 loading.");
			_config = new RogueConfig(((BasePlugin)this).Config);
			_cards = new RogueCardDatabase(GetPluginDirectory(), _config.CardDirectory.Value);
			_cards.Load();
			_events = new RogueEventDispatcher();
			_modifiers = new RogueModifierRegistry();
			RogueGameplayRuntime.Initialize(_events, _modifiers);
			_enemyReplacements = new CorruptionEnemyReplacementSystem();
			_runState = new RogueRunState();
			_corruptions = new CorruptionCardManager(_runState, _enemyReplacements, _modifiers, _events);
			_hostAuthority = new RogueHostAuthority();
			_networkSync = new RogueNetworkSync(_corruptions);
			_triggers = new TriggerRegistry(_events);
			RogueState state = new RogueState();
			CardEffectDispatcher cardEffectDispatcher = new CardEffectDispatcher(_events, _modifiers);
			cardEffectDispatcher.RegisterDefaults();
			_session = new RogueSession(state, cardEffectDispatcher);
			RegisterRuntimeDriver();
			PatchGameplayHooks();
			RogueLogger.Info("Phase 0 prototype loaded. UI will initialize from the runtime driver. Hotkeys: F4 corruptions, F5 roll corruptions, F7 reward, F8 persistent UI, ` card pool, F9 dump, F10 reset, F11 reload by default.");
		}

		public void OnRuntimeUpdate()
		{
			//IL_0094: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_runtimeFaulted)
				{
					return;
				}
				if (!_runtimeUpdateSeen)
				{
					_runtimeUpdateSeen = true;
					RogueLogger.Info("RogueRuntimeDriver Update is active.");
				}
				if (_config == null || _cards == null || _session == null)
				{
					return;
				}
				EnsureUiCreated();
				_events?.Tick(Time.time);
				_modifiers?.RemoveExpired(Time.time);
				RogueGameplayRuntime.Tick(Time.time);
				RogueWatermarkOverride.Tick(Time.unscaledTime);
				if (Input.GetKeyDown(_config.ToggleCorruptionUiHotkey.Value))
				{
					RogueLogger.Info("Toggle corruption UI hotkey pressed.");
					ToggleCorruptionPanel();
				}
				if (Input.GetKeyDown(_config.DebugRollCorruptionHotkey.Value))
				{
					RogueLogger.Info("Debug roll corruption hotkey pressed.");
					DebugRollCorruptions();
				}
				if (Input.GetKeyDown(_config.TogglePersistentUiHotkey.Value))
				{
					RogueLogger.Info("Toggle persistent UI hotkey pressed.");
					_hud?.TogglePersistentUi();
				}
				if (Input.GetKeyDown(_config.RewardHotkey.Value))
				{
					RogueLogger.Info("Reward hotkey pressed.");
					OpenRewardPanel();
				}
				if (Input.GetKeyDown(_config.CardPoolHotkey.Value))
				{
					RogueLogger.Info("Development card pool hotkey pressed.");
					OpenCardPoolPanel();
				}
				if (Input.GetKeyDown(_config.ReloadHotkey.Value))
				{
					RogueLogger.Info("Reload hotkey pressed.");
					ReloadCards();
				}
				if (Input.GetKeyDown(_config.DumpStateHotkey.Value))
				{
					RogueLogger.Info("Dump state hotkey pressed.");
					RogueLogger.Info(_session.State.Dump());
					if (_runState != null)
					{
						RogueLogger.Info(_runState.Dump());
					}
					if (_enemyReplacements != null)
					{
						RogueLogger.Info(_enemyReplacements.Dump());
					}
					if (_modifiers != null)
					{
						RogueLogger.Info(_modifiers.Dump(Time.time));
					}
				}
				if (Input.GetKeyDown(_config.ResetStateHotkey.Value))
				{
					RogueLogger.Info("Reset state hotkey pressed.");
					ResetState();
				}
				_hud?.Tick();
			}
			catch (Exception ex)
			{
				_runtimeFaulted = true;
				RogueLogger.Error("Runtime update failed. Disabling KainRogueProtocol runtime loop to prevent log spam.", ex);
			}
		}

		public void OnRuntimeLateUpdate()
		{
			if (!_runtimeFaulted)
			{
				RogueModalCursorGuard.ForceCursorReleased();
				_hud?.LateTick();
			}
		}

		public void OnRuntimeOnGUI()
		{
			if (!_runtimeFaulted)
			{
				RogueModalCursorGuard.ForceCursorReleased();
			}
		}

		public void OnRuntimeDriverDestroyed(RogueRuntimeDriver driver)
		{
			_hud?.ReleaseCursorCapture();
			RogueLogger.Warning("RogueRuntimeDriver was destroyed.");
		}

		private void OpenRewardPanel()
		{
			if (_cards == null || _session == null || _hud == null)
			{
				return;
			}
			RogueCard[] array = _session.PickRewards(_cards, 3);
			if (array.Length == 0)
			{
				RogueLogger.Warning("No cards are available. Check Custom/KainRogueProtocol/Cards JSON files.");
				return;
			}
			_hud.ShowRewards(array, delegate(RogueCard card)
			{
				_session.SelectReward(card);
				_hud.RefreshState(_session.State);
			});
			RogueLogger.Info($"Opened reward panel with {array.Length} cards.");
		}

		private void OpenCardPoolPanel()
		{
			if (_cards == null || _session == null || _hud == null)
			{
				return;
			}
			RogueCard[] array = _cards.Cards.ToArray();
			if (array.Length == 0)
			{
				RogueLogger.Warning("No cards are available for the development card pool. Check Custom/KainRogueProtocol/Cards JSON files.");
				return;
			}
			_hud.ShowCardPool(array, delegate(RogueCard card)
			{
				_session.SelectReward(card);
				_hud.RefreshState(_session.State);
			});
			RogueLogger.Info($"Opened development card pool with {array.Length} cards.");
		}

		private void ReloadCards()
		{
			_cards?.Load();
			RogueLogger.Info($"Reloaded card database. Cards={_cards?.Cards.Count ?? 0}");
		}

		private void ResetState()
		{
			_session?.ClearForExpeditionExit();
			_corruptions?.Reset();
			RogueGameplayRuntime.ResetFlags();
			if (_session != null)
			{
				_hud?.RefreshState(_session.State);
			}
		}

		private void DebugRollCorruptions()
		{
			if (_hostAuthority != null && _corruptions != null && _networkSync != null && _hud != null && _hostAuthority.TryRollCorruptions(_corruptions, "Debug_Expedition", "Normal"))
			{
				CorruptionRunSnapshot snapshot = _networkSync.CreateCorruptionSnapshot();
				RogueLogger.Info(_networkSync.DumpSnapshot(snapshot));
				_corruptions.MarkLevelLoading();
				_corruptions.MarkExpeditionStarted();
				if (_corruptions.TryReveal(out CorruptionCard[] cards))
				{
					_hud.ShowCorruptions(cards, 7f);
				}
			}
		}

		private void ToggleCorruptionPanel()
		{
			if (_corruptions != null && _hud != null)
			{
				if (_corruptions.State.ActiveCorruptions.Count == 0)
				{
					RogueLogger.Warning("No active corruption cards. Press the debug roll hotkey first in Phase 0.");
				}
				else
				{
					_hud.ToggleCorruptions(_corruptions.State.ActiveCorruptions.ToArray());
				}
			}
		}

		private void RegisterRuntimeDriver()
		{
			RogueRuntimeDriver.Plugin = this;
			((BasePlugin)this).AddComponent<RogueRuntimeDriver>();
			RogueLogger.Info("Requested RogueRuntimeDriver through Bep AddComponent.");
		}

		private void PatchGameplayHooks()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			try
			{
				_harmony = new Harmony("kain.gtfo.rogueprotocol");
				_harmony.PatchAll(typeof(RogueGameplayPatches).Assembly);
				RogueLogger.Info("Gameplay hook patches installed.");
			}
			catch (Exception ex)
			{
				RogueLogger.Error("Failed to install gameplay hook patches. UI/debug systems will continue running.", ex);
			}
		}

		private void EnsureUiCreated()
		{
			if (_hud == null)
			{
				CreateUi();
			}
		}

		private void CreateUi()
		{
			if (_session != null && _config != null)
			{
				_hud = new RogueHudRoot(_config.DebugOverlayEnabled.Value, _config.PersistentUiEnabled.Value);
				_hud.Create();
				_hud.RefreshState(_session.State);
			}
		}

		private static string GetPluginDirectory()
		{
			string location = typeof(RoguePlugin).Assembly.Location;
			string text;
			if (!string.IsNullOrWhiteSpace(location))
			{
				text = Path.GetDirectoryName(location);
				if (text == null)
				{
					return Paths.PluginPath;
				}
			}
			else
			{
				text = Paths.PluginPath;
			}
			return text;
		}
	}
	public sealed class RogueRuntimeDriver : MonoBehaviour
	{
		public static RoguePlugin? Plugin { get; set; }

		public RogueRuntimeDriver(IntPtr ptr)
			: base(ptr)
		{
		}

		public void Start()
		{
			RogueLogger.Info("RogueRuntimeDriver started.");
		}

		public void Update()
		{
			Plugin?.OnRuntimeUpdate();
		}

		public void LateUpdate()
		{
			Plugin?.OnRuntimeLateUpdate();
		}

		public void OnGUI()
		{
			Plugin?.OnRuntimeOnGUI();
		}

		public void OnDestroy()
		{
			Plugin?.OnRuntimeDriverDestroyed(this);
		}
	}
	public sealed class RogueSession
	{
		private readonly RogueState _state;

		private readonly CardEffectDispatcher _effects;

		private readonly Random _random = new Random();

		public RogueState State => _state;

		public RogueSession(RogueState state, CardEffectDispatcher effects)
		{
			_state = state;
			_effects = effects;
		}

		public void EnsureStarted()
		{
			if (_state.Seed == 0)
			{
				_state.StartNewRun(Environment.TickCount);
				RogueLogger.Info($"Started Phase 0 rogue session with seed {_state.Seed}.");
			}
		}

		public void SelectReward(RogueCard card)
		{
			EnsureStarted();
			_state.AddCard(card);
			foreach (RogueCardEffect effect in card.Effects)
			{
				_effects.Apply(effect, card, _state);
			}
		}

		public RogueCard[] PickRewards(RogueCardDatabase database, int count)
		{
			EnsureStarted();
			return database.PickRandom(count, _random);
		}

		public void ClearForExpeditionExit()
		{
			_state.Reset();
			RogueLogger.Info("Cleared Phase 0 runtime state.");
		}
	}
	public sealed class RogueState
	{
		private readonly List<RogueCard> _selectedCards = new List<RogueCard>();

		public int Seed { get; private set; }

		public int Version { get; private set; }

		public IReadOnlyList<RogueCard> SelectedCards => _selectedCards;

		public void StartNewRun(int seed)
		{
			Seed = seed;
			_selectedCards.Clear();
			Version++;
		}

		public void AddCard(RogueCard card)
		{
			_selectedCards.Add(card);
			Version++;
		}

		public void Reset()
		{
			Seed = 0;
			_selectedCards.Clear();
			Version++;
		}

		public string Dump()
		{
			string arg = ((_selectedCards.Count == 0) ? "(none)" : string.Join(", ", _selectedCards.Select((RogueCard card) => $"{card.PersistentID}:{card.Name}")));
			return $"RogueState Seed={Seed} Version={Version} SelectedCards=[{arg}]";
		}
	}
}