using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using ClassesManagerReborn;
using ClassesManagerReborn.Util;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Extensions;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.Utils;
using MrFuntikMod.Cards;
using MrFuntikMod.Effects;
using MrFuntikMod.Extensions;
using MrFuntikMod.RoundsEffects;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using Sonigon.Internal;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnityEngine;
using UnityEngine.Rendering;

[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("MrFuntikMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d9262279e51b5698f505bda77cfc9b625e37f16e")]
[assembly: AssemblyProduct("MrFuntikMod")]
[assembly: AssemblyTitle("MrFuntikMod")]
[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;
		}
	}
}
namespace MFM.Mono
{
	public class MaxHealthEffect : ReversibleEffect
	{
		private bool active;

		private ColorEffect colorEffect;

		private Color color = Color.clear;

		public override void OnAwake()
		{
			((ReversibleEffect)this).SetLivesToEffect(int.MaxValue);
		}

		public override void OnStart()
		{
			base.applyImmediately = false;
			active = false;
		}

		public override void OnUpdate()
		{
			if (HealthInRange())
			{
				((ReversibleEffect)this).ApplyModifiers();
			}
			else if (((ReversibleEffect)this).modifiersActive && !HealthInRange())
			{
				((ReversibleEffect)this).ClearModifiers(false);
			}
			if (!active && HealthInRange())
			{
				ApplyColorEffect();
				active = true;
			}
			else if (active && !HealthInRange())
			{
				if ((Object)(object)colorEffect != (Object)null)
				{
					Object.Destroy((Object)(object)colorEffect);
				}
				active = false;
			}
		}

		private void ApplyColorEffect()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (color != Color.clear)
			{
				colorEffect = ((Component)base.player).gameObject.AddComponent<ColorEffect>();
				colorEffect.SetColor(color);
				Debug.Log((object)"color is set!");
			}
		}

		private bool HealthInRange()
		{
			return (double)base.data.health == (double)base.data.maxHealth;
		}

		public override void OnOnDisable()
		{
			((ReversibleEffect)this).ClearModifiers(false);
			active = false;
		}

		public override void OnOnDestroy()
		{
		}

		public void SetColor(Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			this.color = color;
		}
	}
}
namespace bfrm.Patches
{
	[HarmonyPatch(typeof(CharacterStatModifiers), "AddSlowAddative")]
	public class AntiSlowPatch_AddSlowAddative
	{
		public static bool Prefix(CharacterStatModifiers __instance, ref float slowToAdd, ref float maxValue, ref bool isFastSlow)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component != (Object)null && (Object)(object)((Component)component).gameObject.GetComponent<AntiSlowMono>() != (Object)null)
			{
				PlayResistEffects(component);
				return false;
			}
			return true;
		}

		public static void PlayResistEffects(Player player)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Color color = default(Color);
			((Color)(ref color))..ctor(0.2f, 1f, 0.6f, 1f);
			ShieldEffect.PlayShieldEffect(player, color);
		}
	}
	[HarmonyPatch(typeof(CharacterStatModifiers), "RPCA_AddSlow")]
	public class AntiSlowPatch_RPCA_AddSlow
	{
		public static bool Prefix(CharacterStatModifiers __instance, ref float slowToAdd, ref bool isFastSlow)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component != (Object)null && (Object)(object)((Component)component).gameObject.GetComponent<AntiSlowMono>() != (Object)null)
			{
				AntiSlowPatch_AddSlowAddative.PlayResistEffects(component);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterStatModifiers), "DoSlowDown")]
	public class AntiSlowPatch_DoSlowDown
	{
		public static bool Prefix(CharacterStatModifiers __instance, ref float newSlow)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component != (Object)null && (Object)(object)((Component)component).gameObject.GetComponent<AntiSlowMono>() != (Object)null)
			{
				return false;
			}
			return true;
		}
	}
}
namespace MrFuntikMod
{
	internal class Assets
	{
		private static readonly AssetBundle Bundle = AssetUtils.LoadAssetBundleFromResources("myasset", typeof(MrFuntikMod).Assembly);

		public static GameObject CHESS_KNIGHT_Art = Bundle.LoadAsset<GameObject>("C_CHESS_KNIGHT");

		public static GameObject Narcissism_Art = Bundle.LoadAsset<GameObject>("C_narcissism");

		public static GameObject CHESS_PAWN_Art = Bundle.LoadAsset<GameObject>("C_CHESS_PAWN");

		public static GameObject CHESS_ROOK_Art = Bundle.LoadAsset<GameObject>("C_CHESS_ROOK");

		public static GameObject CHESS_BISHOP_Art = Bundle.LoadAsset<GameObject>("C_CHESS_BISHOP");

		public static GameObject unstable_gun_Art = Bundle.LoadAsset<GameObject>("C_unstable_gun");

		public static GameObject NecroCardArt = Bundle.LoadAsset<GameObject>("C_necro_card");

		public static GameObject Necro2CardArt = Bundle.LoadAsset<GameObject>("C_necro2_card");

		public static GameObject Necro3CardArt = Bundle.LoadAsset<GameObject>("C_necro3_card");

		public static GameObject CHESS_QUEEN_Art = Bundle.LoadAsset<GameObject>("C_CHESS_QUEEN");

		public static GameObject VampireCastleArt = Bundle.LoadAsset<GameObject>("C_VAMPIRE_CASTLE");

		public static GameObject OneShotMan_Art = Bundle.LoadAsset<GameObject>("C_ONESHOT_MAN");

		public static GameObject DrillHands_Art = Bundle.LoadAsset<GameObject>("C_DRILL_HANDS");

		public static GameObject BounceConverter_Art = Bundle.LoadAsset<GameObject>("C_BOUNCE_CONVERTER");

		public static GameObject PhenomenalBalance_Art = Bundle.LoadAsset<GameObject>("C_PHENOMENAL_BALANCE");

		public static GameObject BalanceBlock_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_BLOCK");

		public static GameObject BalanceTank_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_TANK");

		public static GameObject BalanceHitman_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_HITMAN");

		public static GameObject BalanceBullets_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_BULLETS");

		public static GameObject BalanceMayhem_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_MAYHEM");

		public static GameObject BalanceSpeed_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_SPEED");

		public static GameObject BalanceReload_Art = Bundle.LoadAsset<GameObject>("C_BALANCE_RELOAD");

		public static GameObject ThunderCode_Art = Bundle.LoadAsset<GameObject>("C_THUNDER_CORE");

		public static GameObject EarthSpears_Art = Bundle.LoadAsset<GameObject>("C_EARTHSPEARS");

		public static GameObject Dancer_Art = Bundle.LoadAsset<GameObject>("C_DANCER");

		public static GameObject Momentum_Art = Bundle.LoadAsset<GameObject>("C_MOMENTUM");

		public static AudioClip DemRes1 = Bundle.LoadAsset<AudioClip>("dem_res_1");

		public static AudioClip DemRes2 = Bundle.LoadAsset<AudioClip>("dem_rev_2");

		public static AudioClip DemRes3 = Bundle.LoadAsset<AudioClip>("dem_res_3");

		public static AudioClip DemRes4 = Bundle.LoadAsset<AudioClip>("dem_res_4");

		public static AudioClip DemRes5 = Bundle.LoadAsset<AudioClip>("dem_res_pontiff");
	}
	internal class CardCheck : MonoBehaviour
	{
		public static int Amount(Player player, string cardName)
		{
			List<CardInfo> currentCards = player.data.currentCards;
			int num = 0;
			for (int num2 = currentCards.Count - 1; num2 >= 0; num2--)
			{
				if (currentCards[num2].cardName == cardName)
				{
					num++;
				}
			}
			return num;
		}
	}
	public static class ImmunityCardValidator
	{
		public static CardInfo MomentumCardInfo;

		public static bool CanPlayerTakeMomentum(Player player, CardInfo card)
		{
			if ((Object)(object)MomentumCardInfo == (Object)null)
			{
				return true;
			}
			if (((Object)((Component)card).gameObject).name != ((Object)((Component)MomentumCardInfo).gameObject).name)
			{
				return true;
			}
			bool flag = player.data.currentCards.Any((CardInfo c) => ((Object)((Component)c).gameObject).name == ((Object)((Component)MomentumCardInfo).gameObject).name);
			return !flag;
		}

		public static void RegisterValidationFunctions()
		{
			Cards.instance.AddCardValidationFunction((Func<Player, CardInfo, bool>)CanPlayerTakeMomentum);
		}
	}
	[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("com.MrseFuntik.Rounds.MFM", "MrFuntikMod", "1.1.0")]
	[BepInProcess("Rounds.exe")]
	public class MrFuntikMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <GameStart>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public MrFuntikMod <>4__this;

			private List<Player>.Enumerator <>s__1;

			private Player <player>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = default(List<Player>.Enumerator);
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>s__1 = PlayerManager.instance.players.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<player>5__2 = <>s__1.Current;
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(NecroCard2))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(NecroCard2);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(NecroCard3))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(NecroCard3);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(BalanceCard))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(BalanceCard);
						}
						((Component)<player>5__2).gameObject.AddComponent<MFMBalanceMono>();
						<player>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Player>.Enumerator);
				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();
			}
		}

		private const string ModId = "com.MrseFuntik.Rounds.MFM";

		private const string ModName = "MrFuntikMod";

		public const string Version = "1.1.0";

		public const string ModInitials = "MFM";

		internal static List<CardInfo> hiddenCards = new List<CardInfo>();

		internal static CardCategory NonBalanceCard;

		internal static CardCategory BalanceCard;

		internal static CardCategory NonNecroCard;

		internal static CardCategory NecroCard2;

		internal static CardCategory NecroCard3;

		public static MrFuntikMod instance { get; private set; }

		private static void Main()
		{
		}

		private void Awake()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			RarityUtils.AddRarity("NecroCards", 0.11f, new Color(0.96f, 0.188f, 0.188f), new Color(0.96f, 0.188f, 0.188f));
			Harmony val = new Harmony("com.MrseFuntik.Rounds.MFM");
			val.PatchAll();
		}

		private void Start()
		{
			NonNecroCard = CustomCardCategories.instance.CardCategory("NonNecroCard");
			NecroCard2 = CustomCardCategories.instance.CardCategory("NecroCard2");
			NecroCard3 = CustomCardCategories.instance.CardCategory("NecroCard3");
			NonBalanceCard = CustomCardCategories.instance.CardCategory("NonBalanceCard");
			BalanceCard = CustomCardCategories.instance.CardCategory("BalanceCard");
			instance = this;
			CustomCard.BuildCard<ChessPawn>();
			CustomCard.BuildCard<ChessKnightCard>();
			CustomCard.BuildCard<ChessRookCard>();
			CustomCard.BuildCard<ChessBishopCard>();
			CustomCard.BuildCard<ChessQueenCard>();
			CustomCard.BuildCard<NARCISSISM>();
			CustomCard.BuildCard<UnstableGunCard>();
			CustomCard.BuildCard<VampireCastleCard>();
			CustomCard.BuildCard<OneShotManCard>();
			CustomCard.BuildCard<DrillHands>();
			CustomCard.BuildCard<BounceConverter>();
			CustomCard.BuildCard<PhenomenalBalance>();
			CustomCard.BuildCard<BalanceBlock>();
			CustomCard.BuildCard<BalanceHitman>();
			CustomCard.BuildCard<BalanceBullets>();
			CustomCard.BuildCard<BalanceMayhem>();
			CustomCard.BuildCard<BalanceReload>();
			CustomCard.BuildCard<BalanceSpeed>();
			CustomCard.BuildCard<BalanceTank>();
			CustomCard.BuildCard<Necronomicon_I>();
			CustomCard.BuildCard<Necronomicon_II>();
			CustomCard.BuildCard<Necronomicon_II_b>();
			CustomCard.BuildCard<Necronomicon_II_c>();
			CustomCard.BuildCard<Necronomicon_II_d>();
			CustomCard.BuildCard<Necronomicon_II_e>();
			CustomCard.BuildCard<Necronomicon_III>();
			CustomCard.BuildCard<Necronomicon_III_b>();
			CustomCard.BuildCard<Necronomicon_III_c>();
			CustomCard.BuildCard<Necronomicon_III_d>();
			CustomCard.BuildCard<Necronomicon_III_e>();
			CustomCard.BuildCard<ThunderCoreCard>();
			CustomCard.BuildCard<EarthspearsCard>();
			CustomCard.BuildCard<DancerCard>();
			CustomCard.BuildCard<MomentumCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				ImmunityCardValidator.MomentumCardInfo = cardInfo;
				Debug.Log((object)"[MFM] Registered immunity card: Momentum");
			});
			ImmunityCardValidator.RegisterValidationFunctions();
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => PhenomenalBalance.ExtraPicks()));
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)instance, 1f, (Action)delegate
			{
				foreach (Card value in CardManager.cards.Values)
				{
					if (!value.cardInfo.categories.Contains(NecroCard2) && !value.cardInfo.categories.Contains(NecroCard3))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonNecroCard);
					}
					if (!value.cardInfo.categories.Contains(BalanceCard))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonBalanceCard);
					}
				}
			});
		}

		[IteratorStateMachine(typeof(<GameStart>d__17))]
		private IEnumerator GameStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GameStart>d__17(0)
			{
				<>4__this = this,
				gm = gm
			};
		}
	}
}
namespace MrFuntikMod.Effects
{
	public class AntiSlowMono : MonoBehaviour
	{
		private Player player;

		private CharacterStatModifiers stats;

		public void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			stats = ((Component)this).GetComponent<CharacterStatModifiers>();
		}

		public void Update()
		{
			if ((Object)(object)stats != (Object)null && (stats.slow > 0f || stats.slowSlow > 0f || stats.fastSlow > 0f))
			{
				stats.slow = 0f;
				stats.slowSlow = 0f;
				stats.fastSlow = 0f;
			}
		}

		private void OnDestroy()
		{
		}
	}
	public class DancerMono : MonoBehaviour
	{
		private const float BASE_DODGE_CHANCE = 0.15f;

		private const float DODGE_CHANCE_PER_STACK = 0.15f;

		private const float MAX_DODGE_CHANCE = 0.6f;

		private const float DODGE_IMMUNITY_WINDOW = 0.15f;

		public int stackCount = 1;

		private Player player;

		private float lastDodgeTime = -1f;

		private static List<MissTextEffect> textPool = new List<MissTextEffect>();

		private const int POOL_SIZE = 5;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			InitializePool();
		}

		private void InitializePool()
		{
			if (textPool.Count < 5)
			{
				for (int i = textPool.Count; i < 5; i++)
				{
					MissTextEffect missTextEffect = CreateMissTextObject();
					((Component)missTextEffect).gameObject.SetActive(false);
					textPool.Add(missTextEffect);
				}
			}
		}

		public float GetDodgeChance()
		{
			float num = 0.15f + (float)(stackCount - 1) * 0.15f;
			return Mathf.Min(num, 0.6f);
		}

		public bool IsInDodgeImmunity()
		{
			if (!CanDodge())
			{
				return false;
			}
			return Time.time - lastDodgeTime < 0.15f;
		}

		public void ActivateDodgeImmunity()
		{
			lastDodgeTime = Time.time;
		}

		public bool TryDodge()
		{
			if (!CanDodge())
			{
				return false;
			}
			float value = Random.value;
			float dodgeChance = GetDodgeChance();
			return value < dodgeChance;
		}

		public bool CanDodge()
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player.data == (Object)null)
			{
				return false;
			}
			if (player.data.health <= 0f)
			{
				return false;
			}
			if (!((Component)player).gameObject.activeInHierarchy)
			{
				return false;
			}
			return true;
		}

		public void ShowMissText()
		{
			//IL_00a4: 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_00c7: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDodge())
			{
				return;
			}
			ActivateDodgeImmunity();
			MissTextEffect missTextEffect = null;
			foreach (MissTextEffect item in textPool)
			{
				if ((Object)(object)item != (Object)null && !((Component)item).gameObject.activeInHierarchy)
				{
					missTextEffect = item;
					break;
				}
			}
			if ((Object)(object)missTextEffect == (Object)null)
			{
				missTextEffect = CreateMissTextObject();
				textPool.Add(missTextEffect);
			}
			Vector3 position = ((Component)player).transform.position + new Vector3(Random.Range(-0.3f, 0.3f), 0.5f, 0f);
			missTextEffect.Activate(position);
		}

		private MissTextEffect CreateMissTextObject()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("MissText");
			Object.DontDestroyOnLoad((Object)(object)val);
			return val.AddComponent<MissTextEffect>();
		}

		public void AddStack()
		{
			stackCount++;
		}

		public void RemoveStack()
		{
			stackCount--;
		}

		private void OnDestroy()
		{
		}
	}
	public class MissTextEffect : MonoBehaviour
	{
		private TextMesh textMesh;

		private MeshRenderer meshRenderer;

		private TextMesh[] outlineTexts;

		private GameObject[] outlineObjects;

		private const int OUTLINE_COUNT = 8;

		private const float OUTLINE_OFFSET = 0.015f;

		private float lifetime = 1.4f;

		private float timer = 0f;

		private float floatSpeed = 2.5f;

		private Vector3 startPosition;

		private bool isActive = false;

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

		private static readonly Color outlineColor = new Color(0.1f, 0.1f, 0.1f, 1f);

		private static readonly Color endColor = new Color(1f, 0.5f, 0f, 0f);

		private void Awake()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0096: 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_01d2: Unknown result type (might be due to invalid IL or missing references)
			outlineTexts = (TextMesh[])(object)new TextMesh[8];
			outlineObjects = (GameObject[])(object)new GameObject[8];
			for (int i = 0; i < 8; i++)
			{
				outlineObjects[i] = new GameObject($"Outline_{i}");
				outlineObjects[i].transform.SetParent(((Component)this).transform);
				float num = (float)i / 8f * MathF.PI * 2f;
				outlineObjects[i].transform.localPosition = new Vector3(Mathf.Cos(num) * 0.015f, Mathf.Sin(num) * 0.015f, 0.01f);
				outlineTexts[i] = outlineObjects[i].AddComponent<TextMesh>();
				outlineTexts[i].text = "MISS!";
				outlineTexts[i].fontSize = 48;
				outlineTexts[i].characterSize = 0.15f;
				outlineTexts[i].anchor = (TextAnchor)4;
				outlineTexts[i].alignment = (TextAlignment)1;
				outlineTexts[i].color = outlineColor;
				outlineTexts[i].fontStyle = (FontStyle)1;
				MeshRenderer component = outlineObjects[i].GetComponent<MeshRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					((Renderer)component).sortingLayerName = "MostFront";
					((Renderer)component).sortingOrder = 499;
				}
			}
			textMesh = ((Component)this).gameObject.AddComponent<TextMesh>();
			textMesh.text = "MISS!";
			textMesh.fontSize = 48;
			textMesh.characterSize = 0.15f;
			textMesh.anchor = (TextAnchor)4;
			textMesh.alignment = (TextAlignment)1;
			textMesh.color = mainColor;
			textMesh.fontStyle = (FontStyle)1;
			meshRenderer = ((Component)this).GetComponent<MeshRenderer>();
			if ((Object)(object)meshRenderer != (Object)null)
			{
				((Renderer)meshRenderer).sortingLayerName = "MostFront";
				((Renderer)meshRenderer).sortingOrder = 500;
			}
		}

		public void Activate(Vector3 position)
		{
			//IL_0007: 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_0010: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = position;
			startPosition = position;
			timer = 0f;
			isActive = true;
			textMesh.color = mainColor;
			for (int i = 0; i < 8; i++)
			{
				outlineTexts[i].color = outlineColor;
			}
			((Component)this).transform.localScale = Vector3.one * 0.3f;
			float num = Random.Range(-15f, 15f);
			((Component)this).transform.rotation = Quaternion.Euler(0f, 0f, num);
			((Component)this).gameObject.SetActive(true);
		}

		private void Update()
		{
			//IL_0088: 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)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: 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_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			if (!isActive)
			{
				return;
			}
			timer += Time.deltaTime;
			float num = timer / lifetime;
			if (num >= 1f)
			{
				isActive = false;
				((Component)this).gameObject.SetActive(false);
				return;
			}
			float num2 = 1f - Mathf.Pow(1f - num, 2f);
			float num3 = num2 * floatSpeed;
			((Component)this).transform.position = startPosition + new Vector3(0f, num3, 0f);
			float num5;
			if (num < 0.1f)
			{
				float num4 = num / 0.1f;
				num5 = 0.3f + num4 * 1.2f;
			}
			else if (num < 0.2f)
			{
				float num6 = (num - 0.1f) / 0.1f;
				num5 = 1.5f - num6 * 0.3f;
			}
			else if (num < 0.7f)
			{
				float num7 = Mathf.Sin((num - 0.2f) * 20f) * 0.05f;
				num5 = 1.2f + num7;
			}
			else
			{
				float num8 = (num - 0.7f) / 0.3f;
				num5 = 1.2f - num8 * 0.4f;
			}
			((Component)this).transform.localScale = Vector3.one * num5;
			float a;
			if (num < 0.6f)
			{
				a = 1f;
			}
			else
			{
				a = 1f - (num - 0.6f) / 0.4f;
				a = Mathf.Pow(a, 0.5f);
			}
			Color color = Color.Lerp(mainColor, endColor, num * 0.7f);
			color.a = a;
			textMesh.color = color;
			Color color2 = outlineColor;
			color2.a = a;
			for (int i = 0; i < 8; i++)
			{
				outlineTexts[i].color = color2;
			}
			float num9 = Mathf.Sin(timer * 12f) * 0.08f * (1f - num);
			Transform transform = ((Component)this).transform;
			transform.position += new Vector3(num9, 0f, 0f);
			float num10 = Mathf.Sin(timer * 8f) * 5f * (1f - num);
			((Component)this).transform.rotation = Quaternion.Euler(0f, 0f, num10 + Random.Range(-0.5f, 0.5f));
		}
	}
	public class ShieldEffect : MonoBehaviour
	{
		private static Dictionary<int, GameObject> activeShields = new Dictionary<int, GameObject>();

		public static void PlayShieldEffect(Player player, Color color, float duration = 1f, float targetRadius = 0.8f)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0063: 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_00bb: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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 (!((Object)(object)player == (Object)null))
			{
				if (activeShields.TryGetValue(player.playerID, out GameObject value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				GameObject val = new GameObject("ShieldEffect");
				val.transform.SetParent(((Component)player).transform);
				val.transform.localPosition = Vector3.zero;
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				val2.useWorldSpace = false;
				val2.loop = true;
				val2.startWidth = 0.1f;
				val2.endWidth = 0.1f;
				val2.positionCount = 36;
				((Renderer)val2).material = new Material(Shader.Find("Sprites/Default"));
				val2.startColor = color;
				val2.endColor = color;
				((Renderer)val2).sortingLayerName = "UI";
				((Renderer)val2).sortingOrder = 10000;
				for (int i = 0; i < 36; i++)
				{
					float num = (float)i / 36f * MathF.PI * 2f;
					val2.SetPosition(i, new Vector3(Mathf.Cos(num), Mathf.Sin(num), 0f));
				}
				ShieldAnimator shieldAnimator = val.AddComponent<ShieldAnimator>();
				shieldAnimator.Init(val2, color, duration, targetRadius, player.playerID);
				activeShields[player.playerID] = val;
			}
		}

		public static void RemoveShield(int playerID)
		{
			activeShields.Remove(playerID);
		}
	}
	public class ShieldAnimator : MonoBehaviour
	{
		private LineRenderer line;

		private Color baseColor;

		private float duration;

		private float targetRadius;

		private int playerID;

		private float startTime;

		public void Init(LineRenderer lr, Color color, float dur, float radius, int pid)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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)
			line = lr;
			baseColor = color;
			duration = dur;
			targetRadius = radius;
			playerID = pid;
			startTime = Time.time;
			((Component)this).transform.localScale = Vector3.zero;
		}

		private void Update()
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			float num = Time.time - startTime;
			float num2 = num / duration;
			if (num2 >= 1f)
			{
				ShieldEffect.RemoveShield(playerID);
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			float num4;
			float num5;
			if (num2 < 0.2f)
			{
				float num3 = num2 / 0.2f;
				num4 = targetRadius * (1f - Mathf.Pow(1f - num3, 2f));
				num5 = num3;
			}
			else if (num2 < 0.7f)
			{
				float num6 = (num2 - 0.2f) / 0.5f;
				float num7 = 1f + Mathf.Sin(num6 * MathF.PI * 4f) * 0.05f;
				num4 = targetRadius * num7;
				num5 = 1f;
			}
			else
			{
				float num8 = (num2 - 0.7f) / 0.3f;
				num4 = targetRadius * (1f + num8 * 0.1f);
				num5 = 1f - num8;
			}
			((Component)this).transform.localScale = Vector3.one * num4;
			((Component)this).transform.Rotate(0f, 0f, Time.deltaTime * 45f);
			Color val = baseColor;
			val.a = num5 * 0.85f;
			line.startColor = val;
			line.endColor = val;
		}
	}
}
namespace MrFuntikMod.Patches
{
	[Serializable]
	[HarmonyPatch(typeof(Block), "blocked")]
	internal class BlockPatchblocked
	{
		private static void Prefix(Block __instance, GameObject projectile, Vector3 forward, Vector3 hitPos)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			ProjectileHit component = projectile.GetComponent<ProjectileHit>();
			HealthHandler val = (HealthHandler)Traverse.Create((object)__instance).Field("health").GetValue();
			if ((double)component.ownPlayer.data.stats.GetAdditionalData().piercingDamage > 0.0)
			{
				Vector2 val2 = Vector2.op_Implicit((component.bulletCanDealDeamage ? component.damage : 1f) * component.ownPlayer.data.stats.GetAdditionalData().piercingDamage * ((Vector3)(ref forward)).normalized);
				((Damagable)val).TakeDamage(val2, Vector2.op_Implicit(hitPos), component.projectileColor, component.ownWeapon, component.ownPlayer, true, true);
				flag = true;
			}
			if (flag)
			{
				Object.Destroy((Object)(object)projectile);
			}
		}

		private static void Postfix(Block __instance)
		{
			__instance.GetAdditionalData().timeOfLastSuccessfulBlock = Time.time;
		}
	}
	[HarmonyPatch(typeof(ProjectileHit), "RPCA_DoHit")]
	public class DancerDodgePatch
	{
		public static bool Prefix(ProjectileHit __instance, Vector2 hitPoint, Vector2 hitNormal, Vector2 vel, int viewID, int colliderID, bool wasBlocked)
		{
			if (wasBlocked)
			{
				return true;
			}
			if (viewID == -1)
			{
				return true;
			}
			PhotonView photonView = PhotonNetwork.GetPhotonView(viewID);
			if ((Object)(object)photonView == (Object)null)
			{
				return true;
			}
			HealthHandler component = ((Component)photonView).GetComponent<HealthHandler>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			Player component2 = ((Component)component).GetComponent<Player>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			DancerMono component3 = ((Component)component2).GetComponent<DancerMono>();
			if ((Object)(object)component3 == (Object)null)
			{
				return true;
			}
			if (component3.IsInDodgeImmunity())
			{
				return false;
			}
			if (!__instance.view.IsMine)
			{
				return true;
			}
			if (component3.TryDodge())
			{
				NetworkingManager.RPC(typeof(DancerDodgePatch), "RPC_ShowDodgeEffect", new object[1] { component2.playerID });
				return false;
			}
			return true;
		}

		[UnboundRPC]
		public static void RPC_ShowDodgeEffect(int playerID)
		{
			Player val = ((IEnumerable<Player>)PlayerManager.instance.players).FirstOrDefault((Func<Player, bool>)((Player p) => p.playerID == playerID));
			if (!((Object)(object)val == (Object)null))
			{
				DancerMono component = ((Component)val).GetComponent<DancerMono>();
				if ((Object)(object)component != (Object)null)
				{
					component.ShowMissText();
				}
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "CallTakeDamage")]
	public class DancerDodgePatch_CallTakeDamage
	{
		public static bool Prefix(HealthHandler __instance, Vector2 damage, Vector2 position, GameObject damagingWeapon, Player damagingPlayer, bool lethal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (damage == Vector2.zero)
			{
				return true;
			}
			CharacterData component = ((Component)__instance).GetComponent<CharacterData>();
			if (component != null)
			{
				Block block = component.block;
				if (((block != null) ? new bool?(block.IsBlocking()) : null).GetValueOrDefault())
				{
					return true;
				}
			}
			Player component2 = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			DancerMono component3 = ((Component)component2).GetComponent<DancerMono>();
			if ((Object)(object)component3 == (Object)null)
			{
				return true;
			}
			if (component3.IsInDodgeImmunity())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "DoDamage")]
	public class DancerDodgePatch_DoDamage
	{
		public static bool Prefix(HealthHandler __instance, 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_0002: 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;
			}
			DancerMono component2 = ((Component)component).GetComponent<DancerMono>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			if (component2.IsInDodgeImmunity())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "TakeDamage", new Type[]
	{
		typeof(Vector2),
		typeof(Vector2),
		typeof(Color),
		typeof(GameObject),
		typeof(Player),
		typeof(bool),
		typeof(bool)
	})]
	public class DancerDodgePatch_TakeDamage
	{
		public static bool Prefix(HealthHandler __instance, Vector2 damage, Vector2 position, Color dmgColor, GameObject damagingWeapon, Player damagingPlayer, bool lethal, bool ignoreBlock)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (damage == Vector2.zero)
			{
				return true;
			}
			Player component = ((Component)__instance).GetComponent<Player>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			DancerMono component2 = ((Component)component).GetComponent<DancerMono>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			if (component2.IsInDodgeImmunity())
			{
				return false;
			}
			return true;
		}
	}
}
namespace MrFuntikMod.Extensions
{
	[Serializable]
	public class BlockAdditionalData
	{
		public float discombobulateRange;

		public float discombobulateDuration;

		public float timeOfLastSuccessfulBlock;

		public BlockAdditionalData()
		{
			discombobulateRange = 0f;
			discombobulateDuration = 0f;
			timeOfLastSuccessfulBlock = -100f;
		}
	}
	public static class BlockExtension
	{
		public static readonly ConditionalWeakTable<Block, BlockAdditionalData> data = new ConditionalWeakTable<Block, BlockAdditionalData>();

		public static BlockAdditionalData GetAdditionalData(this Block block)
		{
			return data.GetOrCreateValue(block);
		}

		public static void AddData(this Block block, BlockAdditionalData value)
		{
			try
			{
				data.Add(block, value);
			}
			catch (Exception)
			{
			}
		}
	}
	[Serializable]
	public class CardInfoAdditionalData
	{
		public bool isRandom;

		public bool isClassBlacklistCard;

		public CardInfoAdditionalData()
		{
			isRandom = false;
			isClassBlacklistCard = false;
		}
	}
	public static class CardInfoExtension
	{
		public static readonly ConditionalWeakTable<CardInfo, CardInfoAdditionalData> data = new ConditionalWeakTable<CardInfo, CardInfoAdditionalData>();

		public static CardInfoAdditionalData GetAdditionalData(this CardInfo cardInfo)
		{
			return data.GetOrCreateValue(cardInfo);
		}

		public static void AddData(this CardInfo cardInfo, CardInfoAdditionalData value)
		{
			try
			{
				data.Add(cardInfo, value);
			}
			catch (Exception)
			{
			}
		}
	}
	[Serializable]
	public class CharacterStatModifiersAdditionalData
	{
		public float piercingDamage;

		public int shuffles;

		public CharacterStatModifiersAdditionalData()
		{
			piercingDamage = 0f;
			shuffles = 0;
		}
	}
	public static class CharacterStatModifiersExtension
	{
		public static readonly ConditionalWeakTable<CharacterStatModifiers, CharacterStatModifiersAdditionalData> data = new ConditionalWeakTable<CharacterStatModifiers, CharacterStatModifiersAdditionalData>();

		public static CharacterStatModifiersAdditionalData GetAdditionalData(this CharacterStatModifiers characterstats)
		{
			return data.GetOrCreateValue(characterstats);
		}

		public static void AddData(this CharacterStatModifiers characterstats, CharacterStatModifiersAdditionalData value)
		{
			try
			{
				data.Add(characterstats, value);
			}
			catch (Exception)
			{
			}
		}
	}
	[HarmonyPatch(typeof(CharacterStatModifiers), "ResetStats")]
	internal class CharacterStatModifiersPatchResetStats
	{
		private static void Prefix(CharacterStatModifiers __instance)
		{
			__instance.GetAdditionalData().piercingDamage = 0f;
			__instance.GetAdditionalData().shuffles = 0;
		}
	}
}
namespace MrFuntikMod.RoundsEffects
{
	public class FriendlyBulletsDealtDamageEffect : DealtDamageEffect
	{
		public float multiplier = 1f;

		public override void DealtDamage(Vector2 damage, bool selfDamage, Player damagedPlayer = null)
		{
			//IL_000e: 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)
			Player damagedPlayer2 = damagedPlayer;
			if (!selfDamage && (!((Object)(object)damagedPlayer2 != (Object)null) || damagedPlayer2.teamID != ((Component)this).gameObject.GetComponent<Player>().teamID))
			{
				return;
			}
			if (damagedPlayer2.data.health - ((Vector2)(ref damage)).magnitude <= 0f)
			{
				damagedPlayer2.data.healthHandler.Heal(((Vector2)(ref damage)).magnitude * (1f - multiplier));
				return;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Unbound.Instance, 2, (Action)delegate
			{
				damagedPlayer2.data.healthHandler.Heal(((Vector2)(ref damage)).magnitude * (1f - multiplier));
			});
		}
	}
}
namespace MrFuntikMod.Cards
{
	internal class BalanceBlock : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			statModifiers.health = 0.75f;
			statModifiers.movementSpeed = 0.75f;
			block.cdMultiplier = 0.5f;
		}

		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 "Balance: Block";
		}

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

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

		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 = false,
					stat = "HP",
					amount = "-25%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Movespeed",
					amount = "-25%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Block CD",
					amount = "-50%",
					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 "MFM";
		}
	}
	internal class BalanceBullets : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			gun.reloadTime = 0.7f;
			gun.projectileSpeed = 0.7f;
			gun.attackSpeed = 0.625f;
			gun.ammo = 6;
		}

		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 "Balance: Bullets";
		}

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

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

		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
			//IL_008d: 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_0099: 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_00af: 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_00b7: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[4]
			{
				new CardInfoStat
				{
					positive = false,
					stat = "Bullet Speed",
					amount = "-30%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Reload Time",
					amount = "+30%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Ammo",
					amount = "+6",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Attack Speed",
					amount = "+60%",
					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)1;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class BalanceHitman : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			statModifiers.health = 0.6f;
			gun.damage = 1.6f;
			gun.projectileSpeed = 1.6f;
		}

		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 "Balance: Hitman";
		}

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

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

		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 = false,
					stat = "HP",
					amount = "-40%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "DMG",
					amount = "+60%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Bullet Speed",
					amount = "+60%",
					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)0;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class BalanceMayhem : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			gun.damage = 0.6f;
			gun.projectileSpeed = 1.7f;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			IEnumerable<CardInfo> first = ((ObservableCollection<CardInfo>)typeof(CardManager).GetField("activeCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).ToList();
			List<CardInfo> second = (List<CardInfo>)typeof(CardManager).GetField("inactiveCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			ObjectsToSpawn item = new List<ObjectsToSpawn>(((Component)(from card in first.Concat(second).ToList()
				where ((Object)((Component)card).gameObject).name == "TargetBounce"
				select card).ToList()[0]).GetComponent<Gun>().objectsToSpawn).Where((ObjectsToSpawn objectToSpawn) => (Object)(object)objectToSpawn.AddToProjectile.GetComponent<ScreenEdgeBounce>() != (Object)null).ToList()[0];
			List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
			list.Add(item);
			gun.objectsToSpawn = list.ToArray();
			gun.reflects += 4;
		}

		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 "Balance: Mayhem";
		}

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

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

		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 = false,
					stat = "DMG",
					amount = "-40%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Bounce",
					amount = "+4",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Bullet Speed",
					amount = "+70%",
					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 "MFM";
		}
	}
	internal class BalanceReload : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			gun.attackSpeed = 2f;
			gun.reloadTime = 0.5f;
			gun.ammo = 2;
		}

		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 "Balance: Reload";
		}

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

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

		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 = false,
					stat = "Attack Speed",
					amount = "-50%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Reload Time",
					amount = "-60%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Ammo",
					amount = "+2",
					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 "MFM";
		}
	}
	internal class BalanceSpeed : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			gun.projectileSpeed = 0.7f;
			gun.attackSpeed = 1.4285715f;
			statModifiers.movementSpeed = 1.45f;
			statModifiers.numberOfJumps = 2;
		}

		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 "Balance: Speed";
		}

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

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

		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
			//IL_008d: 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_0099: 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_00af: 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_00b7: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[4]
			{
				new CardInfoStat
				{
					positive = false,
					stat = "Bullet Speed",
					amount = "-30%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Attack Speed",
					amount = "-30%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Movespeed",
					amount = "+45%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Jumps",
					amount = "+2",
					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)8;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class BalanceTank : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { MrFuntikMod.BalanceCard };
			statModifiers.health = 2f;
			gun.damage = 0.65f;
			statModifiers.movementSpeed = 0.65f;
		}

		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 "Balance: Tank";
		}

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

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

		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 = false,
					stat = "DMG",
					amount = "-35%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Movespeed",
					amount = "-35%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "HP",
					amount = "+100%",
					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)2;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class BounceConverter : 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)
		{
			IEnumerable<CardInfo> first = ((ObservableCollection<CardInfo>)typeof(CardManager).GetField("activeCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).ToList();
			List<CardInfo> second = (List<CardInfo>)typeof(CardManager).GetField("inactiveCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			ObjectsToSpawn item = new List<ObjectsToSpawn>(((Component)(from card in first.Concat(second).ToList()
				where ((Object)((Component)card).gameObject).name == "TargetBounce"
				select card).ToList()[0]).GetComponent<Gun>().objectsToSpawn).Where((ObjectsToSpawn objectToSpawn) => (Object)(object)objectToSpawn.AddToProjectile.GetComponent<ScreenEdgeBounce>() != (Object)null).ToList()[0];
			List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
			list.Add(item);
			gun.objectsToSpawn = list.ToArray();
			if (gun.reflects < 1)
			{
				gun.reflects += 5;
			}
			else if (gun.reflects > 0 && gun.reflects < 11)
			{
				characterStats.health *= 1f + 0.05f * (float)gun.reflects;
				gun.damage *= 1f + 0.05f * (float)gun.reflects;
				gun.projectileSpeed *= 1f + 0.05f * (float)gun.reflects;
				gun.reflects = 0;
			}
			else
			{
				characterStats.health *= 1.5f;
				gun.damage *= 1.5f;
				gun.projectileSpeed *= 1.5f;
				gun.reflects = 0;
			}
		}

		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 "Bounce Converter";
		}

		protected override string GetDescription()
		{
			return "If you have no bounces, +5 <b><color=#1a9e27>bounces</b></color>. Otherwise, sets bounces to zero and gives +5% to <b><color=#1a9e27>DMG</b></color>, <b><color=#1a9e27>HP</b></color> and <b><color=#1a9e27>Bullet Speed</b></color> for each bounce (max bonus at 10 bounces).";
		}

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

		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()
		{
			return null;
		}

		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 "MFM";
		}
	}
	public class ChessBattleAdvancedCard : CustomCard
	{
		internal static CardInfo card;

		public static string ChessClassName = "Chess";

		public static CardCategory ChessClass = CustomCardCategories.instance.CardCategory("Chess");

		public static CardCategory[] chessClass = (CardCategory[])(object)new CardCategory[1] { ChessClass };

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

		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)
		{
		}

		public override void Callback()
		{
			ExtensionMethods.GetOrAddComponent<ClassNameMono>(((Component)this).gameObject, false);
		}

		protected override string GetTitle()
		{
			return "Chess Battle Advanced";
		}

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

		protected override GameObject GetCardArt()
		{
			return null;
		}

		protected override Rarity GetRarity()
		{
			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_002c: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[1]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Health",
					amount = "+40%"
				}
			};
		}

		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)8;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class ChessBattleAdvancedClass : ClassHandler
	{
		[CompilerGenerated]
		private sealed class <Init>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ChessBattleAdvancedClass <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Debug.Log((object)("Regestering: " + name));
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!Object.op_Implicit((Object)(object)ChessBattleAdvancedCard.card) || !Object.op_Implicit((Object)(object)ChessPawn.card))
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				ClassesRegistry.Register(ChessBattleAdvancedCard.card, (CardType)1, 0);
				ClassesRegistry.Register(ChessPawn.card, (CardType)16, ChessBattleAdvancedCard.card, 0);
				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();
			}
		}

		internal static string name = "Chess";

		[IteratorStateMachine(typeof(<Init>d__1))]
		public override IEnumerator Init()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Init>d__1(0)
			{
				<>4__this = this
			};
		}
	}
	internal class ChessBishopCard : CustomCard
	{
		internal static CardInfo card;

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { ChessBattleAdvancedCard.ChessClass };
			card = cardInfo;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			IEnumerable<CardInfo> first = ((ObservableCollection<CardInfo>)typeof(CardManager).GetField("activeCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).ToList();
			List<CardInfo> second = (List<CardInfo>)typeof(CardManager).GetField("inactiveCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			ObjectsToSpawn item = new List<ObjectsToSpawn>(((Component)(from card in first.Concat(second).ToList()
				where ((Object)((Component)card).gameObject).name == "TargetBounce"
				select card).ToList()[0]).GetComponent<Gun>().objectsToSpawn).Where((ObjectsToSpawn objectToSpawn) => (Object)(object)objectToSpawn.AddToProjectile.GetComponent<ScreenEdgeBounce>() != (Object)null).ToList()[0];
			List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
			list.Add(item);
			gun.objectsToSpawn = list.ToArray();
			gun.reflects += 2;
			gun.projectileColor = new Color(1f, 0.05f, 0f, 1f);
			gun.projectileSpeed *= 2.25f;
			if (gun.slow > 0f)
			{
				gun.slow *= 1.5f;
			}
			else
			{
				gun.slow += 0.5f;
			}
		}

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

		public override void Callback()
		{
			ExtensionMethods.GetOrAddComponent<ClassNameMono>(((Component)this).gameObject, false).className = ChessBattleAdvancedClass.name;
		}

		protected override string GetTitle()
		{
			return "CHESS BISHOP";
		}

		protected override string GetDescription()
		{
			return "Bullets slow the target when hit it." + Environment.NewLine + "Chess Battle Advanced!";
		}

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

		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)1;
		}

		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 = "Bullet Speed",
					amount = "+125%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Bounce",
					amount = "+2",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Bullet Slow",
					amount = "+50%",
					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)0;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class ChessKnightCard : CustomCard
	{
		internal static CardInfo card;

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { ChessBattleAdvancedCard.ChessClass };
			block.forceToAdd = 10f;
			statModifiers.movementSpeed = 1.5f;
			gun.damage = 1.15f;
			statModifiers.numberOfJumps = 1;
			card = cardInfo;
		}

		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)
		{
		}

		public override void Callback()
		{
			ExtensionMethods.GetOrAddComponent<ClassNameMono>(((Component)this).gameObject, false).className = ChessBattleAdvancedClass.name;
		}

		protected override string GetTitle()
		{
			return "CHESS KNIGHT";
		}

		protected override string GetDescription()
		{
			return "Blocking pushes you forward." + Environment.NewLine + "Chess Battle Advanced!";
		}

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

		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)1;
		}

		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 = "Move Speed",
					amount = "+50%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Damage",
					amount = "+15%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Jump",
					amount = "+1",
					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 "MFM";
		}
	}
	public class ChessPawn : CustomCard
	{
		internal static CardInfo card;

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { ChessBattleAdvancedCard.ChessClass };
			statModifiers.health = 1.1f;
			gun.damage = 1.1f;
			gun.attackSpeed = 0.9090909f;
			gun.ammo = 2;
			card = cardInfo;
		}

		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)
		{
		}

		public override void Callback()
		{
			ExtensionMethods.GetOrAddComponent<ClassNameMono>(((Component)this).gameObject, false).className = ChessBattleAdvancedClass.name;
		}

		protected override string GetTitle()
		{
			return "CHESS PAWN";
		}

		protected override string GetDescription()
		{
			return "Chess Battle Advanced!";
		}

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

		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
			//IL_008d: 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_0099: 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_00af: 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_00b7: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[4]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "HP",
					amount = "+10%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "DMG",
					amount = "+10%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Attack Speed",
					amount = "+10%",
					simepleAmount = (SimpleAmount)0
				},
				new CardInfoStat
				{
					positive = true,
					stat = "Ammo",
					amount = "+2",
					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 "MFM";
		}
	}
	public class ChessQueenCard : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			block.cdMultiplier = 1.5f;
			statModifiers.health = 1.25f;
			gun.projectileSpeed = 1.25f;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0073: 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_0103: Unknown result type (might be due to invalid IL or missing references)
			characterStats.GetAdditionalData().piercingDamage += (float)((1.0 - (double)characterStats.GetAdditionalData().piercingDamage) * 0.5);
			HealthBasedEffect val = ((Component)player).gameObject.AddComponent<HealthBasedEffect>();
			((ReversibleEffect)val).gunStatModifier.damage_mult = 1.25f;
			val.SetPercThresholdMax(0.75f);
			val.SetColor(new Color(1f, 0.45f, 0f, 1f));
			HealthBasedEffect val2 = ((Component)player).gameObject.AddComponent<HealthBasedEffect>();
			((ReversibleEffect)val2).gunStatModifier.damage_mult = 1.25f;
			val2.SetPercThresholdMax(0.5f);
			val2.SetColor(new Color(1f, 0.05f, 0f, 1f));
			HealthBasedEffect val3 = ((Component)player).gameObject.AddComponent<HealthBasedEffect>();
			((ReversibleEffect)val3).gunStatModifier.damage_mult = 1.25f;
			val3.SetPercThresholdMax(0.25f);
			val3.SetColor(new Color(0.67f, 0.05f, 1f, 1f));
		}

		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 "Chess Queen";
		}

		protected override string GetDescription()
		{
			return "Every 25% HP lost increases your damage by 25%. Chess Battle Advanced!";
		}

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

		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)2;
		}

		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
			//IL_008d: 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_0099: 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_00af: 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_00b7: Expected O, but got Unknown
			return (CardInfoStat[])(object)new CardInfoStat[4]
			{
				new CardInfoStat
				{
					positive = true,
					stat = "Piercing DMG",
					amount = "+50%",
					simepleAmount = (SimpleAmount)3
				},
				new CardInfoStat
				{
					positive = true,
					stat = "DMG scale on HP",
					amount = "Add",
					simepleAmount = (SimpleAmount)3
				},
				new CardInfoStat
				{
					positive = true,
					stat = "HP & Bullet Speed",
					amount = "+25%",
					simepleAmount = (SimpleAmount)3
				},
				new CardInfoStat
				{
					positive = false,
					stat = "Block Cooldown",
					amount = "+50%",
					simepleAmount = (SimpleAmount)3
				}
			};
		}

		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)8;
		}

		public override string GetModName()
		{
			return "MFM";
		}
	}
	internal class ChessRookCard : CustomCard
	{
		internal static CardInfo card;

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { ChessBattleAdvancedCard.ChessClass };
			statModifiers.health = 1.3f;
			block.cdMultiplier = 0.8f;
			card = cardInfo;
		}

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

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

		public override void Callback()
		{
			ExtensionMethods.GetOrAddComponent<ClassNameMono>(((Component)this).gameObject, false).className = ChessBattleAdvancedClass.name;
		}

		protected override string GetTitle()
		{
			return "CHESS ROOK";
		}

		protected override string GetDescription()
		{
			return "Blocking heals 12% of your max HP." + Environment.NewLine + "Chess Battle Advanced!";
		}

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

		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)1;
		}

		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)