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 ModdingUtils.Extensions;
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 *= 0.75f;
		}

		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 Bailout : 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 *= 0.8f;
			characterStats.movementSpeed *= 0.9f;
			BailoutEffect orAddComponent = ExtensionMethods.GetOrAddComponent<BailoutEffect>(((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)
		{
			BailoutEffect component = ((Component)player).gameObject.GetComponent<BailoutEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "Too big to fail.";
		}

		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 = "Cheat Death";
			val.amount = "35% chance";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "On Bailout";
			val.amount = "25% HP + 2s invuln";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-20%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Move Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class Bankroll : 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			gunAmmo.reloadTime += 0.5f;
			BankrollReloadEffect orAddComponent = ExtensionMethods.GetOrAddComponent<BankrollReloadEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			player.GetGamblerData().bankrollStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("BankrollBullet", new Type[1] { typeof(BankrollEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (player.GetGamblerData().bankrollStacks == 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().bankrollStacks--;
			BankrollReloadEffect component = ((Component)player).gameObject.GetComponent<BankrollReloadEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
			if (player.GetGamblerData().bankrollStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

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

		protected override string GetDescription()
		{
			return "Skim a little off the top — it pays out on reload.";
		}

		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)
			//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 = false;
			val.stat = "Damage";
			val.amount = "-20% (banked)";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Reload Time";
			val.amount = "+0.5s";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class Blackjack : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[2]
			{
				GamblerCategory.Get(),
				GamblerCategory.GetBlackjackUnique()
			};
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			block.additionalBlocks++;
			data.maxHealth *= 0.8f;
			BlackjackEffect orAddComponent = ExtensionMethods.GetOrAddComponent<BlackjackEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(characterStats).blacklistedCategories;
			CardCategory blackjackUnique = GamblerCategory.GetBlackjackUnique();
			if (!blacklistedCategories.Contains(blackjackUnique))
			{
				blacklistedCategories.Add(blackjackUnique);
			}
		}

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

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

		protected override string GetDescription()
		{
			return "Hit me.";
		}

		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)
			//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)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[5];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "On Block";
			val.amount = "Draw 3 cards";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "17-21";
			val.amount = "Reflect + CD buff";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Additional Blocks";
			val.amount = "+1";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Bust (>21)";
			val.amount = "1.8x CD penalty";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-20%";
			val.simepleAmount = (SimpleAmount)0;
			array[4] = 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[2]
			{
				GamblerCategory.Get(),
				GamblerCategory.GetBluffUnique()
			};
		}

		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++;
			List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(characterStats).blacklistedCategories;
			CardCategory bluffUnique = GamblerCategory.GetBluffUnique();
			if (!blacklistedCategories.Contains(bluffUnique))
			{
				blacklistedCategories.Add(bluffUnique);
			}
		}

		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++;
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			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 (5th/3rd at higher stacks)";
			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 CardShark : 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 *= 0.8f;
			CardSharkEffect orAddComponent = ExtensionMethods.GetOrAddComponent<CardSharkEffect>(((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)
		{
			CardSharkEffect component = ((Component)player).gameObject.GetComponent<CardSharkEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "What's yours is mine — and it always was.";
		}

		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 = "Luck Stolen";
			val.amount = "0.10 per opponent";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Steal Timing";
			val.amount = "Each point start";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-20%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class ChipStack : 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)
		{
			characterStats.movementSpeed *= 1.1f;
			ChipStackEffect orAddComponent = ExtensionMethods.GetOrAddComponent<ChipStackEffect>(((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)
		{
			ChipStackEffect component = ((Component)player).gameObject.GetComponent<ChipStackEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Chip Stack";
		}

		protected override string GetDescription()
		{
			return "Put your health where your mouth is.";
		}

		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 = "HP Bet";
			val.amount = "20% per point";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Win Payout";
			val.amount = "250% of bet";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Movement Speed";
			val.amount = "+10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = 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 (±50% / ±70% at higher stacks)";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class CompdDrinks : 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;
			CompdDrinksEffect orAddComponent = ExtensionMethods.GetOrAddComponent<CompdDrinksEffect>(((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)
		{
			CompdDrinksEffect component = ((Component)player).gameObject.GetComponent<CompdDrinksEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Comp'd Drinks";
		}

		protected override string GetDescription()
		{
			return "The house keeps your glass full — until it doesn't.";
		}

		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)
			//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 = "Passive Regen";
			val.amount = "5 HP/s";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Regen Cutout";
			val.amount = "25% every 4s";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class DeadMansHand : 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 *= 1.2f;
			DeadMansHandEffect orAddComponent = ExtensionMethods.GetOrAddComponent<DeadMansHandEffect>(((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)
		{
			DeadMansHandEffect component = ((Component)player).gameObject.GetComponent<DeadMansHandEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Dead Man's Hand";
		}

		protected override string GetDescription()
		{
			return "Aces and eights. If you're going down, take them with you.";
		}

		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)
			//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 = "Revenge Damage";
			val.amount = "40% of Max HP";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max HP";
			val.amount = "+20%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class DealersHand : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[2]
			{
				GamblerCategory.Get(),
				GamblerCategory.GetDealersHandUnique()
			};
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.damage *= 0.85f;
			gunAmmo.maxAmmo = Mathf.Max(gunAmmo.maxAmmo - 1, 1);
			DealersHandEffect orAddComponent = ExtensionMethods.GetOrAddComponent<DealersHandEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(characterStats).blacklistedCategories;
			CardCategory dealersHandUnique = GamblerCategory.GetDealersHandUnique();
			if (!blacklistedCategories.Contains(dealersHandUnique))
			{
				blacklistedCategories.Add(dealersHandUnique);
			}
		}

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

		protected override string GetTitle()
		{
			return "Dealer's Hand";
		}

		protected override string GetDescription()
		{
			return "Every reload deals you a new hand — pray for a royal flush.";
		}

		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 = "On Reload";
			val.amount = "Random damage buff";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Ammo";
			val.amount = "-1";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = 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 Fold : 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 *= 0.85f;
			FoldEffect orAddComponent = ExtensionMethods.GetOrAddComponent<FoldEffect>(((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)
		{
			FoldEffect component = ((Component)player).gameObject.GetComponent<FoldEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "Know when to walk away.";
		}

		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)
			//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 = "Dodge Chance";
			val.amount = "20%";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Speed on Dodge";
			val.amount = "+40% (1.5s)";
			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 GravityRoulette : CustomCard
	{
		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[2]
			{
				GamblerCategory.Get(),
				GamblerCategory.GetGravityRouletteUnique()
			};
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.damage *= 1.15f;
			gun.numberOfProjectiles++;
			gun.attackSpeed *= 1.15f;
			GravityRouletteEffect orAddComponent = ExtensionMethods.GetOrAddComponent<GravityRouletteEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(characterStats).blacklistedCategories;
			CardCategory gravityRouletteUnique = GamblerCategory.GetGravityRouletteUnique();
			if (!blacklistedCategories.Contains(gravityRouletteUnique))
			{
				blacklistedCategories.Add(gravityRouletteUnique);
			}
		}

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

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

		protected override string GetDescription()
		{
			return "Every bullet takes a different flight path — hope for the best.";
		}

		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)
			//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 = "+15%";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Projectiles";
			val.amount = "+1";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-15%";
			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 *= 0.85f;
			HotHandEffect orAddComponent = ExtensionMethods.GetOrAddComponent<HotHandEffect>(((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)
		{
			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 (+5% per extra stack)";
			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 *= 0.8f;
			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. Stacks add 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 InsurancePolicy : 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 *= 1.2f;
			gun.damage *= 0.9f;
			InsurancePolicyEffect orAddComponent = ExtensionMethods.GetOrAddComponent<InsurancePolicyEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			orAddComponent.UpdateDampener();
		}

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

		protected override string GetTitle()
		{
			return "Insurance Policy";
		}

		protected override string GetDescription()
		{
			return "The house always hedges.";
		}

		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 = "Less RNG Swing";
			val.amount = "35% per stack";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max HP";
			val.amount = "+20%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = 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 *= 0.85f;
			JackpotEffect orAddComponent = ExtensionMethods.GetOrAddComponent<JackpotEffect>(((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)
		{
			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 LoadedGame : 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 *= 0.9f;
			characterStats.movementSpeed *= 0.95f;
			LoadedGameEffect orAddComponent = ExtensionMethods.GetOrAddComponent<LoadedGameEffect>(((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)
		{
			LoadedGameEffect component = ((Component)player).gameObject.GetComponent<LoadedGameEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

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

		protected override string GetDescription()
		{
			return "First few hands are on the house. After that, you're on your own. (Affects pre-shot rolls only.)";
		}

		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)
			//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 = "First 5 Shots";
			val.amount = "+0.20 luck";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "After Shot 5";
			val.amount = "-0.10 luck";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "HP";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Movement Speed";
			val.amount = "-5%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = 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 *= 1.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 /= 1.15f;
		}

		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 MartingalePoint : 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.85f;
			gun.attackSpeed *= 1.1f;
			MartingalePointEffect orAddComponent = ExtensionMethods.GetOrAddComponent<MartingalePointEffect>(((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)
		{
			MartingalePointEffect component = ((Component)player).gameObject.GetComponent<MartingalePointEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Martingale (Point)";
		}

		protected override string GetDescription()
		{
			return "Double the bet after every loss. It has to work eventually.";
		}

		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 = "Per Loss";
			val.amount = "+25% dmg, +12% aspd";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max Loss Stacks";
			val.amount = "3";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Base Damage";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class MartingaleShot : 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.75f;
			gunAmmo.maxAmmo = Mathf.Max(gunAmmo.maxAmmo - 1, 1);
			data.maxHealth *= 0.85f;
			MartingaleShotEffect orAddComponent = ExtensionMethods.GetOrAddComponent<MartingaleShotEffect>(((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)
		{
			MartingaleShotEffect component = ((Component)player).gameObject.GetComponent<MartingaleShotEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Martingale (Shot)";
		}

		protected override string GetDescription()
		{
			return "Keep doubling the bet until you score — the payout has to come eventually, right?";
		}

		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)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[5];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Bet Multiplier";
			val.amount = "2x per shot until kill (cap 16x)";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "On Kill";
			val.amount = "Payout for 2 more shots";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Base Damage";
			val.amount = "-25%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Ammo";
			val.amount = "-1";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "HP";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[4] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class Parlay : 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			gun.damage *= 0.8f;
			gun.attackSpeed *= 1.1f;
			data.maxHealth *= 0.9f;
			player.GetGamblerData().parlayStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("ParlayBullet", new Type[1] { typeof(ParlayEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (player.GetGamblerData().parlayStacks == 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().parlayStacks--;
			if (player.GetGamblerData().parlayStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

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

		protected override string GetDescription()
		{
			return "Let it ride — every hit rolls for another.";
		}

		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)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			CardInfoStat[] array = new CardInfoStat[5];
			CardInfoStat val = new CardInfoStat();
			val.positive = true;
			val.stat = "Chain Chance";
			val.amount = "40%";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Chain Damage";
			val.amount = "75% per link";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Base Damage";
			val.amount = "-20%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[4] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class PokerFace : 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.1f;
			PokerFaceEffect orAddComponent = ExtensionMethods.GetOrAddComponent<PokerFaceEffect>(((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)
		{
			PokerFaceEffect component = ((Component)player).gameObject.GetComponent<PokerFaceEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Poker Face";
		}

		protected override string GetDescription()
		{
			return "Never let them see you sweat.";
		}

		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)
			//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 = "Shield on Block";
			val.amount = "15-45 HP";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Shield Duration";
			val.amount = "3s decay";
			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 PotCommitted : 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)
		{
			PotCommittedEffect orAddComponent = ExtensionMethods.GetOrAddComponent<PotCommittedEffect>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			orAddComponent.Recalculate();
		}

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

		protected override string GetTitle()
		{
			return "Pot Committed";
		}

		protected override string GetDescription()
		{
			return "Too deep to fold now.";
		}

		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 = "Per Gambler Card";
			val.amount = "+7% damage";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Per Gambler Card";
			val.amount = "+5% move speed";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Per Gambler Card";
			val.amount = "-4% max HP";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = 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 *= 0.9f;
			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 SideBet : 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 += 10f;
			characterStats.movementSpeed *= 0.9f;
			SideBetEffect orAddComponent = ExtensionMethods.GetOrAddComponent<SideBetEffect>(((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)
		{
			SideBetEffect component = ((Component)player).gameObject.GetComponent<SideBetEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Side Bet";
		}

		protected override string GetDescription()
		{
			return "Winner takes all — loser pays double.";
		}

		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)
			//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 = "Heal on Kill";
			val.amount = "40 HP";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Debt on Death";
			val.amount = "20% max HP";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = true;
			val.stat = "Max HP";
			val.amount = "+10";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Movement Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class SidePot : 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			gun.attackSpeed *= 1.1f;
			data.maxHealth *= 0.9f;
			SidePotManager orAddComponent = ExtensionMethods.GetOrAddComponent<SidePotManager>(((Component)player).gameObject, false);
			orAddComponent.stacks++;
			player.GetGamblerData().sidePotStacks++;
			if (bulletPrefab == null)
			{
				bulletPrefab = new GameObject("SidePotBullet", new Type[1] { typeof(SidePotEffect) });
				Object.DontDestroyOnLoad((Object)(object)bulletPrefab);
			}
			if (player.GetGamblerData().sidePotStacks == 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().sidePotStacks--;
			SidePotManager component = ((Component)player).gameObject.GetComponent<SidePotManager>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
			if (player.GetGamblerData().sidePotStacks <= 0)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.RemoveAll((ObjectsToSpawn s) => s.AddToProjectile == bulletPrefab);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		protected override string GetTitle()
		{
			return "Side Pot";
		}

		protected override string GetDescription()
		{
			return "Part of every hit is riding on the next roll.";
		}

		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)
			//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 = "Delayed Damage";
			val.amount = "30% held [0.5x-2.5x]";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Attack Speed";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			return (CardInfoStat[])(object)array;
		}
	}
	public class SlotMachine : 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.85f;
			gunAmmo.reloadTime += 0.3f;
			data.maxHealth *= 0.9f;
			SlotMachineEffect orAddComponent = ExtensionMethods.GetOrAddComponent<SlotMachineEffect>(((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)
		{
			SlotMachineEffect component = ((Component)player).gameObject.GetComponent<SlotMachineEffect>();
			if (component != null)
			{
				component.stacks--;
				if (component.stacks <= 0)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}

		protected override string GetTitle()
		{
			return "Slot Machine";
		}

		protected override string GetDescription()
		{
			return "Pull the trigger, spin the reels — how many come out?";
		}

		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)
			//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 = "Burst";
			val.amount = "Random [1-5]";
			val.simepleAmount = (SimpleAmount)0;
			array[0] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Damage";
			val.amount = "-15%";
			val.simepleAmount = (SimpleAmount)0;
			array[1] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Reload Time";
			val.amount = "+0.3s";
			val.simepleAmount = (SimpleAmount)0;
			array[2] = val;
			val = new CardInfoStat();
			val.positive = false;
			val.stat = "Max HP";
			val.amount = "-10%";
			val.simepleAmount = (SimpleAmount)0;
			array[3] = 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 min = 0.3f + luck * 1f;
				float max = 2.5f + (float)(stacks - 1) * 1f;
				appliedDamageMult = GamblerRNG.NextFloat(min, max);
				float num = 0.5f - (float)(stacks - 1) * 0.15f + luck * 0.5f;
				num = Mathf.Max(num, 0.2f);
				float max2 = 1.5f + (float)(stacks - 1) * 0.25f;
				appliedHpMult = GamblerRNG.NextFloat(num, max2);
				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 BailoutEffect : MonoBehaviour
	{
		public int stacks;

		public bool invulnerable;

		private Player player;

		private bool usedThisPoint;

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

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			usedThisPoint = false;
			invulnerable = false;
			yield break;
		}

		public bool TryBailout()
		{
			if (player == null || stacks <= 0)
			{
				return false;
			}
			if (usedThisPoint)
			{
				return false;
			}
			float luck = player.GetLuck();
			float num = 0.35f + (float)(stacks - 1) * 0.1f;
			num = Mathf.Min(num, 0.7f);
			if (!GamblerRNG.CoinFlip(num, luck))
			{
				return false;
			}
			usedThisPoint = true;
			player.data.health = player.data.maxHealth * 0.25f;
			float duration = 2f + (float)(stacks - 1) * 0.5f;
			((MonoBehaviour)this).StartCoroutine(InvulnerabilityWindow(duration));
			return true;
		}

		private IEnumerator InvulnerabilityWindow(float duration)
		{
			invulnerable = true;
			yield return (object)new WaitForSeconds(duration);
			invulnerable = false;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
		}
	}
	public class BankrollEffect : 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)
						{
							BankrollReloadEffect component2 = ((Component)ownPlayer).GetComponent<BankrollReloadEffect>();
							if (component2 != null)
							{
								float skimRate = component2.GetSkimRate();
								float num = componentInParent.damage * skimRate;
								componentInParent.damage -= num;
								component2.pool += num;
								float num2 = component2.ConsumePayout();
								if (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 BankrollReloadEffect : MonoBehaviour
	{
		public int stacks;

		public float pool;

		private Player player;

		private int shotsFired;

		private bool payoutReady;

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

		public void OnShotFired(int maxAmmo)
		{
			shotsFired++;
			if (shotsFired >= maxAmmo)
			{
				shotsFired = 0;
				if (pool > 0f)
				{
					payoutReady = true;
				}
			}
		}

		public float ConsumePayout()
		{
			if (!payoutReady || pool <= 0f)
			{
				return 0f;
			}
			float result = pool * GetPayoutMultiplier();
			pool = 0f;
			payoutReady = false;
			return result;
		}

		public float GetSkimRate()
		{
			return Mathf.Min(0.2f + (float)(stacks - 1) * 0.05f, 0.4f);
		}

		public float GetPayoutMultiplier()
		{
			return Mathf.Min(1f + (float)(stacks - 1) * 0.25f, 2.5f);
		}

		private void OnDestroy()
		{
			pool = 0f;
		}
	}
	public class BlackjackEffect : MonoBehaviour
	{
		private struct DamageEntry
		{
			public float amount;

			public float time;
		}

		public int stacks;

		private Player player;

		private Block block;

		private Action<BlockTriggerType> blockAction;

		private int activeCdBuffs;

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

		private const float DAMAGE_WINDOW = 3f;

		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 - 3f;
			recentDamage.RemoveAll((DamageEntry e) => e.time < cutoff);
		}

		public void LogDamage(float amount)
		{
			recentDamage.Add(new DamageEntry
			{
				amount = amount,
				time = Time.time
			});
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger != 0 || player == null)
			{
				return;
			}
			float luck = player.GetLuck();
			float varianceDampener = player.GetGamblerData().varianceDampener;
			int num = 0;
			for (int i = 0; i < 3; i++)
			{
				num += Mathf.RoundToInt(GamblerRNG.Range(1f, 13f, 0f - luck, varianceDampener));
			}
			if (num >= 17 && num <= 21)
			{
				GamblerData gamblerData = player.GetGamblerData();
				if (gamblerData.lastAttacker != null && gamblerData.lastAttacker != player)
				{
					float num2 = 0f;
					for (int j = 0; j < recentDamage.Count; j++)
					{
						num2 += recentDamage[j].amount;
					}
					float num3 = num2 * 0.35f;
					if (num3 > 0f)
					{
						Player lastAttacker = gamblerData.lastAttacker;
						lastAttacker.data.healthHandler.DoDamage(new Vector2(num3, 0f), Vector2.op_Implicit(((Component)lastAttacker).transform.position), Color.clear, (GameObject)null, player, false, false, true);
					}
				}
				recentDamage.Clear();
				((MonoBehaviour)this).StartCoroutine(CdBuff());
			}
			else if (num > 21)
			{
				player.GetGamblerData().pendingBlockCdMult = 1.8f;
			}
		}

		private IEnumerator CdBuff()
		{
			if (block != null)
			{
				float mult = 0.6f;
				Block obj = block;
				obj.cdMultiplier *= mult;
				activeCdBuffs++;
				yield return (object)new WaitForSeconds(5f);
				activeCdBuffs--;
				Block obj2 = block;
				obj2.cdMultiplier /= mult;
			}
		}

		private void OnDestroy()
		{
			if (block != null)
			{
				block.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(block.BlockAction, blockAction);
				for (int i = 0; i < activeCdBuffs; i++)
				{
					Block obj = block;
					obj.cdMultiplier /= 0.6f;
				}
			}
		}
	}
	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, player.GetGamblerData().varianceDampener);
				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 CardSharkEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

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

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player == null || stacks <= 0)
			{
				yield break;
			}
			float num = 0.05f + 0.05f * (float)stacks;
			float num2 = ((Plugin.LuckCap == null) ? 0.6f : Plugin.LuckCap.Value);
			float num3 = 0f;
			foreach (Player player in PlayerManager.instance.players)
			{
				if (player.teamID != this.player.teamID)
				{
					GamblerData gamblerData = player.GetGamblerData();
					float num4 = Mathf.Min(num, gamblerData.luck);
					gamblerData.luck = Mathf.Max(gamblerData.luck - num, 0f);
					num3 += num4;
				}
			}
			if (num3 > 0f)
			{
				GamblerData gamblerData2 = this.player.GetGamblerData();
				gamblerData2.luck = Mathf.Min(gamblerData2.luck + num3, num2);
			}
		}

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

		private Player player;

		private float currentBet;

		private int prevPoints;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			prevPoints = GetMyTeamPoints();
			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)
		{
			currentBet = 0f;
			prevPoints = 0;
			yield break;
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null && stacks > 0)
			{
				float num = 0.15f + 0.05f * (float)stacks;
				float num2 = Mathf.Max(player.data.health * num, 10f);
				if (num2 >= player.data.health)
				{
					num2 = player.data.health - 1f;
				}
				if (num2 > 0f)
				{
					player.data.healthHandler.DoDamage(new Vector2(num2, 0f), Vector2.op_Implicit(((Component)player).transform.position), Color.clear, (GameObject)null, player, false, false, true);
					currentBet = num2;
				}
				else
				{
					currentBet = 0f;
				}
			}
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (player != null && stacks > 0)
			{
				int myTeamPoints = GetMyTeamPoints();
				if (currentBet > 0f && myTeamPoints > prevPoints)
				{
					float num = 2f + 0.5f * (float)stacks;
					player.data.healthHandler.Heal(currentBet * num);
				}
				prevPoints = myTeamPoints;
				currentBet = 0f;
			}
			yield break;
		}

		private int GetMyTeamPoints()
		{
			if (player == null)
			{
				return 0;
			}
			return GamblerTeams.GetTeamScore(player.teamID);
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
			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;
				appliedMultiplier = SpeedMultiplier.ApplyAtkMult(mult: (!flag) ? Mathf.Min(1f + num, 5f) : Mathf.Max(1f - num, 0.05f), gun: gun);
			}
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			appliedMultiplier = SpeedMultiplier.RevertAtkMult(gun, appliedMultiplier);
			yield break;
		}

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

		private Player player;

		private bool regenActive = true;

		private float cutoutTimer;

		private float pointTime;

		private readonly List<float> cutoutTimes = new List<float>();

		private int nextCutoutIndex;

		private const float CHECK_INTERVAL = 4f;

		private const float CUTOUT_DURATION = 3f;

		private const float BASE_REGEN = 5f;

		private const float REGEN_PER_STACK = 3f;

		private const int MAX_PREROLLS = 12;

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

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			regenActive = true;
			cutoutTimer = 0f;
			pointTime = 0f;
			nextCutoutIndex = 0;
			cutoutTimes.Clear();
			if (player == null || stacks <= 0)
			{
				yield break;
			}
			float luck = player.GetLuck();
			for (int i = 1; i <= 12; i++)
			{
				if (GamblerRNG.FumbleCheck(0.25f, luck))
				{
					cutoutTimes.Add((float)i * 4f);
				}
			}
		}

		private void Update()
		{
			if (player == null || player.data.dead)
			{
				return;
			}
			pointTime += Time.deltaTime;
			while (nextCutoutIndex < cutoutTimes.Count && pointTime >= cutoutTimes[nextCutoutIndex])
			{
				if (regenActive)
				{
					regenActive = false;
					cutoutTimer = 3f;
				}
				nextCutoutIndex++;
			}
			if (!regenActive)
			{
				cutoutTimer -= Time.deltaTime;
				if (cutoutTimer <= 0f)
				{
					regenActive = true;
				}
			}
			if (regenActive)
			{
				float num = 5f + (float)(stacks - 1) * 3f;
				float num2 = num * Time.deltaTime;
				if (player.data.health < player.data.maxHealth)
				{
					float num3 = player.data.maxHealth - player.data.health;
					player.data.healthHandler.Heal(Mathf.Min(num2, num3));
				}
			}
		}

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

		private Player player;

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

		public void OnDeath()
		{
			//IL_009d: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (player != null && stacks > 0)
			{
				Player lastAttacker = player.GetGamblerData().lastAttacker;
				if (lastAttacker != null && lastAttacker.data != null && !lastAttacker.data.dead && lastAttacker.teamID != player.teamID)
				{
					float num = 0.4f + (float)(stacks - 1) * 0.15f;
					float num2 = player.data.maxHealth * num;
					lastAttacker.data.healthHandler.DoDamage(new Vector2(num2, 0f), Vector2.op_Implicit(((Component)lastAttacker).transform.position), Color.clear, (GameObject)null, player, false, false, true);
				}
			}
		}

		private void OnDestroy()
		{
		}
	}
	public class DealersHandEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private int shotsFired;

		private float currentDamageMult = 1f;

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

		public void OnShotFired(int maxAmmo)
		{
			shotsFired++;
			if (shotsFired >= maxAmmo)
			{
				shotsFired = 0;
				RollHand();
			}
		}

		private void RollHand()
		{
			if (player != null)
			{
				float luck = player.GetLuck();
				float[] weights = new float[5] { 0.05f, 0.1f, 0.2f, 0.3f, 0.35f };
				switch (GamblerRNG.WeightedRoll(weights, luck))
				{
				case 0:
					currentDamageMult = 2.5f;
					break;
				case 1:
					currentDamageMult = 1.8f;
					break;
				case 2:
					currentDamageMult = 1.5f;
					break;
				case 3:
					currentDamageMult = 1.25f;
					break;
				default:
					currentDamageMult = 1f;
					break;
				}
			}
		}

		public float ConsumeDealerBuff()
		{
			return currentDamageMult;
		}

		private void OnDestroy()
		{
			currentDamageMult = 1f;
		}
	}
	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 FoldEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private CharacterStatModifiers stats;

		private int activeSpeedBuffs;

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

		public bool TryDodge()
		{
			if (player == null)
			{
				return false;
			}
			float luck = player.GetLuck();
			float num = 0.15f + (float)stacks * 0.05f;
			num = Mathf.Min(num, 0.5f);
			if (!GamblerRNG.CoinFlip(num, luck))
			{
				return false;
			}
			((MonoBehaviour)this).StartCoroutine(SpeedBuff());
			return true;
		}

		private IEnumerator SpeedBuff()
		{
			if (stats != null)
			{
				float mult = 1.4f;
				CharacterStatModifiers obj = stats;
				obj.movementSpeed *= mult;
				stats.movementSpeed = Mathf.Min(stats.movementSpeed, Plugin.MovementSpeedCap.Value);
				activeSpeedBuffs++;
				yield return (object)new WaitForSeconds(1.5f);
				activeSpeedBuffs--;
				CharacterStatModifiers obj2 = stats;
				obj2.movementSpeed /= mult;
				stats.movementSpeed = Mathf.Max(stats.movementSpeed, 1f);
			}
		}

		private void OnDestroy()
		{
			if (stats != null && activeSpeedBuffs > 0)
			{
				for (int i = 0; i < activeSpeedBuffs; i++)
				{
					CharacterStatModifiers obj = stats;
					obj.movementSpeed /= 1.4f;
				}
			}
		}
	}
	public class GravityRouletteEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private float savedGravity;

		private bool needsRestore;

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

		public void RollGravity(Gun gun)
		{
			if (player != null)
			{
				savedGravity = gun.gravity;
				float luck = player.GetLuck();
				float[] weights = new float[3] { 0.33f, 0.33f, 0.33f };
				switch (GamblerRNG.WeightedRoll(weights, luck))
				{
				case 0:
					gun.gravity = 0f;
					break;
				case 1:
					gun.gravity = savedGravity * 3f;
					break;
				case 2:
					gun.gravity = 0f - savedGravity;
					break;
				}
				needsRestore = true;
			}
		}

		public void RestoreGravity(Gun gun)
		{
			if (needsRestore)
			{
				gun.gravity = savedGravity;
				needsRestore = false;
			}
		}

		private void OnDestroy()
		{
			if (gun != null)
			{
				RestoreGravity(gun);
			}
		}
	}
	public class HailMaryEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private Block block;

		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>();
			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;
			appliedAtkMult = SpeedMultiplier.ApplyAtkMult(gun, appliedAtkMult);
			if (appliedHpBonus > 0f)
			{
				CharacterData data = player.data;
				data.maxHealth += appliedHpBonus;
				CharacterData data2 = player.data;
				data2.health += appliedHpBonus;
			}
			if (appliedBlockCharges > 0 && block != null)
			{
				Block obj2 = block;
				obj2.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 && appliedDamageMult != 1f)
			{
				Gun obj = gun;
				obj.damage /= appliedDamageMult;
			}
			appliedAtkMult = SpeedMultiplier.RevertAtkMult(gun, 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 obj2 = block;
				obj2.additionalBlocks -= appliedBlockCharges;
			}
			if (player != null && player.data != null && appliedJumps > 0)
			{
				CharacterData data = player.data;
				data.jumps -= appliedJumps;
			}
			appliedDamageMult = 1f;
			appliedHpBonus = 0f;
			appliedBlockCharges = 0;
			appliedJumps = 0;
		}

		private int GetDeficit()
		{
			if (player == null)
			{
				return 0;
			}
			int teamRounds = GamblerTeams.GetTeamRounds(player.teamID);
			int teamRounds2 = GamblerTeams.GetTeamRounds((player.teamID == 0) ? 1 : 0);
			return teamRounds2 - teamRounds;
		}

		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>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null)
			{
				player.GetGamblerData().streakStacks = 0;
			}
			yield break;
		}

		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()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (player == null)
			{
				return;
			}
			GamblerData gamblerData = player.GetGamblerData();
			float luck = player.GetLuck();
			if (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;
					player.data.healthHandler.DoDamage(new Vector2(num, 0f), Vector2.op_Implicit(((Component)player).transform.position), Color.clear, (GameObject)null, player, false, false, true);
				}
			}
			else
			{
				gamblerData.streakStacks = 1;
			}
		}

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

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
		}
	}
	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)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			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 (!(GamblerRNG.NextFloat(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;
					val.data.healthHandler.DoDamage(new Vector2(num4, 0f), Vector2.op_Implicit(((Component)val).transform.position), Color.clear, (GameObject)null, player, false, false, true);
					damageLog.Clear();
				}
			}
		}

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

		private Player player;

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

		public void UpdateDampener()
		{
			if (player != null)
			{
				float varianceDampener = Mathf.Min(0.35f * (float)stacks, 0.8f);
				player.GetGamblerData().varianceDampener = varianceDampener;
			}
		}

		private void OnDestroy()
		{
			if (player != null)
			{
				player.GetGamblerData().varianceDampener = 0f;
			}
		}
	}
	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 (GamblerRNG.NextFloat(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, ownPlayer.GetGamblerData().varianceDampener);
								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 LoadedGameEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private int shotsThisPoint;

		private float currentLuckMod;

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

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

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

		public void ApplyLuckPhase()
		{
			if (player != null)
			{
				currentLuckMod = ((shotsThisPoint >= GetLuckyShots()) ? (-0.1f) : GetLuckBonus());
				player.GetGamblerData().luck += currentLuckMod;
			}
		}

		public void RevertLuckPhase()
		{
			if (player != null)
			{
				player.GetGamblerData().luck -= currentLuckMod;
				currentLuckMod = 0f;
			}
		}

		public void IncrementShot()
		{
			shotsThisPoint++;
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			shotsThisPoint = 0;
			yield break;
		}

		private void OnDestroy()
		{
			if (currentLuckMod != 0f)
			{
				RevertLuckPhase();
			}
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
		}
	}
	public class MartingalePointEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private int lossStacks;

		private float appliedDmgMult = 1f;

		private float appliedAtkMult = 1f;

		private int prevPoints;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)this).GetComponent<Gun>();
			prevPoints = GetMyTeamPoints();
			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)
		{
			RevertBuffs();
			lossStacks = 0;
			prevPoints = 0;
			yield break;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (player != null && stacks > 0)
			{
				RevertBuffs();
				int myTeamPoints = GetMyTeamPoints();
				if (myTeamPoints > prevPoints)
				{
					lossStacks = 0;
				}
				else
				{
					lossStacks = Mathf.Min(lossStacks + 1, 3);
				}
				prevPoints = myTeamPoints;
			}
			yield break;
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player != null && gun != null && stacks > 0 && lossStacks > 0)
			{
				float num = 0.2f + 0.05f * (float)stacks;
				float num2 = 0.09f + 0.03f * (float)stacks;
				appliedDmgMult = 1f + num * (float)lossStacks;
				appliedAtkMult = 1f / (1f + num2 * (float)lossStacks);
				Gun obj = gun;
				obj.damage *= appliedDmgMult;
				appliedAtkMult = SpeedMultiplier.ApplyAtkMult(gun, appliedAtkMult);
			}
			yield break;
		}

		private void RevertBuffs()
		{
			if (gun != null && appliedDmgMult != 1f)
			{
				Gun obj = gun;
				obj.damage /= appliedDmgMult;
			}
			appliedAtkMult = SpeedMultiplier.RevertAtkMult(gun, appliedAtkMult);
			appliedDmgMult = 1f;
		}

		private int GetMyTeamPoints()
		{
			if (player == null)
			{
				return 0;
			}
			return GamblerTeams.GetTeamScore(player.teamID);
		}

		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);
		}
	}
	public class MartingaleShotEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private float betMultiplier = 1f;

		private int payoutShotsRemaining;

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

		public float GetMaxBet()
		{
			float num = 16f;
			for (int i = 1; i < stacks; i++)
			{
				num *= 2f;
			}
			return num;
		}

		public int GetPayoutShots()
		{
			return 3 + (stacks - 1);
		}

		public float GetDamageMultiplier()
		{
			return betMultiplier;
		}

		public void OnShotFired()
		{
			if (payoutShotsRemaining > 0)
			{
				payoutShotsRemaining--;
				if (payoutShotsRemaining <= 0)
				{
					betMultiplier = 1f;
				}
			}
			else
			{
				betMultiplier = Mathf.Min(betMultiplier * 2f, GetMaxBet());
			}
		}

		public void OnKill()
		{
			payoutShotsRemaining = GetPayoutShots();
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			betMultiplier = 1f;
			payoutShotsRemaining = 0;
			yield break;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
		}
	}
	public class ParlayEffect : RayHitEffect
	{
		private const int MAX_CHAINS = 10;

		private const float CHAIN_RANGE = 15f;

		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 parlayStacks = gamblerData.parlayStacks;
							if (parlayStacks > 0)
							{
								float luck = ownPlayer.GetLuck();
								float baseChainChance = GetBaseChainChance(parlayStacks);
								float damageRetention = GetDamageRetention(parlayStacks);
								float damage = componentInParent.damage * damageRetention;
								TryChain(ownPlayer, component, damage, baseChainChance, luck, damageRetention, 0);
								return (HasToReturn)1;
							}
							return (HasToReturn)1;
						}
						return (HasToReturn)1;
					}
					return (HasToReturn)1;
				}
				return (HasToReturn)1;
			}
			return (HasToReturn)1;
		}

		private void TryChain(Player shooter, Player lastVictim, float damage, float baseChance, float luck, float damageRetention, int chainCount)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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)
			if (chainCount < 10 && !(damage < 1f) && GamblerRNG.CoinFlip(baseChance, luck))
			{
				Player val = FindNearestEnemy(shooter, ((Component)lastVictim).transform.position);
				if (val != null && !val.data.dead)
				{
					Vector2 val2 = default(Vector2);
					((Vector2)(ref val2))..ctor(damage, 0f);
					val.data.healthHandler.DoDamage(val2, Vector2.op_Implicit(((Component)val).transform.position), Color.yellow, (GameObject)null, shooter, false, false, false);
					float damage2 = damage * damageRetention;
					TryChain(shooter, val, damage2, baseChance, luck, damageRetention, chainCount + 1);
				}
			}
		}

		private Player FindNearestEnemy(Player shooter, Vector3 fromPosition)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			List<Player> players = PlayerManager.instance.players;
			Player result = null;
			float num = 15f;
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if (val != shooter && val.teamID != shooter.teamID && !val.data.dead)
				{
					float num2 = Vector2.Distance(Vector2.op_Implicit(fromPosition), Vector2.op_Implicit(((Component)val).transform.position));
					if (num2 < num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private float GetBaseChainChance(int stacks)
		{
			return Mathf.Min(0.4f + (float)(stacks - 1) * 0.08f, 0.75f);
		}

		private float GetDamageRetention(int stacks)
		{
			return Mathf.Min(0.75f + (float)(stacks - 1) * 0.05f, 0.9f);
		}
	}
	public class PokerFaceEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Block block;

		private Action<BlockTriggerType> blockAction;

		public float shieldHP;

		private const float MAX_SHIELD = 60f;

		private const float DECAY_DURATION = 3f;

		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()
		{
			if (!(shieldHP <= 0f))
			{
				float num = shieldHP / 3f;
				shieldHP -= num * Time.deltaTime;
				if (shieldHP < 0f)
				{
					shieldHP = 0f;
				}
			}
		}

		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)
			{
				float luck = player.GetLuck();
				float num = GamblerRNG.Range(15f, 45f, luck, player.GetGamblerData().varianceDampener);
				shieldHP = Mathf.Min(shieldHP + num, 60f);
			}
		}

		public float AbsorbDamage(float incomingDmg)
		{
			if (shieldHP <= 0f)
			{
				return incomingDmg;
			}
			if (shieldHP >= incomingDmg)
			{
				shieldHP -= incomingDmg;
				return 0f;
			}
			float result = incomingDmg - shieldHP;
			shieldHP = 0f;
			return result;
		}

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

		private Player player;

		private Gun gun;

		private CharacterStatModifiers stats;

		private float appliedDmgMult = 1f;

		private float appliedMoveMult = 1f;

		private float appliedHpMult = 1f;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			gun = ((Component)this).GetComponent<Gun>();
			stats = ((Component)this).GetComponent<CharacterStatModifiers>();
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)OnPlayerPickEnd);
		}

		private IEnumerator OnPlayerPickEnd(IGameModeHandler gm)
		{
			Recalculate();
			yield break;
		}

		public void Recalculate()
		{
			if (player == null)
			{
				player = ((Component)this).GetComponent<Player>();
			}
			if (gun == null)
			{
				gun = ((Component)this).GetComponent<Gun>();
			}
			if (stats == null)
			{
				stats = ((Component)this).GetComponent<CharacterStatModifiers>();
			}
			if (player == null || gun == null || stats == null)
			{
				return;
			}
			int num = 0;
			CardCategory value = GamblerCategory.Get();
			foreach (CardInfo currentCard in player.data.currentCards)
			{
				if (currentCard.categories != null && currentCard.categories.Contains(value))
				{
					num++;
				}
			}
			float num2 = 1f + (float)num * 0.07f;
			float num3 = Mathf.Min(1f + (float)num * 0.05f, 1.3f);
			float num4 = Mathf.Max(1f - (float)num * 0.04f, 0.1f);
			gun.damage = gun.damage / appliedDmgMult * num2;
			stats.movementSpeed = stats.movementSpeed / appliedMoveMult * num3;
			player.data.maxHealth = player.data.maxHealth / appliedHpMult * num4;
			player.data.health = Mathf.Min(player.data.health, player.data.maxHealth);
			appliedDmgMult = num2;
			appliedMoveMult = num3;
			appliedHpMult = num4;
		}

		public void ResetAppliedMultipliers()
		{
			appliedDmgMult = 1f;
			appliedMoveMult = 1f;
			appliedHpMult = 1f;
		}

		public void RevertAll()
		{
			if (gun != null && appliedDmgMult != 1f)
			{
				Gun obj = gun;
				obj.damage /= appliedDmgMult;
			}
			if (stats != null && appliedMoveMult != 1f)
			{
				CharacterStatModifiers obj2 = stats;
				obj2.movementSpeed /= appliedMoveMult;
			}
			if (player != null && player.data != null && appliedHpMult != 1f)
			{
				CharacterData data = player.data;
				data.maxHealth /= appliedHpMult;
				player.data.health = Mathf.Min(player.data.health, player.data.maxHealth);
			}
			appliedDmgMult = 1f;
			appliedMoveMult = 1f;
			appliedHpMult = 1f;
		}

		private void OnDestroy()
		{
			RevertAll();
			GameModeManager.RemoveHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)OnPlayerPickEnd);
		}
	}
	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)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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)
					{
						val.data.healthHandler.DoDamage(new Vector2(num, 0f), Vector2.op_Implicit(((Component)val).transform.position), Color.clear, (GameObject)null, player, false, false, true);
					}
				}
			}
		}

		private IEnumerator DoFortify()
		{
			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;
				SpeedMultiplier.ApplyAtkMult(gun, atkMult);
				CharacterStatModifiers obj = stats;
				obj.movementSpeed *= moveMult;
				stats.movementSpeed = Mathf.Min(stats.movementSpeed, Plugin.MovementSpeedCap.Value);
				yield return (object)new WaitForSeconds(3f);
				SpeedMultiplier.RevertAtkMult(gun, atkMult);
				CharacterStatModifiers obj2 = stats;
				obj2.movementSpeed /= moveMult;
				stats.movementSpeed = Mathf.Max(stats.movementSpeed, 1f);
			}
		}

		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 SideBetEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private bool gotKillThisPoint;

		private bool diedThisPoint;

		private float pendingDebt;

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			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)
		{
			gotKillThisPoint = false;
			diedThisPoint = false;
			pendingDebt = 0f;
			yield break;
		}

		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			if (player == null || stacks <= 0)
			{
				yield break;
			}
			if (pendingDebt > 0f)
			{
				float num = pendingDebt;
				pendingDebt = 0f;
				if (num >= player.data.health)
				{
					num = player.data.health - 1f;
				}
				if (num > 0f)
				{
					player.data.healthHandler.DoDamage(new Vector2(num, 0f), Vector2.op_Implicit(((Component)player).transform.position), Color.clear, (GameObject)null, player, false, false, true);
				}
			}
			gotKillThisPoint = false;
			diedThisPoint = false;
		}

		private IEnumerator OnPointEnd(IGameModeHandler gm)
		{
			if (player != null && stacks > 0)
			{
				if (gotKillThisPoint)
				{
					float num = 25f + 15f * (float)stacks;
					player.data.healthHandler.Heal(num);
				}
				else if (diedThisPoint)
				{
					float num2 = 0.15f + 0.05f * (float)stacks;
					pendingDebt = player.data.maxHealth * num2;
				}
			}
			yield break;
		}

		public void OnKill()
		{
			gotKillThisPoint = true;
		}

		public void OnDeath()
		{
			diedThisPoint = true;
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)OnPointEnd);
			GameModeManager.RemoveHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
		}
	}
	public class SidePotEffect : 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)
						{
							SidePotManager component2 = ((Component)ownPlayer).GetComponent<SidePotManager>();
							if (component2 != null)
							{
								float holdRate = component2.GetHoldRate();
								float num = componentInParent.damage * holdRate;
								componentInParent.damage -= num;
								float luck = ownPlayer.GetLuck();
								component2.QueueDelayedDamage(component, num, luck);
								return (HasToReturn)1;
							}
							return (HasToReturn)1;
						}
						return (HasToReturn)1;
					}
					return (HasToReturn)1;
				}
				return (HasToReturn)1;
			}
			return (HasToReturn)1;
		}
	}
	public class SidePotManager : MonoBehaviour
	{
		public int stacks;

		private Player player;

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

		public void QueueDelayedDamage(Player target, float baseDamage, float luck)
		{
			((MonoBehaviour)this).StartCoroutine(DelayedDamageCoroutine(target, baseDamage, luck));
		}

		private IEnumerator DelayedDamageCoroutine(Player target, float baseDamage, float luck)
		{
			yield return (object)new WaitForSeconds(2f);
			if (target != null && target.data != null && !target.data.dead)
			{
				float multiplier = GamblerRNG.Range(0.5f, 2.5f, luck, player.GetGamblerData().varianceDampener);
				float finalDamage = baseDamage * multiplier;
				Vector2 dmgVector = new Vector2(finalDamage, 0f);
				target.data.healthHandler.DoDamage(dmgVector, Vector2.op_Implicit(((Component)target).transform.position), Color.red, (GameObject)null, player, false, false, false);
			}
		}

		public float GetHoldRate()
		{
			return Mathf.Min(0.3f + (float)(stacks - 1) * 0.1f, 0.6f);
		}

		private void OnDestroy()
		{
			((MonoBehaviour)this).StopAllCoroutines();
		}
	}
	public class SlotMachineEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		private Gun gun;

		private int savedBursts;

		private bool needsRestore;

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

		public void RollBurst(Gun gun)
		{
			if (player != null)
			{
				savedBursts = gun.bursts;
				float luck = player.GetLuck();
				int num = 5 + (stacks - 1) * 2;
				float[] array = new float[5] { 0.1f, 0.2f, 0.25f, 0.25f, 0.2f };
				float[] array2 = new float[num];
				int num2 = num - 5;
				for (int i = 0; i < 5; i++)
				{
					array2[num2 + i] = array[i];
				}
				for (int j = 0; j < num2; j++)
				{
					array2[j] = 0.05f;
				}
				int num3 = GamblerRNG.WeightedRoll(array2, luck);
				int num4 = num - num3;
				gun.bursts = num4 - 1;
				needsRestore = true;
			}
		}

		public void RestoreBurst(Gun gun)
		{
			if (needsRestore)
			{
				gun.bursts = savedBursts;
				needsRestore = false;
			}
		}

		private void OnDestroy()
		{
			if (gun != null)
			{
				RestoreBurst(gun);
			}
		}
	}
	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 = GamblerRNG.NextFloat(0f, 1f) < num;
				if (isDud)
				{
					componentInParent.damage = 0f;
				}
			}
		}
	}
	public class WildCardEffect : MonoBehaviour
	{
		public int stacks;

		private Player player;

		public int pendingExtraProjectiles;

		public bool rollPending;

		public int savedProjectilesForRevert;

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

		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 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>();
			prevPoints = GetMyTeamPoints();
			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;
				appliedAtkMult = SpeedMultiplier.ApplyAtkMult(gun, appliedAtkMult);
				CharacterStatModifiers obj2 = stats;
				obj2.movementSpeed *= appliedMoveMult;
			}
			yield break;
		}

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

		private int GetMyTeamPoints()
		{
			if (player == null)
			{
				return 0;
			}
			return GamblerTeams.GetTeamScore(player.teamID);
		}

		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;

		private static CardCategory _bluffUnique;

		private static CardCategory _blackjackUnique;

		private static CardCategory _dealersHandUnique;

		private static CardCategory _gravityRouletteUnique;

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

		public static CardCategory GetBluffUnique()
		{
			if (_bluffUnique == null)
			{
				_bluffUnique = CustomCardCategories.instance.CardCategory("GamblerBluffUnique");
			}
			return _bluffUnique;
		}

		public static CardCategory GetBlackjackUnique()
		{
			if (_blackjackUnique == null)
			{
				_blackjackUnique = CustomCardCategories.instance.CardCategory("GamblerBlackjackUnique");
			}
			return _blackjackUnique;
		}

		public static CardCategory GetDealersHandUnique()
		{
			if (_dealersHandUnique == null)
			{
				_dealersHandUnique = CustomCardCategories.instance.CardCategory("GamblerDealersHandUnique");
			}
			return _dealersHandUnique;
		}

		public static CardCategory GetGravityRouletteUnique()
		{
			if (_gravityRouletteUnique == null)
			{
				_gravityRouletteUnique = CustomCardCategories.instance.CardCategory("GamblerGravityRouletteUnique");
			}
			return _gravityRouletteUnique;
		}
	}
	public class GamblerData
	{
		public float luck;

		public int shotCounter;

		public int streakStacks;

		public float lastHitTime;

		public int loadedDiceStacks;

		public int doubleOrNothingStacks;

		public int ricochetStacks;

		public int snakeEyesStacks;

		public int winStreak;

		public float pendingBlockCdMult;

		public int tempBlockCharges;

		public int fortifyActive;

		public Player lastAttacker;

		public int bankrollStacks;

		public int sidePotStacks;

		public int parlayStacks;

		public float varianceDampener;

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

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

		private static MethodInfo _dieMethod;

		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 void ForceKill(this Player player)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (_dieMethod == null)
			{
				_dieMethod = typeof(HealthHandler).GetMethod("RPCA_Die", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_dieMethod != null)
			{
				_dieMethod.Invoke(player.data.healthHandler, new object[1] { Vector2.up });
			}
		}
	}
	public static class GamblerRNG
	{
		private static Random _rng = new Random();

		public static void Reseed(int seed)
		{
			_rng = new Random(seed);
		}

		public static float NextFloat(float min, float max)
		{
			return min + (float)_rng.NextDouble() * (max - min);
		}

		public static float Range(float min, float max, float luck)
		{
			float num = luck * 0.5f;
			float min2 = min + num;
			float max2 = max + num;
			return NextFloat(min2, max2);
		}

		public static float Range(float min, float max, float luck, float dampener)
		{
			if (dampener > 0f)
			{
				float num = (min + max) / 2f;
				min = num - (num - min) * (1f - dampener);
				max = num + (max - num) * (1f - dampener);
			}
			float num2 = luck * 0.5f;
			return NextFloat(min + num2, max + num2);
		}

		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 = NextFloat(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 NextFloat(0f, 1f) < num;
		}

		public static bool FumbleCheck(float baseChance, float luck)
		{
			float num = baseChance - luck * 0.15f;
			num = Mathf.Max(num, 0.05f);
			return NextFloat(0f, 1f) < num;
		}
	}
	internal static class GamblerTeams
	{
		public static int GetTeamScore(int teamID)
		{
			//IL_0010: 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)
			IGameModeHandler currentHandler = GameModeManager.CurrentHandler;
			if (currentHandler == null)
			{
				return 0;
			}
			return currentHandler.GetTeamScore(teamID).points;
		}

		public static int GetTeamRounds(int teamID)
		{
			//IL_0010: 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)
			IGameModeHandler currentHandler = GameModeManager.CurrentHandler;
			if (currentHandler == null)
			{
				return 0;
			}
			return currentHandler.GetTeamScore(teamID).rounds;
		}
	}
}
namespace GamblersChoice.Patches
{
	[HarmonyPatch(typeof(Gun), "Attack")]
	internal class GunAttackPatch
	{
		private static void Prefix(Gun __instance)
		{
			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)
				{
					component.savedProjectilesForRevert = __instance.numberOfProjectiles;
					__instance.numberOfProjectiles += num;
				}
			}
			((Component)componentInParent).GetComponent<GravityRouletteEffect>()?.RollGravity(__instance);
			((Component)componentInParent).GetComponent<SlotMachineEffect>()?.RollBurst(__instance);
			((Component)componentInParent).GetComponent<LoadedGameEffect>()?.ApplyLuckPhase();
			((Component)componentInParent).GetComponent<CardCounterEffect>()?.IncrementCounter();
		}

		private static void Postfix(Gun __instance)
		{
			Player componentInParent = ((Component)__instance).GetComponentInParent<Player>();
			if (componentInParent == null)
			{
				return;
			}
			LoadedGameEffect component = ((Component)componentInParent).GetComponent<LoadedGameEffect>();
			if (component != null)
			{
				component.RevertLuckPhase();
				component.IncrementShot();
			}
			((Component)componentInParent).GetComponent<GravityRouletteEffect>()?.RestoreGravity(__instance);
			((Component)componentInParent).GetComponent<SlotMachineEffect>()?.RestoreBurst(__instance);
			((Component)componentInParent).GetComponent<MartingaleShotEffect>()?.OnShotFired();
			BankrollReloadEffect component2 = ((Component)componentInParent).GetComponent<BankrollReloadEffect>();
			if (component2 != null)
			{
				GunAmmo component3 = ((Component)componentInParent).GetComponent<GunAmmo>();
				if (component3 != null)
				{
					component2.OnShotFired(component3.maxAmmo);
				}
			}
			DealersHandEffect component4 = ((Component)componentInParent).GetComponent<DealersHandEffect>();
			if (component4 != null)
			{
				GunAmmo component5 = ((Component)componentInParent).GetComponent<GunAmmo>();
				if (component5 != null)
				{
					component4.OnShotFired(component5.maxAmmo);
				}
			}
			WildCardEffect component6 = ((Component)componentInParent).GetComponent<WildCardEffect>();
			if (component6 != null && component6.savedProjectilesForRevert > 0)
			{
				__instance.numberOfProjectiles = component6.savedProjectilesForRevert;
				component6.savedProjectilesForRevert = 0;
			}
		}
	}
	[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;
				}
			}
			DealersHandEffect component4 = ((Component)ownPlayer).GetComponent<DealersHandEffect>();
			if (component4 != null)
			{
				float num2 = component4.ConsumeDealerBuff();
				if (num2 != 1f)
				{
					__instance.damage *= num2;
				}
			}
			MartingaleShotEffect component5 = ((Component)ownPlayer).GetComponent<MartingaleShotEffect>();
			if (component5 != null)
			{
				float damageMultiplier2 = component5.GetDamageMultiplier();
				if (damageMultiplier2 != 1f)
				{
					__instance.damage *= damageMultiplier2;
				}
			}
			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 HealthHandlerDiePrefix
	{
		private static bool Prefix(HealthHandler __instance)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component == null)
			{
				return true;
			}
			BailoutEffect component2 = ((Component)component).GetComponent<BailoutEffect>();
			if (component2 != null && component2.TryBailout())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "RPCA_Die")]
	internal class HealthHandlerDiePatch
	{
		private static void Postfix(HealthHandler __instance)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component == null)
			{
				return;
			}
			((Component)component).GetComponent<DeadMansHandEffect>()?.OnDeath();
			((Component)component).GetComponent<SideBetEffect>()?.OnDeath();
			Player lastAttacker = component.GetGamblerData().lastAttacker;
			if (lastAttacker != null && lastAttacker != component && lastAttacker.teamID != component.teamID)
			{
				((Component)lastAttacker).GetComponent<JackpotEffect>()?.OnKill();
				((Component)lastAttacker).GetComponent<SideBetEffect>()?.OnKill();
				((Component)lastAttacker).GetComponent<MartingaleShotEffect>()?.OnKill();
				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();
					((Component)val).GetComponent<SideBetEffect>()?.OnKill();
					((Component)val).GetComponent<MartingaleShotEffect>()?.OnKill();
				}
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "DoDamage")]
	internal class HealthHandlerDoDamagePrefix
	{
		private static bool Prefix(HealthHandler __instance, ref Vector2 damage)
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component == null)
			{
				return true;
			}
			GamblerData gamblerData = component.GetGamblerData();
			float num = ((!(damage.x > 0f)) ? damage.y : damage.x);
			if (num > 0f)
			{
				PokerFaceEffect component2 = ((Component)component).GetComponent<PokerFaceEffect>();
				if (component2 != null && component2.shieldHP > 0f)
				{
					float num2 = component2.AbsorbDamage(num);
					float num3 = num - num2;
					if (num3 > 0f)
					{
						if (damage.x > 0f)
						{
							damage.x = Mathf.Max(damage.x - num3, 0f);
						}
						else if (damage.y > 0f)
						{
							damage.y = Mathf.Max(damage.y - num3, 0f);
						}
						num = num2;
					}
				}
			}
			if (num > 0f && gamblerData.fortifyActive > 0)
			{
				float num4 = num * 0.5f * (float)gamblerData.fortifyActive;
				if (num4 > num)
				{
					num4 = num;
				}
				if (damage.x > 0f)
				{
					damage.x = Mathf.Max(damage.x - num4, 0f);
				}
				else if (damage.y > 0f)
				{
					damage.y = Mathf.Max(damage.y - num4, 0f);
				}
				num -= num4;
			}
			if (num <= 0f)
			{
				damage = Vector2.zero;
				return true;
			}
			BailoutEffect component3 = ((Component)component).GetComponent<BailoutEffect>();
			if (component3 != null && component3.invulnerable)
			{
				damage = Vector2.zero;
				return true;
			}
			FoldEffect component4 = ((Component)component).GetComponent<FoldEffect>();
			if (component4 != null && component4.TryDodge())
			{
				damage = Vector2.zero;
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HealthHandler), "DoDamage")]
	internal class HealthHandlerDoDamagePatch
	{
		private static void Postfix(HealthHandler __instance, Vector2 damage)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component != null)
			{
				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);
					((Component)component).GetComponent<BlackjackEffect>()?.LogDamage(num);
				}
			}
		}
	}
	[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)
		{
			Player component = ((Component)__instance).GetComponent<Player>();
			if (component != null)
			{
				component.GetGamblerData().ResetPerRound();
				((Component)component).GetComponent<PotCommittedEffect>()?.ResetAppliedMultipliers();
			}
		}
	}
}
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.3.4")]
	[BepInProcess("Rounds.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static Plugin Instance;

		internal static ManualLogSource Log;

		internal static ConfigEntry<float> LuckCap;

		internal static ConfigEntry<float> MovementSpeedCap;

		private void Awake()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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");
			MovementSpeedCap = ((BaseUnityPlugin)this).Config.Bind<float>("Balance", "MovementSpeedCap", 2.5f, "Maximum movement speed multiplier to prevent exponential growth");
			Harmony val = new Harmony("com.nicho.rounds.gamblerschoice");
			val.PatchAll();
			Log.LogInfo((object)string.Format("{0} v{1} loaded", "Gamblers Choice", "1.3.4"));
		}

		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>();
			CustomCard.BuildCard<Bankroll>();
			CustomCard.BuildCard<SidePot>();
			CustomCard.BuildCard<Parlay>();
			CustomCard.BuildCard<GravityRoulette>();
			CustomCard.BuildCard<SlotMachine>();
			CustomCard.BuildCard<DealersHand>();
			CustomCard.BuildCard<Fold>();
			CustomCard.BuildCard<PokerFace>();
			CustomCard.BuildCard<Blackjack>();
			CustomCard.BuildCard<CompdDrinks>();
			CustomCard.BuildCard<ChipStack>();
			CustomCard.BuildCard<SideBet>();
			CustomCard.BuildCard<MartingalePoint>();
			CustomCard.BuildCard<CardShark>();
			CustomCard.BuildCard<PotCommitted>();
			CustomCard.BuildCard<LoadedGame>();
			CustomCard.BuildCard<MartingaleShot>();
			CustomCard.BuildCard<DeadMansHand>();
			CustomCard.BuildCard<Bailout>();
			CustomCard.BuildCard<InsurancePolicy>();
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStartReset);
			Unbound.RegisterCredits("Gamblers Choice", new string[1] { "nicho" }, "GitHub", "");
			Log.LogInfo((object)"All 37 cards registered");
		}

		private static IEnumerator GameStartReset(IGameModeHandler gm)
		{
			int seed = ComputeMatchSeed();
			GamblerRNG.Reseed(seed);
			foreach (Player player in PlayerManager.instance.players)
			{
				player.GetGamblerData().ResetAll();
			}
			yield break;
		}

		private static int ComputeMatchSeed()
		{
			List<Player> list = ((PlayerManager.instance == null) ? null : PlayerManager.instance.players);
			if (list == null || list.Count == 0)
			{
				return 0;
			}
			List<int> list2 = new List<int>(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] != null)
				{
					list2.Add(list[i].playerID);
				}
			}
			if (list2.Count == 0)
			{
				return 0;
			}
			list2.Sort();
			int num = 17;
			for (int j = 0; j < list2.Count; j++)
			{
				num = num * 31 + list2[j];
			}
			return num;
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "com.nicho.rounds.gamblerschoice";

		public const string NAME = "Gamblers Choice";

		public const string VERSION = "1.3.4";
	}
	internal static class SpeedMultiplier
	{
		public static float ApplyAtkMult(Gun gun, float mult)
		{
			if (gun == null)
			{
				return 1f;
			}
			gun.attackSpeed *= mult;
			return mult;
		}

		public static float RevertAtkMult(Gun gun, float applied)
		{
			if (gun != null && applied != 1f)
			{
				gun.attackSpeed /= applied;
			}
			return 1f;
		}
	}
}