using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using CardThemeLib;
using ClassesManagerReborn;
using ClassesManagerReborn.Util;
using HarmonyLib;
using Jotunn.Utils;
using KFC.Cards;
using KFC.MonoBehaviors;
using KFC.Monos;
using KFC.RiftShenanigans;
using KFC.UnessesaryAddons;
using ModdingUtils.Extensions;
using ModdingUtils.Utils;
using ModsPlus;
using Photon.Pun;
using RarityLib.Utils;
using SimulationChamber;
using Sonigon;
using TMPro;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WillsWackyManagers.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("koalasfantasticcards")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("koalasfantasticcards")]
[assembly: AssemblyTitle("koalasfantasticcards")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace KFC
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("koala.koalas.fantastic.cards", "Koalas Fantastic Cards", "3.6.1")]
	[BepInProcess("Rounds.exe")]
	public class KFC : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<CardInfo, bool> <>9__22_0;

			public static UnityAction <>9__22_1;

			public static Action<CardInfo> <>9__22_2;

			public static Action<CardInfo> <>9__22_3;

			public static Action<CardInfo> <>9__22_4;

			public static Action<CardInfo> <>9__22_5;

			public static Action<CardInfo> <>9__22_6;

			public static Action<CardInfo> <>9__22_7;

			public static Action<CardInfo> <>9__22_8;

			public static Action<CardInfo> <>9__22_9;

			public static Action<CardInfo> <>9__22_10;

			public static Action<CardInfo> <>9__22_11;

			public static Action<CardInfo> <>9__22_12;

			public static Action<CardInfo> <>9__22_13;

			public static Action<CardInfo> <>9__22_14;

			public static Action<CardInfo> <>9__22_15;

			public static Action<CardInfo> <>9__22_16;

			public static Action<CardInfo> <>9__22_17;

			public static Action<CardInfo> <>9__22_18;

			public static Action<CardInfo> <>9__22_19;

			public static Action<CardInfo> <>9__22_20;

			public static Action<CardInfo> <>9__22_21;

			public static Action<CardInfo> <>9__22_22;

			public static Action<CardInfo> <>9__22_23;

			public static Action<CardInfo> <>9__22_24;

			public static Action<CardInfo> <>9__22_25;

			public static Action<CardInfo> <>9__22_26;

			public static Action<CardInfo> <>9__22_27;

			public static Action<CardInfo> <>9__22_28;

			public static Action<CardInfo> <>9__22_29;

			public static Action<CardInfo> <>9__22_30;

			public static Action<CardInfo> <>9__22_31;

			public static Action<CardInfo> <>9__22_32;

			public static Action<CardInfo> <>9__22_33;

			public static Action<CardInfo> <>9__22_34;

			public static Action<CardInfo> <>9__22_35;

			public static Action<CardInfo> <>9__22_36;

			public static Action<CardInfo> <>9__22_37;

			internal bool <Start>b__22_0(CardInfo c)
			{
				return c.cardName.ToLower() == "mayhem";
			}

			internal void <Start>b__22_1()
			{
			}

			internal void <Start>b__22_2(CardInfo card)
			{
				BoxedBullets.card = card;
				ExtensionMethods.SetAbbreviation(card, "Bb");
			}

			internal void <Start>b__22_3(CardInfo card)
			{
				StayWinning.card = card;
				ExtensionMethods.SetAbbreviation(card, "Sw");
			}

			internal void <Start>b__22_4(CardInfo card)
			{
				splinter.card = card;
				ExtensionMethods.SetAbbreviation(card, "Sp");
			}

			internal void <Start>b__22_5(CardInfo card)
			{
				indiajoenas.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ij");
			}

			internal void <Start>b__22_6(CardInfo card)
			{
				legos.card = card;
				ExtensionMethods.SetAbbreviation(card, "Le");
			}

			internal void <Start>b__22_7(CardInfo card)
			{
				uwullets.card = card;
				ExtensionMethods.SetAbbreviation(card, "Uw");
			}

			internal void <Start>b__22_8(CardInfo card)
			{
				scp_500.card = card;
				ExtensionMethods.SetAbbreviation(card, "S5");
			}

			internal void <Start>b__22_9(CardInfo card)
			{
				doomSlayer.card = card;
				ExtensionMethods.SetAbbreviation(card, "DS");
			}

			internal void <Start>b__22_10(CardInfo card)
			{
				blackholegun.card = card;
				ExtensionMethods.SetAbbreviation(card, "Bh");
			}

			internal void <Start>b__22_11(CardInfo card)
			{
				Armor.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ar");
			}

			internal void <Start>b__22_12(CardInfo card)
			{
				Extendo.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ex");
			}

			internal void <Start>b__22_13(CardInfo card)
			{
				KingOfSpeed.card = card;
			}

			internal void <Start>b__22_14(CardInfo card)
			{
				swordinstone.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ss");
			}

			internal void <Start>b__22_15(CardInfo card)
			{
				excaliber.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ex");
			}

			internal void <Start>b__22_16(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				failure.card = card;
				ExtensionMethods.SetAbbreviation(card, "XX");
			}

			internal void <Start>b__22_17(CardInfo card)
			{
				RiftWalker.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rw");
			}

			internal void <Start>b__22_18(CardInfo card)
			{
				RiftGun.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rh");
			}

			internal void <Start>b__22_19(CardInfo card)
			{
				RiftBody.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rb");
			}

			internal void <Start>b__22_20(CardInfo card)
			{
				RiftMind.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rm");
			}

			internal void <Start>b__22_21(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				RiftSoul.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rs");
			}

			internal void <Start>b__22_22(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				Rifted.card = card;
			}

			internal void <Start>b__22_23(CardInfo card)
			{
				ViruzCard.card = card;
			}

			internal void <Start>b__22_24(CardInfo card)
			{
				Ard.card = card;
				ExtensionMethods.SetAbbreviation(card, "A+");
			}

			internal void <Start>b__22_25(CardInfo card)
			{
				Bard.card = card;
				ExtensionMethods.SetAbbreviation(card, "B+");
			}

			internal void <Start>b__22_26(CardInfo card)
			{
				Ccard.card = card;
				ExtensionMethods.SetAbbreviation(card, "C+");
			}

			internal void <Start>b__22_27(CardInfo card)
			{
				VoloMori.card = card;
			}

			internal void <Start>b__22_28(CardInfo card)
			{
				ImCursed.card = card;
			}

			internal void <Start>b__22_29(CardInfo card)
			{
				F3nxCorgi.card = card;
			}

			internal void <Start>b__22_30(CardInfo card)
			{
				Alyssa.card = card;
			}

			internal void <Start>b__22_31(CardInfo card)
			{
				Geballion.card = card;
			}

			internal void <Start>b__22_32(CardInfo card)
			{
				HaruShijun.card = card;
			}

			internal void <Start>b__22_33(CardInfo card)
			{
				Pexiltd.card = card;
			}

			internal void <Start>b__22_34(CardInfo card)
			{
				LaggyBullets.card = card;
				CurseManager.instance.RegisterCurse(card);
			}

			internal void <Start>b__22_35(CardInfo card)
			{
				Shadow.card = card;
				CurseManager.instance.RegisterCurse(card);
			}

			internal void <Start>b__22_36(CardInfo card)
			{
				rerollNew.card = card;
				CurseManager.instance.RegisterCurse(card);
			}

			internal void <Start>b__22_37(CardInfo card)
			{
				NoAim.card = card;
				CurseManager.instance.RegisterCurse(card);
			}
		}

		private const string ModId = "koala.koalas.fantastic.cards";

		private const string ModName = "Koalas Fantastic Cards";

		public const string Version = "3.6.1";

		public const string ModInitials = "KFC";

		public const string ModIntDed = "KFC";

		public const string CurseInt = "KFC Curses";

		public static KFC instance;

		public static AudioClip uwu;

		public static AudioClip honk;

		public static AudioClip owo;

		public static int pogess = 0;

		internal static AssetBundle ArtAssets;

		internal static AssetBundle ArtAssets2;

		public static ConfigEntry<bool> cardSounds;

		public ObjectsToSpawn wallbounce;

		internal static GameObject BoxProj;

		internal static int BoxCap = 5;

		private static float myst = 477.2f;

		public static object[] mysteryValue = new object[4]
		{
			myst,
			1f + myst / 500f,
			myst / 5f + "%",
			myst / 15f + "%"
		};

		public static bool Debug = false;

		private void HearCardsAction(bool val)
		{
			cardSounds.Value = val;
		}

		private void NewGUI(GameObject menu)
		{
			string[] array = new string[19]
			{
				"Fake", "Fantastic", "Fabulous", "Fried", "Fancy", "Freaky", "Fat", "Foolish", "Funny", "False",
				"Fortuitus", "Fast", "Ferocious", "Fair", "Fashionable", "Finger-lickin", "Female", "Fucking Annoying", "Forbidden"
			};
			MenuHandler.CreateToggle(cardSounds.Value, "Custom Card Sounds", menu, (UnityAction<bool>)HearCardsAction, 50, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		}

		public static bool hasCard(CardInfo card, Player player)
		{
			foreach (CardInfo currentCard in player.data.currentCards)
			{
				if (((Object)currentCard).name == ((Object)card).name)
				{
					return true;
				}
			}
			return false;
		}

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			Harmony val = new Harmony("koala.koalas.fantastic.cards");
			val.PatchAll();
			instance = this;
			FieldInfo field = typeof(CardManager).GetField("defaultCards", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			CardInfo[] source = (CardInfo[])field.GetValue(null);
			CardInfo val2 = source.Where((CardInfo c) => c.cardName.ToLower() == "mayhem").ToArray()[0];
			ObjectsToSpawn val3 = ((Component)val2).gameObject.GetComponent<Gun>().objectsToSpawn[0];
			wallbounce = val3;
			string[] array = new string[19]
			{
				"Fake", "Fantastic", "Fabulous", "Fried", "Fancy", "Freaky", "Fat", "Foolish", "Funny", "False",
				"Fortuitus", "Fast", "Ferocious", "Fair", "Fashionable", "Finger-lickin", "Female", "Fucking Annoying", "Forbidden"
			};
			string text = array[Random.Range(0, array.Length)];
			string text2 = "Koala's " + text + " Cards";
			object obj = <>c.<>9__22_1;
			if (obj == null)
			{
				UnityAction val4 = delegate
				{
				};
				<>c.<>9__22_1 = val4;
				obj = (object)val4;
			}
			Unbound.RegisterMenu(text2, (UnityAction)obj, (Action<GameObject>)NewGUI, (GameObject)null, true);
			cardSounds = ((BaseUnityPlugin)this).Config.Bind<bool>("KFC", "HearStuff", true, (ConfigDescription)null);
			ArtAssets = AssetUtils.LoadAssetBundleFromResources("kfccards", typeof(KFC).Assembly);
			ArtAssets2 = AssetUtils.LoadAssetBundleFromResources("vkfcassets", typeof(KFC).Assembly);
			CardThemeLib.instance.CreateOrGetType("Koality", new CardThemeColor
			{
				bgColor = new Color(0f, 0f, 0f),
				targetColor = new Color(0.9f, 0f, 0.9f)
			});
			uwu = ArtAssets.LoadAsset<AudioClip>("uwu");
			owo = ArtAssets.LoadAsset<AudioClip>("owo");
			honk = ArtAssets.LoadAsset<AudioClip>("honk");
			if ((Object)(object)ArtAssets == (Object)null)
			{
				Debug.Log((object)"Koalas Fantastic art asset bundle either doesn't exist or failed to load.");
			}
			if ((Object)(object)ArtAssets2 == (Object)null)
			{
				Debug.Log((object)"Koalas Less Fantastic art asset bundle either doesn't exist or failed to load.");
			}
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_Excaliber", ArtAssets.LoadAsset<GameObject>("CrucibleSword"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_Boulder", ArtAssets.LoadAsset<GameObject>("Boulder"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_BlackHole", ArtAssets.LoadAsset<GameObject>("BlackHole"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_Turret", ArtAssets.LoadAsset<GameObject>("Turret"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_Buff", ArtAssets.LoadAsset<GameObject>("Buff"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_LegoBrickR", ArtAssets.LoadAsset<GameObject>("legoBrickR"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_LegoBrickY", ArtAssets.LoadAsset<GameObject>("legoBrickY"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_LegoBrickG", ArtAssets.LoadAsset<GameObject>("legoBrickG"));
			PhotonNetwork.PrefabPool.RegisterPrefab("KFC_LegoBrickB", ArtAssets.LoadAsset<GameObject>("legoBrickB"));
			BoxProj = ArtAssets2.LoadAsset<GameObject>("VKFC_Box");
			BoxProj.AddComponent<OwnerScript>();
			PhotonNetwork.PrefabPool.RegisterPrefab("VKFC_Box", BoxProj);
			CustomCard.BuildCard<BoxedBullets>((Action<CardInfo>)delegate(CardInfo card)
			{
				BoxedBullets.card = card;
				ExtensionMethods.SetAbbreviation(card, "Bb");
			});
			CustomCard.BuildCard<StayWinning>((Action<CardInfo>)delegate(CardInfo card)
			{
				StayWinning.card = card;
				ExtensionMethods.SetAbbreviation(card, "Sw");
			});
			CustomCard.BuildCard<splinter>((Action<CardInfo>)delegate(CardInfo card)
			{
				splinter.card = card;
				ExtensionMethods.SetAbbreviation(card, "Sp");
			});
			CustomCard.BuildCard<indiajoenas>((Action<CardInfo>)delegate(CardInfo card)
			{
				indiajoenas.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ij");
			});
			CustomCard.BuildCard<legos>((Action<CardInfo>)delegate(CardInfo card)
			{
				legos.card = card;
				ExtensionMethods.SetAbbreviation(card, "Le");
			});
			CustomCard.BuildCard<uwullets>((Action<CardInfo>)delegate(CardInfo card)
			{
				uwullets.card = card;
				ExtensionMethods.SetAbbreviation(card, "Uw");
			});
			CustomCard.BuildCard<scp_500>((Action<CardInfo>)delegate(CardInfo card)
			{
				scp_500.card = card;
				ExtensionMethods.SetAbbreviation(card, "S5");
			});
			CustomCard.BuildCard<doomSlayer>((Action<CardInfo>)delegate(CardInfo card)
			{
				doomSlayer.card = card;
				ExtensionMethods.SetAbbreviation(card, "DS");
			});
			CustomCard.BuildCard<blackholegun>((Action<CardInfo>)delegate(CardInfo card)
			{
				blackholegun.card = card;
				ExtensionMethods.SetAbbreviation(card, "Bh");
			});
			CustomCard.BuildCard<Armor>((Action<CardInfo>)delegate(CardInfo card)
			{
				Armor.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ar");
			});
			CustomCard.BuildCard<Extendo>((Action<CardInfo>)delegate(CardInfo card)
			{
				Extendo.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ex");
			});
			CustomCard.BuildCard<KingOfSpeed>((Action<CardInfo>)delegate(CardInfo card)
			{
				KingOfSpeed.card = card;
			});
			CustomCard.BuildCard<swordinstone>((Action<CardInfo>)delegate(CardInfo card)
			{
				swordinstone.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ss");
			});
			CustomCard.BuildCard<excaliber>((Action<CardInfo>)delegate(CardInfo card)
			{
				excaliber.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ex");
			});
			CustomCard.BuildCard<failure>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				failure.card = card;
				ExtensionMethods.SetAbbreviation(card, "XX");
			});
			CustomCard.BuildCard<RiftWalker>((Action<CardInfo>)delegate(CardInfo card)
			{
				RiftWalker.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rw");
			});
			CustomCard.BuildCard<RiftGun>((Action<CardInfo>)delegate(CardInfo card)
			{
				RiftGun.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rh");
			});
			CustomCard.BuildCard<RiftBody>((Action<CardInfo>)delegate(CardInfo card)
			{
				RiftBody.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rb");
			});
			CustomCard.BuildCard<RiftMind>((Action<CardInfo>)delegate(CardInfo card)
			{
				RiftMind.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rm");
			});
			CustomCard.BuildCard<RiftSoul>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				RiftSoul.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rs");
			});
			CustomCard.BuildCard<Rifted>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				Rifted.card = card;
			});
			CustomCard.BuildCard<ViruzCard>((Action<CardInfo>)delegate(CardInfo card)
			{
				ViruzCard.card = card;
			});
			CustomCard.BuildCard<Ard>((Action<CardInfo>)delegate(CardInfo card)
			{
				Ard.card = card;
				ExtensionMethods.SetAbbreviation(card, "A+");
			});
			CustomCard.BuildCard<Bard>((Action<CardInfo>)delegate(CardInfo card)
			{
				Bard.card = card;
				ExtensionMethods.SetAbbreviation(card, "B+");
			});
			CustomCard.BuildCard<Ccard>((Action<CardInfo>)delegate(CardInfo card)
			{
				Ccard.card = card;
				ExtensionMethods.SetAbbreviation(card, "C+");
			});
			CustomCard.BuildCard<VoloMori>((Action<CardInfo>)delegate(CardInfo card)
			{
				VoloMori.card = card;
			});
			CustomCard.BuildCard<ImCursed>((Action<CardInfo>)delegate(CardInfo card)
			{
				ImCursed.card = card;
			});
			CustomCard.BuildCard<F3nxCorgi>((Action<CardInfo>)delegate(CardInfo card)
			{
				F3nxCorgi.card = card;
			});
			CustomCard.BuildCard<Alyssa>((Action<CardInfo>)delegate(CardInfo card)
			{
				Alyssa.card = card;
			});
			CustomCard.BuildCard<Geballion>((Action<CardInfo>)delegate(CardInfo card)
			{
				Geballion.card = card;
			});
			CustomCard.BuildCard<HaruShijun>((Action<CardInfo>)delegate(CardInfo card)
			{
				HaruShijun.card = card;
			});
			CustomCard.BuildCard<Pexiltd>((Action<CardInfo>)delegate(CardInfo card)
			{
				Pexiltd.card = card;
			});
			CustomCard.BuildCard<LaggyBullets>((Action<CardInfo>)delegate(CardInfo card)
			{
				LaggyBullets.card = card;
				CurseManager.instance.RegisterCurse(card);
			});
			CustomCard.BuildCard<Shadow>((Action<CardInfo>)delegate(CardInfo card)
			{
				Shadow.card = card;
				CurseManager.instance.RegisterCurse(card);
			});
			CustomCard.BuildCard<rerollNew>((Action<CardInfo>)delegate(CardInfo card)
			{
				rerollNew.card = card;
				CurseManager.instance.RegisterCurse(card);
			});
			CustomCard.BuildCard<NoAim>((Action<CardInfo>)delegate(CardInfo card)
			{
				NoAim.card = card;
				CurseManager.instance.RegisterCurse(card);
			});
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
		}

		public IEnumerator GameStart(IGameModeHandler gameModeHandler)
		{
			foreach (Player p in PlayerManager.instance.players)
			{
				((Component)p).gameObject.AddComponent<KoalasBonusStats>();
			}
			yield break;
		}
	}
}
namespace KFC.UnessesaryAddons
{
	public class OwnerScript : MonoBehaviour
	{
		public Player Owner = null;

		private Rigidbody2D rb;

		public void FixedUpdate()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Owner != (Object)null)
			{
				rb = ((Component)this).GetComponent<Rigidbody2D>();
				rb.mass = Owner.data.weaponHandler.gun.damage * 20000f;
				((Component)((Component)this).transform.GetChild(0)).GetComponent<SpriteRenderer>().color = PlayerManager.instance.GetColorFromPlayer(Owner.playerID).color;
				((Component)this).GetComponent<SFPolygon>().shadowLayers = LayerMask.op_Implicit(-1);
			}
		}
	}
}
namespace KFC.RiftShenanigans
{
	public class RiftBodyMono : CardEffect
	{
		private float bodyTimer = 12.5f;

		private ParticleSystem[] jumpParts;

		private ParticleSystem[] landParts;

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			bodyTimer = 12.5f;
			yield break;
		}

		private void InvisPlayer()
		{
			((Component)((CardEffect)this).player.data.weaponHandler.gun).gameObject.SetActive(false);
			((Component)((Component)((CardEffect)this).player).transform.GetChild(0)).gameObject.SetActive(false);
			if (!((CardEffect)this).player.data.view.IsMine)
			{
				((Component)((Component)((CardEffect)this).player).transform.GetChild(1)).gameObject.SetActive(false);
				((Component)((Component)((CardEffect)this).player).transform.GetChild(2)).gameObject.SetActive(false);
				((Component)((Component)((Component)((CardEffect)this).player).transform.GetChild(3)).transform.GetChild(1)).gameObject.SetActive(false);
				((Component)((Component)((Component)((CardEffect)this).player).transform.GetChild(4)).transform.GetChild(0)).gameObject.SetActive(false);
				((Component)((Component)((CardEffect)this).player).transform.GetChild(6)).gameObject.SetActive(false);
				jumpParts = ((CardEffect)this).player.data.jump.jumpPart;
				landParts = ((CardEffect)this).player.data.landParts;
				((CardEffect)this).player.data.jump.jumpPart = null;
				((CardEffect)this).player.data.landParts = null;
				((Component)((CardEffect)this).player.data.healthHandler).gameObject.SetActive(false);
				SpriteRenderer[] componentsInChildren = ((Component)((CardEffect)this).player).GetComponentsInChildren<SpriteRenderer>();
				foreach (SpriteRenderer val in componentsInChildren)
				{
					((Renderer)val).enabled = false;
				}
			}
		}

		private void VisPlayer()
		{
			((Component)((CardEffect)this).player.data.weaponHandler.gun).gameObject.SetActive(true);
			((Component)((Component)((CardEffect)this).player).transform.GetChild(0)).gameObject.SetActive(true);
			((Component)((Component)((CardEffect)this).player).transform.GetChild(1)).gameObject.SetActive(true);
			((Component)((Component)((CardEffect)this).player).transform.GetChild(2)).gameObject.SetActive(true);
			((Component)((Component)((Component)((CardEffect)this).player).transform.GetChild(3)).transform.GetChild(1)).gameObject.SetActive(true);
			((Component)((Component)((Component)((CardEffect)this).player).transform.GetChild(4)).transform.GetChild(0)).gameObject.SetActive(true);
			((Component)((Component)((CardEffect)this).player).transform.GetChild(6)).gameObject.SetActive(true);
			((CardEffect)this).player.data.jump.jumpPart = jumpParts;
			((CardEffect)this).player.data.landParts = landParts;
			((Component)((CardEffect)this).player.data.healthHandler).gameObject.SetActive(true);
			SpriteRenderer[] componentsInChildren = ((Component)((CardEffect)this).player).GetComponentsInChildren<SpriteRenderer>();
			foreach (SpriteRenderer val in componentsInChildren)
			{
				((Renderer)val).enabled = true;
			}
		}

		public override void OnBlock(BlockTriggerType blockTriggerType)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			((CardEffect)this).OnBlock(blockTriggerType);
			if (!(bodyTimer > 12.5f))
			{
				return;
			}
			bodyTimer = 0f;
			for (int i = 0; i < ((Component)((CardEffect)this).player).transform.childCount; i++)
			{
				GameObject gameObject = ((Component)((Component)((CardEffect)this).player).transform.GetChild(i)).gameObject;
				if (((Object)gameObject).name == "BegoneThot(Clone)" || ((Object)gameObject).name == "SupriseMofo(Clone)")
				{
					Object.Destroy((Object)(object)gameObject);
				}
			}
			GameObject val = KFC.ArtAssets.LoadAsset<GameObject>("BegoneThot");
			Object.Instantiate<GameObject>(val, ((Component)((CardEffect)this).player).transform);
			InvisPlayer();
			Collider2D[] componentsInChildren = ((Component)((CardEffect)this).player).GetComponentsInChildren<Collider2D>();
			foreach (Collider2D val2 in componentsInChildren)
			{
				((Behaviour)val2).enabled = false;
			}
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)KFC.instance, 5f, (Action)delegate
			{
				VisPlayer();
				Collider2D[] componentsInChildren2 = ((Component)((CardEffect)this).player).GetComponentsInChildren<Collider2D>();
				foreach (Collider2D val3 in componentsInChildren2)
				{
					((Behaviour)val3).enabled = true;
				}
				GameObject val4 = KFC.ArtAssets.LoadAsset<GameObject>("SupriseMofo");
				Object.Instantiate<GameObject>(val4, ((Component)((CardEffect)this).player).transform);
				ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)KFC.instance, 10f, (Action)delegate
				{
					GameObject val5 = KFC.ArtAssets.LoadAsset<GameObject>("SupriseMofo");
					Object.Instantiate<GameObject>(val5, ((Component)((CardEffect)this).player).transform);
				});
			});
		}

		public void Update()
		{
			bodyTimer += TimeHandler.deltaTime;
		}
	}
	public class RiftFreeMono : MonoBehaviour
	{
		public void Update()
		{
			Player component = ((Component)this).gameObject.GetComponent<Player>();
			component.data.silenceHandler.StopSilence();
			component.data.stunHandler.StopStun();
		}
	}
	public class RiftSoulMono : CardEffect
	{
		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 10, (Action)delegate
			{
				Cards.instance.AddCardToPlayer(((CardEffect)this).player, Rifted.card, false, "__", 0f, 0f);
				CardBarUtils.instance.ShowImmediate(((CardEffect)this).player, Rifted.card);
				Gun gun = ((CardEffect)this).gun;
				gun.damage *= 0.99f;
				Gun gun2 = ((CardEffect)this).gun;
				gun2.dmgMOnBounce *= 0.99f;
				Gun gun3 = ((CardEffect)this).gun;
				gun3.speedMOnBounce *= 0.99f;
				Gun gun4 = ((CardEffect)this).gun;
				gun4.spread += 0.01f;
				Gun gun5 = ((CardEffect)this).gun;
				gun5.projectileSpeed *= 0.99f;
				CharacterStatModifiers characterStats = ((CardEffect)this).characterStats;
				characterStats.movementSpeed *= 0.99f;
				CharacterData data = ((CardEffect)this).player.data;
				data.maxHealth *= 0.99f;
				((CardEffect)this).player.data.health = ((CardEffect)this).player.data.maxHealth;
				Gun gun6 = ((CardEffect)this).gun;
				gun6.reloadTime *= 1.01f;
				Gun gun7 = ((CardEffect)this).gun;
				gun7.attackSpeed *= 1.01f;
				Gun gun8 = ((CardEffect)this).gun;
				gun8.reloadTimeAdd += 0.05f;
			});
			yield break;
		}
	}
}
namespace KFC.ArtSchenanigans
{
	public class KoalaArtHandler : MonoBehaviour
	{
		public GameObject owner;

		public void Update()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)owner == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			Scene scene = owner.scene;
			if (((Scene)(ref scene)).name == "DontDestroyOnLoad")
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void DestroyMe()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class Aahahsdhahh : MonoBehaviour
	{
		public KoalaArtHandler handler;

		public void OnDestroy()
		{
			handler.DestroyMe();
		}
	}
}
namespace KFC.Monos
{
	public class BoxThoseBullets : CardEffect
	{
		public List<GameObject> Boxes = new List<GameObject>();

		private int curBox = 0;

		protected override void OnDestroy()
		{
			KillBoxes();
		}

		public override void OnShoot(GameObject projectile)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			if (Boxes.Count == 0)
			{
				SpawnBoxes();
			}
			GameObject val = Boxes[curBox];
			curBox++;
			if (curBox == KFC.BoxCap)
			{
				curBox = 0;
			}
			val.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
			val.transform.position = projectile.transform.position + ((Vector3)(ref ((CardEffect)this).player.data.aimDirection)).normalized * 3f;
			val.transform.rotation = Quaternion.identity;
			float num = Mathf.Sqrt(((CardEffect)this).gun.projectileSpeed);
			Vector3 val2 = ((Vector3)(ref ((CardEffect)this).player.data.aimDirection)).normalized;
			float num2 = Random.Range(0f - ((CardEffect)this).gun.spread, ((CardEffect)this).gun.spread);
			num2 /= (1f + ((CardEffect)this).gun.projectileSpeed * 0.5f) * 0.5f;
			val2 += Vector3.Cross(val2, Vector3.forward) * num2;
			val.GetComponent<Rigidbody2D>().AddForce(Vector2.op_Implicit(((Vector3)(ref val2)).normalized * 40000000f * ((CardEffect)this).gun.damage * num));
			PhotonNetwork.Destroy(projectile);
		}

		[UnboundRPC]
		public static void RPCDistributeOwners(int playerId)
		{
			OwnerScript[] array = Object.FindObjectsOfType<OwnerScript>();
			foreach (OwnerScript ownerScript in array)
			{
				if ((Object)(object)ownerScript.Owner == (Object)null)
				{
					ownerScript.Owner = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, playerId);
					break;
				}
			}
		}

		public override void OnTakeDamage(Vector2 damage, bool selfDamage)
		{
			if (((CardEffect)this).player.data.health < 0f)
			{
				ResetBoxes();
			}
		}

		public override IEnumerator OnPointEnd(IGameModeHandler gameModeHandler)
		{
			KillBoxes();
			yield return null;
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			SpawnBoxes();
			yield return null;
		}

		public void SpawnBoxes()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (Boxes.Count > 0)
			{
				KillBoxes();
			}
			for (int i = 0; i < KFC.BoxCap; i++)
			{
				GameObject item = PhotonNetwork.Instantiate("VKFC_Box", new Vector3(999f, 999f, 0f), Quaternion.identity, (byte)0, (object[])null);
				Boxes.Add(item);
				NetworkingManager.RPC(typeof(BoxThoseBullets), "RPCDistributeOwners", new object[1] { ((CardEffect)this).player.playerID });
			}
		}

		public void ResetBoxes()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			foreach (GameObject box in Boxes)
			{
				box.transform.position = new Vector3(999f, 999f, 0f);
			}
		}

		public void KillBoxes()
		{
			foreach (GameObject box in Boxes)
			{
				PhotonNetwork.Destroy(box.gameObject);
			}
			Boxes.Clear();
		}
	}
	public class WeStayWinning : CardEffect
	{
		public Dictionary<int, int> TeamScore = new Dictionary<int, int>();

		public override IEnumerator OnPickPhaseStart(IGameModeHandler gameModeHandler)
		{
			foreach (KeyValuePair<int, int> ts in TeamScore)
			{
				if (ts.Key != ((CardEffect)this).player.teamID && GameModeManager.CurrentHandler.GetTeamScore(ts.Key).rounds != ts.Value)
				{
					Cards.instance.RemoveAllCardsFromPlayer(((CardEffect)this).player, true);
					while (((CardEffect)this).player.data.currentCards.IndexOf(StayWinning.card) != -1)
					{
						Cards.instance.RemoveCardFromPlayer(((CardEffect)this).player, ((CardEffect)this).player.data.currentCards.IndexOf(StayWinning.card));
					}
				}
			}
			yield return null;
		}
	}
}
namespace KFC.MonoBehaviors
{
	public class armor_mono : CardEffect
	{
		private float armorHp = 0f;

		private bool armorDestroyed = true;

		private GameObject hbarcolor;

		private GameObject hbargray;

		private void ResetHealthBar()
		{
			armorHp = 0f;
			foreach (CardInfo currentCard in ((CardEffect)this).player.data.currentCards)
			{
				if ((Object)(object)currentCard == (Object)(object)Armor.card)
				{
					armorHp += 1f;
				}
			}
			armorDestroyed = false;
		}

		protected override void Start()
		{
			ResetHealthBar();
			((CardEffect)this).Start();
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			ResetHealthBar();
			yield break;
		}

		private void Update()
		{
		}

		public override void OnRevive()
		{
			ResetHealthBar();
			((CardEffect)this).OnRevive();
		}

		public override void OnTakeDamage(Vector2 damage, bool selfDamage)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			float magnitude = ((Vector2)(ref damage)).magnitude;
			if (!armorDestroyed)
			{
				armorHp -= 1f;
				CharacterData data = ((CardEffect)this).player.data;
				data.health += magnitude;
				if (armorHp <= 0f)
				{
					armorDestroyed = true;
				}
			}
			((CardEffect)this).OnTakeDamage(damage, selfDamage);
		}
	}
	public class blackholegun_Mono : CardEffect
	{
		private GameObject bhole;

		protected override void Start()
		{
			((CardEffect)this).Start();
		}

		public override void OnShoot(GameObject projectile)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (((CardEffect)this).player.data.view.IsMine)
			{
				if (Object.op_Implicit((Object)(object)bhole))
				{
					Object.Destroy((Object)(object)bhole.GetComponent<blackHole_Mono>().projec);
					PhotonNetwork.Destroy(bhole);
				}
				bhole = PhotonNetwork.Instantiate("KFC_BlackHole", ((Component)((CardEffect)this).data.hand).transform.position, Quaternion.identity, (byte)0, (object[])null);
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 5, (Action)delegate
			{
				if ((Object)(object)GameObject.Find("BlackHole(Clone)").GetComponent<blackHole_Mono>() == (Object)null)
				{
					GameObject.Find("BlackHole(Clone)").AddComponent<blackHole_Mono>().projec = projectile;
				}
			});
		}

		public override IEnumerator OnPointEnd(IGameModeHandler gameModeHandler)
		{
			if (((CardEffect)this).player.data.view.IsMine && Object.op_Implicit((Object)(object)bhole))
			{
				Object.Destroy((Object)(object)bhole.GetComponent<blackHole_Mono>().projec);
				PhotonNetwork.Destroy(bhole);
			}
			return ((CardEffect)this).OnPointEnd(gameModeHandler);
		}
	}
	public class blackHole_Mono : MonoBehaviour
	{
		private float size;

		public GameObject projec;

		public void Start()
		{
			//IL_0046: 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)
			size = 0.5f;
			((Component)((Component)this).gameObject.transform.GetChild(0)).transform.localScale = new Vector3(size / 3f, size / 3f, size / 3f);
			((Component)((Component)this).gameObject.transform.GetChild(1)).transform.localScale = new Vector3(size, size, size);
		}

		public void Update()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			size += TimeHandler.deltaTime;
			((Component)((Component)this).gameObject.transform.GetChild(0)).transform.localScale = new Vector3(size / 3f, size / 3f, size / 3f);
			((Component)((Component)this).gameObject.transform.GetChild(1)).transform.localScale = new Vector3(size, size, size);
			((Component)((Component)this).gameObject.transform).GetComponentInChildren<DamageBox>().damage = size * 25f;
			if (size < 1f)
			{
				((Component)((Component)this).gameObject.transform).GetComponentInChildren<DamageBox>().damage = 0f;
			}
			List<Player> players = PlayerManager.instance.players;
			if ((Object)(object)projec != (Object)null)
			{
				((Component)this).gameObject.transform.position = projec.transform.position;
			}
			if (players.Count == 0)
			{
				return;
			}
			foreach (Player item in players)
			{
				float num = Vector2.Distance(Vector2.op_Implicit(((Component)item).transform.position), Vector2.op_Implicit(((Component)this).transform.position));
				if (num < size * 1.5f && size > 1f)
				{
					item.data.stats.gravity = 0f - Math.Abs(item.data.stats.gravity);
					Vector3 position = Vector3.MoveTowards(((Component)item).transform.position, ((Component)this).gameObject.transform.position, TimeHandler.deltaTime * size * 2f);
					((Component)item).transform.position = position;
				}
				else
				{
					item.data.stats.gravity = Math.Abs(item.data.stats.gravity);
				}
			}
		}
	}
	public class laggyMono : CardEffect
	{
		public override void OnShoot(GameObject projectile)
		{
			float num = 0f;
			foreach (CardInfo currentCard in ((CardEffect)this).player.data.currentCards)
			{
				if ((Object)(object)currentCard == (Object)(object)LaggyBullets.card)
				{
					num += 1f;
				}
			}
			projectile.SetActive(false);
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)KFC.instance, num, (Action)delegate
			{
				projectile.SetActive(true);
			});
		}
	}
	public class AimlessMono : CardEffect
	{
		public struct MousePoint
		{
			public int X;

			public int Y;

			public MousePoint(int x, int y)
			{
				X = x;
				Y = y;
			}
		}

		[DllImport("user32.dll")]
		public static extern bool SetCursorPos(int X, int Y);

		[DllImport("user32.dll")]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool GetCursorPos(out MousePoint lpMousePoint);

		public override void OnShoot(GameObject projectile)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			GetCursorPos(out var lpMousePoint);
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(Input.mousePosition.x, Input.mousePosition.y, ((Component)((CardEffect)this).player).transform.position.z);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor((float)lpMousePoint.X - val.x, (float)lpMousePoint.Y + val.y - (float)Screen.height);
			SetCursorPos((int)val2.x + (int)((float)Screen.width * Random.Range(0.05f, 0.95f)), (int)val2.y + (int)((float)Screen.height * Random.Range(0.05f, 0.95f)));
		}
	}
	public class rerollCurse : CardEffect
	{
		private CardInfo lastCard = rerollNew.card;

		protected override void Start()
		{
			lastCard = rerollNew.card;
		}

		private void Update()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			CardInfo val = ((CardEffect)this).data.currentCards[((CardEffect)this).data.currentCards.Count - 1];
			if (!((Object)(object)val != (Object)(object)lastCard))
			{
				return;
			}
			Dictionary<string, Card> cards = CardManager.cards;
			Rarity rarity = val.rarity;
			List<CardInfo> list = new List<CardInfo>();
			foreach (Card value in cards.Values)
			{
				CardInfo cardInfo = value.cardInfo;
				if (cardInfo.rarity == rarity && Cards.instance.PlayerIsAllowedCard(((CardEffect)this).player, cardInfo) && CardManager.IsCardActive(cardInfo) && (Object)(object)cardInfo != (Object)(object)val)
				{
					list.Add(cardInfo);
				}
			}
			CardInfo newCard = list.ElementAt(Random.Range(0, list.Count));
			lastCard = val;
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 10, (Action)delegate
			{
				lastCard = newCard;
				Cards.instance.RemoveCardFromPlayer(((CardEffect)this).player, ((CardEffect)this).data.currentCards.Count - 1);
				Cards.instance.AddCardsToPlayer(((CardEffect)this).player, (CardInfo[])(object)new CardInfo[1] { newCard }, false, (string[])null, (float[])null, (float[])null);
			});
		}
	}
	public class shadowMono : CardEffect
	{
		private GameObject coverPrefab;

		private GameObject cover;

		private void Start()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			coverPrefab = KFC.ArtAssets.LoadAsset<GameObject>("ShadowCover");
			cover = Object.Instantiate<GameObject>(coverPrefab, ((Component)((CardEffect)this).player).transform);
			cover.transform.localPosition = Vector3.zero;
			((Renderer)cover.GetComponent<SpriteRenderer>()).sortingLayerID = -1160774667;
			SpriteRenderer[] componentsInChildren = cover.GetComponentsInChildren<SpriteRenderer>();
			foreach (SpriteRenderer val in componentsInChildren)
			{
				((Renderer)val).sortingLayerID = -1160774667;
			}
		}

		private void Update()
		{
			if ((Object)(object)cover != (Object)null)
			{
				if (Input.anyKey)
				{
					cover.SetActive(true);
				}
				else
				{
					cover.SetActive(false);
				}
			}
		}
	}
	public class Fortune : CardEffect
	{
		public void Update()
		{
			if (((CardEffect)this).player.data.maxHealth > 0f)
			{
				((CardEffect)this).player.data.healthHandler.Heal(((CardEffect)this).player.data.maxHealth * (1f / 3f) * TimeHandler.deltaTime);
			}
		}
	}
	public class StatThief : CardEffect
	{
		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			List<Player> others = PlayerManager.instance.players.Where((Player p) => p.playerID != ((CardEffect)this).player.playerID).ToList();
			float[] statChanges = new float[7];
			foreach (Player o in others)
			{
				Gun g = o.data.weaponHandler.gun;
				statChanges[0] += g.damage;
				g.damage *= 0.99f;
				statChanges[1] += o.data.maxHealth / 100f;
				CharacterData data = o.data;
				data.maxHealth *= 0.99f;
				o.data.health = o.data.maxHealth;
				statChanges[2] += 0.3f / g.attackSpeed;
				g.attackSpeed /= 0.99f;
				statChanges[3] += 1f / ((Component)g).gameObject.GetComponentInChildren<GunAmmo>().reloadTimeMultiplier;
				GunAmmo componentInChildren = ((Component)g).gameObject.GetComponentInChildren<GunAmmo>();
				componentInChildren.reloadTimeMultiplier /= 0.99f;
				statChanges[4] += o.data.stats.movementSpeed;
				CharacterStatModifiers stats = o.data.stats;
				stats.movementSpeed *= 0.99f;
				statChanges[5] += o.data.stats.jump;
				CharacterStatModifiers stats2 = o.data.stats;
				stats2.jump *= 0.99f;
				statChanges[6] += 1f / o.data.block.cdMultiplier;
				Block block = o.data.block;
				block.cdMultiplier /= 0.99f;
			}
			for (int i = 0; i < statChanges.Length; i++)
			{
				statChanges[i] *= 0.01f;
				statChanges[i] += 1f;
			}
			Gun gun = ((CardEffect)this).gun;
			gun.damage *= statChanges[0];
			CharacterData data2 = ((CardEffect)this).player.data;
			data2.maxHealth *= statChanges[1];
			((CardEffect)this).player.data.health = ((CardEffect)this).player.data.maxHealth;
			Gun gun2 = ((CardEffect)this).gun;
			gun2.attackSpeedMultiplier /= statChanges[2];
			GunAmmo gunAmmo = ((CardEffect)this).gunAmmo;
			gunAmmo.reloadTimeMultiplier /= statChanges[3];
			CharacterStatModifiers characterStats = ((CardEffect)this).characterStats;
			characterStats.movementSpeed *= statChanges[4];
			CharacterStatModifiers characterStats2 = ((CardEffect)this).characterStats;
			characterStats2.jump *= statChanges[5];
			Block block2 = ((CardEffect)this).block;
			block2.cdMultiplier *= statChanges[6];
			yield return null;
		}
	}
	public class KoalasDeath : CardEffect
	{
		public void Update()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			float num = ((CardEffect)this).player.data.maxHealth * 0.15f * TimeHandler.deltaTime;
			((Damagable)((CardEffect)this).player.data.healthHandler).CallTakeDamage(Vector2.one * num, Vector2.zero, (GameObject)null, (Player)null, true);
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			((CardEffect)this).player.data.health = ((CardEffect)this).player.data.maxHealth;
			yield return null;
		}
	}
	public class Thief : CardEffect
	{
		private int stealDelay = 0;

		private int coolDown = 2;

		internal List<string> blacklistedCategories = new List<string> { "CardManipulation", "Grants Curses", "GivesNulls" };

		public override IEnumerator OnPickPhaseEnd(IGameModeHandler gameModeHandler)
		{
			stealDelay++;
			if (stealDelay >= coolDown)
			{
				stealDelay = 0;
				List<Player> others = PlayerManager.instance.players.Where((Player p) => p.playerID != ((CardEffect)this).player.playerID).ToList();
				Dictionary<Player, List<CardInfo>> stuff = new Dictionary<Player, List<CardInfo>>();
				foreach (Player o in others)
				{
					List<CardInfo> cords = o.data.currentCards.Where((CardInfo c) => c.categories.Select((CardCategory c) => ((Object)c).name.ToLowerInvariant()).Intersect(blacklistedCategories.Select((string s) => s.ToLowerInvariant())).Count() <= 0 && Cards.instance.PlayerIsAllowedCard(((CardEffect)this).player, c)).ToList();
					string cardStuff = "";
					foreach (CardInfo c3 in cords)
					{
						cardStuff = cardStuff + c3.cardName + ", ";
					}
					if (cords.Count() > 0)
					{
						stuff.Add(o, cords);
					}
				}
				if (stuff.Count == 0)
				{
					Cards.instance.AddCardToPlayer(((CardEffect)this).player, MasterThief.card, false, "", 0f, 0f);
				}
				else
				{
					foreach (KeyValuePair<Player, List<CardInfo>> kvp in stuff)
					{
						string cardNames = "";
						foreach (CardInfo c2 in kvp.Value)
						{
							cardNames = cardNames + c2.cardName + ", ";
						}
						cardNames.Remove(0, cardNames.Length - 2);
						MonoBehaviour.print((object)("ID: " + kvp.Key.playerID + " | Cards: " + cardNames));
					}
					int dicIndex = Random.Range(0, stuff.Count);
					KeyValuePair<Player, List<CardInfo>> victim = stuff.ElementAt(dicIndex);
					CardInfo randCard = victim.Value[Random.Range(0, victim.Value.Count)];
					int index = victim.Key.data.currentCards.IndexOf(randCard);
					Cards.instance.AddCardToPlayer(((CardEffect)this).player, randCard, false, "", 0f, 0f);
					Cards.instance.RemoveCardFromPlayer(victim.Key, index);
				}
			}
			yield return null;
		}
	}
	public class GeballionsAura : CardEffect
	{
		private int time = 0;

		private bool inGame = false;

		public void OnEnable()
		{
			inGame = true;
		}

		public override IEnumerator OnRoundStart(IGameModeHandler gameModeHandler)
		{
			inGame = true;
			time = 0;
			yield break;
		}

		public override void OnRevive()
		{
			inGame = true;
			time = 0;
		}

		public override IEnumerator OnRoundEnd(IGameModeHandler gameModeHandler)
		{
			inGame = false;
			yield break;
		}

		public void Update()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			time++;
			if (!inGame || time < 300)
			{
				return;
			}
			List<Player> list = PlayerManager.instance.players.Where((Player pl) => pl.playerID != ((CardEffect)this).player.playerID && pl.teamID != ((CardEffect)this).player.teamID && pl.data.health > 0f).ToList();
			if (((CardEffect)this).player.data.health <= 0f)
			{
				inGame = false;
				return;
			}
			foreach (Player item in list)
			{
				if (Vector3.Distance(((Component)((CardEffect)this).player).transform.position, ((Component)item).transform.position) < 10f)
				{
					Vector2 val = Vector2.one * ((CardEffect)this).player.data.maxHealth * 0.05f * TimeHandler.deltaTime;
					item.data.healthHandler.DoDamage(val, Vector2.zero, Color.red, (GameObject)null, ((CardEffect)this).player, true, true, true);
				}
			}
		}
	}
	public class GattlingHandler : CardEffect
	{
		public GameObject gattling;

		public void OnEnable()
		{
			if (!Object.op_Implicit((Object)(object)gattling))
			{
				gattling = Object.Instantiate<GameObject>(KFC.ArtAssets.LoadAsset<GameObject>("gattlin"));
			}
		}

		public void Update()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)gattling))
			{
				if (((Behaviour)((CardEffect)this).player).isActiveAndEnabled)
				{
					gattling.transform.position = ((CardEffect)this).player.data.hand.position;
					gattling.transform.up = ((CardEffect)this).player.data.aimDirection;
				}
				else
				{
					gattling.transform.position = new Vector3(1000f, 1000f, 0f);
				}
			}
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			if (!Object.op_Implicit((Object)(object)gattling))
			{
				gattling = Object.Instantiate<GameObject>(KFC.ArtAssets.LoadAsset<GameObject>("gattlin"));
			}
			return ((CardEffect)this).OnPointStart(gameModeHandler);
		}

		public override IEnumerator OnPointEnd(IGameModeHandler gameModeHandler)
		{
			Object.Destroy((Object)(object)gattling);
			gattling = null;
			return ((CardEffect)this).OnPointEnd(gameModeHandler);
		}

		protected override void OnDestroy()
		{
			Object.Destroy((Object)(object)gattling);
			((CardEffect)this).OnDestroy();
		}
	}
	public class MerlinChaos : CardEffect
	{
		public override void OnShoot(GameObject projectile)
		{
			ExtensionMethods.GetOrAddComponent<RBGullets>(projectile.gameObject, false);
		}
	}
	public class RBGullets : MonoBehaviour
	{
		private int phase = 1;

		private float[] cols = new float[3] { 1f, 0f, 0f };

		public void Update()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			int num = Random.Range(0, 10);
			int num2 = 1;
			if (num <= 3)
			{
				num2 = -1;
			}
			int num3 = Random.Range(0, 10);
			int num4 = 1;
			if (num3 <= 3)
			{
				num4 = -1;
			}
			((Component)this).gameObject.GetComponent<Rigidbody2D>().velocity = new Vector2(((Component)this).gameObject.GetComponent<Rigidbody2D>().velocity.x * (float)num2, ((Component)this).gameObject.GetComponent<Rigidbody2D>().velocity.y * (float)num4);
			switch (phase)
			{
			case 1:
				cols[1] += TimeHandler.deltaTime * 10f;
				if (cols[1] >= 1f)
				{
					cols[1] = 1f;
					phase = 2;
				}
				break;
			case 2:
				cols[0] -= TimeHandler.deltaTime * 10f;
				if (cols[0] <= 0f)
				{
					cols[0] = 0f;
					phase = 3;
				}
				break;
			case 3:
				cols[2] += TimeHandler.deltaTime * 10f;
				if (cols[2] >= 1f)
				{
					cols[2] = 1f;
					phase = 4;
				}
				break;
			case 4:
				cols[1] -= TimeHandler.deltaTime * 10f;
				if (cols[1] <= 0f)
				{
					cols[1] = 0f;
					phase = 5;
				}
				break;
			case 5:
				cols[0] += TimeHandler.deltaTime * 10f;
				if (cols[0] >= 1f)
				{
					cols[0] = 1f;
					phase = 6;
				}
				break;
			case 6:
				cols[2] -= TimeHandler.deltaTime * 10f;
				if (cols[2] <= 0f)
				{
					cols[2] = 0f;
					phase = 1;
				}
				break;
			}
			TrailRenderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TrailRenderer>();
			Color val2 = default(Color);
			foreach (TrailRenderer val in componentsInChildren)
			{
				((Color)(ref val2))..ctor(1f, 1f, 1f, 1f);
				switch (phase)
				{
				case 1:
					((Color)(ref val2))..ctor(1f, 0f, 0f);
					break;
				case 2:
					((Color)(ref val2))..ctor(1f, 1f, 0f);
					break;
				case 3:
					((Color)(ref val2))..ctor(0f, 1f, 0f);
					break;
				case 4:
					((Color)(ref val2))..ctor(0f, 1f, 1f);
					break;
				case 5:
					((Color)(ref val2))..ctor(0f, 0f, 1f);
					break;
				case 6:
					((Color)(ref val2))..ctor(1f, 0f, 1f);
					break;
				}
				val.startColor = val2;
				val.endColor = val2;
			}
		}
	}
	public class meteorHandler : CardEffect
	{
		public float height = 20f;

		public void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			Vector2 sensorSize = MainCam.instance.cam.sensorSize;
			height = ((Vector2)(ref sensorSize))[1];
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(((Component)((CardEffect)this).player).transform.position.x, ((Component)((CardEffect)this).player).transform.position.y + (height - ((Component)((CardEffect)this).player).transform.position.y), ((Component)((CardEffect)this).player).transform.position.z);
			float x = MainCam.instance.cam.ScreenToWorldPoint(Input.mousePosition).x;
			float y = MainCam.instance.cam.ScreenToWorldPoint(Input.mousePosition).y;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(x, y, ((Component)((CardEffect)this).player).transform.position.z);
			Vector3 val3 = val2 - val;
			ExtensionMethods.SetFieldValue((object)((CardEffect)this).gun, "forceShootDir", (object)val3);
		}

		public override void OnShoot(GameObject projectile)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(projectile.transform.position.x, projectile.transform.position.y + (2.5f + height - ((Component)((CardEffect)this).player).transform.position.y), projectile.transform.position.z);
			projectile.transform.position = position;
		}
	}
	public class BottomRock : CardEffect
	{
		public float[] trueStatsFP = new float[5];

		public float[] trueStatsFN = new float[4];

		public int[] trueStatsIP = new int[5];

		public float[] maxStatsFP = new float[5];

		public float[] maxStatsFN = new float[4];

		public int[] maxStatsIP = new int[5];

		public bool build = false;

		protected override void Start()
		{
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 15, (Action)delegate
			{
				BuildStats();
			});
		}

		private void BuildStats()
		{
			trueStatsFP[0] = ((CardEffect)this).gun.damage;
			trueStatsFP[1] = ((CardEffect)this).data.maxHealth;
			trueStatsFP[2] = ((CardEffect)this).characterStats.movementSpeed;
			trueStatsFP[3] = ((CardEffect)this).characterStats.jump;
			trueStatsFP[4] = ((CardEffect)this).characterStats.lifeSteal;
			trueStatsFN[0] = ((CardEffect)this).gun.attackSpeed;
			trueStatsFN[1] = ((Component)((CardEffect)this).gun).GetComponentInChildren<GunAmmo>().reloadTime;
			trueStatsFN[2] = ((CardEffect)this).block.cooldown;
			trueStatsFN[3] = ((CardEffect)this).characterStats.sizeMultiplier;
			trueStatsIP[0] = ((CardEffect)this).characterStats.numberOfJumps;
			trueStatsIP[1] = ((CardEffect)this).gun.ammo;
			trueStatsIP[2] = ((CardEffect)this).block.additionalBlocks;
			trueStatsIP[3] = ((CardEffect)this).gun.numberOfProjectiles;
			trueStatsIP[4] = ((CardEffect)this).gun.reflects;
			maxStatsFP[0] = ((CardEffect)this).gun.damage;
			maxStatsFP[1] = ((CardEffect)this).data.maxHealth;
			maxStatsFP[2] = ((CardEffect)this).characterStats.movementSpeed;
			maxStatsFP[3] = ((CardEffect)this).characterStats.jump;
			maxStatsFP[4] = ((CardEffect)this).characterStats.lifeSteal;
			maxStatsFN[0] = ((CardEffect)this).gun.attackSpeed;
			maxStatsFN[1] = ((Component)((CardEffect)this).gun).GetComponentInChildren<GunAmmo>().reloadTime;
			maxStatsFN[2] = ((CardEffect)this).block.cooldown;
			maxStatsFN[3] = ((CardEffect)this).characterStats.sizeMultiplier;
			maxStatsIP[0] = ((CardEffect)this).characterStats.numberOfJumps;
			maxStatsIP[1] = ((CardEffect)this).gun.ammo;
			maxStatsIP[2] = ((CardEffect)this).block.additionalBlocks;
			maxStatsIP[3] = ((CardEffect)this).gun.numberOfProjectiles;
			maxStatsIP[4] = ((CardEffect)this).gun.reflects;
			build = true;
		}

		private void Update()
		{
			if (!build)
			{
				return;
			}
			float[] array = new float[5]
			{
				((CardEffect)this).gun.damage,
				((CardEffect)this).data.maxHealth,
				((CardEffect)this).characterStats.movementSpeed,
				((CardEffect)this).characterStats.jump,
				((CardEffect)this).characterStats.lifeSteal
			};
			float[] array2 = new float[4]
			{
				((CardEffect)this).gun.attackSpeed,
				((Component)((CardEffect)this).gun).GetComponentInChildren<GunAmmo>().reloadTime,
				((CardEffect)this).block.cooldown,
				((CardEffect)this).characterStats.sizeMultiplier
			};
			int[] array3 = new int[5]
			{
				((CardEffect)this).characterStats.numberOfJumps,
				((CardEffect)this).gun.ammo,
				((CardEffect)this).block.additionalBlocks,
				((CardEffect)this).gun.numberOfProjectiles,
				((CardEffect)this).gun.reflects
			};
			for (int i = 0; i < array.Length; i++)
			{
				float num = array[i];
				if (num != maxStatsFP[i])
				{
					float num2 = num / maxStatsFP[i];
					trueStatsFP[i] *= num2;
					if (trueStatsFP[i] > maxStatsFP[i])
					{
						maxStatsFP[i] = trueStatsFP[i];
					}
				}
			}
			for (int j = 0; j < array2.Length; j++)
			{
				float num3 = array2[j];
				if (num3 != maxStatsFN[j])
				{
					float num4 = num3 / maxStatsFN[j];
					trueStatsFN[j] *= num4;
					if (trueStatsFN[j] < maxStatsFN[j])
					{
						maxStatsFN[j] = trueStatsFN[j];
					}
				}
			}
			for (int k = 0; k < array3.Length; k++)
			{
				int num5 = array3[k];
				if (num5 != maxStatsIP[k])
				{
					int num6 = num5 - maxStatsIP[k];
					trueStatsIP[k] += num6;
					if (trueStatsIP[k] > maxStatsIP[k])
					{
						maxStatsIP[k] = trueStatsIP[k];
					}
				}
			}
			((CardEffect)this).gun.damage = maxStatsFP[0];
			float num7 = ((CardEffect)this).data.maxHealth / ((CardEffect)this).data.health;
			((CardEffect)this).data.maxHealth = maxStatsFP[1];
			((CardEffect)this).data.health = ((CardEffect)this).data.maxHealth / num7;
			((CardEffect)this).characterStats.movementSpeed = maxStatsFP[2];
			((CardEffect)this).characterStats.jump = maxStatsFP[3];
			((CardEffect)this).characterStats.lifeSteal = maxStatsFP[4];
			((CardEffect)this).gun.attackSpeed = maxStatsFN[0];
			((Component)((CardEffect)this).gun).GetComponentInChildren<GunAmmo>().reloadTime = maxStatsFN[1];
			((CardEffect)this).block.cooldown = maxStatsFN[2];
			((CardEffect)this).characterStats.sizeMultiplier = maxStatsFN[3];
			((CardEffect)this).characterStats.numberOfJumps = maxStatsIP[0];
			((CardEffect)this).gun.ammo = maxStatsIP[1];
			((CardEffect)this).block.additionalBlocks = maxStatsIP[2];
			((CardEffect)this).gun.numberOfProjectiles = maxStatsIP[3];
			((CardEffect)this).gun.reflects = maxStatsIP[4];
		}
	}
	public class excaliber_Mono : CardEffect
	{
		public ExcaliberSword_Mono excaliberSword;

		private float swordShoot = 0f;

		private CustomHealthBar swordCool;

		protected override void Start()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			((CardEffect)this).Start();
			Renderer[] componentsInChildren = ((Component)((Component)((CardEffect)this).gun).transform).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.enabled = false;
			}
			GameObject val2 = PhotonNetwork.Instantiate("KFC_Excaliber", ((Component)((CardEffect)this).data.hand).transform.position, Quaternion.identity, (byte)0, (object[])null);
			NetworkingManager.RPC(typeof(excaliber_Mono), "RPCSword", new object[2]
			{
				((Object)val2).name,
				((CardEffect)this).player.playerID
			});
			excaliberSword = ExtensionMethods.GetOrAddComponent<ExcaliberSword_Mono>(val2, false);
			excaliberSword.player = ((CardEffect)this).player;
			((Component)((Component)((Component)((CardEffect)this).gun).transform).GetComponentInChildren<Canvas>()).gameObject.AddComponent<CanvasGroup>().alpha = 0f;
			swordCool = ((Component)((Component)excaliberSword).gameObject.transform.GetChild(2)).gameObject.AddComponent<CustomHealthBar>();
			swordCool.SetValues(swordShoot, ((CardEffect)this).gun.attackSpeed * 5f / 0.3f);
			swordCool.SetColor(Color.red);
			FixSword();
		}

		[UnboundRPC]
		public static void RPCSword(string swordName, int playerid)
		{
			List<Rigidbody2D> list = (from g in Object.FindObjectsOfType<Rigidbody2D>()
				where ((Object)g).name == swordName
				select g).ToList();
			foreach (Rigidbody2D item in list)
			{
				if ((Object)(object)((Component)item).gameObject.GetComponent<ExcaliberSword_Mono>() == (Object)null)
				{
					((Component)item).gameObject.AddComponent<ExcaliberSword_Mono>().player = PlayerManager.instance.players.Where((Player p) => p.playerID == playerid).ToArray()[0];
					break;
				}
			}
		}

		private void FixSword()
		{
			Renderer[] componentsInChildren = ((Component)((Component)((CardEffect)this).gun).transform).GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				val.enabled = false;
			}
			PolygonCollider2D componentInChildren = ((Component)excaliberSword).gameObject.GetComponentInChildren<PolygonCollider2D>();
			Collider2D[] componentsInChildren2 = ((Component)((CardEffect)this).player).GetComponentsInChildren<Collider2D>();
			foreach (Collider2D val2 in componentsInChildren2)
			{
				Physics2D.IgnoreCollision((Collider2D)(object)componentInChildren, val2);
			}
		}

		public override void OnShoot(GameObject projectile)
		{
			PhotonNetwork.Destroy(projectile);
			if (!excaliberSword.boomer && swordShoot > ((CardEffect)this).gun.attackSpeed * 5f / 0.3f)
			{
				excaliberSword.StartBoomer();
				swordShoot = 0f;
			}
		}

		public void Update()
		{
			swordShoot += TimeHandler.deltaTime;
			swordCool.SetValues(swordShoot, ((CardEffect)this).gun.attackSpeed * 5f / 0.3f);
		}

		public void OnEnable()
		{
			FixSword();
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			FixSword();
			yield break;
		}

		public override void OnRevive()
		{
			FixSword();
		}

		protected override void OnDestroy()
		{
			PhotonNetwork.Destroy(((Component)excaliberSword).gameObject);
			((CardEffect)this).OnDestroy();
		}
	}
	public class ExcaliberSword_Mono : MonoBehaviour
	{
		public Player player;

		private Rigidbody2D rigid;

		private DamageBox damagebox;

		public bool boomer = false;

		private Vector2 swordLoc;

		private Vector3 swordAim;

		private Vector3 targetLoc;

		private bool goOut = true;

		private void Start()
		{
			rigid = ((Component)this).gameObject.GetComponent<Rigidbody2D>();
			damagebox = ((Component)this).gameObject.GetComponentInChildren<DamageBox>();
			damagebox.damage = player.data.weaponHandler.gun.damage;
		}

		public void StartBoomer()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			boomer = true;
			goOut = true;
			targetLoc = player.data.hand.position + ((Vector3)(ref player.data.aimDirection)).normalized * 30f;
			swordAim = player.data.aimDirection;
		}

		public Vector2 RotateVector(Vector2 v, float angle)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			float num = angle * (MathF.PI / 180f);
			float num2 = v.x * Mathf.Cos(num) - v.y * Mathf.Sin(num);
			float num3 = v.x * Mathf.Sin(num) + v.y * Mathf.Cos(num);
			return new Vector2(num2, num3);
		}

		private void Update()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			if (!player.data.view.IsMine)
			{
				return;
			}
			if (!boomer)
			{
				swordLoc = Vector2.op_Implicit(player.data.hand.position);
				swordAim = player.data.aimDirection;
			}
			if (boomer)
			{
				if (goOut)
				{
					swordLoc = Vector2.MoveTowards(swordLoc, Vector2.op_Implicit(targetLoc), 60f * TimeHandler.deltaTime * player.data.weaponHandler.gun.projectileSpeed);
					if (Vector2.Distance(swordLoc, Vector2.op_Implicit(targetLoc)) < 1f)
					{
						goOut = false;
					}
					swordAim = player.data.aimDirection;
				}
				if (!goOut)
				{
					swordLoc = Vector2.MoveTowards(swordLoc, Vector2.op_Implicit(player.data.hand.position), 60f * TimeHandler.deltaTime * player.data.weaponHandler.gun.projectileSpeed);
					if (Vector2.Distance(swordLoc, Vector2.op_Implicit(player.data.hand.position)) < 1f)
					{
						boomer = false;
					}
					swordAim = player.data.aimDirection;
				}
			}
			player.data.weaponHandler.gun.ammo = 0;
			rigid.position = swordLoc;
			((Component)rigid).transform.up = swordAim;
			if (player.data.health <= 0f)
			{
				rigid.position = new Vector2(1000f, 1000f);
			}
		}
	}
	public class BulletPusher : CardEffect
	{
		public float dist = 0f;

		public override void OnShoot(GameObject projectile)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Vector3)(ref ((CardEffect)this).player.data.aimDirection)).normalized * dist;
			Transform transform = projectile.transform;
			transform.position += val;
			((CardEffect)this).OnShoot(projectile);
		}
	}
	public class BulletSword : CardEffect
	{
		private bool going = true;

		private SimulatedGun swordMaker;

		public override IEnumerator OnJumpCoroutine()
		{
			if (!Object.op_Implicit((Object)(object)swordMaker))
			{
				swordMaker = ((Component)((CardEffect)this).player).GetComponent<SimulatedGun>();
			}
			yield return MakeBulletSword();
		}

		public override IEnumerator OnRoundStart(IGameModeHandler gameModeHandler)
		{
			if (!Object.op_Implicit((Object)(object)swordMaker))
			{
				swordMaker = ((Component)((CardEffect)this).player).GetComponent<SimulatedGun>();
			}
			going = true;
			yield return MakeBulletSword();
		}

		public override IEnumerator OnRoundEnd(IGameModeHandler gameModeHandler)
		{
			going = false;
			yield return null;
		}

		private IEnumerable MakeBulletSword()
		{
			while (going)
			{
				yield return (object)new WaitForSecondsRealtime(0.2f);
				swordMaker.SimulatedAttack(((CardEffect)this).player.playerID, ((CardEffect)this).gun.shootPosition.position, ((CardEffect)this).data.aimDirection, 0f, ((CardEffect)this).gun.damage, (Transform)null, false);
			}
			yield return null;
		}
	}
	public class indiajon_Mono : CardEffect
	{
		private int rocks = 0;

		private List<GameObject> rooks = new List<GameObject>();

		public void SpawnBall()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			if (rocks >= 3)
			{
				rocks--;
				PhotonNetwork.Destroy(rooks[0]);
				rooks.RemoveAt(0);
			}
			List<Player> list = PlayerManager.instance.players.Where((Player pl) => pl.playerID != ((CardEffect)this).player.playerID && pl.teamID != ((CardEffect)this).player.teamID && pl.data.health > 0f).ToList();
			if (list.Count == 0)
			{
				return;
			}
			Player val = list[Random.Range(0, list.Count)];
			Vector3 normalized = ((Vector3)(ref val.data.aimDirection)).normalized;
			int num = 15;
			Vector3 val2 = ((Component)val).transform.position + new Vector3(0f, (float)num, 0f);
			GameObject betterBall = PhotonNetwork.Instantiate("KFC_Boulder", val2, Quaternion.identity, (byte)0, (object[])null);
			betterBall.GetComponent<Rigidbody2D>().velocity = Vector2.op_Implicit(new Vector3(0f, -50f, 0f));
			rooks.Add(betterBall);
			rocks++;
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)KFC.instance, 5f, (Action)delegate
			{
				if (Object.op_Implicit((Object)(object)betterBall))
				{
					rocks--;
					rooks.Remove(betterBall);
					PhotonNetwork.Destroy(betterBall);
				}
			});
		}

		public override void OnBlock(BlockTriggerType trigger)
		{
			SpawnBall();
		}
	}
	public class BallObject : MonoBehaviour
	{
		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.localRotation = Quaternion.Euler(new Vector3(90f, 0f, 0f));
		}
	}
	public class legos_Mono : CardEffect
	{
		private int leegos = 0;

		private List<GameObject> leeeeeeeegs = new List<GameObject>();

		public override void OnBulletHit(GameObject projectile, HitInfo hit)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			((CardEffect)this).OnBulletHit(projectile, hit);
			if (leegos >= 10)
			{
				PhotonNetwork.Destroy(leeeeeeeegs[0]);
				leeeeeeeegs.RemoveAt(0);
				leegos--;
			}
			leegos++;
			string[] array = new string[4] { "KFC_LegoBrickR", "KFC_LegoBrickY", "KFC_LegoBrickB", "KFC_LegoBrickG" };
			string text = array[Random.Range(0, array.Length)];
			GameObject lego = PhotonNetwork.Instantiate(text, projectile.transform.position, Quaternion.identity, (byte)0, (object[])null);
			leeeeeeeegs.Add(lego);
			lego.gameObject.GetComponent<DamageBox>().damage = 0f;
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)KFC.instance, 10f, (Action)delegate
			{
				if (Object.op_Implicit((Object)(object)lego))
				{
					leegos--;
					leeeeeeeegs.Remove(lego);
					PhotonNetwork.Destroy(lego);
				}
			});
		}
	}
	public class ShopHandle : MonoBehaviour
	{
		public void Update()
		{
			Player player = ((Component)this).GetComponent<Player>();
			if (!Input.GetMouseButtonDown(0))
			{
				return;
			}
			try
			{
				CardBar val = CardBarUtils.instance.PlayersCardBar(player.playerID);
				string text = ExtensionMethods.GetFieldValue((object)val, "currentCard").ToString();
				if (text == null || !((Component)player).gameObject.GetComponent<PhotonView>().IsMine)
				{
					return;
				}
				string text2 = text.Substring(0, text.IndexOf('('));
				CardInfo cardInfoWithName = CardManager.GetCardInfoWithName(text2);
				if (!((Object)(object)cardInfoWithName == (Object)(object)Sacrafice.card))
				{
					Cards.instance.RemoveCardsFromPlayer(player, new int[2]
					{
						player.data.currentCards.IndexOf(Sacrafice.card),
						player.data.currentCards.IndexOf(cardInfoWithName)
					});
					ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 20, (Action)delegate
					{
						CurseManager.instance.CursePlayer(player);
					});
				}
			}
			catch
			{
			}
		}
	}
	public class sp500Manager : CardEffect
	{
		private int indexing = -1;

		public override void OnTakeDamage(Vector2 damage, bool selfDamage)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (selfDamage)
			{
				float magnitude = ((Vector2)(ref damage)).magnitude;
				if (magnitude < 10f)
				{
					CharacterData data = ((CardEffect)this).player.data;
					data.health += magnitude;
				}
				else
				{
					CharacterData data2 = ((CardEffect)this).player.data;
					data2.health += 10f;
				}
			}
			((CardEffect)this).OnTakeDamage(damage, selfDamage);
		}

		private void ReverseBads(CardInfo c)
		{
			Gun component = ((Component)c).gameObject.GetComponent<Gun>();
			CharacterStatModifiers component2 = ((Component)c).gameObject.GetComponent<CharacterStatModifiers>();
			if (component.reloadTimeAdd > 0f)
			{
				GunAmmo gunAmmo = ((CardEffect)this).gunAmmo;
				gunAmmo.reloadTimeAdd -= component.reloadTimeAdd;
			}
			if (component.ammo < 0)
			{
				GunAmmo gunAmmo2 = ((CardEffect)this).gunAmmo;
				gunAmmo2.maxAmmo -= component.ammo;
			}
			if (component.attackSpeed > 1f)
			{
				Gun gun = ((CardEffect)this).gun;
				gun.attackSpeed /= component.attackSpeed;
			}
			if (component.reloadTime > 1f)
			{
				GunAmmo gunAmmo3 = ((CardEffect)this).gunAmmo;
				gunAmmo3.reloadTime /= component.reloadTime;
			}
			if (component2.health < 1f)
			{
				CharacterStatModifiers characterStats = ((CardEffect)this).characterStats;
				characterStats.health /= component2.health;
			}
			if (component.damage < 1f)
			{
				Gun gun2 = ((CardEffect)this).gun;
				gun2.damage /= component.damage;
			}
			if (component.projectileSpeed < 1f)
			{
				Gun gun3 = ((CardEffect)this).gun;
				gun3.projectileSpeed /= component.projectileSpeed;
			}
			if (component2.movementSpeed < 1f)
			{
				CharacterStatModifiers characterStats2 = ((CardEffect)this).characterStats;
				characterStats2.movementSpeed /= component2.movementSpeed;
			}
			if (component.dmgMOnBounce < 1f)
			{
				Gun gun4 = ((CardEffect)this).gun;
				gun4.dmgMOnBounce /= component.dmgMOnBounce;
			}
			if (component.speedMOnBounce < 1f)
			{
				Gun gun5 = ((CardEffect)this).gun;
				gun5.speedMOnBounce /= component.speedMOnBounce;
			}
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			if (indexing == -1)
			{
				indexing = ((CardEffect)this).player.data.currentCards.IndexOf(scp_500.card) + 1;
			}
			if (indexing <= ((CardEffect)this).player.data.currentCards.Count)
			{
				yield break;
			}
			List<CardInfo> cardstoCheck = ((CardEffect)this).player.data.currentCards;
			cardstoCheck.RemoveRange(0, indexing - 1);
			foreach (CardInfo c in cardstoCheck)
			{
				ReverseBads(c);
			}
			indexing = ((CardEffect)this).player.data.currentCards.Count;
		}

		public override void OnJump()
		{
			if (indexing == -1)
			{
				indexing = ((CardEffect)this).player.data.currentCards.IndexOf(scp_500.card) + 1;
			}
			if (indexing > ((CardEffect)this).player.data.currentCards.Count)
			{
				List<CardInfo> currentCards = ((CardEffect)this).player.data.currentCards;
				currentCards.RemoveRange(0, indexing - 1);
				foreach (CardInfo item in currentCards)
				{
					ReverseBads(item);
				}
				indexing = ((CardEffect)this).player.data.currentCards.Count;
			}
			((CardEffect)this).OnJump();
		}
	}
	public class byebyeWall : CardEffect
	{
		public override void OnBulletHit(GameObject projectile, HitInfo hit)
		{
			if (!Object.op_Implicit((Object)(object)((Component)hit.collider).gameObject.GetComponent<Player>()))
			{
				((Component)hit.collider).gameObject.SetActive(false);
			}
		}
	}
	public class UnlimitedAmmo : CardEffect
	{
		public void Update()
		{
			int num = 3;
			foreach (CardInfo currentCard in ((CardEffect)this).player.data.currentCards)
			{
				num += ((Component)currentCard).gameObject.GetComponent<Gun>().ammo;
			}
			if (((CardEffect)this).gunAmmo.maxAmmo == 90)
			{
				((CardEffect)this).gunAmmo.maxAmmo = num;
			}
		}
	}
	public class tracers : CardEffect
	{
		public override void OnShoot(GameObject projectile)
		{
			TrailRenderer[] componentsInChildren = projectile.GetComponentsInChildren<TrailRenderer>();
			foreach (TrailRenderer val in componentsInChildren)
			{
				val.time = 1f;
			}
		}
	}
	public class FuckMe : CardEffect
	{
		private float t = 0f;

		private float a;

		private float b;

		private float c;

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			t += 1f;
			a = 1f;
			b = 1f;
			c = 1f;
			foreach (CardInfo card in ((CardEffect)this).player.data.currentCards)
			{
				if (card.cardName.ToLower().Equals("increase a"))
				{
					a += 1f;
				}
				if (card.cardName.ToLower().Equals("increase b"))
				{
					b += 1f;
				}
				if (card.cardName.ToLower().Equals("increase c"))
				{
					c += 1f;
				}
			}
			float mult = (float)(((Math.Pow(a * t, 1.2) + (double)(3f * b * t) + (double)(c * t / 4f)) / (double)(100f / (c / 8f)) - (double)(b / 3f)) / 6.0) + 1f;
			if (mult < 0.2f)
			{
				mult = 0.2f;
			}
			Gun gun = ((CardEffect)this).gun;
			gun.damage *= mult;
			Gun gun2 = ((CardEffect)this).gun;
			gun2.attackSpeed /= mult;
			GunAmmo gunAmmo = ((CardEffect)this).gunAmmo;
			gunAmmo.reloadTimeMultiplier /= mult;
			Gun gun3 = ((CardEffect)this).gun;
			gun3.projectileSpeed *= mult;
			CharacterData data = ((CardEffect)this).player.data;
			data.maxHealth *= mult;
			((CardEffect)this).player.data.health = ((CardEffect)this).player.data.maxHealth;
			CharacterStatModifiers characterStats = ((CardEffect)this).characterStats;
			characterStats.jump /= (mult + 1f) / 2f;
			CharacterStatModifiers characterStats2 = ((CardEffect)this).characterStats;
			characterStats2.movementSpeed *= mult;
			Block block = ((CardEffect)this).block;
			block.cdMultiplier /= mult;
			yield break;
		}
	}
	public class KoalasBonusStats : MonoBehaviour
	{
		public Vector2 shootPos;
	}
}
namespace KFC.Cards
{
	public class Armor : CustomEffectCard<armor_mono>
	{
		internal static CardInfo card;

		public override CardDetails<armor_mono> Details => new CardDetails<armor_mono>
		{
			Title = "Armor",
			Description = "Tanks one hit of damage",
			ModName = "KFC",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Armor"),
			Rarity = (Rarity)2,
			Theme = (CardThemeColorType)1
		};
	}
	public class blackholegun : CustomEffectCard<blackholegun_Mono>
	{
		internal static CardInfo card;

		public override CardDetails<blackholegun_Mono> Details => new CardDetails<blackholegun_Mono>
		{
			Title = "Blackhole Gun",
			Description = "Bro stole it from stickfight\n:skull:",
			ModName = "KFC",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Blackhole"),
			Rarity = RarityUtils.GetRarity("Mythical"),
			Theme = (CardThemeColorType)0
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
			gun.gravity = 0f;
			gun.ignoreWalls = true;
			gun.projectileSpeed = 0.1f;
			gun.destroyBulletAfter = 30f;
		}
	}
	public class BoxedBullets : CustomEffectCard<BoxThoseBullets>
	{
		internal static CardInfo card;

		public override CardDetails<BoxThoseBullets> Details => new CardDetails<BoxThoseBullets>
		{
			Title = "Boxed Bullets",
			Description = "Shoot boxes at people instead of bullets",
			ModName = "KFC",
			Art = KFC.ArtAssets2.LoadAsset<GameObject>("C_BoxedBullets"),
			Rarity = (Rarity)2,
			Theme = (CardThemeColorType)8,
			OwnerOnly = true
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers)
		{
			cardInfo.allowMultiple = false;
		}
	}
	public class LaggyBullets : CustomEffectCard<laggyMono>
	{
		internal static CardInfo card;

		public override CardDetails<laggyMono> Details => new CardDetails<laggyMono>
		{
			Title = "Laggy Bullets",
			Description = "Wait im lagging",
			ModName = "KFC Curses",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Laggy"),
			Rarity = (Rarity)1,
			Theme = (CardThemeColorType)4
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CurseManager.instance.curseCategory };
		}
	}
	public class NoAim : CustomEffectCard<AimlessMono>
	{
		internal static CardInfo card;

		public override CardDetails<AimlessMono> Details => new CardDetails<AimlessMono>
		{
			Title = "Cant Aim",
			Description = "What are you aiming at",
			ModName = "KFC Curses",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_NoAim"),
			Rarity = (Rarity)2,
			Theme = (CardThemeColorType)4,
			OwnerOnly = true
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CurseManager.instance.curseCategory };
		}
	}
	public class rerollNew : CustomEffectCard<rerollCurse>
	{
		internal static CardInfo card;

		public override CardDetails<rerollCurse> Details => new CardDetails<rerollCurse>
		{
			Title = "Instant Rerolling",
			Description = "Rerolls all future picks",
			ModName = "KFC Curses",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Shadow"),
			Rarity = (Rarity)2,
			Theme = (CardThemeColorType)4,
			OwnerOnly = true
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CurseManager.instance.curseCategory };
		}
	}
	public class Shadow : CustomEffectCard<shadowMono>
	{
		internal static CardInfo card;

		public override CardDetails<shadowMono> Details => new CardDetails<shadowMono>
		{
			Title = "Peephole",
			Description = "When you do anything, become shrouded in darkness",
			ModName = "KFC Curses",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Shadow"),
			Rarity = (Rarity)2,
			Theme = (CardThemeColorType)4,
			OwnerOnly = true
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CurseManager.instance.curseCategory };
		}
	}
	public class Alyssa : SimpleCard
	{
		internal static CardInfo card;

		public override CardDetails Details
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_0059: 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_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				CardDetails val = new CardDetails();
				val.Title = "Project Alyssa";
				val.Description = "+14 Projectile Speed";
				val.ModName = "KFC";
				val.Art = KFC.ArtAssets.LoadAsset<GameObject>("C_Alyssa");
				val.Rarity = (Rarity)2;
				val.Theme = (CardThemeColorType)7;
				val.Stats = (CardInfoStat[])(object)new CardInfoStat[1]
				{
					new CardInfoStat
					{
						amount = "<#FF00FF>*14",
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Projectile Speed"
					}
				};
				return val;
			}
		}

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.projectileSpeed = 14f;
		}
	}
	public class AncientKoala : SimpleCard
	{
		internal static CardInfo card;

		public override CardDetails Details => new CardDetails
		{
			Title = "Ancient Koala",
			Description = "<#ff00ff>Only the first gains a fragment of true power",
			ModName = "KFC",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_KoalaMain"),
			Rarity = RarityUtils.GetRarity("Divine"),
			Theme = CardThemeLib.instance.CreateOrGetType("Koality", (CardThemeColor)null)
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				for (int i = 0; i < ((Component)this).transform.childCount; i++)
				{
					Transform child = ((Component)this).transform.GetChild(i);
					if (((Object)child).name.Remove(9).ToLower() == "koalamain")
					{
						Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(i)).gameObject);
					}
				}
				GameObject val = KFC.ArtAssets.LoadAsset<GameObject>("KoalaMain");
				((Renderer)val.gameObject.GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)val.gameObject.GetComponent<SpriteRenderer>()).sortingOrder = 11;
				((Renderer)((Component)val.transform.GetChild(0)).GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)((Component)val.transform.GetChild(0)).GetComponent<SpriteRenderer>()).sortingOrder = 12;
				((Renderer)((Component)val.transform.GetChild(1)).GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)((Component)val.transform.GetChild(1)).GetComponent<SpriteRenderer>()).sortingOrder = 13;
				((Renderer)((Component)val.transform.GetChild(2)).GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)((Component)val.transform.GetChild(2)).GetComponent<SpriteRenderer>()).sortingOrder = 14;
				((Renderer)((Component)val.transform.GetChild(2).GetChild(0)).GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)((Component)val.transform.GetChild(2).GetChild(0)).GetComponent<SpriteRenderer>()).sortingOrder = 15;
				((Renderer)((Component)val.transform.GetChild(3)).GetComponent<SpriteRenderer>()).sortingLayerName = "MostFront";
				((Renderer)((Component)val.transform.GetChild(3)).GetComponent<SpriteRenderer>()).sortingOrder = 13;
				val.gameObject.layer = 21;
				for (int j = 0; j < val.transform.childCount; j++)
				{
					((Component)val.transform.GetChild(j)).gameObject.layer = 21;
				}
				Object.Instantiate<GameObject>(val, ((Component)this).transform);
				val.transform.localPosition = Vector3.zero;
			}
			catch
			{
			}
			CardInfoExtension.GetAdditionalData(cardInfo).canBeReassigned = false;
			cardInfo.categories = (CardCategory[])(object)new CardCategory[2]
			{
				CustomCardCategories.instance.CardCategory("cantEternity"),
				CustomCardCategories.instance.CardCategory("CardManipulation")
			};
		}

		protected override void Added(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			bool flag = false;
			Player[] array = PlayerManager.instance.players.ToArray();
			foreach (Player val in array)
			{
				foreach (CardInfo currentCard in val.data.currentCards)
				{
					if ((Object)(object)currentCard == (Object)(object)card)
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				Cards.instance.RemoveAllCardsFromPlayer(player, true);
				Cards.instance.AddCardToPlayer(player, KoalaWrath.card, false, "", 0f, 0f);
				return;
			}
			CardInfo[] gifts = (CardInfo[])(object)new CardInfo[4]
			{
				KoalaGlory.card,
				KoalaThief.card,
				KoalaMight.card,
				KoalaStats.card
			};
			List<CardInfo> list = gifts.ToList();
			foreach (CardInfo currentCard2 in player.data.currentCards)
			{
				CardInfo[] array2 = gifts;
				foreach (CardInfo val2 in array2)
				{
					if ((Object)(object)currentCard2 == (Object)(object)val2)
					{
						list.Remove(val2);
					}
				}
			}
			CardInfo[] array3 = list.ToArray();
			if (array3.Length != 0)
			{
				int num = Random.Range(0, array3.Length);
				int index = gifts.ToList().IndexOf(array3[num]);
				ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)KFC.instance, 10, (Action)delegate
				{
					Cards.instance.AddCardToPlayer(player, gifts[index], false, "", 0f, 0f);
				});
			}
		}
	}
	public class KoalaGlory : CustomEffectCard<Fortune>
	{
		internal static CardInfo card;

		public override CardDetails<Fortune> Details
		{
			get
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: 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_00b4: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Expected O, but got Unknown
				CardDetails<Fortune> val = new CardDetails<Fortune>();
				val.Title = "Glory of Koala";
				val.Description = "You gain an abundance of fame and fortune";
				val.ModName = "KFC";
				val.Art = KFC.ArtAssets.LoadAsset<GameObject>("C_KoalaGlory");
				val.Rarity = RarityUtils.GetRarity("Legendary");
				val.Theme = CardThemeLib.instance.CreateOrGetType("Koality", (CardThemeColor)null);
				val.Stats = (CardInfoStat[])(object)new CardInfoStat[2]
				{
					new CardInfoStat
					{
						amount = "<#ff00ff>+25% of Others",
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Max Hp"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>10% Max Hp",
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Healing per second"
					}
				};
				return val;
			}
		}

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers)
		{
			CardInfoExtension.GetAdditionalData(cardInfo).canBeReassigned = false;
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CustomCardCategories.instance.CardCategory("cantEternity") };
		}

		protected override void Added(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			Player[] array = PlayerManager.instance.players.Where((Player p) => p.playerID != player.playerID).ToArray();
			float num = 0f;
			Player[] array2 = array;
			foreach (Player val in array2)
			{
				num += val.data.maxHealth * 0.25f;
			}
			CharacterData data2 = player.data;
			data2.maxHealth += num;
			player.data.health = player.data.maxHealth;
		}

		public override bool GetEnabled()
		{
			return false;
		}
	}
	public class KoalaMight : SimpleCard
	{
		internal static CardInfo card;

		public override CardDetails Details
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Expected O, but got Unknown
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: 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_00f7: Expected O, but got Unknown
				//IL_00f9: Unknown result type (might be due to invalid IL