using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using InfoOverhaul.Delta;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using ShieldsMod.Cards;
using ShieldsMod.Networking;
using ShieldsMod.Poison;
using ShieldsMod.Shield;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnityEngine;
using UnityEngine.UI;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShieldsMod
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("ShieldsMod", "Shields Mod for ROUNDS", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		private void Awake()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			SLog.Section("Plugin Awake");
			new Harmony("ShieldsMod").PatchAll();
			((Component)this).gameObject.AddComponent<ShieldManager>();
			((Component)this).gameObject.AddComponent<PoisonResistanceManager>();
			ShieldCardRegistrar.RegisterAll();
			PoisonCardRegistrar.RegisterAll();
			SLog.Line("Plugin ShieldsMod loaded.");
		}
	}
	internal static class SLog
	{
		private const string Sep = "=====================";

		public static void Section(string title)
		{
			Plugin.Logger.LogInfo((object)"=====================");
			Plugin.Logger.LogInfo((object)("[ShieldsMod] " + title));
			Plugin.Logger.LogInfo((object)"=====================");
		}

		public static void Line(string message)
		{
			Plugin.Logger.LogInfo((object)("[ShieldsMod] " + message));
		}

		public static void Warn(string message)
		{
			Plugin.Logger.LogWarning((object)("[ShieldsMod] " + message));
		}

		public static void Error(string message)
		{
			Plugin.Logger.LogError((object)("[ShieldsMod] " + message));
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ShieldsMod";

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

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace ShieldsMod.Shield
{
	internal static class ShieldHandRebuild
	{
		private static Dictionary<string, float> _multiplierByCardName;

		internal static void RegisterTier(CardInfo card, float multiplier)
		{
			if (!((Object)(object)card == (Object)null) && !string.IsNullOrEmpty(card.cardName))
			{
				if (_multiplierByCardName == null)
				{
					_multiplierByCardName = new Dictionary<string, float>(StringComparer.Ordinal);
				}
				_multiplierByCardName[card.cardName] = multiplier;
			}
		}

		internal static void RebuildForPlayer(int playerID)
		{
			if ((Object)(object)ShieldManager.instance == (Object)null || (Object)(object)PlayerManager.instance == (Object)null)
			{
				return;
			}
			Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
			if (val?.data?.currentCards == null)
			{
				return;
			}
			float num = 100f;
			int num2 = 0;
			if (_multiplierByCardName != null)
			{
				foreach (CardInfo currentCard in val.data.currentCards)
				{
					if (!((Object)(object)currentCard == (Object)null))
					{
						string cardName = currentCard.cardName;
						if (string.IsNullOrEmpty(cardName) && (Object)(object)currentCard.sourceCard != (Object)null)
						{
							cardName = currentCard.sourceCard.cardName;
						}
						if (!string.IsNullOrEmpty(cardName) && _multiplierByCardName.TryGetValue(cardName, out var value))
						{
							num *= value;
							num2++;
						}
					}
				}
			}
			ShieldState orCreateShield = ShieldManager.instance.GetOrCreateShield(playerID);
			float max = orCreateShield.Max;
			orCreateShield.Max = num;
			orCreateShield.Current = Mathf.Min(orCreateShield.Current, orCreateShield.Max);
			ShieldManager.instance.RefreshVisual(playerID);
			SLog.Line($"ShieldHandRebuild player={playerID} tiers={num2} max {max:F0} -> {orCreateShield.Max:F0} current={orCreateShield.Current:F0}");
		}
	}
	public class ShieldManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <OnBattleStart>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <OnBattleStart>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				instance?.ResetAllForBattle();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <OnGameStart>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <OnGameStart>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				instance?.CleanupOrphanedAttachments();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <OnPointEnd>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <OnPointEnd>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				instance?.CleanupOrphanedAttachments();
				return false;
			}

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

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

		public static ShieldManager instance;

		private readonly Dictionary<int, ShieldState> _shields = new Dictionary<int, ShieldState>();

		private readonly Dictionary<int, ShieldVisual> _visuals = new Dictionary<int, ShieldVisual>();

		private readonly Dictionary<int, ShieldParryTrigger> _parryTriggers = new Dictionary<int, ShieldParryTrigger>();

		private readonly Dictionary<int, float> _poisonDrainBlockedUntil = new Dictionary<int, float>();

		private const float PoisonDrainBlockDuration = 4f;

		private void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			SLog.Section("ShieldManager — Awake");
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)OnBattleStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}

		[IteratorStateMachine(typeof(<OnBattleStart>d__8))]
		private static IEnumerator OnBattleStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleStart>d__8(0);
		}

		[IteratorStateMachine(typeof(<OnPointEnd>d__9))]
		private static IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPointEnd>d__9(0);
		}

		[IteratorStateMachine(typeof(<OnGameStart>d__10))]
		private static IEnumerator OnGameStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnGameStart>d__10(0);
		}

		public void ResetAllForBattle()
		{
			_poisonDrainBlockedUntil.Clear();
			SLog.Section("ShieldManager — ResetAllForBattle");
			if ((Object)(object)PlayerManager.instance == (Object)null)
			{
				SLog.Warn("PlayerManager.instance is null.");
				return;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if (!((Object)(object)player == (Object)null))
				{
					ShieldState orCreateShield = GetOrCreateShield(player.playerID);
					orCreateShield.ResetToFull();
					EnsureAttachments(player, orCreateShield);
					RefreshVisual(player.playerID);
					SLog.Line($"player={player.playerID} shield={orCreateShield.Current}/{orCreateShield.Max}");
				}
			}
		}

		public ShieldState GetOrCreateShield(int playerID)
		{
			if (!_shields.TryGetValue(playerID, out var value))
			{
				value = new ShieldState();
				_shields[playerID] = value;
			}
			return value;
		}

		public ShieldState GetShield(int playerID)
		{
			return GetOrCreateShield(playerID);
		}

		public bool TryAbsorbFull(int playerID, float damageAmount, out bool depleted)
		{
			depleted = false;
			ShieldState orCreateShield = GetOrCreateShield(playerID);
			if (!orCreateShield.IsActive || damageAmount <= 0f)
			{
				return false;
			}
			if (damageAmount >= orCreateShield.Current)
			{
				orCreateShield.Current = 0f;
				depleted = true;
			}
			else
			{
				orCreateShield.Current -= damageAmount;
			}
			RefreshVisual(playerID);
			return true;
		}

		public void MarkPoisonDepleted(int playerID)
		{
			_poisonDrainBlockedUntil[playerID] = Time.time + 4f;
		}

		public bool IsPoisonDrainBlocked(int playerID)
		{
			if (_poisonDrainBlockedUntil.TryGetValue(playerID, out var value))
			{
				return Time.time < value;
			}
			return false;
		}

		public void RefreshVisual(int playerID)
		{
			if (_visuals.TryGetValue(playerID, out var value) && (Object)(object)value != (Object)null)
			{
				value.Refresh();
			}
			if (_parryTriggers.TryGetValue(playerID, out var value2) && (Object)(object)value2 != (Object)null)
			{
				value2.UpdateEnabled();
			}
		}

		private void EnsureAttachments(Player player, ShieldState state)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			int playerID = player.playerID;
			if (!_visuals.TryGetValue(playerID, out var value) || (Object)(object)value == (Object)null)
			{
				GameObject val = new GameObject($"ShieldVisual_P{playerID}");
				val.transform.SetParent(((Component)player).transform, false);
				value = val.AddComponent<ShieldVisual>();
				value.Init(player, state);
				_visuals[playerID] = value;
			}
			else
			{
				value.SetState(state);
				value.Refresh();
			}
			if (!_parryTriggers.TryGetValue(playerID, out var value2) || (Object)(object)value2 == (Object)null)
			{
				GameObject val2 = new GameObject($"ShieldParry_P{playerID}");
				val2.transform.SetParent(((Component)player).transform, false);
				value2 = val2.AddComponent<ShieldParryTrigger>();
				float radius = ShieldVisual.GetBodyRadius(player) * 1.44f;
				value2.Init(player, state, radius);
				_parryTriggers[playerID] = value2;
			}
			else
			{
				value2.SetState(state);
				value2.UpdateEnabled();
			}
		}

		private void CleanupOrphanedAttachments()
		{
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, ShieldVisual> visual in _visuals)
			{
				if ((Object)(object)visual.Value == (Object)null)
				{
					list.Add(visual.Key);
				}
			}
			foreach (int item in list)
			{
				_visuals.Remove(item);
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, ShieldParryTrigger> parryTrigger in _parryTriggers)
			{
				if ((Object)(object)parryTrigger.Value == (Object)null)
				{
					list2.Add(parryTrigger.Key);
				}
			}
			foreach (int item2 in list2)
			{
				_parryTriggers.Remove(item2);
			}
		}
	}
	public class ShieldParryTrigger : MonoBehaviour
	{
		private Player _owner;

		private Block _block;

		private CircleCollider2D _trigger;

		private ShieldState _state;

		private readonly HashSet<int> _recentlyDeflected = new HashSet<int>();

		public void Init(Player owner, ShieldState state, float radius)
		{
			_owner = owner;
			_state = state;
			_block = ((Component)owner).GetComponent<Block>();
			_trigger = ((Component)this).gameObject.AddComponent<CircleCollider2D>();
			((Collider2D)_trigger).isTrigger = true;
			_trigger.radius = radius;
			Rigidbody2D obj = ((Component)this).gameObject.AddComponent<Rigidbody2D>();
			obj.bodyType = (RigidbodyType2D)1;
			obj.simulated = true;
			UpdateEnabled();
		}

		public void SetState(ShieldState state)
		{
			_state = state;
		}

		public void SetRadius(float worldRadius)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_owner == (Object)null) && !((Object)(object)_trigger == (Object)null))
			{
				float num = Mathf.Max(((Component)_owner).transform.localScale.x, 0.01f);
				_trigger.radius = worldRadius / num;
			}
		}

		public void UpdateEnabled()
		{
			if ((Object)(object)_trigger != (Object)null)
			{
				((Behaviour)_trigger).enabled = _state != null && _state.IsActive;
			}
		}

		private void LateUpdate()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_owner == (Object)null))
			{
				((Component)this).transform.position = ((Component)_owner).transform.position;
				float bodyRadius = ShieldVisual.GetBodyRadius(_owner);
				SetRadius(bodyRadius * 1.44f);
				UpdateEnabled();
			}
		}

		private void OnTriggerEnter2D(Collider2D other)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_owner == (Object)null || (Object)(object)_block == (Object)null || _state == null || !_state.IsActive || !_block.IsBlocking())
			{
				return;
			}
			ProjectileHit val = ((Component)other).GetComponent<ProjectileHit>() ?? ((Component)other).GetComponentInParent<ProjectileHit>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			PhotonView component = ((Component)val).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null || !component.IsMine)
			{
				return;
			}
			int instanceID = ((Object)((Component)val).gameObject).GetInstanceID();
			if (!_recentlyDeflected.Contains(instanceID) && IsEnemyProjectile(val))
			{
				Vector3 position = ((Component)val).transform.position;
				Vector3 val2 = ((Component)val).transform.forward;
				if (((Vector3)(ref val2)).sqrMagnitude < 0.001f)
				{
					Vector3 val3 = position - ((Component)_owner).transform.position;
					val2 = ((Vector3)(ref val3)).normalized;
				}
				_recentlyDeflected.Add(instanceID);
				_block.DoBlock(((Component)val).gameObject, val2, position);
				SLog.Line($"Outer parry player={_owner.playerID} projectile={((Object)((Component)val).gameObject).name}");
			}
		}

		private bool IsEnemyProjectile(ProjectileHit projHit)
		{
			Player val = projHit.ownPlayer;
			if ((Object)(object)val == (Object)null)
			{
				SpawnedAttack component = ((Component)projHit).GetComponent<SpawnedAttack>();
				if ((Object)(object)component != (Object)null)
				{
					val = component.spawner;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (val.playerID != _owner.playerID)
			{
				return (Object)(object)((Component)val).transform.root != (Object)(object)((Component)_owner).transform.root;
			}
			return false;
		}

		private void OnTriggerExit2D(Collider2D other)
		{
			ProjectileHit val = ((Component)other).GetComponent<ProjectileHit>() ?? ((Component)other).GetComponentInParent<ProjectileHit>();
			if ((Object)(object)val != (Object)null)
			{
				_recentlyDeflected.Remove(((Object)((Component)val).gameObject).GetInstanceID());
			}
		}
	}
	public class ShieldState
	{
		public const float DefaultMax = 100f;

		public float Max = 100f;

		public float Current = 100f;

		public const float BubbleAlpha = 0.05f;

		public float Percent
		{
			get
			{
				if (!(Max > 0f))
				{
					return 0f;
				}
				return Current / Max;
			}
		}

		public bool IsActive => Current > 0f;

		public void ResetToFull()
		{
			Current = Max;
		}

		public Color GetBubbleColor(float alpha = 0.05f)
		{
			//IL_005d: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			float percent = Percent;
			Color val = default(Color);
			if (percent > 0.65f)
			{
				((Color)(ref val))..ctor(0.2f, 0.9f, 0.25f);
			}
			else if (percent > 0.35f)
			{
				((Color)(ref val))..ctor(0.95f, 0.85f, 0.15f);
			}
			else
			{
				((Color)(ref val))..ctor(0.95f, 0.2f, 0.15f);
			}
			return new Color(val.r, val.g, val.b, alpha);
		}
	}
	public class ShieldVisual : MonoBehaviour
	{
		public const float SizeMultiplier = 1.44f;

		private const int CircleTexSize = 128;

		private Player _player;

		private SpriteRenderer _sprite;

		private ShieldState _state;

		public static Sprite SharedCircleSprite { get; private set; }

		public void Init(Player player, ShieldState state)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			_player = player;
			_state = state;
			if ((Object)(object)SharedCircleSprite == (Object)null)
			{
				SharedCircleSprite = CreateCircleSprite(128);
			}
			GameObject val = new GameObject("ShieldBubbleSprite");
			val.transform.SetParent(((Component)this).transform, false);
			_sprite = val.AddComponent<SpriteRenderer>();
			_sprite.sprite = SharedCircleSprite;
			((Renderer)_sprite).sortingOrder = -1;
			int num = SortingLayer.NameToID("Player" + (player.playerID + 1));
			if (num != 0)
			{
				((Renderer)_sprite).sortingLayerID = num;
			}
			player.data.SetWobbleObjectChild(((Component)this).transform);
			Refresh();
		}

		public void SetState(ShieldState state)
		{
			_state = state;
		}

		public void Refresh()
		{
			//IL_005c: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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)
			if ((Object)(object)_sprite == (Object)null || (Object)(object)_player == (Object)null || _state == null)
			{
				return;
			}
			if (!_state.IsActive)
			{
				((Renderer)_sprite).enabled = false;
				return;
			}
			((Renderer)_sprite).enabled = true;
			_sprite.color = _state.GetBubbleColor();
			float num = GetBodyRadius(_player) * 2f * 1.44f;
			Bounds bounds = _sprite.sprite.bounds;
			float x = ((Bounds)(ref bounds)).size.x;
			if (x > 0.0001f)
			{
				((Component)_sprite).transform.localScale = Vector3.one * (num / x);
			}
		}

		public static float GetBodyRadius(Player player)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return 0.5f;
			}
			CircleCollider2D val = ((Component)player).GetComponent<CircleCollider2D>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)player).GetComponentInChildren<CircleCollider2D>();
			}
			return (((Object)(object)val != (Object)null) ? val.radius : 0.5f) * ((Component)player).transform.localScale.x;
		}

		private void LateUpdate()
		{
			if (_state != null && _state.IsActive)
			{
				Refresh();
			}
		}

		private static Sprite CreateCircleSprite(int size)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_00ab: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			float num = (float)(size - 1) * 0.5f;
			float num2 = num - 1f;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num3 = (float)j - num;
					float num4 = (float)i - num;
					float num5 = Mathf.Sqrt(num3 * num3 + num4 * num4);
					float num6 = ((num5 <= num2) ? 1f : Mathf.Clamp01(1f - (num5 - num2)));
					val.SetPixel(j, i, new Color(1f, 1f, 1f, num6));
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), (float)size);
		}
	}
}
namespace ShieldsMod.Poison
{
	internal static class PoisonDamageDetector
	{
		public static bool IsPoisonDamage(Color blinkColor, GameObject damagingWeapon)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)damagingWeapon != (Object)null)
			{
				if ((Object)(object)damagingWeapon.GetComponentInChildren<RayHitPoison>() != (Object)null)
				{
					return true;
				}
				Transform root = damagingWeapon.transform.root;
				if ((Object)(object)root != (Object)null && (Object)(object)((Component)root).GetComponentInChildren<RayHitPoison>() != (Object)null)
				{
					return true;
				}
			}
			if (blinkColor.g > 0.35f && blinkColor.g >= blinkColor.r)
			{
				return blinkColor.g >= blinkColor.b;
			}
			return false;
		}
	}
	internal static class PoisonHandRebuild
	{
		private static Dictionary<string, float> _reductionByCardName;

		internal static void RegisterTier(string cardName, float totalReduction)
		{
			if (!string.IsNullOrEmpty(cardName))
			{
				if (_reductionByCardName == null)
				{
					_reductionByCardName = new Dictionary<string, float>(StringComparer.Ordinal);
				}
				_reductionByCardName[cardName] = totalReduction;
			}
		}

		internal static float ComputeReductionFromHand(IEnumerable<CardInfo> cards)
		{
			float num = 0f;
			if (_reductionByCardName == null || cards == null)
			{
				return num;
			}
			foreach (CardInfo card in cards)
			{
				if (!((Object)(object)card == (Object)null))
				{
					string cardName = card.cardName;
					if (string.IsNullOrEmpty(cardName) && (Object)(object)card.sourceCard != (Object)null)
					{
						cardName = card.sourceCard.cardName;
					}
					if (!string.IsNullOrEmpty(cardName) && _reductionByCardName.TryGetValue(cardName, out var value))
					{
						num = Math.Max(num, value);
					}
				}
			}
			return num;
		}

		internal static void RebuildForPlayer(int playerID)
		{
			PoisonResistanceManager.instance?.RebuildForPlayer(playerID);
		}
	}
	public class PoisonResistanceManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <OnBattleStart>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

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

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

			[DebuggerHidden]
			public <OnBattleStart>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if ((Object)(object)PlayerManager.instance == (Object)null)
				{
					return false;
				}
				foreach (Player player in PlayerManager.instance.players)
				{
					if ((Object)(object)player != (Object)null)
					{
						instance?.RebuildForPlayer(player.playerID);
					}
				}
				return false;
			}

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

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

		public static PoisonResistanceManager instance;

		private readonly Dictionary<int, float> _reductionByPlayer = new Dictionary<int, float>();

		private void Awake()
		{
			instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)OnBattleStart);
			SLog.Section("PoisonResistanceManager — Awake");
		}

		[IteratorStateMachine(typeof(<OnBattleStart>d__3))]
		private static IEnumerator OnBattleStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleStart>d__3(0);
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}

		public float GetReduction(int playerID)
		{
			if (!_reductionByPlayer.TryGetValue(playerID, out var value))
			{
				return 0f;
			}
			return value;
		}

		public float GetReductionPercent(int playerID)
		{
			return GetReduction(playerID) * 100f;
		}

		public void RebuildForPlayer(int playerID)
		{
			if (!((Object)(object)PlayerManager.instance == (Object)null))
			{
				Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
				if (val?.data?.currentCards != null)
				{
					float num = PoisonHandRebuild.ComputeReductionFromHand(val.data.currentCards);
					_reductionByPlayer[playerID] = num;
					SLog.Line($"PoisonResistance rebuild player={playerID} reduction={num * 100f:F0}%");
				}
			}
		}

		public float ApplyResistance(int playerID, float rawDamage, out float resistedAmount)
		{
			float reduction = GetReduction(playerID);
			resistedAmount = rawDamage * reduction;
			return rawDamage - resistedAmount;
		}
	}
}
namespace ShieldsMod.Patches
{
	[HarmonyPatch]
	internal static class CardDeleteRebuildPatch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("Rounds2Mod.CardDeleteManager");
			if (!(type == null))
			{
				return AccessTools.Method(type, "URPC_SyncDelete", (Type[])null, (Type[])null);
			}
			return null;
		}

		private static bool Prepare()
		{
			bool num = TargetMethod() != null;
			if (!num)
			{
				SLog.Line("CardDeleteRebuildPatch — Rounds2Mod.CardDeleteManager not found; delete hook skipped.");
			}
			return num;
		}

		private static void Postfix(int playerID)
		{
			ShieldHandRebuild.RebuildForPlayer(playerID);
			PoisonHandRebuild.RebuildForPlayer(playerID);
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "DoDamage")]
	internal static class HealthHandlerDoDamagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(HealthHandler __instance, ref Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon, Player damagingPlayer, bool healthRemoval, bool lethal, bool ignoreBlock)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			if (damage == Vector2.zero)
			{
				return true;
			}
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			float magnitude = ((Vector2)(ref damage)).magnitude;
			float num = magnitude;
			bool flag = PoisonDamageDetector.IsPoisonDamage(blinkColor, damagingWeapon);
			if (flag && (Object)(object)PoisonResistanceManager.instance != (Object)null && PoisonResistanceManager.instance.GetReduction(component.playerID) > 0f)
			{
				num = PoisonResistanceManager.instance.ApplyResistance(component.playerID, magnitude, out var _);
				if (num > 0f)
				{
					damage = ((Vector2)(ref damage)).normalized * num;
				}
				else
				{
					damage = Vector2.zero;
				}
			}
			if (num <= 0f)
			{
				return false;
			}
			if ((Object)(object)ShieldManager.instance == (Object)null)
			{
				if (flag && magnitude > num)
				{
					LogPoisonPlayerDamage(component.playerID, magnitude, num);
				}
				return true;
			}
			if (!ShieldManager.instance.TryAbsorbFull(component.playerID, num, out var depleted))
			{
				if (flag && ShieldManager.instance.IsPoisonDrainBlocked(component.playerID))
				{
					SLog.Line($"[ShieldsMod] Poison tick for player {component.playerID} suppressed — shield already drained this DoT.");
					return false;
				}
				if (flag && magnitude > num)
				{
					LogPoisonPlayerDamage(component.playerID, magnitude, num);
				}
				return true;
			}
			if (flag && depleted)
			{
				ShieldManager.instance.MarkPoisonDepleted(component.playerID);
			}
			if (flag && magnitude > num)
			{
				LogPoisonShieldDamage(component.playerID, magnitude, num, depleted);
			}
			damage = Vector2.zero;
			if ((Object)(object)component.data?.view != (Object)null && component.data.view.IsMine)
			{
				ShieldNetworkSync.BroadcastShieldHealth(component.playerID, ShieldManager.instance.GetShield(component.playerID).Current);
			}
			return false;
		}

		private static void LogPoisonPlayerDamage(int playerID, float rawAmount, float actualAmount)
		{
			SLog.Section("Poison resistance — player");
			SLog.Line($"Player {playerID} would've taken {rawAmount:F1} poison damage but took {actualAmount:F1} instead.");
		}

		private static void LogPoisonShieldDamage(int playerID, float rawAmount, float actualAmount, bool depleted)
		{
			SLog.Section("Poison resistance — shield");
			SLog.Line($"Player {playerID}'s shield would've taken {rawAmount:F1} poison damage but took {actualAmount:F1} instead (depleted={depleted}).");
		}
	}
}
namespace ShieldsMod.Networking
{
	public static class ShieldNetworkSync
	{
		public static void BroadcastShieldHealth(int playerID, float current)
		{
			SLog.Line($"BroadcastShieldHealth player={playerID} current={current:F1}");
			NetworkingManager.RPC(typeof(ShieldNetworkSync), "URPC_SetShieldHealth", new object[2] { playerID, current });
		}

		[UnboundRPC]
		public static void URPC_SetShieldHealth(int playerID, float current)
		{
			if (!((Object)(object)ShieldManager.instance == (Object)null))
			{
				ShieldState orCreateShield = ShieldManager.instance.GetOrCreateShield(playerID);
				orCreateShield.Current = Mathf.Clamp(current, 0f, orCreateShield.Max);
				ShieldManager.instance.RefreshVisual(playerID);
				SLog.Line($"URPC_SetShieldHealth player={playerID} current={orCreateShield.Current:F1}");
			}
		}
	}
}
namespace ShieldsMod.Cards
{
	public static class CardArtLoader
	{
		private static readonly Dictionary<string, GameObject> Cache = new Dictionary<string, GameObject>();

		public static string AssetsDirectory => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? "", "assets");

		public static GameObject Load(string fileName)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			SLog.Section("CardArtLoader.Load — '" + fileName + "'");
			SLog.Line("AssetsDirectory = " + AssetsDirectory);
			if (string.IsNullOrEmpty(fileName))
			{
				SLog.Warn("Load called with empty fileName — returning null.");
				return null;
			}
			if (Cache.TryGetValue(fileName, out var value) && (Object)(object)value != (Object)null)
			{
				SLog.Line("Returning cached art object.");
				return value;
			}
			string text = Path.Combine(AssetsDirectory, fileName);
			SLog.Line("Full path = " + text);
			SLog.Line($"File.Exists = {File.Exists(text)}");
			if (!File.Exists(text))
			{
				SLog.Warn("Card art not found at: " + text);
				return null;
			}
			byte[] array = File.ReadAllBytes(text);
			SLog.Line($"Read {array.Length} bytes.");
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			bool flag = ImageConversion.LoadImage(val, array);
			SLog.Line($"Texture.LoadImage = {flag}, size = {((Texture)val).width}x{((Texture)val).height}");
			if (!flag)
			{
				SLog.Warn("Failed to decode card art: " + text);
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Sprite sprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			GameObject val2 = new GameObject("ShieldsCardArt_" + fileName);
			Object.DontDestroyOnLoad((Object)(object)val2);
			RectTransform obj = val2.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			((Transform)obj).localPosition = Vector3.up * 10000f;
			Image obj2 = val2.AddComponent<Image>();
			obj2.sprite = sprite;
			obj2.preserveAspect = true;
			((Graphic)obj2).raycastTarget = false;
			Cache[fileName] = val2;
			SLog.Line("Loaded card art '" + fileName + "' from " + text);
			return val2;
		}
	}
	internal static class PoisonCardDeltaRegistrar
	{
		internal static void RegisterAll()
		{
			SLog.Section("PoisonCardDeltaRegistrar — RegisterAll");
			RegisterTier(PoisonCardRegistry.Lv1, 0.25f);
			RegisterTier(PoisonCardRegistry.Lv2, 0.5f);
			RegisterTier(PoisonCardRegistry.Lv3, 0.75f);
		}

		private static void RegisterTier(CardInfo card, float totalReduction)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			if (!((Object)(object)card == (Object)null))
			{
				PoisonHandRebuild.RegisterTier(card.cardName, totalReduction);
				CardDeltaRegistry.RegisterSimple(card.cardName, (SimpleDeltaProvider)((Player player, CardInfo _) => ComputeDelta(player, totalReduction)));
				SLog.Line($"Registered poison delta preview for '{card.cardName}' ({totalReduction * 100f:F0}%).");
			}
		}

		private static IReadOnlyList<(string label, string before, string after)> ComputeDelta(Player player, float tierReduction)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)PoisonResistanceManager.instance == (Object)null)
			{
				return Array.Empty<(string, string, string)>();
			}
			float reductionPercent = PoisonResistanceManager.instance.GetReductionPercent(player.playerID);
			float num = tierReduction * 100f;
			return new(string, string, string)[1] { ("Poison Resistance", $"{reductionPercent:F0}%", $"{num:F0}%") };
		}
	}
	internal static class PoisonCardRegistrar
	{
		internal static void RegisterAll()
		{
			SLog.Section("PoisonCardRegistrar — RegisterAll");
			CustomCard.BuildCard<PoisonResistanceLv3>((Action<CardInfo>)delegate(CardInfo ci)
			{
				PoisonCardRegistry.Lv3 = ci;
			});
			CustomCard.BuildCard<PoisonResistanceLv2>((Action<CardInfo>)delegate(CardInfo ci)
			{
				PoisonCardRegistry.Lv2 = ci;
			});
			CustomCard.BuildCard<PoisonResistanceLv1>((Action<CardInfo>)OnLv1Built);
		}

		private static void OnLv1Built(CardInfo ci)
		{
			PoisonCardRegistry.Lv1 = ci;
			SLog.Line("Registered Poison Resistance LV1: " + ci.cardName);
			PoisonCardRegistry.WireLevelChain();
			RegisterPrerequisites();
			PoisonCardDeltaRegistrar.RegisterAll();
		}

		private static void RegisterPrerequisites()
		{
			SLog.Section("PoisonCardRegistrar — RegisterPrerequisites");
			if (!RtgPrerequisiteBridge.IsAvailable)
			{
				SLog.Warn("RoundsTheGathering not available — poison cards will NOT be unlock-gated.");
				return;
			}
			TryRegister(PoisonCardRegistry.Lv2, PoisonCardRegistry.Lv1);
			TryRegister(PoisonCardRegistry.Lv3, PoisonCardRegistry.Lv2);
		}

		private static void TryRegister(CardInfo card, CardInfo required)
		{
			if (!((Object)(object)card == (Object)null) && !((Object)(object)required == (Object)null))
			{
				bool flag = RtgPrerequisiteBridge.Register(card.cardName, required.cardName);
				SLog.Line($"Prereq: \"{card.cardName}\" requires \"{required.cardName}\" — registered={flag}");
			}
		}
	}
	internal static class PoisonCardRegistry
	{
		internal static CardInfo Lv1;

		internal static CardInfo Lv2;

		internal static CardInfo Lv3;

		internal static void WireLevelChain()
		{
			SetNext<PoisonResistanceLv1>(Lv1, Lv2);
			SetNext<PoisonResistanceLv2>(Lv2, Lv3);
			SLog.Line("Poison card level chain wired (LV1 -> LV3).");
		}

		private static void SetNext<T>(CardInfo from, CardInfo to) where T : PoisonResistanceBase
		{
			if (!((Object)(object)from == (Object)null))
			{
				T component = ((Component)from).GetComponent<T>();
				if ((Object)(object)component != (Object)null)
				{
					component.NextLevelCard = to;
				}
			}
		}
	}
	public abstract class PoisonResistanceBase : CustomCard
	{
		public CardInfo NextLevelCard;

		protected abstract int Level { get; }

		protected abstract float TotalReduction { get; }

		protected abstract string ArtFileName { get; }

		protected abstract Rarity CardRarity { get; }

		protected override string GetTitle()
		{
			return "Poison Resistance " + Roman(Level);
		}

		protected override string GetDescription()
		{
			return "Decrease the effects of Poison on both you and your shield by " + PercentLabel(TotalReduction) + ".";
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					amount = PercentLabel(TotalReduction),
					stat = "Poison Resist",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override Rarity GetRarity()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return CardRarity;
		}

		protected override GameObject GetCardArt()
		{
			return CardArtLoader.Load(ArtFileName);
		}

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

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

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!((Object)(object)player == (Object)null))
			{
				PoisonResistanceManager.instance?.RebuildForPlayer(player.playerID);
				SLog.Section($"PoisonResistance LV{Level} — OnAddCard");
				SLog.Line($"player={player.playerID} totalReduction={TotalReduction * 100f:F0}%");
				if ((Object)(object)NextLevelCard != (Object)null)
				{
					SLog.Line($"Next tier '{NextLevelCard.cardName}' becomes draftable now that LV{Level} is owned.");
				}
			}
		}

		private static string PercentLabel(float reduction)
		{
			return $"{Mathf.RoundToInt(reduction * 100f)}%";
		}

		private static string Roman(int level)
		{
			return level switch
			{
				1 => "I", 
				2 => "II", 
				3 => "III", 
				_ => level.ToString(), 
			};
		}
	}
	public class PoisonResistanceLv1 : PoisonResistanceBase
	{
		protected override int Level => 1;

		protected override float TotalReduction => 0.25f;

		protected override string ArtFileName => "poison_resistance_lv1.png";

		protected override Rarity CardRarity => (Rarity)0;
	}
	public class PoisonResistanceLv2 : PoisonResistanceBase
	{
		protected override int Level => 2;

		protected override float TotalReduction => 0.5f;

		protected override string ArtFileName => "poison_resistance_lv2.png";

		protected override Rarity CardRarity => (Rarity)2;
	}
	public class PoisonResistanceLv3 : PoisonResistanceBase
	{
		protected override int Level => 3;

		protected override float TotalReduction => 0.75f;

		protected override string ArtFileName => "poison_resistance_lv3.png";

		protected override Rarity CardRarity => (Rarity)2;
	}
	internal static class RtgPrerequisiteBridge
	{
		private static MethodInfo _registerMethod;

		private static bool _resolved;

		public static bool IsAvailable
		{
			get
			{
				Resolve();
				return _registerMethod != null;
			}
		}

		private static void Resolve()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "RoundsTheGathering");
				if (assembly == null)
				{
					SLog.Warn("RoundsTheGathering assembly not found — shield unlock chain will not be registered.");
					return;
				}
				Type type = assembly.GetType("RoundsTheGathering.CardPrerequisiteRegistry");
				if (type == null)
				{
					SLog.Warn("RoundsTheGathering.CardPrerequisiteRegistry type not found.");
					return;
				}
				_registerMethod = type.GetMethod("RegisterPrerequisite", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
				{
					typeof(string),
					typeof(string)
				}, null);
				if (_registerMethod == null)
				{
					SLog.Warn("RegisterPrerequisite(string, string) not found on CardPrerequisiteRegistry.");
				}
			}
			catch (Exception ex)
			{
				SLog.Error("Failed to resolve RoundsTheGathering registry: " + ex.Message);
			}
		}

		internal static bool Register(string cardName, string requiredCardName)
		{
			Resolve();
			if (_registerMethod == null)
			{
				return false;
			}
			try
			{
				_registerMethod.Invoke(null, new object[2] { cardName, requiredCardName });
				return true;
			}
			catch (Exception ex)
			{
				SLog.Error("RegisterPrerequisite invoke failed: " + ex.Message);
				return false;
			}
		}
	}
	internal static class ShieldCardDeltaRegistrar
	{
		internal static void RegisterAll()
		{
			SLog.Section("ShieldCardDeltaRegistrar — RegisterAll");
			RegisterTier(ShieldCardRegistry.Lv1, 1.1f);
			RegisterTier(ShieldCardRegistry.Lv2, 1.25f);
			RegisterTier(ShieldCardRegistry.Lv3, 1.5f);
			RegisterTier(ShieldCardRegistry.Lv4, 2f);
			RegisterTier(ShieldCardRegistry.Lv5, 2.65f);
		}

		private static void RegisterTier(CardInfo card, float multiplier)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if ((Object)(object)card == (Object)null)
			{
				SLog.Warn("ShieldCardDeltaRegistrar — skipped null card reference.");
				return;
			}
			ShieldHandRebuild.RegisterTier(card, multiplier);
			CardDeltaRegistry.RegisterSimple(card.cardName, (SimpleDeltaProvider)((Player player, CardInfo _) => ComputeShieldDelta(player, multiplier)));
			SLog.Line($"Registered stat-delta preview for '{card.cardName}' (x{multiplier:F2}).");
		}

		private static IReadOnlyList<(string label, string before, string after)> ComputeShieldDelta(Player player, float multiplier)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)ShieldManager.instance == (Object)null)
			{
				return Array.Empty<(string, string, string)>();
			}
			float max = ShieldManager.instance.GetShield(player.playerID).Max;
			float num = max * multiplier;
			return new(string, string, string)[1] { ("Shield Max", $"{max:F0}", $"{num:F0}") };
		}
	}
	internal static class ShieldCardRegistrar
	{
		internal static void RegisterAll()
		{
			SLog.Section("ShieldCardRegistrar — RegisterAll");
			CustomCard.BuildCard<UpgradeShieldLv5>((Action<CardInfo>)OnLv5Built);
			CustomCard.BuildCard<UpgradeShieldLv4>((Action<CardInfo>)OnLv4Built);
			CustomCard.BuildCard<UpgradeShieldLv3>((Action<CardInfo>)OnLv3Built);
			CustomCard.BuildCard<UpgradeShieldLv2>((Action<CardInfo>)OnLv2Built);
			CustomCard.BuildCard<UpgradeShieldLv1>((Action<CardInfo>)OnLv1Built);
		}

		private static void OnLv5Built(CardInfo ci)
		{
			ShieldCardRegistry.Lv5 = ci;
			SLog.Line("Registered LV5: " + ci.cardName);
		}

		private static void OnLv4Built(CardInfo ci)
		{
			ShieldCardRegistry.Lv4 = ci;
			SLog.Line("Registered LV4: " + ci.cardName);
		}

		private static void OnLv3Built(CardInfo ci)
		{
			ShieldCardRegistry.Lv3 = ci;
			SLog.Line("Registered LV3: " + ci.cardName);
		}

		private static void OnLv2Built(CardInfo ci)
		{
			ShieldCardRegistry.Lv2 = ci;
			SLog.Line("Registered LV2: " + ci.cardName);
		}

		private static void OnLv1Built(CardInfo ci)
		{
			ShieldCardRegistry.Lv1 = ci;
			SLog.Line("Registered LV1: " + ci.cardName);
			ShieldCardRegistry.WireLevelChain();
			RegisterPrerequisites();
			ShieldCardDeltaRegistrar.RegisterAll();
		}

		private static void RegisterPrerequisites()
		{
			SLog.Section("ShieldCardRegistrar — RegisterPrerequisites");
			if (!RtgPrerequisiteBridge.IsAvailable)
			{
				SLog.Warn("RoundsTheGathering not available — shield cards will NOT be unlock-gated.");
				return;
			}
			TryRegister(ShieldCardRegistry.Lv2, ShieldCardRegistry.Lv1);
			TryRegister(ShieldCardRegistry.Lv3, ShieldCardRegistry.Lv2);
			TryRegister(ShieldCardRegistry.Lv4, ShieldCardRegistry.Lv3);
			TryRegister(ShieldCardRegistry.Lv5, ShieldCardRegistry.Lv4);
		}

		private static void TryRegister(CardInfo card, CardInfo required)
		{
			if ((Object)(object)card == (Object)null || (Object)(object)required == (Object)null)
			{
				SLog.Warn("Skipping prerequisite registration — a card reference was null.");
				return;
			}
			bool flag = RtgPrerequisiteBridge.Register(card.cardName, required.cardName);
			SLog.Line($"Prereq: \"{card.cardName}\" requires \"{required.cardName}\" — registered={flag}");
		}
	}
	internal static class ShieldCardRegistry
	{
		internal static CardInfo Lv1;

		internal static CardInfo Lv2;

		internal static CardInfo Lv3;

		internal static CardInfo Lv4;

		internal static CardInfo Lv5;

		internal static void WireLevelChain()
		{
			SetNext<UpgradeShieldLv1>(Lv1, Lv2);
			SetNext<UpgradeShieldLv2>(Lv2, Lv3);
			SetNext<UpgradeShieldLv3>(Lv3, Lv4);
			SetNext<UpgradeShieldLv4>(Lv4, Lv5);
			SLog.Line("Shield card level chain wired (LV1 -> LV5).");
		}

		private static void SetNext<T>(CardInfo from, CardInfo to) where T : UpgradeShieldHealthBase
		{
			if (!((Object)(object)from == (Object)null))
			{
				T component = ((Component)from).GetComponent<T>();
				if ((Object)(object)component != (Object)null)
				{
					component.NextLevelCard = to;
				}
			}
		}
	}
	public abstract class UpgradeShieldHealthBase : CustomCard
	{
		public CardInfo NextLevelCard;

		protected abstract int Level { get; }

		protected abstract float Multiplier { get; }

		protected abstract string ArtFileName { get; }

		protected abstract Rarity CardRarity { get; }

		protected override string GetTitle()
		{
			return "Upgrade Shield Health " + Roman(Level);
		}

		protected override string GetDescription()
		{
			return "Increases max shield health by " + PercentLabel(Multiplier) + ". Multiplies with other shield upgrades.";
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					amount = PercentLabel(Multiplier),
					stat = "Shield Max",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override Rarity GetRarity()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return CardRarity;
		}

		protected override GameObject GetCardArt()
		{
			return CardArtLoader.Load(ArtFileName);
		}

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

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

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)ShieldManager.instance == (Object)null))
			{
				int playerID = player.playerID;
				ShieldState orCreateShield = ShieldManager.instance.GetOrCreateShield(playerID);
				float max = orCreateShield.Max;
				orCreateShield.Max *= Multiplier;
				orCreateShield.Current = Mathf.Min(orCreateShield.Current, orCreateShield.Max);
				ShieldManager.instance.RefreshVisual(playerID);
				SLog.Section($"UpgradeShieldHealth LV{Level} — OnAddCard");
				SLog.Line($"player={playerID} multiplier={Multiplier:F2} max {max:F1} -> {orCreateShield.Max:F1}");
				if ((Object)(object)NextLevelCard != (Object)null)
				{
					SLog.Line($"Next tier '{NextLevelCard.cardName}' becomes draftable now that LV{Level} is owned.");
				}
				else
				{
					SLog.Line("This is the final tier (no next level).");
				}
			}
		}

		private static string PercentLabel(float multiplier)
		{
			return $"+{Mathf.RoundToInt((multiplier - 1f) * 100f)}%";
		}

		private static string Roman(int level)
		{
			return level switch
			{
				1 => "I", 
				2 => "II", 
				3 => "III", 
				4 => "IV", 
				5 => "V", 
				_ => level.ToString(), 
			};
		}
	}
	public class UpgradeShieldLv1 : UpgradeShieldHealthBase
	{
		protected override int Level => 1;

		protected override float Multiplier => 1.1f;

		protected override string ArtFileName => "lv1_artwork.png";

		protected override Rarity CardRarity => (Rarity)0;
	}
	public class UpgradeShieldLv2 : UpgradeShieldHealthBase
	{
		protected override int Level => 2;

		protected override float Multiplier => 1.25f;

		protected override string ArtFileName => "lv2_artwork.png";

		protected override Rarity CardRarity => (Rarity)0;
	}
	public class UpgradeShieldLv3 : UpgradeShieldHealthBase
	{
		protected override int Level => 3;

		protected override float Multiplier => 1.5f;

		protected override string ArtFileName => "lv3_artwork.png";

		protected override Rarity CardRarity => (Rarity)1;
	}
	public class UpgradeShieldLv4 : UpgradeShieldHealthBase
	{
		protected override int Level => 4;

		protected override float Multiplier => 2f;

		protected override string ArtFileName => "lv4_artwork.png";

		protected override Rarity CardRarity => (Rarity)1;
	}
	public class UpgradeShieldLv5 : UpgradeShieldHealthBase
	{
		protected override int Level => 5;

		protected override float Multiplier => 2.65f;

		protected override string ArtFileName => "lv5_artwork.png";

		protected override Rarity CardRarity => (Rarity)2;
	}
}