using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using GamblersChoice.Cards;
using GamblersChoice.Effects;
using HarmonyLib;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace GamblersChoice.Cards
{
	public class AllIn : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gunAmmo.maxAmmo--;
			AllInEffect orAddComponent = ExtensionMethods.GetOrAddComponent<AllInEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			AllInEffect component = ((Component)player).gameObject.GetComponent<AllInEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "All In";
		}

		protected override string GetDescription()
		{
			return "Every point is a new deal. Your power is random — and so is your life.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Damage";
			val.amount = "Random [0.3x - 2.5x]";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "HP";
			val.amount = "Random [0.5x - 1.5x]";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max Ammo";
			val.amount = "-1";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class AnteUp : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.damage *= 1.35f;
			gun.knockback *= 1.2f;
			data.maxHealth = Mathf.Max(data.maxHealth - 25f, 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 "Ante Up";
		}

		protected override string GetDescription()
		{
			return "Bet your body on your bullets.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Damage";
			val.amount = "+35%";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Knockback";
			val.amount = "+20%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-25";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class Bluff : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			block.additionalBlocks++;
			BluffEffect orAddComponent = ExtensionMethods.GetOrAddComponent<BluffEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			BluffEffect component = ((Component)player).gameObject.GetComponent<BluffEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "Your block cooldown is a gamble — sometimes instant, sometimes glacial.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Blocks";
			val.amount = "+1";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Block CD";
			val.amount = "Random [0.2x - 2.5x]";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class CardCounter : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.damage *= 0.9f;
			CardCounterEffect orAddComponent = ExtensionMethods.GetOrAddComponent<CardCounterEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			player.GetGamblerData().cardCounterStacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().cardCounterStacks--;
			CardCounterEffect component = ((Component)player).gameObject.GetComponent<CardCounterEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Card Counter";
		}

		protected override string GetDescription()
		{
			return "Count your shots. Every seventh is a guaranteed jackpot hit.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Crit";
			val.amount = "Every 7th shot: 2.5x";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class CoinFlip : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			CoinFlipEffect orAddComponent = ExtensionMethods.GetOrAddComponent<CoinFlipEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			CoinFlipEffect component = ((Component)player).gameObject.GetComponent<CoinFlipEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Coin Flip";
		}

		protected override string GetDescription()
		{
			return "Heads you're fast, tails you're slow. Flip each point.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[1];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Attack Speed";
			val.amount = "±30% per point";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class DoubleOrNothing : CustomCard
	{
		private static GameObject bulletPrefab;

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

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			gun.attackSpeed *= 1.1f;
			player.GetGamblerData().doubleOrNothingStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("DoubleOrNothingBullet", new Type[1] { typeof(DoubleOrNothingEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (player.GetGamblerData().doubleOrNothingStacks == 1)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				ObjectsToSpawn val = new ObjectsToSpawn();
				val.AddToProjectile = bulletPrefab;
				list.Add(val);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().doubleOrNothingStacks--;
			if (player.GetGamblerData().doubleOrNothingStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		protected override string GetTitle()
		{
			return "Double or Nothing";
		}

		protected override string GetDescription()
		{
			return "Every shot's a bet. Might hit twice as hard. Might not hit at all.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Double Chance";
			val.amount = "35%";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Nothing Chance";
			val.amount = "15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class HailMary : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			HailMaryEffect orAddComponent = ExtensionMethods.GetOrAddComponent<HailMaryEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			HailMaryEffect component = ((Component)player).gameObject.GetComponent<HailMaryEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Hail Mary";
		}

		protected override string GetDescription()
		{
			return "The further behind you fall, the harder you hit. Desperation is fuel.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Behind by 1";
			val.amount = "+25% dmg, +15% AS";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Behind by 3+";
			val.amount = "+80% dmg, +45% AS";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Tied/Ahead";
			val.amount = "-10% dmg, -10% AS";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class HotHand : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			data.maxHealth = Mathf.Max(data.maxHealth - 15f, 1f);
			HotHandEffect orAddComponent = ExtensionMethods.GetOrAddComponent<HotHandEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			player.GetGamblerData().hotHandStacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().hotHandStacks--;
			HotHandEffect component = ((Component)player).gameObject.GetComponent<HotHandEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Hot Hand";
		}

		protected override string GetDescription()
		{
			return "Ride the streak. Every hit builds your fire — but a fumble burns you.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Streak Damage";
			val.amount = "+20% per hit";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Fumble Chance";
			val.amount = "15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-15";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class HouseEdge : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			block.cdMultiplier *= 0.85f;
			gun.damage *= 0.85f;
			data.maxHealth = Mathf.Max(data.maxHealth - 20f, 1f);
			HouseEdgeEffect orAddComponent = ExtensionMethods.GetOrAddComponent<HouseEdgeEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			HouseEdgeEffect component = ((Component)player).gameObject.GetComponent<HouseEdgeEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "House Edge";
		}

		protected override string GetDescription()
		{
			return "Block at the right moment and send their damage right back — with interest.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: 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_0098: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[4];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Reflect on Block";
			val.amount = "30% chance";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Block CD";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-20";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class Jackpot : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.attackSpeed *= 1.15f;
			data.maxHealth = Mathf.Max(data.maxHealth - 15f, 1f);
			JackpotEffect orAddComponent = ExtensionMethods.GetOrAddComponent<JackpotEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			player.GetGamblerData().jackpotStacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().jackpotStacks--;
			JackpotEffect component = ((Component)player).gameObject.GetComponent<JackpotEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "Kill an enemy and pray for the big payout — a full heal.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Full Heal on Kill";
			val.amount = "25% chance";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-15";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class LoadedDice : CustomCard
	{
		private static GameObject bulletPrefab;

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

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			player.GetGamblerData().loadedDiceStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("LoadedDiceBullet", new Type[1] { typeof(LoadedDiceEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (player.GetGamblerData().loadedDiceStacks == 1)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				ObjectsToSpawn val = new ObjectsToSpawn();
				val.AddToProjectile = bulletPrefab;
				list.Add(val);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().loadedDiceStacks--;
			if (player.GetGamblerData().loadedDiceStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		protected override string GetTitle()
		{
			return "Loaded Dice";
		}

		protected override string GetDescription()
		{
			return "Each bullet deals random damage — sometimes pitiful, sometimes devastating.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[1];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Damage";
			val.amount = "Random [0.5x - 1.5x]";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class LuckyPenny : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().luck += 0.15f;
			data.maxHealth += 15f;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().luck -= 0.15f;
			data.maxHealth = Mathf.Max(data.maxHealth - 15f, 1f);
		}

		protected override string GetTitle()
		{
			return "Lucky Penny";
		}

		protected override string GetDescription()
		{
			return "A small charm that tips the odds in your favor.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max HP";
			val.amount = "+15";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Luck";
			val.amount = "+0.15";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class RicochetRoulette : CustomCard
	{
		private static GameObject bulletPrefab;

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

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			gun.projectileSpeed *= 1.15f;
			GamblerData gamblerData = player.GetGamblerData();
			gamblerData.ricochetStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("RicochetRouletteBullet", new Type[1] { typeof(RicochetRouletteEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (gamblerData.ricochetStacks == 1)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				ObjectsToSpawn val = new ObjectsToSpawn();
				val.AddToProjectile = bulletPrefab;
				list.Add(val);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			GamblerData gamblerData = player.GetGamblerData();
			gamblerData.ricochetStacks--;
			if (gamblerData.ricochetStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		protected override string GetTitle()
		{
			return "Ricochet Roulette";
		}

		protected override string GetDescription()
		{
			return "Your bullets bounce off walls — sometimes once, sometimes a dozen times.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Bounces";
			val.amount = "Random [0-4]";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Bullet Speed";
			val.amount = "+15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class ShellGame : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			data.maxHealth = Mathf.Max(data.maxHealth - 10f, 1f);
			ShellGameEffect orAddComponent = ExtensionMethods.GetOrAddComponent<ShellGameEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			ShellGameEffect component = ((Component)player).gameObject.GetComponent<ShellGameEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Shell Game";
		}

		protected override string GetDescription()
		{
			return "Block and spin the wheel — every block triggers a random bonus.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "On Block";
			val.amount = "Random effect";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-10";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class SnakeEyes : CustomCard
	{
		private static GameObject dudPrefab;

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

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			gunAmmo.maxAmmo += 3;
			player.GetGamblerData().snakeEyesStacks++;
			if (dudPrefab == null)
			{
				dudPrefab = new GameObject("SnakeEyesDud", new Type[1] { typeof(SnakeEyesDudEffect) });
				Object.DontDestroyOnLoad((Object)(object)dudPrefab);
			}
			if (player.GetGamblerData().snakeEyesStacks == 1)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				ObjectsToSpawn val = new ObjectsToSpawn();
				val.AddToProjectile = dudPrefab;
				list.Add(val);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			player.GetGamblerData().snakeEyesStacks--;
			if (player.GetGamblerData().snakeEyesStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == dudPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		protected override string GetTitle()
		{
			return "Snake Eyes";
		}

		protected override string GetDescription()
		{
			return "More ammo, but some rounds are blanks.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max Ammo";
			val.amount = "+3";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Dud Chance";
			val.amount = "20%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class WildCard : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.damage *= 0.8f;
			gun.spread += 0.1f;
			WildCardEffect orAddComponent = ExtensionMethods.GetOrAddComponent<WildCardEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			WildCardEffect component = ((Component)player).gameObject.GetComponent<WildCardEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Wild Card";
		}

		protected override string GetDescription()
		{
			return "Every trigger pull is a surprise — you never know how many bullets come out.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[3];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Extra Projectiles";
			val.amount = "0-3 random";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-20%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Spread";
			val.amount = "+0.1";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class WinningStreak : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { GamblerCategory.Get() };
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			WinningStreakEffect orAddComponent = ExtensionMethods.GetOrAddComponent<WinningStreakEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			WinningStreakEffect component = ((Component)player).gameObject.GetComponent<WinningStreakEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Winning Streak";
		}

		protected override string GetDescription()
		{
			return "Keep winning and the house pays out bigger. Lose and pay the tilt tax.";
		}

		protected override GameObject GetCardArt()
		{
			return null;
		}

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

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

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

		protected override CardInfoStat[] GetStats()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[2];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Per Win";
			val.amount = "+15% dmg, +8% speed";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "On Loss";
			val.amount = "-10% dmg (tilt)";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
}
namespace GamblersChoice.Effects
{
	public class AllInEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private float appliedDamageMult = 1f;

		private float appliedHpMult = 1f;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)player).GetComponent<Gun>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null && gun != null)
			{
				float luck = player.GetLuck();
				float num = 0.3f + luck * 1f;
				float num2 = 2.5f + (float)(stacks - 1) * 1f;
				appliedDamageMult = Random.Range(num, num2);
				float num3 = 0.5f - (float)(stacks - 1) * 0.15f + luck * 0.5f;
				num3 = Mathf.Max(num3, 0.2f);
				float num4 = 1.5f + (float)(stacks - 1) * 0.25f;
				appliedHpMult = Random.Range(num3, num4);
				Gun obj = gun;
				obj.damage *= appliedDamageMult;
				float maxHealth = player.data.maxHealth;
				CharacterData data = player.data;
				data.maxHealth *= appliedHpMult;
				if (maxHealth > 0f)
				{
					player.data.health = player.data.health * player.data.maxHealth / maxHealth;
				}
			}
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (gun != null && appliedDamageMult != 1f)
			{
				Gun obj = gun;
				obj.damage /= appliedDamageMult;
				appliedDamageMult = 1f;
			}
			if (player != null && player.data != null && appliedHpMult != 1f)
			{
				float maxHealth = player.data.maxHealth;
				CharacterData data = player.data;
				data.maxHealth /= appliedHpMult;
				if (maxHealth > 0f)
				{
					player.data.health = player.data.health * player.data.maxHealth / maxHealth;
				}
				appliedHpMult = 1f;
			}
			yield break;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}
	}
	public class BluffEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Block block;

		private Action<BlockTriggerType> blockAction;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			block = ((Component)this).GetComponent<Block>();
			blockAction = OnBlock;
			block.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(block.BlockAction, blockAction);
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger == 0 && player != null && block != null)
			{
				float luck = player.GetLuck();
				float num = Mathf.Max(0.2f - (float)(stacks - 1) * 0.05f, 0.05f);
				float num2 = 2.5f - (float)(stacks - 1) * 0.3f;
				num2 = Mathf.Max(num2 - luck * 2f, num + 0.2f);
				float num3 = GamblerRNG.Range(num, num2, 0f);
				num3 = Mathf.Max(num3, 0.05f);
				player.GetGamblerData().pendingBlockCdMult = num3;
			}
		}

		private void OnDestroy()
		{
			if (block != null)
			{
				block.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(block.BlockAction, blockAction);
			}
		}
	}
	public class CardCounterEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		public bool nextShotIsCrit;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}

		public int GetCritInterval()
		{
			return Mathf.Max(7 - (stacks - 1) * 2, 3);
		}

		public void IncrementCounter()
		{
			GamblerData gamblerData = player.GetGamblerData();
			gamblerData.shotCounter++;
			int critInterval = GetCritInterval();
			if (gamblerData.shotCounter >= critInterval)
			{
				gamblerData.shotCounter = 0;
				nextShotIsCrit = true;
			}
		}

		public float ConsumeCrit()
		{
			if (nextShotIsCrit)
			{
				nextShotIsCrit = false;
				return 2.5f;
			}
			return 1f;
		}

		private IEnumerator OnGameStart(IGameModeHandler gm)
		{
			if (player != null)
			{
				player.GetGamblerData().shotCounter = 0;
			}
			nextShotIsCrit = false;
			yield break;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}
	}
	public class CoinFlipEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private float appliedMultiplier = 1f;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)player).GetComponent<Gun>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null && gun != null)
			{
				float luck = player.GetLuck();
				bool flag = GamblerRNG.CoinFlip(0.5f, luck);
				float num = 0.1f + (float)stacks * 0.2f;
				if (flag)
				{
					appliedMultiplier = 1f - num;
				}
				else
				{
					appliedMultiplier = 1f + num;
				}
				Gun obj = gun;
				obj.attackSpeed *= appliedMultiplier;
			}
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (gun != null && appliedMultiplier != 1f)
			{
				Gun obj = gun;
				obj.attackSpeed /= appliedMultiplier;
				appliedMultiplier = 1f;
			}
			yield break;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}
	}
	public class DoubleOrNothingEffect : RayHitEffect
	{
		public override HasToReturn DoHitEffect(HitInfo hit)
		{
			if (hit.transform != null)
			{
				Player component = ((Component)hit.transform).GetComponent<Player>();
				if (component != null)
				{
					ProjectileHit componentInParent = ((Component)this).GetComponentInParent<ProjectileHit>();
					if (componentInParent != null)
					{
						Player ownPlayer = componentInParent.ownPlayer;
						if (ownPlayer != null)
						{
							GamblerData gamblerData = ownPlayer.GetGamblerData();
							int doubleOrNothingStacks = gamblerData.doubleOrNothingStacks;
							if (doubleOrNothingStacks > 0)
							{
								float luck = ownPlayer.GetLuck();
								float num = 0.35f + (float)(doubleOrNothingStacks - 1) * 0.1f + luck * 0.15f;
								float num2 = Mathf.Max(0.15f + (float)(doubleOrNothingStacks - 1) * 0.05f - luck * 0.15f, 0.03f);
								float num3 = Mathf.Max(1f - num - num2, 0f);
								float[] weights = new float[3] { num, num2, num3 };
								switch (GamblerRNG.WeightedRoll(weights, 0f))
								{
								case 0:
									componentInParent.damage *= 2f;
									break;
								case 1:
									componentInParent.damage = 0f;
									break;
								}
								return (HasToReturn)1;
							}
							return (HasToReturn)1;
						}
						return (HasToReturn)1;
					}
					return (HasToReturn)1;
				}
				return (HasToReturn)1;
			}
			return (HasToReturn)1;
		}
	}
	public class HailMaryEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private Block block;

		private CharacterStatModifiers stats;

		private float appliedDamageMult = 1f;

		private float appliedAtkMult = 1f;

		private float appliedHpBonus;

		private int appliedBlockCharges;

		private int appliedJumps;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)this).GetComponent<Gun>();
			block = ((Component)this).GetComponent<Block>();
			stats = ((Component)this).GetComponent<CharacterStatModifiers>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player == null || gun == null)
			{
				yield break;
			}
			int deficit = GetDeficit();
			float luck = player.GetLuck();
			float num = 1f + (float)(stacks - 1) * 0.4f;
			if (deficit <= 0)
			{
				appliedDamageMult = 1f - 0.1f * num;
				appliedAtkMult = 1f + 0.1f * num;
				appliedHpBonus = 0f;
				appliedBlockCharges = 0;
				appliedJumps = 0;
			}
			else
			{
				int num2 = Mathf.Min(deficit, 3);
				float num3 = ((num2 != 1) ? 0f : (luck * 0.25f));
				float num4;
				float num5;
				float num6;
				switch (num2)
				{
				case 1:
					num4 = 0.25f + num3;
					num5 = 0.15f;
					num6 = 20f;
					appliedBlockCharges = 0;
					appliedJumps = 0;
					break;
				case 2:
					num4 = 0.5f;
					num5 = 0.3f;
					num6 = 40f;
					appliedBlockCharges = 1;
					appliedJumps = 0;
					break;
				default:
					num4 = 0.8f;
					num5 = 0.45f;
					num6 = 60f;
					appliedBlockCharges = 1;
					appliedJumps = 1;
					break;
				}
				appliedDamageMult = 1f + num4 * num;
				appliedAtkMult = 1f / (1f + num5 * num);
				appliedHpBonus = num6 * num;
			}
			Gun obj = gun;
			obj.damage *= appliedDamageMult;
			Gun obj2 = gun;
			obj2.attackSpeed *= appliedAtkMult;
			if (appliedHpBonus > 0f)
			{
				CharacterData data = player.data;
				data.maxHealth += appliedHpBonus;
				CharacterData data2 = player.data;
				data2.health += appliedHpBonus;
			}
			if (appliedBlockCharges > 0 && block != null)
			{
				Block obj3 = block;
				obj3.additionalBlocks += appliedBlockCharges;
			}
			if (appliedJumps > 0)
			{
				CharacterData data3 = player.data;
				data3.jumps += appliedJumps;
			}
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			RevertBuffs();
			yield break;
		}

		private void RevertBuffs()
		{
			if (gun != null)
			{
				if (appliedDamageMult != 1f)
				{
					Gun obj = gun;
					obj.damage /= appliedDamageMult;
				}
				if (appliedAtkMult != 1f)
				{
					Gun obj2 = gun;
					obj2.attackSpeed /= appliedAtkMult;
				}
			}
			if (player != null && player.data != null && appliedHpBonus > 0f)
			{
				player.data.maxHealth = Mathf.Max(player.data.maxHealth - appliedHpBonus, 1f);
				player.data.health = Mathf.Min(player.data.health, player.data.maxHealth);
			}
			if (block != null && appliedBlockCharges > 0)
			{
				Block obj3 = block;
				obj3.additionalBlocks -= appliedBlockCharges;
			}
			if (player != null && player.data != null && appliedJumps > 0)
			{
				CharacterData data = player.data;
				data.jumps -= appliedJumps;
			}
			appliedDamageMult = 1f;
			appliedAtkMult = 1f;
			appliedHpBonus = 0f;
			appliedBlockCharges = 0;
			appliedJumps = 0;
		}

		private int GetDeficit()
		{
			if (player == null)
			{
				return 0;
			}
			GM_ArmsRace val = Object.FindObjectOfType<GM_ArmsRace>();
			if (val == null)
			{
				return 0;
			}
			int num = ((player.teamID != 0) ? val.p2Rounds : val.p1Rounds);
			int num2 = ((player.teamID != 0) ? val.p1Rounds : val.p2Rounds);
			return num2 - num;
		}

		private void OnDestroy()
		{
			RevertBuffs();
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}
	}
	public class HotHandEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

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

		private void Update()
		{
			if (player != null)
			{
				GamblerData gamblerData = player.GetGamblerData();
				if (gamblerData.streakStacks > 0 && Time.time - gamblerData.lastHitTime > 2f)
				{
					gamblerData.streakStacks = 0;
				}
			}
		}

		public int GetMaxStacks()
		{
			return 5 + (stacks - 1) * 2;
		}

		public float GetDamagePerStack()
		{
			return 0.2f + (float)(stacks - 1) * 0.05f;
		}

		public float GetDamageMultiplier()
		{
			GamblerData gamblerData = player.GetGamblerData();
			return 1f + (float)gamblerData.streakStacks * GetDamagePerStack();
		}

		public void OnHitEnemy()
		{
			if (player == null)
			{
				return;
			}
			GamblerData gamblerData = player.GetGamblerData();
			float luck = player.GetLuck();
			if (Time.time - gamblerData.lastHitTime <= 1.5f && gamblerData.streakStacks > 0)
			{
				int maxStacks = GetMaxStacks();
				if (gamblerData.streakStacks < maxStacks)
				{
					gamblerData.streakStacks++;
				}
				if (GamblerRNG.FumbleCheck(0.15f, luck))
				{
					float num = 5f * (float)gamblerData.streakStacks;
					gamblerData.streakStacks = 0;
					CharacterData data = player.data;
					data.health -= num;
				}
			}
			else
			{
				gamblerData.streakStacks = 1;
			}
			gamblerData.lastHitTime = Time.time;
		}

		public void OnTakeDamage()
		{
			if (player != null)
			{
				player.GetGamblerData().streakStacks = 0;
			}
		}

		private void OnDestroy()
		{
		}
	}
	public class HouseEdgeEffect : MonoBehaviour
	{
		private struct DamageEntry
		{
			public float amount;

			public float time;

			public Player attacker;
		}

		public int stacks;

		private Player player;

		private Block block;

		private Action<BlockTriggerType> blockAction;

		private List<DamageEntry> damageLog = new List<DamageEntry>();

		private const float WINDOW = 2f;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			block = ((Component)this).GetComponent<Block>();
			blockAction = OnBlock;
			block.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(block.BlockAction, blockAction);
		}

		private void Update()
		{
			float cutoff = Time.time - 2f;
			damageLog.RemoveAll((DamageEntry e) => e.time < cutoff);
		}

		public void LogDamage(float amount, Player attacker)
		{
			if (attacker != null && attacker != player)
			{
				damageLog.Add(new DamageEntry
				{
					amount = amount,
					time = Time.time,
					attacker = attacker
				});
			}
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger != 0 || player == null || damageLog.Count == 0)
			{
				return;
			}
			float luck = player.GetLuck();
			float num = 0.3f + luck * 0.3f;
			num = Mathf.Min(num, 0.75f);
			if (!(Random.Range(0f, 1f) >= num))
			{
				float num2 = 0f;
				Player val = null;
				for (int i = 0; i < damageLog.Count; i++)
				{
					num2 += damageLog[i].amount;
					val = damageLog[i].attacker;
				}
				if (val != null)
				{
					float num3 = 0.5f + (float)stacks * 0.5f;
					float num4 = num2 * num3;
					CharacterData data = val.data;
					data.health -= num4;
					damageLog.Clear();
				}
			}
		}

		private void OnDestroy()
		{
			if (block != null)
			{
				block.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(block.BlockAction, blockAction);
			}
		}
	}
	public class JackpotEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

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

		public void OnKill()
		{
			if (player != null && stacks > 0)
			{
				float luck = player.GetLuck();
				float num = 0.25f + (float)(stacks - 1) * 0.15f + luck * 0.3f;
				num = Mathf.Min(num, 0.7f);
				if (Random.Range(0f, 1f) < num)
				{
					player.data.healthHandler.Heal(player.data.maxHealth);
				}
			}
		}

		private void OnDestroy()
		{
		}
	}
	public class LoadedDiceEffect : RayHitEffect
	{
		public override HasToReturn DoHitEffect(HitInfo hit)
		{
			if (hit.transform != null)
			{
				Player component = ((Component)hit.transform).GetComponent<Player>();
				if (component != null)
				{
					ProjectileHit componentInParent = ((Component)this).GetComponentInParent<ProjectileHit>();
					if (componentInParent != null)
					{
						Player ownPlayer = componentInParent.ownPlayer;
						if (ownPlayer != null)
						{
							GamblerData gamblerData = ownPlayer.GetGamblerData();
							int loadedDiceStacks = gamblerData.loadedDiceStacks;
							if (loadedDiceStacks > 0)
							{
								float luck = ownPlayer.GetLuck();
								float num = 0.5f - (float)(loadedDiceStacks - 1) * 0.25f;
								float max = 1.5f + (float)(loadedDiceStacks - 1) * 0.25f;
								num = Mathf.Max(num, 0f);
								float num2 = GamblerRNG.Range(num, max, luck);
								num2 = Mathf.Max(num2, 0f);
								componentInParent.damage *= num2;
								return (HasToReturn)1;
							}
							return (HasToReturn)1;
						}
						return (HasToReturn)1;
					}
					return (HasToReturn)1;
				}
				return (HasToReturn)1;
			}
			return (HasToReturn)1;
		}
	}
	public class RicochetRouletteEffect : MonoBehaviour
	{
		private void Start()
		{
			ProjectileHit componentInParent = ((Component)this).GetComponentInParent<ProjectileHit>();
			if (componentInParent == null)
			{
				return;
			}
			Player ownPlayer = componentInParent.ownPlayer;
			if (ownPlayer == null)
			{
				return;
			}
			GamblerData gamblerData = ownPlayer.GetGamblerData();
			int ricochetStacks = gamblerData.ricochetStacks;
			if (ricochetStacks <= 0)
			{
				return;
			}
			float luck = ownPlayer.GetLuck();
			int num = 4 + (ricochetStacks - 1) * 3;
			float[] array = new float[num + 1];
			for (int i = 0; i <= num; i++)
			{
				switch (i)
				{
				case 0:
					array[i] = 0.25f;
					break;
				case 1:
					array[i] = 0.25f;
					break;
				case 2:
					array[i] = 0.25f;
					break;
				case 3:
					array[i] = 0.15f;
					break;
				case 4:
					array[i] = 0.1f;
					break;
				default:
					array[i] = 0.08f;
					break;
				}
			}
			if (luck > 0f)
			{
				float num2 = Mathf.Min(luck * 0.5f, array[0] * 0.8f);
				array[0] -= num2;
				int num3 = Mathf.Max(num / 2, 1);
				array[num3] += num2;
			}
			int num4 = GamblerRNG.WeightedRoll(array, 0f);
			RayHitReflect componentInParent2 = ((Component)this).GetComponentInParent<RayHitReflect>();
			if (componentInParent2 != null)
			{
				componentInParent2.reflects += num4;
			}
		}
	}
	public class ShellGameEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private Block block;

		private CharacterStatModifiers stats;

		private Action<BlockTriggerType> blockAction;

		private int tempBlockCharges;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)this).GetComponent<Gun>();
			block = ((Component)this).GetComponent<Block>();
			stats = ((Component)this).GetComponent<CharacterStatModifiers>();
			blockAction = OnBlock;
			block.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(block.BlockAction, blockAction);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger == 0 && player != null)
			{
				for (int i = 0; i < stacks; i++)
				{
					RollEffect();
				}
			}
		}

		private void RollEffect()
		{
			float luck = player.GetLuck();
			float[] weights = new float[5] { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f };
			switch (GamblerRNG.WeightedRoll(weights, luck))
			{
			case 0:
				DoBurst();
				break;
			case 1:
				((MonoBehaviour)this).StartCoroutine(DoFortify());
				break;
			case 2:
				((MonoBehaviour)this).StartCoroutine(DoAdrenaline());
				break;
			case 3:
				player.data.healthHandler.Heal(20f);
				break;
			case 4:
			{
				Block obj = block;
				obj.additionalBlocks++;
				tempBlockCharges++;
				player.GetGamblerData().tempBlockCharges++;
				break;
			}
			}
		}

		private void DoBurst()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0093: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			float num = 30f;
			float num2 = 3f;
			List<Player> players = PlayerManager.instance.players;
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if (val != player && val.teamID != player.teamID)
				{
					float num3 = Vector2.Distance(new Vector2(((Component)player).transform.position.x, ((Component)player).transform.position.y), new Vector2(((Component)val).transform.position.x, ((Component)val).transform.position.y));
					if (num3 <= num2)
					{
						CharacterData data = val.data;
						data.health -= num;
					}
				}
			}
		}

		private IEnumerator DoFortify()
		{
			float origDmgMult = 1f;
			GamblerData data = player.GetGamblerData();
			data.fortifyActive++;
			yield return (object)new WaitForSeconds(2.5f);
			data.fortifyActive--;
		}

		private IEnumerator DoAdrenaline()
		{
			if (gun != null && stats != null)
			{
				float atkMult = 0.7f;
				float moveMult = 1.4f;
				Gun obj = gun;
				obj.attackSpeed *= atkMult;
				CharacterStatModifiers obj2 = stats;
				obj2.movementSpeed *= moveMult;
				yield return (object)new WaitForSeconds(3f);
				Gun obj3 = gun;
				obj3.attackSpeed /= atkMult;
				CharacterStatModifiers obj4 = stats;
				obj4.movementSpeed /= moveMult;
			}
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (tempBlockCharges > 0 && block != null)
			{
				Block obj = block;
				obj.additionalBlocks -= tempBlockCharges;
				player.GetGamblerData().tempBlockCharges -= tempBlockCharges;
				tempBlockCharges = 0;
			}
			yield break;
		}

		private void OnDestroy()
		{
			if (block != null)
			{
				block.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(block.BlockAction, blockAction);
			}
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
		}
	}
	public class SnakeEyesDudEffect : MonoBehaviour
	{
		private bool isDud;

		private void Start()
		{
			ProjectileHit componentInParent = ((Component)this).GetComponentInParent<ProjectileHit>();
			if (componentInParent == null)
			{
				return;
			}
			Player ownPlayer = componentInParent.ownPlayer;
			if (ownPlayer != null)
			{
				float luck = ownPlayer.GetLuck();
				float num = Mathf.Max(0.2f - luck * 0.25f, 0.05f);
				isDud = Random.Range(0f, 1f) < num;
				if (isDud)
				{
					componentInParent.damage = 0f;
				}
			}
		}
	}
	public class WildCardEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		public int pendingExtraProjectiles;

		public bool rollPending;

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

		public void RollExtraProjectiles()
		{
			if (player == null)
			{
				return;
			}
			float luck = player.GetLuck();
			int num = 3 + (stacks - 1) * 2;
			float[] array = new float[num + 1];
			for (int i = 0; i <= num; i++)
			{
				switch (i)
				{
				case 0:
					array[i] = 0.3f;
					break;
				case 1:
					array[i] = 0.3f;
					break;
				case 2:
					array[i] = 0.25f;
					break;
				case 3:
					array[i] = 0.15f;
					break;
				default:
					array[i] = 0.1f;
					break;
				}
			}
			pendingExtraProjectiles = GamblerRNG.WeightedRoll(array, luck);
			rollPending = true;
		}

		public int ConsumeExtra()
		{
			if (!rollPending)
			{
				return 0;
			}
			rollPending = false;
			return pendingExtraProjectiles;
		}

		public float GetExtraDamageMultiplier()
		{
			return 0.5f;
		}
	}
	public class WinningStreakEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private CharacterStatModifiers stats;

		private float appliedDamageMult = 1f;

		private float appliedAtkMult = 1f;

		private float appliedMoveMult = 1f;

		private int prevPoints;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)this).GetComponent<Gun>();
			stats = ((Component)this).GetComponent<CharacterStatModifiers>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}

		private IEnumerator OnGameStart(IGameModeHandler gm)
		{
			player.GetGamblerData().winStreak = 0;
			prevPoints = 0;
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			RevertBuffs();
			int myTeamPoints = GetMyTeamPoints();
			if (myTeamPoints > prevPoints)
			{
				player.GetGamblerData().winStreak++;
			}
			else
			{
				player.GetGamblerData().winStreak = 0;
			}
			prevPoints = myTeamPoints;
			yield break;
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null && gun != null && stats != null)
			{
				int winStreak = player.GetGamblerData().winStreak;
				float num = 1f + (float)(stacks - 1) * 0.5f;
				if (winStreak == 0)
				{
					appliedDamageMult = 1f - 0.1f * (0.5f + (float)stacks * 0.5f);
					appliedAtkMult = 1f;
					appliedMoveMult = 1f;
				}
				else
				{
					int num2 = Mathf.Min(winStreak, 4);
					float num3 = (float)num2 * 0.15f * num;
					float num4 = (float)num2 * 0.08f * num;
					appliedDamageMult = 1f + num3;
					appliedAtkMult = 1f / (1f + num4);
					appliedMoveMult = 1f + num4;
				}
				Gun obj = gun;
				obj.damage *= appliedDamageMult;
				Gun obj2 = gun;
				obj2.attackSpeed *= appliedAtkMult;
				CharacterStatModifiers obj3 = stats;
				obj3.movementSpeed *= appliedMoveMult;
			}
			yield break;
		}

		private void RevertBuffs()
		{
			if (gun != null && appliedDamageMult != 1f)
			{
				Gun obj = gun;
				obj.damage /= appliedDamageMult;
			}
			if (gun != null && appliedAtkMult != 1f)
			{
				Gun obj2 = gun;
				obj2.attackSpeed /= appliedAtkMult;
			}
			if (stats != null && appliedMoveMult != 1f)
			{
				CharacterStatModifiers obj3 = stats;
				obj3.movementSpeed /= appliedMoveMult;
			}
			appliedDamageMult = 1f;
			appliedAtkMult = 1f;
			appliedMoveMult = 1f;
		}

		private int GetMyTeamPoints()
		{
			if (player == null)
			{
				return 0;
			}
			GM_ArmsRace val = Object.FindObjectOfType<GM_ArmsRace>();
			if (val == null)
			{
				return 0;
			}
			return (player.teamID != 0) ? val.p2Points : val.p1Points;
		}

		private void OnDestroy()
		{
			RevertBuffs();
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
			GameModeManager.RemoveHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}
	}
}
namespace GamblersChoice
{
	internal static class GamblerCategory
	{
		private static CardCategory _cat;

		public static CardCategory Get()
		{
			if (_cat == null)
			{
				_cat = CustomCardCategories.instance.CardCategory("Gambler");
			}
			return _cat;
		}
	}
	public class GamblerData
	{
		public float luck;

		public int shotCounter;

		public int streakStacks;

		public float lastHitTime;

		public int loadedDiceStacks;

		public int doubleOrNothingStacks;

		public int cardCounterStacks;

		public int jackpotStacks;

		public int hotHandStacks;

		public int snakeEyesStacks;

		public int ricochetStacks;

		public int winStreak;

		public float pendingBlockCdMult;

		public int tempBlockCharges;

		public int fortifyActive;

		public Player lastAttacker;

		public void ResetPerRound()
		{
			shotCounter = 0;
			streakStacks = 0;
			lastHitTime = 0f;
			winStreak = 0;
			pendingBlockCdMult = 0f;
			tempBlockCharges = 0;
			fortifyActive = 0;
			lastAttacker = null;
		}

		public void ResetAll()
		{
			luck = 0f;
			loadedDiceStacks = 0;
			doubleOrNothingStacks = 0;
			cardCounterStacks = 0;
			jackpotStacks = 0;
			hotHandStacks = 0;
			snakeEyesStacks = 0;
			ricochetStacks = 0;
			ResetPerRound();
		}
	}
	public static class GamblerDataExtension
	{
		private static readonly ConditionalWeakTable<Player, GamblerData> table = new ConditionalWeakTable<Player, GamblerData>();

		public static GamblerData GetGamblerData(this Player player)
		{
			return table.GetOrCreateValue(player);
		}

		public static float GetLuck(this Player player)
		{
			float luck = player.GetGamblerData().luck;
			float num = ((Plugin.LuckCap == null) ? 0.6f : Plugin.LuckCap.Value);
			return Mathf.Min(luck, num);
		}
	}
	public static class GamblerRNG
	{
		public static float Range(float min, float max, float luck)
		{
			float num = luck * 0.5f;
			float num2 = min + num;
			float num3 = max + num;
			return Random.Range(num2, num3);
		}

		public static int WeightedRoll(float[] weights, float luck)
		{
			float[] array = (float[])weights.Clone();
			if (array.Length > 1 && luck > 0f)
			{
				float num = luck * array[^1] * 0.5f;
				array[0] += num;
				array[^1] = Mathf.Max(array[^1] - num, 0.01f);
			}
			float num2 = 0f;
			for (int i = 0; i < array.Length; i++)
			{
				num2 += array[i];
			}
			float num3 = Random.Range(0f, num2);
			float num4 = 0f;
			for (int j = 0; j < array.Length; j++)
			{
				num4 += array[j];
				if (num3 < num4)
				{
					return j;
				}
			}
			return array.Length - 1;
		}

		public static bool CoinFlip(float headsChance, float luck)
		{
			float num = headsChance + luck * 0.3f;
			num = Mathf.Clamp(num, 0.05f, 0.95f);
			return Random.Range(0f, 1f) < num;
		}

		public static bool FumbleCheck(float baseChance, float luck)
		{
			float num = baseChance - luck * 0.15f;
			num = Mathf.Max(num, 0.05f);
			return Random.Range(0f, 1f) < num;
		}
	}
}
namespace GamblersChoice.Patches
{
	[HarmonyPatch(typeof(Gun), "Attack")]
	internal class GunAttackPatch
	{
		private static int savedProjectiles;

		private static bool wildCardActive;

		private static void Prefix(Gun __instance)
		{
			wildCardActive = false;
			Player componentInParent = ((Component)__instance).GetComponentInParent<Player>();
			if (componentInParent == null)
			{
				return;
			}
			WildCardEffect component = ((Component)componentInParent).GetComponent<WildCardEffect>();
			if (component != null)
			{
				component.RollExtraProjectiles();
				int num = component.ConsumeExtra();
				if (num > 0)
				{
					savedProjectiles = __instance.numberOfProjectiles;
					__instance.numberOfProjectiles += num;
					wildCardActive = true;
				}
			}
		}

		private static void Postfix(Gun __instance)
		{
			Player componentInParent = ((Component)__instance).GetComponentInParent<Player>();
			if (componentInParent != null)
			{
				if (wildCardActive)
				{
					__instance.numberOfProjectiles = savedProjectiles;
					wildCardActive = false;
				}
				((Component)componentInParent).GetComponent<CardCounterEffect>()?.IncrementCounter();
			}
		}
	}
	[HarmonyPatch(typeof(ProjectileHit), "Hit")]
	internal class ProjectileHitPatch
	{
		private static void Prefix(ProjectileHit __instance, HitInfo hit)
		{
			if (hit.transform == null)
			{
				return;
			}
			Player component = ((Component)hit.transform).GetComponent<Player>();
			if (component == null)
			{
				return;
			}
			Player ownPlayer = __instance.ownPlayer;
			if (ownPlayer == null)
			{
				return;
			}
			HotHandEffect component2 = ((Component)ownPlayer).GetComponent<HotHandEffect>();
			if (component2 != null)
			{
				float damageMultiplier = component2.GetDamageMultiplier();
				if (damageMultiplier != 1f)
				{
					__instance.damage *= damageMultiplier;
				}
			}
			CardCounterEffect component3 = ((Component)ownPlayer).GetComponent<CardCounterEffect>();
			if (component3 != null)
			{
				float num = component3.ConsumeCrit();
				if (num != 1f)
				{
					__instance.damage *= num;
				}
			}
			GamblerData gamblerData = component.GetGamblerData();
			gamblerData.lastAttacker = ownPlayer;
		}

		private static void Postfix(ProjectileHit __instance, HitInfo hit)
		{
			if (hit.transform == null)
			{
				return;
			}
			Player component = ((Component)hit.transform).GetComponent<Player>();
			if (component != null)
			{
				Player ownPlayer = __instance.ownPlayer;
				if (ownPlayer != null)
				{
					((Component)ownPlayer).GetComponent<HotHandEffect>()?.OnHitEnemy();
				}
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "RPCA_Die")]
	internal class HealthHandlerDiePatch
	{
		private static void Postfix(HealthHandler __instance)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component == null)
			{
				return;
			}
			List<Player> players = PlayerManager.instance.players;
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if (val != component && val.teamID != component.teamID)
				{
					((Component)val).GetComponent<JackpotEffect>()?.OnKill();
				}
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "DoDamage")]
	internal class HealthHandlerDoDamagePatch
	{
		private static void Postfix(HealthHandler __instance, Vector2 damage)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component == null)
			{
				return;
			}
			float num = ((!(damage.x > 0f)) ? damage.y : damage.x);
			if (!(num <= 0f))
			{
				GamblerData gamblerData = component.GetGamblerData();
				((Component)component).GetComponent<HotHandEffect>()?.OnTakeDamage();
				((Component)component).GetComponent<HouseEdgeEffect>()?.LogDamage(num, gamblerData.lastAttacker);
				if (gamblerData.fortifyActive > 0)
				{
					float num2 = num * 0.5f * (float)gamblerData.fortifyActive;
					component.data.healthHandler.Heal(num2);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Block), "ResetCD")]
	internal class BlockResetCDPatch
	{
		private static void Postfix(Block __instance)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component != null)
			{
				GamblerData gamblerData = component.GetGamblerData();
				if (gamblerData.pendingBlockCdMult > 0f && gamblerData.pendingBlockCdMult != 1f)
				{
					__instance.counter *= gamblerData.pendingBlockCdMult;
					gamblerData.pendingBlockCdMult = 0f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterStatModifiers), "ResetStats")]
	internal class ResetStatsPatch
	{
		private static void Postfix(CharacterStatModifiers __instance)
		{
			((Component)__instance).GetComponent<Player>()?.GetGamblerData().ResetPerRound();
		}
	}
}
namespace GamblersChoice
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.nicho.rounds.gamblerschoice", "Gamblers Choice", "1.0.2")]
	[BepInProcess("Rounds.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static Plugin Instance;

		internal static ManualLogSource Log;

		internal static ConfigEntry<float> LuckCap;

		private void Awake()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			LuckCap = ((BaseUnityPlugin)this).Config.Bind<float>("Balance", "LuckCapOverride", 0.6f, "Maximum luck value for balance tuning");
			Harmony val = new Harmony("com.nicho.rounds.gamblerschoice");
			val.PatchAll();
			Log.LogInfo((object)string.Format("{0} v{1} loaded", "Gamblers Choice", "1.0.2"));
		}

		private void Start()
		{
			CustomCard.BuildCard<LoadedDice>();
			CustomCard.BuildCard<SnakeEyes>();
			CustomCard.BuildCard<LuckyPenny>();
			CustomCard.BuildCard<AnteUp>();
			CustomCard.BuildCard<CoinFlip>();
			CustomCard.BuildCard<DoubleOrNothing>();
			CustomCard.BuildCard<CardCounter>();
			CustomCard.BuildCard<Jackpot>();
			CustomCard.BuildCard<AllIn>();
			CustomCard.BuildCard<HotHand>();
			CustomCard.BuildCard<Bluff>();
			CustomCard.BuildCard<ShellGame>();
			CustomCard.BuildCard<HouseEdge>();
			CustomCard.BuildCard<WildCard>();
			CustomCard.BuildCard<RicochetRoulette>();
			CustomCard.BuildCard<WinningStreak>();
			CustomCard.BuildCard<HailMary>();
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStartReset);
			Log.LogInfo((object)"All 17 cards registered");
		}

		private static IEnumerator GameStartReset(IGameModeHandler gm)
		{
			foreach (Player player in PlayerManager.instance.players)
			{
				player.GetGamblerData().ResetAll();
			}
			yield break;
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "com.nicho.rounds.gamblerschoice";

		public const string NAME = "Gamblers Choice";

		public const string VERSION = "1.0.2";
	}
}