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.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.RiftShenanigans;
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.5.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__19_0;

			public static UnityAction <>9__19_1;

			public static Action<CardInfo> <>9__19_2;

			public static Action<CardInfo> <>9__19_3;

			public static Action<CardInfo> <>9__19_4;

			public static Action<CardInfo> <>9__19_5;

			public static Action<CardInfo> <>9__19_6;

			public static Action<CardInfo> <>9__19_7;

			public static Action<CardInfo> <>9__19_8;

			public static Action<CardInfo> <>9__19_9;

			public static Action<CardInfo> <>9__19_10;

			public static Action<CardInfo> <>9__19_11;

			public static Action<CardInfo> <>9__19_12;

			public static Action<CardInfo> <>9__19_13;

			public static Action<CardInfo> <>9__19_14;

			public static Action<CardInfo> <>9__19_15;

			public static Action<CardInfo> <>9__19_16;

			public static Action<CardInfo> <>9__19_17;

			public static Action<CardInfo> <>9__19_18;

			public static Action<CardInfo> <>9__19_19;

			public static Action<CardInfo> <>9__19_20;

			public static Action<CardInfo> <>9__19_21;

			public static Action<CardInfo> <>9__19_22;

			public static Action<CardInfo> <>9__19_23;

			public static Action<CardInfo> <>9__19_24;

			public static Action<CardInfo> <>9__19_25;

			public static Action<CardInfo> <>9__19_26;

			public static Action<CardInfo> <>9__19_27;

			public static Action<CardInfo> <>9__19_28;

			public static Action<CardInfo> <>9__19_29;

			public static Action<CardInfo> <>9__19_30;

			public static Action<CardInfo> <>9__19_31;

			public static Action<CardInfo> <>9__19_32;

			public static Action<CardInfo> <>9__19_33;

			public static Action<CardInfo> <>9__19_34;

			public static Action<CardInfo> <>9__19_35;

			public static Action<CardInfo> <>9__19_36;

			public static Action<CardInfo> <>9__19_37;

			public static Action<CardInfo> <>9__19_38;

			public static Action<CardInfo> <>9__19_39;

			public static Action<CardInfo> <>9__19_40;

			public static Action<CardInfo> <>9__19_41;

			public static Action<CardInfo> <>9__19_42;

			public static Action<CardInfo> <>9__19_43;

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

			internal void <Start>b__19_1()
			{
			}

			internal void <Start>b__19_2(CardInfo card)
			{
				AncientKoala.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ak");
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal void <Start>b__19_19(CardInfo card)
			{
				UncappedAmmo.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ua");
			}

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

			internal void <Start>b__19_21(CardInfo card)
			{
				Sacrafice.card = card;
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			internal void <Start>b__19_43(CardInfo card)
			{
				Shadow.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.5.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;

		public static ConfigEntry<bool> cardSounds;

		public ObjectsToSpawn wallbounce;

		private static float myst = 331.8f;

		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_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0201: 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__19_1;
			if (obj == null)
			{
				UnityAction val4 = delegate
				{
				};
				<>c.<>9__19_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);
			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)"Chad Vanilla 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"));
			CustomCard.BuildCard<AncientKoala>((Action<CardInfo>)delegate(CardInfo card)
			{
				AncientKoala.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ak");
			});
			CustomCard.BuildCard<KoalaGlory>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				KoalaGlory.card = card;
			});
			CustomCard.BuildCard<KoalaThief>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				KoalaThief.card = card;
			});
			CustomCard.BuildCard<KoalaMight>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				KoalaMight.card = card;
			});
			CustomCard.BuildCard<KoalaStats>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				KoalaStats.card = card;
			});
			CustomCard.BuildCard<MasterThief>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				MasterThief.card = card;
			});
			CustomCard.BuildCard<KoalaWrath>((Action<CardInfo>)delegate(CardInfo card)
			{
				Cards.instance.AddHiddenCard(card);
				KoalaWrath.card = card;
			});
			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<RedHerring>((Action<CardInfo>)delegate(CardInfo card)
			{
				RedHerring.card = card;
				ExtensionMethods.SetAbbreviation(card, "Rh");
			});
			CustomCard.BuildCard<UncappedAmmo>((Action<CardInfo>)delegate(CardInfo card)
			{
				UncappedAmmo.card = card;
				ExtensionMethods.SetAbbreviation(card, "Ua");
			});
			CustomCard.BuildCard<KingOfSpeed>((Action<CardInfo>)delegate(CardInfo card)
			{
				KingOfSpeed.card = card;
			});
			CustomCard.BuildCard<Sacrafice>((Action<CardInfo>)delegate(CardInfo card)
			{
				Sacrafice.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);
			});
		}

		public IEnumerator GameStart(IGameModeHandler gameModeHandler)
		{
			foreach (Player p in PlayerManager.instance.players)
			{
				((Component)p).gameObject.AddComponent<KoalasBonusStats>();
			}
			yield break;
		}
	}
}
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.MonoBehaviors
{
	public class armor_mono : CardEffect
	{
		private float armorHp = 0f;

		private bool armorDestroyed = true;

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

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

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

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

		public override void OnTakeDamage(Vector2 damage, bool selfDamage)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			float magnitude = ((Vector2)(ref damage)).magnitude;
			if (!armorDestroyed)
			{
				armorHp -= magnitude;
				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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)bhole))
			{
				PhotonNetwork.Destroy(bhole);
				Object.Destroy((Object)(object)bhole.GetComponent<blackHole_Mono>().projec);
			}
			bhole = Object.Instantiate<GameObject>(KFC.ArtAssets.LoadAsset<GameObject>("BlackHole"), ((Component)((CardEffect)this).data.hand).transform.position, Quaternion.identity);
			bhole.AddComponent<blackHole_Mono>().projec = projectile;
		}

		public override IEnumerator OnPointEnd(IGameModeHandler gameModeHandler)
		{
			if (Object.op_Implicit((Object)(object)bhole))
			{
				PhotonNetwork.Destroy(bhole);
				Object.Destroy((Object)(object)bhole.GetComponent<blackHole_Mono>().projec);
			}
			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_0045: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)projec == (Object)null)
			{
				PhotonNetwork.Destroy(((Component)this).gameObject);
			}
			size += TimeHandler.deltaTime;
			((Component)this).gameObject.transform.position = projec.transform.position;
			((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 (players.Count == 0)
			{
				return;
			}
			foreach (Player item in players)
			{
				float num = Vector2.Distance(Vector2.op_Implicit(((Component)item).transform.position), Vector2.op_Implicit(projec.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 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 dalala : CardEffect
	{
		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			yield break;
		}
	}
	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 bool inGame = false;

		public void OnEnable()
		{
			inGame = true;
		}

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

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

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

		public void Update()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00df: 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)
			if (!inGame)
			{
				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_00f5: 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);
			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)
		{
			GameObject.Find(swordName).AddComponent<ExcaliberSword_Mono>().player = PlayerManager.instance.players.Where((Player p) => p.playerID == playerid).ToArray()[0];
		}

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

		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_0020: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_0162: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			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 superhot_mono : CardEffect
	{
		private float moveCD = 2.5f;

		private float moveCDMax = 2.5f;

		public void Update()
		{
			if (((Behaviour)((CardEffect)this).player).isActiveAndEnabled && Input.anyKey)
			{
				moveCD = 0f;
			}
			moveCD += Time.deltaTime;
			if (!(moveCD > moveCDMax))
			{
			}
		}
	}
	public class turretMono : CardEffect
	{
		public turretController controller;

		private void SpawnTurret()
		{
			//IL_0011: 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)
			GameObject val = PhotonNetwork.Instantiate("KFC_Turret", ((Component)((CardEffect)this).player).transform.position, Quaternion.identity, (byte)0, (object[])null);
			controller = val.AddComponent<turretController>();
			((object)val.AddComponent<Gun>()).Equals((object?)((CardEffect)this).gun);
			controller.owner = ((CardEffect)this).player;
		}

		public override void OnJump()
		{
			((CardEffect)this).OnJump();
			SpawnTurret();
		}

		public override IEnumerator OnPointStart(IGameModeHandler gameModeHandler)
		{
			SpawnTurret();
			return ((CardEffect)this).OnPointStart(gameModeHandler);
		}
	}
	public class turretController : MonoBehaviour
	{
		public Player owner;

		private Rigidbody2D rigid;

		private float playerDist = 1000f;

		private Vector2 targetLoc;

		public Gun gun;

		private float maxHealth = 100f;

		private float health = 100f;

		private float damage = 100f;

		private CustomHealthBar turretHealh;

		private float attackSpeed = 0.2f;

		private float attackCount = 0f;

		private void Start()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			rigid = ((Component)this).gameObject.GetComponent<Rigidbody2D>();
			turretHealh = ((Component)this).gameObject.AddComponent<CustomHealthBar>();
			turretHealh.SetColor(Color.magenta);
			turretHealh.SetValues(health, maxHealth);
			gun.damage = 100f;
			gun.gravity = 0f;
			gun.ignoreWalls = true;
		}

		private Vector2 nearestPlayer()
		{
			//IL_0046: 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)
			//IL_003a: 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_0111: 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: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			playerDist = 1000f;
			List<Player> list = PlayerManager.instance.players.Where((Player pl) => pl.playerID != owner.playerID && pl.teamID != owner.teamID && pl.data.health > 0f).ToList();
			if (list.Count == 0)
			{
				return Vector2.zero;
			}
			targetLoc = Vector2.zero;
			foreach (Player item in list)
			{
				if (Vector2.Distance(Vector2.op_Implicit(((Component)this).gameObject.transform.position), Vector2.op_Implicit(((Component)item).transform.position)) < playerDist)
				{
					targetLoc = Vector2.op_Implicit(((Component)item).transform.position);
					playerDist = Vector2.Distance(Vector2.op_Implicit(((Component)this).gameObject.transform.position), Vector2.op_Implicit(((Component)item).transform.position));
				}
			}
			return targetLoc;
		}

		private void Update()
		{
			//IL_001a: 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_002f: 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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			turretHealh.SetValues(health, maxHealth);
			Vector2 val = nearestPlayer() - Vector2.op_Implicit(((Component)this).gameObject.transform.position);
			((Component)((Component)this).gameObject.transform.GetChild(0)).gameObject.transform.up = Vector2.op_Implicit(val);
			Vector2 normalized = ((Vector2)(ref val)).normalized;
			attackCount += TimeHandler.deltaTime;
			MonoBehaviour.print((object)damage);
			if (attackCount > attackSpeed)
			{
				attackCount = 0f;
				MonoBehaviour.print((object)"shoot");
			}
		}
	}
	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 = "Gain a 100 hp armor that is seperate from your main hp",
			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 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 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 = RarityUtils.GetRarity("Legendary"),
			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 Daladas : CustomEffectCard<dalala>
	{
		internal static CardInfo card;

		public override CardDetails<dalala> Details => new CardDetails<dalala>
		{
			Title = "A bunch of legos",
			Description = "Everybody hates you",
			ModName = "KFC",
			Art = KFC.ArtAssets.LoadAsset<GameObject>("C_DalaDas"),
			Rarity = RarityUtils.GetRarity("Legendary"),
			Theme = (CardThemeColorType)1,
			OwnerOnly = true
		};

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			cardInfo.allowMultiple = false;
		}
	}
	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 = "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 or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Expected O, but got Unknown
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Expected O, but got Unknown
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Expected O, but got Unknown
				CardDetails val = new CardDetails();
				val.Title = "Might of Koala";
				val.Description = "You gain great strength";
				val.ModName = "KFC";
				val.Art = KFC.ArtAssets.LoadAsset<GameObject>("C_KoalaMight");
				val.Rarity = RarityUtils.GetRarity("Legendary");
				val.Theme = CardThemeLib.instance.CreateOrGetType("Koality", (CardThemeColor)null);
				val.Stats = (CardInfoStat[])(object)new CardInfoStat[6]
				{
					new CardInfoStat
					{
						amount = "<#ff00ff>+" + KFC.mysteryValue[2],
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Damage"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>+" + KFC.mysteryValue[2],
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Attack Speed"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>+" + KFC.mysteryValue[2],
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Reload Time"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>+" + KFC.mysteryValue[3],
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Percentage Damage"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>+8",
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Ammo"
					},
					new CardInfoStat
					{
						amount = "<#ff00ff>Reset",
						positive = true,
						simepleAmount = (SimpleAmount)0,
						stat = "Spread"
					}
				};
				return val;
			}
		}

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers)
		{
			cardInfo.categories = (CardCategory[])(object)new CardCategory[1] { CustomCardCategories.instance.CardCategory("cantEternity") };
			gun.damage = (float)KFC.mysteryValue[1];
			gun.attackSpeed = 1f / (float)KFC.mysteryValue[1];
			gun.reloadTime = 1f / (float)KFC.mysteryValue[1];
			gun.percentageDamage = ((float)KFC.mysteryValue[1] - 1f) / 3f;
			gun.ammo = 8;
		}

		protected override void Added(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			gun.spread = 0f;
		}

		public override bool GetEnabled()
		{
			return false;
		}
	}
	public class KoalaStats : CustomEffectCard<StatThief>
	{
		internal static CardInfo card;

		public override CardDetails<StatThief> 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 inv