Decompiled source of EpicCards v1.0.10

BepInEx/plugins/Epicninjaman-EpicCards/EpicCards.dll

Decompiled 4 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BossSlothsCards.Extensions;
using EpicCards.Cards;
using EpicCards.Effects;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Extensions;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.Utils;
using UnboundLib;
using UnboundLib.Cards;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EpicCards")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a8c8fafbd9c652469d88f4416204abe9e75c8873")]
[assembly: AssemblyProduct("EpicCards")]
[assembly: AssemblyTitle("EpicCards")]
[assembly: AssemblyVersion("1.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;
		}
	}
}
public static class ExtensionMethods
{
	public static void RemovePlayerDiedAction(this PlayerManager pm, Action<Player, int> listener)
	{
		Action<Player, int> source = (Action<Player, int>)ExtensionMethods.GetFieldValue((object)pm, "PlayerDiedAction");
		source = (Action<Player, int>)Delegate.Remove(source, listener);
		ExtensionMethods.SetFieldValue((object)pm, "PlayerDiedAction", (object)source);
	}
}
namespace BossSlothsCards.Extensions
{
	public static class PlayerManagerExtension
	{
		public static Player GetRandomEnemy(this PlayerManager playerManager, Player player)
		{
			if (playerManager.players.Count == 1)
			{
				return null;
			}
			List<Player> list = new List<Player>(playerManager.players);
			Player[] playersInTeam = playerManager.GetPlayersInTeam(player.teamID);
			foreach (Player item in playersInTeam)
			{
				list.Remove(item);
			}
			return list[Random.Range(0, list.Count)];
		}

		public static Player GetPlayerWithID(this PlayerManager playerManager, int playerID)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			return (Player)typeof(PlayerManager).InvokeMember("GetPlayerWithID", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, playerManager, new object[1] { playerID });
		}
	}
}
namespace EpicCards
{
	internal class Assets
	{
		private static readonly AssetBundle Bundle = AssetUtils.LoadAssetBundleFromResources("epiccardsart", typeof(EpicCards).Assembly);

		public static GameObject GrowRayArt = Bundle.LoadAsset<GameObject>("C_GrowRay");

		public static GameObject AntManArt = Bundle.LoadAsset<GameObject>("C_AntMan");

		public static GameObject CopyCatArt = Bundle.LoadAsset<GameObject>("C_CopyCat");
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.epicninjaman.rounds.EpicCards", "EpicCards", "1.0.0")]
	[BepInProcess("Rounds.exe")]
	public class EpicCards : BaseUnityPlugin
	{
		private const string ModId = "com.epicninjaman.rounds.EpicCards";

		private const string ModName = "EpicCards";

		public const string Version = "1.0.0";

		public const string ModInitials = "EC";

		public static EpicCards instance { get; private set; }

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony val = new Harmony("com.epicninjaman.rounds.EpicCards");
			val.PatchAll();
		}

		private void Start()
		{
			CustomCard.BuildCard<CopyCat>();
			CustomCard.BuildCard<GrowRay>();
			CustomCard.BuildCard<ShrinkBlock>();
			instance = this;
		}
	}
}
namespace EpicCards.Effects
{
	public class GrowRayEffect : RayHitEffect
	{
		public override HasToReturn DoHitEffect(HitInfo hit)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Collider2D collider = hit.collider;
				if ((Object)(object)collider == (Object)null)
				{
					return (HasToReturn)1;
				}
				Player componentInParent = ((Component)collider).GetComponentInParent<Player>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return (HasToReturn)1;
				}
				GrowRayReversibleEffect component = ((Component)componentInParent).gameObject.GetComponent<GrowRayReversibleEffect>();
				if ((Object)(object)component == (Object)null)
				{
					GrowRayReversibleEffect growRayReversibleEffect = ((Component)componentInParent).gameObject.AddComponent<GrowRayReversibleEffect>();
					growRayReversibleEffect.Initialize(1.2f, 10f);
				}
				else
				{
					component.ApplyGrowth(1.2f, 10f);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError("Error in GrowRayEffect: " + ex.Message);
			}
			return (HasToReturn)1;
		}
	}
	public class GrowRayReversibleEffect : ReversibleEffect
	{
		private float sizeIncreaseFactor;

		private float duration;

		private float maxSize = 10f;

		private float balloonPopThreshold = 2.5f;

		private Vector3 initialSize;

		private bool isInitialized = false;

		private Coroutine sizeResetCoroutine;

		public void Initialize(float sizeIncreaseFactor, float duration)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			this.sizeIncreaseFactor = sizeIncreaseFactor;
			this.duration = duration;
			if (!isInitialized)
			{
				initialSize = ((Component)base.player).transform.localScale;
				isInitialized = true;
			}
			ApplyGrowth(sizeIncreaseFactor, duration);
			PlayerManager.instance.AddPlayerDiedAction((Action<Player, int>)PlayerDied);
			HealthHandler healthHandler = base.player.data.healthHandler;
			healthHandler.reviveAction = (Action)Delegate.Combine(healthHandler.reviveAction, new Action(OnRevive));
		}

		public void ApplyGrowth(float sizeIncreaseFactor, float duration)
		{
			//IL_001a: 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_0054: 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_0099: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: 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_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			this.sizeIncreaseFactor = sizeIncreaseFactor;
			this.duration = duration;
			if (((Component)base.player).transform.localScale.x < maxSize || ((Component)base.player).transform.localScale.y < maxSize || ((Component)base.player).transform.localScale.z < maxSize)
			{
				Transform transform = ((Component)base.player).transform;
				transform.localScale *= sizeIncreaseFactor;
				if (((Component)base.player).transform.localScale.x > maxSize)
				{
					((Component)base.player).transform.localScale = new Vector3(maxSize, ((Component)base.player).transform.localScale.y, ((Component)base.player).transform.localScale.z);
				}
				if (((Component)base.player).transform.localScale.y > maxSize)
				{
					((Component)base.player).transform.localScale = new Vector3(((Component)base.player).transform.localScale.x, maxSize, ((Component)base.player).transform.localScale.z);
				}
				if (((Component)base.player).transform.localScale.z > maxSize)
				{
					((Component)base.player).transform.localScale = new Vector3(((Component)base.player).transform.localScale.x, ((Component)base.player).transform.localScale.y, maxSize);
				}
				if (sizeResetCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(sizeResetCoroutine);
				}
				sizeResetCoroutine = ((MonoBehaviour)this).StartCoroutine(ResetSizeGradually());
			}
		}

		private IEnumerator ResetSizeGradually()
		{
			float elapsed = 0f;
			Vector3 targetSize = initialSize;
			Vector3 startSize = ((Component)base.player).transform.localScale;
			while (elapsed < duration)
			{
				((Component)base.player).transform.localScale = Vector3.Lerp(startSize, targetSize, elapsed / duration);
				elapsed += Time.deltaTime;
				yield return null;
			}
			((Component)base.player).transform.localScale = targetSize;
			sizeResetCoroutine = null;
		}

		public override void OnOnDestroy()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PlayerManager.instance != (Object)null)
			{
				PlayerManager.instance.RemovePlayerDiedAction(PlayerDied);
			}
			if ((Object)(object)base.player != (Object)null && (Object)(object)base.player.data != (Object)null && (Object)(object)base.player.data.healthHandler != (Object)null)
			{
				HealthHandler healthHandler = base.player.data.healthHandler;
				healthHandler.reviveAction = (Action)Delegate.Remove(healthHandler.reviveAction, new Action(OnRevive));
			}
			((Component)base.player).transform.localScale = initialSize;
		}

		private void OnRevive()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((Component)base.player).transform.localScale = initialSize;
		}

		private void PlayerDied(Player diedPlayer, int remainingPlayers)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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)
			if ((Object)(object)diedPlayer == (Object)(object)base.player)
			{
				if (((Component)base.player).transform.localScale.x >= balloonPopThreshold || ((Component)base.player).transform.localScale.y >= balloonPopThreshold || ((Component)base.player).transform.localScale.z >= balloonPopThreshold)
				{
				}
				((Component)base.player).transform.localScale = initialSize;
			}
		}
	}
	public class ShrinkOnBlockEffect : MonoBehaviour
	{
		private class BlockEvent
		{
			public float ShrinkAmount { get; set; }

			public float ResetTime { get; set; }
		}

		private Player player;

		private Block block;

		private Vector3 initialScale;

		private float shrinkFactor = 0.75f;

		private float resetDuration = 5f;

		private const float minScale = 0.25f;

		private Queue<BlockEvent> blockEvents = new Queue<BlockEvent>();

		private void Start()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			player = ((Component)this).GetComponent<Player>();
			block = ((Component)player).GetComponent<Block>();
			initialScale = ((Component)player).transform.localScale;
			Block obj = block;
			obj.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(obj.BlockAction, new Action<BlockTriggerType>(OnBlock));
			PlayerManager.instance.AddPlayerDiedAction((Action<Player, int>)PlayerDied);
			HealthHandler healthHandler = player.data.healthHandler;
			healthHandler.reviveAction = (Action)Delegate.Combine(healthHandler.reviveAction, new Action(OnRevive));
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_001b: 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_002b: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger == 1)
			{
				return;
			}
			Vector3 val = ((Component)player).transform.localScale * shrinkFactor;
			if (val.x >= 0.25f && val.y >= 0.25f && val.z >= 0.25f)
			{
				((Component)player).transform.localScale = val;
				BlockEvent item = new BlockEvent
				{
					ShrinkAmount = shrinkFactor,
					ResetTime = Time.time + resetDuration
				};
				blockEvents.Enqueue(item);
				if (blockEvents.Count == 1)
				{
					((MonoBehaviour)this).StartCoroutine(HandleBlockEvents());
				}
			}
		}

		private IEnumerator HandleBlockEvents()
		{
			while (blockEvents.Count > 0)
			{
				BlockEvent currentEvent = blockEvents.Peek();
				yield return (object)new WaitForSeconds(currentEvent.ResetTime - Time.time);
				Transform transform = ((Component)player).transform;
				transform.localScale /= currentEvent.ShrinkAmount;
				blockEvents.Dequeue();
			}
		}

		private void PlayerDied(Player diedPlayer, int remainingPlayers)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)diedPlayer == (Object)(object)player)
			{
				((Component)player).transform.localScale = initialScale;
				blockEvents.Clear();
			}
		}

		private void Update()
		{
			//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)
			if (((Component)player).transform.localScale == initialScale)
			{
				blockEvents.Clear();
			}
		}

		private void OnRevive()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((Component)player).transform.localScale = initialScale;
			blockEvents.Clear();
		}

		private void OnDestroy()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			Block obj = block;
			obj.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(obj.BlockAction, new Action<BlockTriggerType>(OnBlock));
			if ((Object)(object)PlayerManager.instance != (Object)null)
			{
				PlayerManager.instance.RemovePlayerDiedAction(PlayerDied);
			}
			if ((Object)(object)player != (Object)null && (Object)(object)player.data != (Object)null && (Object)(object)player.data.healthHandler != (Object)null)
			{
				HealthHandler healthHandler = player.data.healthHandler;
				healthHandler.reviveAction = (Action)Delegate.Remove(healthHandler.reviveAction, new Action(OnRevive));
			}
			((Component)player).transform.localScale = initialScale;
		}
	}
}
namespace EpicCards.Cards
{
	public class CopyCat : CustomCard
	{
		protected override string GetTitle()
		{
			return "Copycat";
		}

		protected override string GetDescription()
		{
			return "Copy a random valid card from a random enemy";
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			Debug.Log((object)"Adding Copycat card");
			Player randomEnemy = PlayerManager.instance.GetRandomEnemy(player);
			if ((Object)(object)randomEnemy == (Object)null || randomEnemy.data.currentCards.Count == 0)
			{
				return;
			}
			int num = 0;
			while (num <= 50)
			{
				int index = Random.Range(0, randomEnemy.data.currentCards.Count);
				num++;
				if (!Cards.instance.PlayerIsAllowedCard(player, randomEnemy.data.currentCards[index]))
				{
					continue;
				}
				CardInfo val = randomEnemy.data.currentCards[index];
				Cards.instance.AddCardToPlayer(player, val, false, "", 0f, 0f, true);
				CardBarUtils.instance.ShowAtEndOfPhase(player, val);
				break;
			}
		}

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers)
		{
			Debug.Log((object)"Setting up Copycat card");
			cardInfo.allowMultiple = true;
			CardInfoExtension.GetAdditionalData(cardInfo).canBeReassigned = false;
		}

		protected override CardInfoStat[] GetStats()
		{
			return null;
		}

		protected override Rarity GetRarity()
		{
			//IL_0002: 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)
			return (Rarity)0;
		}

		protected override GameObject GetCardArt()
		{
			return Assets.CopyCatArt;
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0002: 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)
			return (CardThemeColorType)0;
		}

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

		public override void OnRemoveCard()
		{
		}
	}
	internal class GrowRay : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			//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)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			gun.objectsToSpawn = (ObjectsToSpawn[])(object)new ObjectsToSpawn[1]
			{
				new ObjectsToSpawn
				{
					AddToProjectile = ((Component)new GameObject("GrowRayEffect").AddComponent<GrowRayEffect>()).gameObject
				}
			};
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.attackSpeed *= 0.25f;
			gun.damage *= 0.8f;
		}

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

		protected override string GetTitle()
		{
			return "Grow Ray";
		}

		protected override string GetDescription()
		{
			return "Makes your enemies grow larger when hit.";
		}

		protected override GameObject GetCardArt()
		{
			return Assets.GrowRayArt;
		}

		protected override Rarity GetRarity()
		{
			//IL_0002: 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)
			return (Rarity)0;
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0009: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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: Expected O, but got Unknown
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[3]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Grow Size",
					amount = "+20%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Attack Speed",
					amount = "+75%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Damage",
					amount = "-20%",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0002: 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)
			return (CardThemeColorType)4;
		}

		public override string GetModName()
		{
			return "EC";
		}
	}
	internal class ShrinkBlock : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			((Component)player).gameObject.AddComponent<ShrinkOnBlockEffect>();
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			Object.Destroy((Object)(object)((Component)player).gameObject.GetComponent<ShrinkOnBlockEffect>());
		}

		protected override string GetTitle()
		{
			return "Ant Man";
		}

		protected override string GetDescription()
		{
			return "Shrink each time you block. Shrink wears off after 5s.";
		}

		protected override GameObject GetCardArt()
		{
			return Assets.AntManArt;
		}

		protected override Rarity GetRarity()
		{
			//IL_0002: 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)
			return (Rarity)0;
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0009: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Player Size",
					amount = "-25%",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0002: 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)
			return (CardThemeColorType)3;
		}

		public override string GetModName()
		{
			return "EC";
		}
	}
	internal class Template : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
		}

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

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

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

		protected override string GetDescription()
		{
			return "CardDescription";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

		protected override Rarity GetRarity()
		{
			//IL_0002: 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)
			return (Rarity)0;
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_0009: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Effect",
					amount = "No",
					simepleAmount = (SimpleAmount)0
				}
			};
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0002: 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)
			return (CardThemeColorType)7;
		}

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