using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using CardThemeLib;
using ClassesManagerReborn;
using ClassesManagerReborn.Util;
using CooldownUILib;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Extensions;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.RoundsEffects;
using ModdingUtils.Utils;
using MrFuntikMod.Cards;
using MrFuntikMod.Effects;
using MrFuntikMod.Extensions;
using MrFuntikMod.Helper;
using MrFuntikMod.MonoBehaviors;
using MrFuntikMod.MonoBehaviours;
using MrFuntikMod.Patches;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using Sonigon.Internal;
using SoundImplementation;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[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("MFM")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+339ce8822e544755b30c5e6c8e06e8b468f4c230")]
[assembly: AssemblyProduct("MFM")]
[assembly: AssemblyTitle("MFM")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace MrFuntikMod
{
	internal class Assets
	{
		private const string BUNDLE_IS = "isbundle";

		private const string BUNDLE_IS_V2 = "isbundlev2";

		private const string BUNDLE_DRON = "dron-asset-2";

		private const string BUNDLE_MFM = "myasset";

		private const string BUNDLE_BFRM = "bfrm";

		private static AssetBundle _bundle;

		private static AssetBundle _bundle2;

		private static AssetBundle _bundleDron;

		private static AssetBundle _bundleMFM;

		private static AssetBundle _bundleBFRM;

		private static bool _loadAttempted;

		private static readonly Dictionary<string, GameObject> _assetCache;

		private static readonly Dictionary<string, Sprite> _spriteCache;

		private static readonly Dictionary<string, AudioClip> _audioCache;

		public static GameObject StepBackArt => SafeLoadAsset(_bundle, "isbundle", "C_StepBack");

		public static GameObject BlackPillArt => SafeLoadAsset(_bundle, "isbundle", "C_BlackPill");

		public static GameObject GymBossArt => SafeLoadAsset(_bundle, "isbundle", "C_GymBoss");

		public static GameObject TakeAimArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_TakeAim");

		public static GameObject AllCardArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_AllCard");

		public static GameObject NothingArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_Nothing");

		public static GameObject SomethingArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_Something");

		public static GameObject ItBecomesAllArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_ItBecomesAll");

		public static GameObject FragileStrengthArt => SafeLoadAsset(_bundle2, "isbundlev2", "C_FragileStrength");

		public static GameObject KamikazeArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Kamikaze");

		public static GameObject SpeedDemonArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "С_Speed_Demon");

		public static GameObject QuickReloadArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_QuickReload");

		public static GameObject MinigunArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Minigun");

		public static GameObject PhoenixArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Phoenix");

		public static GameObject TankArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Tank");

		public static GameObject SprayArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Spray");

		public static GameObject FriendlyBounceArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_FriendlyBounce");

		public static GameObject JumperArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Jumper");

		public static GameObject HealMeArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_HealMe");

		public static GameObject ThornShieldArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_ThornShield");

		public static GameObject SmallButToughArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_SmallButTough");

		public static GameObject BulletTeleporterArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_BulletTeleporter");

		public static GameObject ComeToMeArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_ComeToMe");

		public static GameObject AntiradarArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Antiradar");

		public static GameObject RandomTeleportArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "С_RandomTeleport");

		public static GameObject DestroyerArt => SafeLoadAsset(_bundleDron, "dron-asset-2", "C_Destroyer");

		public static Sprite GunAsset => SafeLoadSprite(_bundleDron, "dron-asset-2", "Minigun-Gun");

		public static Sprite RedSquare => SafeLoadSprite(_bundleDron, "dron-asset-2", "RedSquare");

		public static GameObject MyBulletPrefab => SafeLoadAsset(_bundleDron, "dron-asset-2", "MyBullet");

		public static GameObject CHESS_KNIGHT_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CHESS_KNIGHT");

		public static GameObject Narcissism_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_narcissism");

		public static GameObject CHESS_PAWN_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CHESS_PAWN");

		public static GameObject CHESS_ROOK_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CHESS_ROOK");

		public static GameObject CHESS_BISHOP_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CHESS_BISHOP");

		public static GameObject unstable_gun_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_unstable_gun");

		public static GameObject NecroCardArt => SafeLoadAsset(_bundleMFM, "myasset", "C_necro_card");

		public static GameObject Necro2CardArt => SafeLoadAsset(_bundleMFM, "myasset", "C_necro2_card");

		public static GameObject Necro3CardArt => SafeLoadAsset(_bundleMFM, "myasset", "C_necro3_card");

		public static GameObject CHESS_QUEEN_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CHESS_QUEEN");

		public static GameObject VampireCastleArt => SafeLoadAsset(_bundleMFM, "myasset", "C_VAMPIRE_CASTLE");

		public static GameObject OneShotMan_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_ONESHOT_MAN");

		public static GameObject DrillHands_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_DRILL_HANDS");

		public static GameObject BounceConverter_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BOUNCE_CONVERTER");

		public static GameObject PhenomenalBalance_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_PHENOMENAL_BALANCE");

		public static GameObject BalanceBlock_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_BLOCK");

		public static GameObject BalanceTank_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_TANK");

		public static GameObject BalanceHitman_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_HITMAN");

		public static GameObject BalanceBullets_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_BULLETS");

		public static GameObject BalanceMayhem_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_MAYHEM");

		public static GameObject BalanceSpeed_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_SPEED");

		public static GameObject BalanceReload_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BALANCE_RELOAD");

		public static GameObject Dominion_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_DOMINION");

		public static GameObject AuraBloodRot_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_BLOOD_ROT");

		public static GameObject AuraBrokenBurstRot_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_BROKEN_BURST");

		public static GameObject AuraColdWater_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_COLD_WATER");

		public static GameObject AuraDeathSentence_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_DEATH_SENTENCE");

		public static GameObject AuraHeavyHands_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_HEAVY_HANDS");

		public static GameObject AuraOverheated_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_OVERHEATED");

		public static GameObject AuraSlowSleep_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_SLOW_SLEEP");

		public static GameObject AuraSoftRicochet_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_SOFT_RICOCHET");

		public static GameObject AuraWeakening_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AURA_WEAKENING");

		public static GameObject ThunderCode_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_THUNDER_CORE");

		public static GameObject EarthSpears_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_EARTHSPEARS");

		public static GameObject Dancer_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_DANCER");

		public static GameObject Momentum_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_MOMENTUM");

		public static GameObject Aegis_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_AEGIS");

		public static GameObject Immunize_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_IMMUNIZE");

		public static GameObject Rooted_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_ROOTED");

		public static GameObject SonicRiot_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_SONIC_RIOT");

		public static GameObject ControlledFire_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_CONTROLLED_FIRE");

		public static GameObject Unstoppable_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_UNSTOPPABLE");

		public static GameObject SaferyDetonator_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_SAFETY_DETONATOR");

		public static GameObject AntiRadar_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_ANTI_RADAR");

		public static GameObject Berserker_Art => SafeLoadAsset(_bundleMFM, "myasset", "C_BERSERKER");

		public static GameObject ExecutionerArt => SafeLoadAsset(_bundleBFRM, "bfrm", "C_EXECUTIONER");

		public static AudioClip ScorpionGetOverHereSound => SafeLoadAudioClip(_bundleBFRM, "bfrm", "scorpion_get_over_here");

		public static AudioClip DemRes1 => SafeLoadAudioClip(_bundleMFM, "myasset", "dem_res_1");

		public static AudioClip DemRes2 => SafeLoadAudioClip(_bundleMFM, "myasset", "dem_rev_2");

		public static AudioClip DemRes3 => SafeLoadAudioClip(_bundleMFM, "myasset", "dem_res_3");

		public static AudioClip DemRes4 => SafeLoadAudioClip(_bundleMFM, "myasset", "dem_res_4");

		public static AudioClip DemRes5 => SafeLoadAudioClip(_bundleMFM, "myasset", "dem_res_pontiff");

		static Assets()
		{
			_loadAttempted = false;
			_assetCache = new Dictionary<string, GameObject>();
			_spriteCache = new Dictionary<string, Sprite>();
			_audioCache = new Dictionary<string, AudioClip>();
		}

		public static void PreloadBundles()
		{
			LoadBundles();
		}

		private static void LoadBundles()
		{
			if (_loadAttempted)
			{
				return;
			}
			_loadAttempted = true;
			IEnumerable<AssetBundle> allLoadedAssetBundles = AssetBundle.GetAllLoadedAssetBundles();
			foreach (AssetBundle item in allLoadedAssetBundles)
			{
				if (((Object)item).name == "isbundle")
				{
					_bundle = item;
					MrFuntikMod.Log("[MFM][Assets] isbundle already loaded, reusing");
				}
				if (((Object)item).name == "isbundlev2")
				{
					_bundle2 = item;
					MrFuntikMod.Log("[MFM][Assets] isbundlev2 already loaded, reusing");
				}
				if (((Object)item).name == "dron-asset-2")
				{
					_bundleDron = item;
					MrFuntikMod.Log("[MFM][Assets] dron-asset-2 already loaded, reusing");
				}
				if (((Object)item).name == "myasset")
				{
					_bundleMFM = item;
					MrFuntikMod.Log("[MFM][Assets] myasset already loaded, reusing");
				}
				if (((Object)item).name == "bfrm")
				{
					_bundleBFRM = item;
					MrFuntikMod.Log("[MFM][Assets] bfrm already loaded, reusing");
				}
			}
			if ((Object)(object)_bundle == (Object)null)
			{
				try
				{
					_bundle = AssetUtils.LoadAssetBundleFromResources("isbundle", typeof(MrFuntikMod).Assembly);
				}
				catch (Exception ex)
				{
					MrFuntikMod.LogError("[MFM][Assets] FAILED to load isbundle: " + ex.Message);
				}
			}
			if ((Object)(object)_bundle2 == (Object)null)
			{
				try
				{
					_bundle2 = AssetUtils.LoadAssetBundleFromResources("isbundlev2", typeof(MrFuntikMod).Assembly);
				}
				catch (Exception ex2)
				{
					MrFuntikMod.LogError("[MFM][Assets] FAILED to load isbundlev2: " + ex2.Message);
				}
			}
			if ((Object)(object)_bundleDron == (Object)null)
			{
				try
				{
					_bundleDron = AssetUtils.LoadAssetBundleFromResources("dron-asset-2", typeof(MrFuntikMod).Assembly);
				}
				catch (Exception ex3)
				{
					MrFuntikMod.LogError("[MFM][Assets] FAILED to load dron-asset-2: " + ex3.Message);
				}
			}
			if ((Object)(object)_bundleMFM == (Object)null)
			{
				try
				{
					_bundleMFM = AssetUtils.LoadAssetBundleFromResources("myasset", typeof(MrFuntikMod).Assembly);
				}
				catch (Exception ex4)
				{
					MrFuntikMod.LogError("[MFM][Assets] FAILED to load myasset: " + ex4.Message);
				}
			}
			if (!((Object)(object)_bundleBFRM == (Object)null))
			{
				return;
			}
			try
			{
				_bundleBFRM = AssetUtils.LoadAssetBundleFromResources("bfrm", typeof(MrFuntikMod).Assembly);
			}
			catch (Exception ex5)
			{
				MrFuntikMod.LogError("[MFM][Assets] FAILED to load bfrm: " + ex5.Message);
			}
		}

		private static GameObject SafeLoadAsset(AssetBundle bundle, string bundleName, string assetName)
		{
			LoadBundles();
			string key = bundleName + ":" + assetName;
			if (_assetCache.TryGetValue(key, out GameObject value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				_assetCache.Remove(key);
			}
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject val = bundle.LoadAsset<GameObject>(assetName);
				if ((Object)(object)val == (Object)null)
				{
					MrFuntikMod.LogWarning("[MFM][Assets] Asset '" + assetName + "' not found in '" + bundleName + "'");
				}
				else
				{
					_assetCache[key] = val;
				}
				return val;
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[MFM][Assets] Exception loading '" + assetName + "': " + ex.Message);
				return null;
			}
		}

		private static Sprite SafeLoadSprite(AssetBundle bundle, string bundleName, string assetName)
		{
			LoadBundles();
			string key = bundleName + ":" + assetName;
			if (_spriteCache.TryGetValue(key, out Sprite value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				_spriteCache.Remove(key);
			}
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			try
			{
				Sprite val = bundle.LoadAsset<Sprite>(assetName);
				if ((Object)(object)val == (Object)null)
				{
					MrFuntikMod.LogWarning("[MFM][Assets] Sprite '" + assetName + "' not found in '" + bundleName + "'");
				}
				else
				{
					_spriteCache[key] = val;
				}
				return val;
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[MFM][Assets] Exception loading sprite '" + assetName + "': " + ex.Message);
				return null;
			}
		}

		private static AudioClip SafeLoadAudioClip(AssetBundle bundle, string bundleName, string assetName)
		{
			LoadBundles();
			string key = bundleName + ":" + assetName;
			if (_audioCache.TryGetValue(key, out AudioClip value))
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
				_audioCache.Remove(key);
			}
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			try
			{
				AudioClip val = bundle.LoadAsset<AudioClip>(assetName);
				if ((Object)(object)val == (Object)null)
				{
					MrFuntikMod.LogWarning("[MFM][Assets] AudioClip '" + assetName + "' not found in '" + bundleName + "'");
				}
				else
				{
					_audioCache[key] = val;
				}
				return val;
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[MFM][Assets] Exception loading AudioClip '" + assetName + "': " + ex.Message);
				return null;
			}
		}
	}
	internal static class ScreenEdgeBounceHelper
	{
		private static ObjectsToSpawn _cached;

		private static ObjectsToSpawn GetSpawnObject()
		{
			if (_cached != null)
			{
				return _cached;
			}
			try
			{
				IEnumerable<CardInfo> first = ((ObservableCollection<CardInfo>)typeof(CardManager).GetField("activeCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null)).ToList();
				List<CardInfo> second = (List<CardInfo>)typeof(CardManager).GetField("inactiveCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
				_cached = (from c in first.Concat(second)
					where ((Object)((Component)c).gameObject).name == "TargetBounce"
					select c).SelectMany((CardInfo c) => ((Component)c).GetComponent<Gun>().objectsToSpawn).FirstOrDefault((Func<ObjectsToSpawn, bool>)((ObjectsToSpawn o) => (Object)(object)o.AddToProjectile.GetComponent<ScreenEdgeBounce>() != (Object)null));
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[ScreenEdgeBounceHelper] Failed to get spawn object: " + ex.Message);
			}
			return _cached;
		}

		public static void Add(Gun gun)
		{
			ObjectsToSpawn spawnObject = GetSpawnObject();
			if (spawnObject != null)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				list.Add(spawnObject);
				gun.objectsToSpawn = list.ToArray();
			}
		}

		public static void Remove(Gun gun)
		{
			ObjectsToSpawn spawnObject = GetSpawnObject();
			if (spawnObject != null)
			{
				List<ObjectsToSpawn> list = gun.objectsToSpawn.ToList();
				if (list.Remove(spawnObject))
				{
					gun.objectsToSpawn = list.ToArray();
				}
			}
		}
	}
	internal class CardCheck : MonoBehaviour
	{
		public static readonly string[] AllowedModInitials = new string[4] { "BFRM", "MFM", "IS", "DRON" };

		public static int Amount(Player player, string cardName)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.data == (Object)null || player.data.currentCards == null)
			{
				return 0;
			}
			List<CardInfo> currentCards = player.data.currentCards;
			int num = 0;
			for (int num2 = currentCards.Count - 1; num2 >= 0; num2--)
			{
				if ((Object)(object)currentCards[num2] != (Object)null && currentCards[num2].cardName == cardName)
				{
					num++;
				}
			}
			return num;
		}

		public static int AmountFromAllowedMods(Player player, string cardName)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.data == (Object)null || player.data.currentCards == null)
			{
				return 0;
			}
			List<CardInfo> currentCards = player.data.currentCards;
			int num = 0;
			for (int num2 = currentCards.Count - 1; num2 >= 0; num2--)
			{
				CardInfo val = currentCards[num2];
				if ((Object)(object)val != (Object)null && val.cardName == cardName && IsFromAllowedMod(val))
				{
					num++;
				}
			}
			return num;
		}

		public static bool HasCardFromAllowedMods(Player player, string cardName)
		{
			return AmountFromAllowedMods(player, cardName) > 0;
		}

		public static bool IsFromAllowedMod(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return false;
			}
			string cardModName = GetCardModName(card);
			if (string.IsNullOrEmpty(cardModName))
			{
				return false;
			}
			for (int i = 0; i < AllowedModInitials.Length; i++)
			{
				if (cardModName == AllowedModInitials[i])
				{
					return true;
				}
			}
			return false;
		}

		private static string GetCardModName(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return null;
			}
			string cardName = card.cardName;
			if ((Object)(object)card.sourceCard != (Object)null)
			{
				cardName = card.sourceCard.cardName;
			}
			try
			{
				foreach (KeyValuePair<string, Card> card2 in CardManager.cards)
				{
					if ((Object)(object)card2.Value.cardInfo != (Object)null && card2.Value.cardInfo.cardName == cardName)
					{
						return card2.Value.category;
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public static class MapUtils
	{
		private static Scene mapScene;

		private static List<GameObject> mapObjects;

		public static void DestroyMapObject(GameObject gameObject)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			try
			{
				if (UpdateMapObjectsList())
				{
					string name = ((Scene)(ref mapScene)).name;
					Scene scene = gameObject.scene;
					if (name.Equals(((Scene)(ref scene)).name) && IsValidMapObject(gameObject))
					{
						Object.Destroy((Object)(object)gameObject);
					}
				}
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[MrFuntikMod] DestroyMapObject error: " + ex.Message);
			}
		}

		private static bool UpdateMapObjectsList()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (mapObjects != null)
				{
					mapObjects.Clear();
				}
				mapObjects = new List<GameObject>();
				if (SceneManager.sceneCount < 2)
				{
					return false;
				}
				mapScene = SceneManager.GetSceneAt(1);
				if (!((Scene)(ref mapScene)).IsValid())
				{
					return false;
				}
				GameObject[] rootGameObjects = ((Scene)(ref mapScene)).GetRootGameObjects();
				if (rootGameObjects.Length == 0)
				{
					return false;
				}
				GameObject val = rootGameObjects[0];
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val2 in array)
				{
					if (IsValidMapObject(((Component)val2).gameObject))
					{
						mapObjects.Add(((Component)val2).gameObject);
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				MrFuntikMod.LogError("[MrFuntikMod] UpdateMapObjectsList error: " + ex.Message);
				return false;
			}
		}

		private static bool IsValidMapObject(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null || !obj.activeInHierarchy)
			{
				return false;
			}
			Collider2D component = obj.GetComponent<Collider2D>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			SpriteRenderer component2 = obj.GetComponent<SpriteRenderer>();
			if ((Object)(object)component2 == (Object)null)
			{
				return false;
			}
			SFPolygon component3 = obj.GetComponent<SFPolygon>();
			if ((Object)(object)component3 != (Object)null && !((Behaviour)component3).isActiveAndEnabled)
			{
				return false;
			}
			return true;
		}
	}
	internal static class ElasticConfig
	{
		public const float BASE_MOVE_SPEED_MULT = 1.25f;

		public const float BASE_BOOST_DURATION = 5f;

		public const float BASE_BOOST_DAMAGE_MULT = 0.5f;

		public const float PAIN_FUEL_DURATION_PER_STACK = 2f;

		public const float RECOUP_HEAL_FRACTION = 0.25f;

		public const float RECOUP_HEAL_DELAY = 0.5f;

		public const float REFLEX_DAMAGE_PER_STACK = 0.5f;

		public const float PRESSURE_DAMAGE_PER_HIT = 0.2f;

		public const float PRESSURE_DAMAGE_MAX = 2f;

		public const float CADENCE_RELOAD_PER_HIT = 0.1f;

		public const float CADENCE_RELOAD_MIN = 0.2f;

		public const float PARRY_CD_PER_HIT = 0.1f;

		public const float PARRY_CD_MIN = 0.2f;

		public const float FRENZY_DURATION_PER_HIT = 1f;

		public const float FRENZY_BONUS_MAX = 5f;

		public const float ACCELERATE_SPEED_PER_HIT = 0.1f;

		public const float ACCELERATE_SPEED_MAX = 1.8f;

		public const float QUICKEN_ATTACK_SPEED_PER_HIT = 0.1f;

		public const float QUICKEN_ATTACK_SPEED_MIN = 0.2f;

		public const float RAPID_BULLET_SPEED_PER_HIT = 0.1f;

		public const float RAPID_BULLET_SPEED_MAX = 2f;

		public const float DEVOUR_LIFESTEAL_PER_HIT = 0.1f;

		public const float DEVOUR_LIFESTEAL_MAX = 1f;

		public const float FURY_DAMAGE_PER_STACK = 0.25f;

		public const float HASTE_ATTACK_SPEED_PER_STACK = 0.25f;

		public const float SURGE_BULLET_SPEED_PER_STACK = 0.5f;

		public const float ZEN_HP_PER_SECOND = 10f;

		public const float BLOODRUSH_LIFESTEAL_PER_STACK = 0.25f;

		public const float TEMPO_RELOAD_PER_STACK = 0.25f;

		public const float AEGIS_BLOCK_CD_PER_STACK = 0.25f;

		public const float RUSH_MOVE_SPEED_PER_STACK = 0.25f;

		public const float TRAIL_TIME = 0.45f;

		public const float TRAIL_START_WIDTH = 0.04f;

		public const float TRAIL_MIN_VERTEX = 0.03f;

		public const float TRAIL_ALPHA_START = 0.5f;

		public const float TRAIL_FLICKER_SPEED = 4f;

		public const float TRAIL_FLICKER_PHASE = 1.2f;
	}
	public static class PhoenixSurgeHelper
	{
		public static bool HasKamikaze(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)player).gameObject.GetComponent<KamikazeMono>() != (Object)null;
		}

		public static void CheckUnlockPhoenixSurge(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (HasKamikaze(player) && blacklistedCategories.Contains(MrFuntikMod.PhoenixSurgeCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.PhoenixSurgeCategory);
				}
			}
		}

		public static void CheckLockPhoenixSurge(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.PhoenixSurgeCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.PhoenixSurgeCategory);
				}
			}
		}
	}
	public static class VengefulSparkConfig
	{
		public const float DAMAGE_REFLECT_PERCENT = 0.3f;

		public const float MIN_DAMAGE_THRESHOLD = 3f;

		public const float COOLDOWN = 0.5f;
	}
	public static class ArcFieldHelper
	{
		public static bool HasThunderCore(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			MonoBehaviour[] components = ((Component)player).gameObject.GetComponents<MonoBehaviour>();
			MonoBehaviour[] array = components;
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name == "ElectricBulletEffect")
				{
					return true;
				}
			}
			return CardCheck.HasCardFromAllowedMods(player, "Thunder Core");
		}

		public static bool HasPlanet(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			MonoBehaviour[] components = ((Component)player).gameObject.GetComponents<MonoBehaviour>();
			MonoBehaviour[] array = components;
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name == "GravityFieldMono")
				{
					return true;
				}
			}
			return CardCheck.HasCardFromAllowedMods(player, "Planet");
		}

		public static void CheckUnlockArcField(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				bool flag = HasThunderCore(player);
				bool flag2 = HasPlanet(player);
				if (flag && flag2 && blacklistedCategories.Contains(MrFuntikMod.ArcFieldCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.ArcFieldCategory);
				}
			}
		}

		public static void CheckLockArcField(Player player, string removingComponent)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
			bool flag = HasThunderCore(player);
			bool flag2 = HasPlanet(player);
			if (removingComponent == "ThunderCore")
			{
				int num = CardCheck.AmountFromAllowedMods(player, "Thunder Core");
				if (num <= 1)
				{
					flag = false;
				}
			}
			if (removingComponent == "Planet")
			{
				int num2 = CardCheck.AmountFromAllowedMods(player, "Planet");
				if (num2 <= 1)
				{
					flag2 = false;
				}
			}
			if ((!flag || !flag2) && !blacklistedCategories.Contains(MrFuntikMod.ArcFieldCategory))
			{
				blacklistedCategories.Add(MrFuntikMod.ArcFieldCategory);
			}
		}
	}
	public static class GravitySurgeHelper
	{
		public static bool HasPlanet(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			MonoBehaviour[] components = ((Component)player).gameObject.GetComponents<MonoBehaviour>();
			MonoBehaviour[] array = components;
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name == "GravityFieldMono")
				{
					return true;
				}
			}
			return CardCheck.HasCardFromAllowedMods(player, "Planet");
		}

		public static void CheckUnlockGravitySurge(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (HasPlanet(player) && blacklistedCategories.Contains(MrFuntikMod.GravitySurgeCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.GravitySurgeCategory);
				}
			}
		}

		public static void CheckLockGravitySurge(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.GravitySurgeCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.GravitySurgeCategory);
				}
			}
		}

		public static void CheckLockGravitySurgeOnStackRemove(Player player, bool isLastStack)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int num = CardCheck.AmountFromAllowedMods(player, "Planet");
			if (num <= 1)
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.GravitySurgeCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.GravitySurgeCategory);
				}
			}
		}
	}
	public static class ImmunityHelper
	{
		private static CardCategory _immunityCategory;

		private static CardCategory ImmunityCategory
		{
			get
			{
				if ((Object)(object)_immunityCategory == (Object)null)
				{
					_immunityCategory = CustomCardCategories.instance.CardCategory("ImmunityCards");
				}
				return _immunityCategory;
			}
		}

		public static int CountImmunityCards(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.data == (Object)null || player.data.currentCards == null)
			{
				return 0;
			}
			int num = 0;
			foreach (CardInfo currentCard in player.data.currentCards)
			{
				if (!((Object)(object)currentCard == (Object)null) && currentCard.categories != null && currentCard.categories.Contains(ImmunityCategory) && CardCheck.IsFromAllowedMod(currentCard))
				{
					num++;
				}
			}
			return num;
		}

		public static void CheckUnlockImmunityMaster(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				int num = CountImmunityCards(player) + 1;
				if (num >= 2 && blacklistedCategories.Contains(MrFuntikMod.ImmunityMasterCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.ImmunityMasterCategory);
				}
			}
		}

		public static void CheckLockImmunityMaster(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				int num = CountImmunityCards(player) - 1;
				if (num < 2 && !blacklistedCategories.Contains(MrFuntikMod.ImmunityMasterCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.ImmunityMasterCategory);
				}
			}
		}
	}
	public static class RollbackHelper
	{
		public static bool HasBacktrack(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return (Object)(object)((Component)player).gameObject.GetComponent<BacktrackMono>() != (Object)null;
		}

		public static void CheckUnlockRollback(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (HasBacktrack(player) && blacklistedCategories.Contains(MrFuntikMod.RollbackCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.RollbackCategory);
				}
			}
		}

		public static void CheckLockRollback(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				BacktrackMono component = ((Component)player).gameObject.GetComponent<BacktrackMono>();
				bool flag = false;
				if (!blacklistedCategories.Contains(MrFuntikMod.RollbackCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.RollbackCategory);
				}
			}
		}

		public static void CheckLockRollbackOnStackRemove(Player player, bool isLastStack)
		{
			if (!((Object)(object)player == (Object)null) && isLastStack)
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.RollbackCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.RollbackCategory);
				}
			}
		}
	}
	public static class ScorchHelper
	{
		public static bool HasBlazingTrail(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			MonoBehaviour[] components = ((Component)player).gameObject.GetComponents<MonoBehaviour>();
			MonoBehaviour[] array = components;
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name == "BlazingTrailEffect")
				{
					return true;
				}
			}
			return CardCheck.HasCardFromAllowedMods(player, "Blazing Trail");
		}

		public static void CheckUnlockScorch(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (HasBlazingTrail(player) && blacklistedCategories.Contains(MrFuntikMod.ScorchCategory))
				{
					blacklistedCategories.Remove(MrFuntikMod.ScorchCategory);
				}
			}
		}

		public static void CheckLockScorch(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.ScorchCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.ScorchCategory);
				}
			}
		}

		public static void CheckLockScorchOnStackRemove(Player player, bool isLastStack)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int num = CardCheck.AmountFromAllowedMods(player, "Blazing Trail");
			if (num <= 1)
			{
				List<CardCategory> blacklistedCategories = CharacterStatModifiersExtension.GetAdditionalData(player.data.stats).blacklistedCategories;
				if (!blacklistedCategories.Contains(MrFuntikMod.ScorchCategory))
				{
					blacklistedCategories.Add(MrFuntikMod.ScorchCategory);
				}
			}
		}
	}
	[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.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.MrseFuntik.Rounds.MFM", "MrFuntikMod", "3.4.0")]
	[BepInProcess("Rounds.exe")]
	public class MrFuntikMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <GameStart>d__47 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public MrFuntikMod <>4__this;

			private List<Player>.Enumerator <>s__1;

			private Player <player>5__2;

			private GravitySurgeMono <gravitySurge>5__3;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				ImmunityAntiRadarCard.ClearCache();
				DeathDefyMono.ClearStaticData();
				ExecutionerMono.ClearPendingExecutions();
				BurnEffectManager.ClearAll();
				NothingTimerManager.ClearAll();
				LootRunnerManager.ClearPointEffects();
				BombermanMine.ClearAllLocal();
				OneCutManager.Reset();
				<>s__1 = PlayerManager.instance.players.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<player>5__2 = <>s__1.Current;
						<gravitySurge>5__3 = ((Component)<player>5__2).GetComponent<GravitySurgeMono>();
						if ((Object)(object)<gravitySurge>5__3 != (Object)null)
						{
							<gravitySurge>5__3.ResetState();
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ImmunityCards))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ImmunityCards);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ImmunityMasterCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ImmunityMasterCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ArcFieldCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ArcFieldCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(GravitySurgeCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(GravitySurgeCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(AuraCards))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(AuraCards);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(AuraMasterCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(AuraMasterCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(RollbackCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(RollbackCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ScorchCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ScorchCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(PhoenixSurgeCategory))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(PhoenixSurgeCategory);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ResetCards))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ResetCards);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(ElasticSubCards))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(ElasticSubCards);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(BloodPactSubCards))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(BloodPactSubCards);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(NecroCard2))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(NecroCard2);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(NecroCard3))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(NecroCard3);
						}
						if (!CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Contains(BalanceCard))
						{
							CharacterStatModifiersExtension.GetAdditionalData(<player>5__2.data.stats).blacklistedCategories.Add(BalanceCard);
						}
						((Component)<player>5__2).gameObject.AddComponent<MFMBalanceMono>();
						<gravitySurge>5__3 = null;
						<player>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Player>.Enumerator);
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ResetEffects>d__41 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public MrFuntikMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				NothingTimerManager.ClearAll();
				LootRunnerManager.ClearPointEffects();
				<>4__this.DestroyAll<NothingMono>();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ResetPointEffects>d__42 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public MrFuntikMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.DestroyAll<NothingMono>();
				<>4__this.DestroyAll<TeleportGhostEffect>();
				<>4__this.DestroyAll<TeleportWaveEffect>();
				<>4__this.DestroyAll<CircleWaveEffect>();
				<>4__this.DestroyAll<EarthspearsEffect>();
				<>4__this.DestroyAll<ReaperSoulEffect>();
				<>4__this.DestroyAll<ElectricBulletEffect>();
				<>4__this.DestroyAll<VengefulSparkEffect>();
				<>4__this.DestroyAll<ExecutionerBullet>();
				<>4__this.DestroyAll<LastChanceBulletMono>();
				<>4__this.ClearSunStrikeEffects();
				BombermanMine.ClearAllLocal();
				LootRunnerManager.ClearPointEffects();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

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

		private const string ModName = "MrFuntikMod";

		public const string Version = "3.4.0";

		public const string ModInitials = "MFM";

		public const bool DebugLogs = false;

		internal static ManualLogSource ModLogger;

		internal static CardCategory NonBalanceCard;

		internal static CardCategory BalanceCard;

		internal static CardCategory NonNecroCard;

		internal static CardCategory NecroCard2;

		internal static CardCategory NecroCard3;

		internal static CardCategory NonImmunityCards;

		internal static CardCategory ImmunityCards;

		internal static CardCategory ImmunityMasterCategory;

		internal static CardCategory AuraMasterCategory;

		internal static CardCategory ArcFieldCategory;

		internal static CardCategory GravitySurgeCategory;

		internal static CardCategory NonAuraCards;

		internal static CardCategory AuraCards;

		internal static CardCategory RollbackCategory;

		internal static CardCategory ScorchCategory;

		internal static CardCategory PhoenixSurgeCategory;

		internal static CardCategory ResetCards;

		internal static CardCategory NonResetCards;

		internal static CardCategory ElasticSubCards;

		internal static CardCategory NonElasticCards;

		internal static CardCategory ElasticClassCategory;

		internal static CardCategory BloodPactClassCategory;

		internal static CardCategory BloodPactSubCards;

		internal static CardCategory NonBloodPactCards;

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

		private Harmony harmony;

		public static MrFuntikMod instance { get; private set; }

		public static void Log(string msg)
		{
			bool flag = false;
		}

		public static void LogWarning(string msg)
		{
			bool flag = false;
		}

		public static void LogError(string msg)
		{
			bool flag = false;
		}

		private void Awake()
		{
			//IL_0025: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			ModLogger = ((BaseUnityPlugin)this).Logger;
			RarityUtils.AddRarity("Hidden", 1f, new Color(0.85f, 0.5f, 0.35f), new Color(0.45f, 0.25f, 0.15f));
			CardThemeLib.instance.CreateOrGetType("Hidden", new CardThemeColor
			{
				bgColor = new Color(0.15f, 0.1f, 0.08f),
				targetColor = new Color(0.85f, 0.5f, 0.35f)
			});
			RarityUtils.AddRarity("NecroCards", 0.11f, new Color(0.96f, 0.188f, 0.188f), new Color(0.96f, 0.188f, 0.188f));
			harmony = new Harmony("com.MrseFuntik.Rounds.MFM");
			harmony.PatchAll();
		}

		private void Start()
		{
			Assets.PreloadBundles();
			AntiSlowExternalModsPatch.ApplyPatches(harmony);
			NonNecroCard = CustomCardCategories.instance.CardCategory("NonNecroCard");
			NecroCard2 = CustomCardCategories.instance.CardCategory("NecroCard2");
			NecroCard3 = CustomCardCategories.instance.CardCategory("NecroCard3");
			NonBalanceCard = CustomCardCategories.instance.CardCategory("NonBalanceCard");
			BalanceCard = CustomCardCategories.instance.CardCategory("BalanceCard");
			NonImmunityCards = CustomCardCategories.instance.CardCategory("NonImmunityCards");
			ImmunityCards = CustomCardCategories.instance.CardCategory("ImmunityCards");
			ImmunityMasterCategory = CustomCardCategories.instance.CardCategory("ImmunityMasterCategory");
			AuraMasterCategory = CustomCardCategories.instance.CardCategory("AuraMasterCategory");
			ArcFieldCategory = CustomCardCategories.instance.CardCategory("ArcFieldCategory");
			GravitySurgeCategory = CustomCardCategories.instance.CardCategory("GravitySurgeCategory");
			NonAuraCards = CustomCardCategories.instance.CardCategory("NonAuraCards");
			AuraCards = CustomCardCategories.instance.CardCategory("AuraCards");
			RollbackCategory = CustomCardCategories.instance.CardCategory("RollbackCategory");
			ScorchCategory = CustomCardCategories.instance.CardCategory("ScorchCategory");
			PhoenixSurgeCategory = CustomCardCategories.instance.CardCategory("PhoenixSurgeCategory");
			ResetCards = CustomCardCategories.instance.CardCategory("ResetCards");
			NonResetCards = CustomCardCategories.instance.CardCategory("NonResetCards");
			ElasticSubCards = CustomCardCategories.instance.CardCategory("ElasticSubCards");
			NonElasticCards = CustomCardCategories.instance.CardCategory("NonElasticCards");
			ElasticClassCategory = CustomCardCategories.instance.CardCategory("ElasticClassCategory");
			BloodPactClassCategory = CustomCardCategories.instance.CardCategory("BloodPactClassCategory");
			BloodPactSubCards = CustomCardCategories.instance.CardCategory("BloodPactSubCards");
			NonBloodPactCards = CustomCardCategories.instance.CardCategory("NonBloodPactCards");
			instance = this;
			DeathDefyHandler.RegisterHooks();
			CustomCard.BuildCard<WeakenedDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<SoftRicochetDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<ColdWaterDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<HeavyHandsDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<OverheatedDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<DeathSentenceDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<BrokenBurstDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<BloodRotDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<SlowStepDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<SuppressionDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_1>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_2>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_3>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_4>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_5>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_6>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<AmmoDrop_Bonus_7>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<KineticArmorCard>();
			CustomCard.BuildCard<SwapStrikeCard>();
			CustomCard.BuildCard<FalloffForceCard>();
			CustomCard.BuildCard<SurpriseGiftCard>();
			CustomCard.BuildCard<LootRunnerCard>();
			CustomCard.BuildCard<DuplicateCard>();
			CustomCard.BuildCard<TrafficLightCard>();
			CustomCard.BuildCard<AmmoDropCard>();
			CustomCard.BuildCard<RicochetPowerCard>();
			CustomCard.BuildCard<PlanetCard>();
			CustomCard.BuildCard<BlazingTrailCard>();
			CustomCard.BuildCard<ScorchCard>();
			CustomCard.BuildCard<SoulPiercerCard>();
			CustomCard.BuildCard<DeathDefyCard>();
			CustomCard.BuildCard<FadeoutCard>();
			CustomCard.BuildCard<ExtendedGuardCard>();
			CustomCard.BuildCard<ExecutionerCard>();
			CustomCard.BuildCard<ReaperCard>();
			CustomCard.BuildCard<ScorpionCard>();
			CustomCard.BuildCard<SunStrikeCard>();
			CustomCard.BuildCard<BounceSplitCard>();
			CustomCard.BuildCard<VengefulSparkCard>();
			CustomCard.BuildCard<LifeBetCard>();
			CustomCard.BuildCard<HexReboundCard>();
			CustomCard.BuildCard<FinisherCard>();
			CustomCard.BuildCard<SidePortalCard>();
			CustomCard.BuildCard<ThunderCoreCard>();
			CustomCard.BuildCard<EarthspearsCard>();
			CustomCard.BuildCard<DancerCard>();
			CustomCard.BuildCard<AegisCard>();
			CustomCard.BuildCard<BombermanCard>();
			CustomCard.BuildCard<BerserkerCard>();
			CustomCard.BuildCard<LastChanceCard>();
			CustomCard.BuildCard<PhoenixSurgeCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<ArcFieldCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				ArcFieldCard.cardInfoSelf = cardInfo;
			});
			CustomCard.BuildCard<GravitySurgeCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				GravitySurgeCard.cardInfoSelf = cardInfo;
			});
			CustomCard.BuildCard<BacktrackCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				BacktrackCard.cardInfoSelf = cardInfo;
			});
			CustomCard.BuildCard<RollbackCard>();
			CustomCard.BuildCard<DominionCard>();
			CustomCard.BuildCard<AuraWeakeningCard>();
			CustomCard.BuildCard<AuraSoftRicochetCard>();
			CustomCard.BuildCard<AuraColdWaterCard>();
			CustomCard.BuildCard<AuraHeavyHandsCard>();
			CustomCard.BuildCard<AuraOverheatedCard>();
			CustomCard.BuildCard<AuraDeathSentenceCard>();
			CustomCard.BuildCard<AuraBrokenBurstCard>();
			CustomCard.BuildCard<AuraBloodRotCard>();
			CustomCard.BuildCard<AuraSlowStepCard>();
			CustomCard.BuildCard<AuraSuppressionCard>();
			CustomCard.BuildCard<CalibrateCard>();
			CustomCard.BuildCard<CalibrateBulletSpreadCard>();
			CustomCard.BuildCard<CalibrateSizeCard>();
			CustomCard.BuildCard<CalibrateBouncesCard>();
			CustomCard.BuildCard<CalibrateMovementSpeedCard>();
			CustomCard.BuildCard<CalibrateDamageCard>();
			CustomCard.BuildCard<CalibrateAmmoCard>();
			CustomCard.BuildCard<CalibrateBulletRangeCard>();
			CustomCard.BuildCard<CalibrateBulletSpeedCard>();
			CustomCard.BuildCard<CalibrateReloadSpeedCard>();
			CustomCard.BuildCard<CalibrateBlockCooldownCard>();
			CustomCard.BuildCard<CalibrateBulletGravityCard>();
			CustomCard.BuildCard<CalibrateJumpHeightCard>();
			CustomCard.BuildCard<CalibrateHPCard>();
			CustomCard.BuildCard<CalibrateAttackSpeedCard>();
			CustomCard.BuildCard<CalibrateGravityCard>();
			CustomCard.BuildCard<ImmunizeCard>();
			CustomCard.BuildCard<ImmunityMomentumCard>();
			CustomCard.BuildCard<ImmunityUnstoppableCard>();
			CustomCard.BuildCard<ImmunityRootedCard>();
			CustomCard.BuildCard<ImmunitySonicRiotCard>();
			CustomCard.BuildCard<ImmunitySafetyDetonatorCard>();
			CustomCard.BuildCard<ImmunityAntiRadarCard>();
			CustomCard.BuildCard<ImmunityBorderlineCard>();
			CustomCard.BuildCard<ImmunityControlledFireCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				ImmunityControlledFireCard.cardInfoSelf = cardInfo;
			});
			CustomCard.BuildCard<BloodPactCard>();
			CustomCard.BuildCard<BloodPactOfferingCard>();
			CustomCard.BuildCard<BPHemorrhageCard>();
			CustomCard.BuildCard<BPSurgeCard>();
			CustomCard.BuildCard<BPSwiftCard>();
			CustomCard.BuildCard<BPPredatorCard>();
			CustomCard.BuildCard<BPVolleyCard>();
			CustomCard.BuildCard<BPRicochetCard>();
			CustomCard.BuildCard<BPTorrentCard>();
			CustomCard.BuildCard<BPPierceCard>();
			CustomCard.BuildCard<BPBloodbathCard>();
			CustomCard.BuildCard<BPOverdrawCard>();
			CustomCard.BuildCard<BPFirstBloodCard>();
			CustomCard.BuildCard<BPFocusCard>();
			CustomCard.BuildCard<BPExecuteCard>();
			CustomCard.BuildCard<BPBloodDebtCard>();
			CustomCard.BuildCard<BPChainCard>();
			CustomCard.BuildCard<BPSealCard>();
			CustomCard.BuildCard<BPBloodFrenzyCard>();
			CustomCard.BuildCard<BPBloodTributeCard>();
			CustomCard.BuildCard<ElasticCard>();
			CustomCard.BuildCard<ElasticChargeCard>();
			CustomCard.BuildCard<ElasticPainFuelCard>();
			CustomCard.BuildCard<ElasticReflexCard>();
			CustomCard.BuildCard<ElasticParryCard>();
			CustomCard.BuildCard<ElasticFuryCard>();
			CustomCard.BuildCard<ElasticHasteCard>();
			CustomCard.BuildCard<ElasticSurgeCard>();
			CustomCard.BuildCard<ElasticPressureCard>();
			CustomCard.BuildCard<ElasticRecoupCard>();
			CustomCard.BuildCard<ElasticCadenceCard>();
			CustomCard.BuildCard<ElasticZenCard>();
			CustomCard.BuildCard<ElasticFrenzyCard>();
			CustomCard.BuildCard<ElasticBloodrushCard>();
			CustomCard.BuildCard<ElasticAccelerateCard>();
			CustomCard.BuildCard<ElasticQuickenCard>();
			CustomCard.BuildCard<ElasticRapidCard>();
			CustomCard.BuildCard<ElasticDevourCard>();
			CustomCard.BuildCard<ElasticTempoCard>();
			CustomCard.BuildCard<ElasticAegisCard>();
			CustomCard.BuildCard<ElasticRushCard>();
			CustomCard.BuildCard<StepBackCard>();
			CustomCard.BuildCard<BlackPillBlessingCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<BlackPillCurseCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<BlackPillCard>();
			CustomCard.BuildCard<GymBossCard>();
			CustomCard.BuildCard<TakeAimCard>();
			CustomCard.BuildCard<NothingCard>();
			CustomCard.BuildCard<ItBecomesAllCard>();
			CustomCard.BuildCard<FragileStrengthCard>();
			CustomCard.BuildCard<AllCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<SomethingCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<BulletTeleporterCard>();
			CustomCard.BuildCard<ComeToMeCard>();
			CustomCard.BuildCard<DestroyerCard>();
			CustomCard.BuildCard<FriendlyBounceCard>();
			CustomCard.BuildCard<JumperCard>();
			CustomCard.BuildCard<MinigunCard>();
			CustomCard.BuildCard<PhoenixCard>();
			CustomCard.BuildCard<HealMeCard>();
			CustomCard.BuildCard<KamikazeCard>();
			CustomCard.BuildCard<RandomTeleportCard>();
			CustomCard.BuildCard<SmallButToughCard>();
			CustomCard.BuildCard<SpeedDemonCard>();
			CustomCard.BuildCard<SprayCard>();
			CustomCard.BuildCard<TankCard>();
			CustomCard.BuildCard<ThornShieldCard>();
			CustomCard.BuildCard<ChessPawn>();
			CustomCard.BuildCard<ChessKnightCard>();
			CustomCard.BuildCard<ChessRookCard>();
			CustomCard.BuildCard<ChessBishopCard>();
			CustomCard.BuildCard<ChessQueenCard>();
			CustomCard.BuildCard<NARCISSISM>();
			CustomCard.BuildCard<UnstableGunCard>();
			CustomCard.BuildCard<VampireCastleCard>();
			CustomCard.BuildCard<OneShotManCard>();
			CustomCard.BuildCard<DrillHands>();
			CustomCard.BuildCard<BounceConverter>();
			CustomCard.BuildCard<PhenomenalBalance>();
			CustomCard.BuildCard<BalanceBlock>();
			CustomCard.BuildCard<BalanceHitman>();
			CustomCard.BuildCard<BalanceBullets>();
			CustomCard.BuildCard<BalanceMayhem>();
			CustomCard.BuildCard<BalanceReload>();
			CustomCard.BuildCard<BalanceSpeed>();
			CustomCard.BuildCard<BalanceTank>();
			CustomCard.BuildCard<Necronomicon_I>();
			CustomCard.BuildCard<Necronomicon_II>();
			CustomCard.BuildCard<Necronomicon_II_b>();
			CustomCard.BuildCard<Necronomicon_II_c>();
			CustomCard.BuildCard<Necronomicon_II_d>();
			CustomCard.BuildCard<Necronomicon_II_e>();
			CustomCard.BuildCard<Necronomicon_III>();
			CustomCard.BuildCard<Necronomicon_III_b>();
			CustomCard.BuildCard<Necronomicon_III_c>();
			CustomCard.BuildCard<Necronomicon_III_d>();
			CustomCard.BuildCard<Necronomicon_III_e>();
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => BloodPactOfferingCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ElasticChargeCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => CalibrateCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ImmunizeCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => DominionCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => OneCutCard.ExtraPicks()));
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => PhenomenalBalance.ExtraPicks()));
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
			GameModeManager.AddHook("GameEnd", (Func<IGameModeHandler, IEnumerator>)ResetEffects);
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)ResetEffects);
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)BlazingTrailCard.RepairAllEffects);
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => LootRunnerManager.StartPointEffects()));
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)ResetPointEffects);
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)instance, 1f, (Action)delegate
			{
				foreach (Card value in CardManager.cards.Values)
				{
					if (!value.cardInfo.categories.Contains(ImmunityCards))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonImmunityCards);
					}
					if (!value.cardInfo.categories.Contains(AuraCards))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonAuraCards);
					}
					if (!value.cardInfo.categories.Contains(ResetCards))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonResetCards);
					}
					if (!value.cardInfo.categories.Contains(ElasticSubCards))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonElasticCards);
					}
					if (!value.cardInfo.categories.Contains(BloodPactSubCards))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonBloodPactCards);
					}
					if (!value.cardInfo.categories.Contains(NecroCard2) && !value.cardInfo.categories.Contains(NecroCard3))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonNecroCard);
					}
					if (!value.cardInfo.categories.Contains(BalanceCard))
					{
						value.cardInfo.categories = CollectionExtensions.AddToArray<CardCategory>(value.cardInfo.categories, NonBalanceCard);
					}
				}
			});
		}

		[IteratorStateMachine(typeof(<ResetEffects>d__41))]
		private IEnumerator ResetEffects(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResetEffects>d__41(0)
			{
				<>4__this = this,
				gm = gm
			};
		}

		[IteratorStateMachine(typeof(<ResetPointEffects>d__42))]
		private IEnumerator ResetPointEffects(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ResetPointEffects>d__42(0)
			{
				<>4__this = this,
				gm = gm
			};
		}

		private void ClearSunStrikeEffects()
		{
			DestroyGameObjectsWith<SunStrikeWarningEffect>();
			DestroyGameObjectsWith<SunStrikeImpactEffect>();
			DestroyGameObjectsWith<SunStrikeAfterglowEffect>();
			DestroyNamedSunStrikeObjects();
		}

		private void DestroyAll<T>() where T : Object
		{
			T[] array = Object.FindObjectsOfType<T>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)array[num]);
			}
		}

		private void DestroyGameObjectsWith<T>() where T : Component
		{
			T[] array = Object.FindObjectsOfType<T>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				if ((Object)(object)array[num] != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array[num]).gameObject);
				}
			}
		}

		private void DestroyNamedSunStrikeObjects()
		{
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				GameObject val = array[num];
				if ((Object)(object)val != (Object)null && ((Object)val).name.StartsWith("SunStrike_", StringComparison.Ordinal))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		[IteratorStateMachine(typeof(<GameStart>d__47))]
		private IEnumerator GameStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GameStart>d__47(0)
			{
				<>4__this = this,
				gm = gm
			};
		}
	}
}
namespace MrFuntikMod.Helper
{
	public static class BFRMSoundHelper
	{
		private static readonly SoundParameterIntensity SoundIntensity = new SoundParameterIntensity(1f, (UpdateMode)1);

		private static AudioSource _audioSource;

		private static AudioClip _lootRunnerPickClip;

		private static AudioClip _scorpionGetOverHereClip;

		public static void PlayLootRunnerPick(Player player)
		{
			Log("Loot Runner pick sound requested.");
			PlayUnityLootSoundDelayed(player, 0.05f);
		}

		public static void PlayScorpionGetOverHere(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				AudioClip val = Assets.ScorpionGetOverHereSound;
				if ((Object)(object)val == (Object)null)
				{
					val = GetScorpionGetOverHereClip();
				}
				PlayAudioClip2D(val, 0.8f, "Scorpion get-over-here");
			}
		}

		private static void PlayUnityLootSoundDelayed(Player player, float delay)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)MrFuntikMod.instance == (Object)null))
			{
				ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)MrFuntikMod.instance, delay, (Action)delegate
				{
					PlayUnity2DSound(0.5f);
				});
			}
		}

		private static void PlayNecronomiconStyleSoundDelayed(Player player, float delay)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)MrFuntikMod.instance == (Object)null))
			{
				int playerId = player.playerID;
				ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)MrFuntikMod.instance, delay, (Action)delegate
				{
					Player val = FindPlayer(playerId);
					Transform target = (((Object)(object)val != (Object)null) ? ((Component)val).transform : ((Component)MrFuntikMod.instance).transform);
					PlayNecronomiconStyleSound(target);
				});
			}
		}

		private static void PlayNecronomiconStyleSound(Transform target)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || (Object)(object)SoundManager.Instance == (Object)null)
			{
				Log("Necronomicon-style sound unavailable: missing target or SoundManager.");
				return;
			}
			AudioClip demRes = Assets.DemRes1;
			if ((Object)(object)demRes == (Object)null)
			{
				Log("Necronomicon-style sound unavailable: Assets.DemRes1 is null.");
				return;
			}
			SoundContainer val = ScriptableObject.CreateInstance<SoundContainer>();
			val.audioClip[0] = demRes;
			val.setting.volumeIntensityEnable = true;
			SoundEvent val2 = ScriptableObject.CreateInstance<SoundEvent>();
			val2.soundContainerArray[0] = val;
			SoundParameterIntensity val3 = new SoundParameterIntensity(0.5f, (UpdateMode)0);
			val3.intensity = target.localScale.x * Optionshandler.vol_Master * Optionshandler.vol_Sfx / 1.2f * 1.15f;
			SoundManager.Instance.Play(val2, target, (SoundParameterBase[])(object)new SoundParameterBase[1] { (SoundParameterBase)val3 });
			Log("Necronomicon-style DemRes1 sound played.");
		}

		private static void PlayPlayerSpawnSoundDelayed(Player player, float delay, float volume)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)MrFuntikMod.instance == (Object)null)
			{
				return;
			}
			int playerId = player.playerID;
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)MrFuntikMod.instance, delay, (Action)delegate
			{
				Player val = FindPlayer(playerId);
				object obj;
				if (!((Object)(object)val != (Object)null))
				{
					SoundManager instance = SoundManager.Instance;
					obj = ((instance != null) ? instance.GetTransform() : null);
				}
				else
				{
					obj = ((Component)val).transform;
				}
				Transform target = (Transform)obj;
				PlayUnity2DSound(1f);
				PlayPlayerSpawnSound(val, target, volume);
			});
		}

		private static void PlayPlayerSpawnSound(Player player, Transform target, float volume)
		{
			if (!((Object)(object)SoundManager.Instance == (Object)null) && !((Object)(object)target == (Object)null))
			{
				SoundEvent playerSpawnSound = GetPlayerSpawnSound(player);
				if ((Object)(object)playerSpawnSound == (Object)null)
				{
					Log("Player spawn sound was not available.");
					return;
				}
				SoundIntensity.intensity = volume * Optionshandler.vol_Master * Optionshandler.vol_Sfx;
				SoundManager.Instance.Play(playerSpawnSound, target, (SoundParameterBase[])(object)new SoundParameterBase[1] { (SoundParameterBase)SoundIntensity });
				Log("Sonigon player spawn sound played.");
			}
		}

		private static void PlayUnity2DSound(float volume)
		{
			AudioSource audioSource = GetAudioSource();
			AudioClip lootRunnerPickClip = GetLootRunnerPickClip();
			PlayAudioClip2D(lootRunnerPickClip, volume, "Unity 2D loot");
		}

		private static void PlayAudioClip2D(AudioClip clip, float volume, string label)
		{
			AudioSource audioSource = GetAudioSource();
			if ((Object)(object)audioSource == (Object)null || (Object)(object)clip == (Object)null)
			{
				Log(label + " sound unavailable.");
				return;
			}
			audioSource.volume = Mathf.Clamp01(volume);
			audioSource.PlayOneShot(clip, Mathf.Clamp01(volume));
			Log(label + " sound played.");
		}

		private static AudioSource GetAudioSource()
		{
			if ((Object)(object)_audioSource != (Object)null)
			{
				return _audioSource;
			}
			if ((Object)(object)MrFuntikMod.instance == (Object)null)
			{
				return null;
			}
			_audioSource = ((Component)MrFuntikMod.instance).gameObject.GetComponent<AudioSource>();
			if ((Object)(object)_audioSource == (Object)null)
			{
				_audioSource = ((Component)MrFuntikMod.instance).gameObject.AddComponent<AudioSource>();
			}
			_audioSource.playOnAwake = false;
			_audioSource.loop = false;
			_audioSource.spatialBlend = 0f;
			_audioSource.ignoreListenerPause = true;
			_audioSource.priority = 0;
			_audioSource.volume = 1f;
			return _audioSource;
		}

		private static AudioClip GetLootRunnerPickClip()
		{
			if ((Object)(object)_lootRunnerPickClip != (Object)null)
			{
				return _lootRunnerPickClip;
			}
			int num = Mathf.CeilToInt(21168f);
			float[] array = new float[num];
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / 44100f;
				float num3 = num2 / 0.48f;
				float num4 = Mathf.SmoothStep(0f, 1f, Mathf.Clamp01(num3 / 0.08f));
				float num5 = 1f - Mathf.SmoothStep(0f, 1f, Mathf.Clamp01((num3 - 0.62f) / 0.38f));
				float num6 = num4 * num5 * Mathf.Exp((0f - num3) * 1.35f);
				float num7 = Mathf.Sin(3690.3035f * num2);
				float num8 = Mathf.Sin(4649.494f * Mathf.Max(0f, num2 - 0.055f));
				float num9 = Mathf.Sin(6206.3423f * Mathf.Max(0f, num2 - 0.13f));
				float num10 = Mathf.Sin(7380.607f * Mathf.Max(0f, num2 - 0.2f));
				array[i] = (num7 * 0.36f + num8 * 0.28f + num9 * 0.18f + num10 * 0.08f) * num6 * 0.55f;
			}
			_lootRunnerPickClip = AudioClip.Create("BFRM_LootRunnerPick_2D", num, 1, 44100, false);
			_lootRunnerPickClip.SetData(array, 0);
			return _lootRunnerPickClip;
		}

		private static AudioClip GetScorpionGetOverHereClip()
		{
			if ((Object)(object)_scorpionGetOverHereClip != (Object)null)
			{
				return _scorpionGetOverHereClip;
			}
			string scorpionExternalSoundPath = GetScorpionExternalSoundPath();
			if (string.IsNullOrEmpty(scorpionExternalSoundPath) || !File.Exists(scorpionExternalSoundPath))
			{
				Log("Scorpion external sound file not found. Expected scorpion_get_over_here.wav near MFM.dll.");
				return null;
			}
			try
			{
				_scorpionGetOverHereClip = LoadWav(scorpionExternalSoundPath, "BFRM_Scorpion_GetOverHere");
				return _scorpionGetOverHereClip;
			}
			catch (Exception ex)
			{
				Log("Failed to load Scorpion external sound: " + ex.Message);
				return null;
			}
		}

		private static string GetScorpionExternalSoundPath()
		{
			string location = typeof(MrFuntikMod).Assembly.Location;
			string text = (string.IsNullOrEmpty(location) ? null : Path.GetDirectoryName(location));
			if (!string.IsNullOrEmpty(text))
			{
				string text2 = Path.Combine(text, "scorpion_get_over_here.wav");
				if (File.Exists(text2))
				{
					return text2;
				}
			}
			string text3 = Path.Combine(Environment.CurrentDirectory, "scorpion_get_over_here.wav");
			if (File.Exists(text3))
			{
				return text3;
			}
			return (!string.IsNullOrEmpty(text)) ? Path.Combine(text, "scorpion_get_over_here.wav") : text3;
		}

		private static AudioClip LoadWav(string path, string clipName)
		{
			byte[] array = File.ReadAllBytes(path);
			if (array.Length < 44)
			{
				throw new InvalidDataException("WAV file is too small.");
			}
			int num = ReadInt32(array, 0);
			int num2 = ReadInt32(array, 8);
			if (num != 1179011410 || num2 != 1163280727)
			{
				throw new InvalidDataException("File is not a RIFF/WAVE file.");
			}
			int num3 = 12;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = -1;
			int num9 = 0;
			while (num3 + 8 <= array.Length)
			{
				string @string = Encoding.ASCII.GetString(array, num3, 4);
				int num10 = ReadInt32(array, num3 + 4);
				int num11 = num3 + 8;
				if (@string == "fmt ")
				{
					num7 = ReadInt16(array, num11);
					num4 = ReadInt16(array, num11 + 2);
					num5 = ReadInt32(array, num11 + 4);
					num6 = ReadInt16(array, num11 + 14);
				}
				else if (@string == "data")
				{
					num8 = num11;
					num9 = num10;
					break;
				}
				num3 = num11 + num10 + num10 % 2;
			}
			if (num8 < 0 || num9 <= 0)
			{
				throw new InvalidDataException("WAV data chunk was not found.");
			}
			if (num4 <= 0 || num5 <= 0)
			{
				throw new InvalidDataException("WAV format chunk is invalid.");
			}
			if (num7 != 1 && num7 != 3)
			{
				throw new InvalidDataException("Only PCM and IEEE float WAV files are supported.");
			}
			int num12 = num6 / 8;
			int num13 = num9 / num12;
			float[] array2 = new float[num13];
			for (int i = 0; i < num13; i++)
			{
				int offset = num8 + i * num12;
				array2[i] = ReadSample(array, offset, num6, num7);
			}
			AudioClip val = AudioClip.Create(clipName, num13 / num4, num4, num5, false);
			val.SetData(array2, 0);
			return val;
		}

		private static float ReadSample(byte[] data, int offset, int bitsPerSample, int audioFormat)
		{
			if (audioFormat == 3 && bitsPerSample == 32)
			{
				return BitConverter.ToSingle(data, offset);
			}
			switch (bitsPerSample)
			{
			case 8:
				return (float)(data[offset] - 128) / 128f;
			case 16:
				return (float)BitConverter.ToInt16(data, offset) / 32768f;
			case 24:
			{
				int num = data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16);
				if (((uint)num & 0x800000u) != 0)
				{
					num |= -16777216;
				}
				return (float)num / 8388608f;
			}
			case 32:
				return (float)BitConverter.ToInt32(data, offset) / 2.1474836E+09f;
			default:
				throw new InvalidDataException("Unsupported WAV bit depth: " + bitsPerSample);
			}
		}

		private static short ReadInt16(byte[] data, int offset)
		{
			return BitConverter.ToInt16(data, offset);
		}

		private static int ReadInt32(byte[] data, int offset)
		{
			return BitConverter.ToInt32(data, offset);
		}

		private static SoundEvent GetPlayerSpawnSound(Player player)
		{
			if ((Object)(object)PlayerManager.instance == (Object)null || PlayerManager.instance.soundCharacterSpawn == null || PlayerManager.instance.soundCharacterSpawn.Length == 0)
			{
				return null;
			}
			int num = 0;
			if ((Object)(object)player != (Object)null)
			{
				num = Mathf.Abs(player.playerID) % PlayerManager.instance.soundCharacterSpawn.Length;
			}
			return PlayerManager.instance.soundCharacterSpawn[num];
		}

		private static Player FindPlayer(int playerId)
		{
			if ((Object)(object)PlayerManager.instance == (Object)null || PlayerManager.instance.players == null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player != (Object)null && player.playerID == playerId)
				{
					return player;
				}
			}
			return null;
		}

		private static void Log(string message)
		{
			ManualLogSource modLogger = MrFuntikMod.ModLogger;
			if (modLogger != null)
			{
				modLogger.LogInfo((object)("[BFRM][Sound] " + message));
			}
		}
	}
}
namespace MrFuntikMod.Extensions
{
	[Serializable]
	public class BlockAdditionalData
	{
		public float discombobulateRange;

		public float discombobulateDuration;

		public float timeOfLastSuccessfulBlock;

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

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

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

		public bool isClassBlacklistCard;

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

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

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

		public int shuffles;

		public int oneCutPending;

		public int calibrateStacks;

		public int elasticPickStacks;

		public int bloodPactPickStacks;

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

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

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

		public override void DealtDamage(Vector2 damage, bool selfDamage, Player damagedPlayer = null)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Player damagedPlayer2 = damagedPlayer;
			if (!selfDamage && (!((Object)(object)damagedPlayer2 != (Object)null) || damagedPlayer2.teamID != ((Component)this).gameObject.GetComponent<Player>().teamID))
			{
				return;
			}
			if (damagedPlayer2.data.health - ((Vector2)(ref damage)).magnitude <= 0f)
			{
				damagedPlayer2.data.healthHandler.Heal(((Vector2)(ref damage)).magnitude * (1f - multiplier));
				return;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Unbound.Instance, 2, (Action)delegate
			{
				damagedPlayer2.data.healthHandler.Heal(((Vector2)(ref damage)).magnitude * (1f - multiplier));
			});
		}
	}
}
namespace MrFuntikMod.MonoBehaviours
{
	public class RandomTeleportMono : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <OnPointStart>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public RandomTeleportMono <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.ResetState();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Player player;

		private Block block;

		private CharacterData data;

		private const float TELEPORT_COOLDOWN = 4f;

		private float cooldownRemaining = 0f;

		private bool isReady = true;

		private readonly int maxAttempts = 100;

		private Action<BlockTriggerType> blockAction;

		private CooldownUI cooldownUI;

		public void Initialize(Player player, Block block)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			this.player = player;
			this.block = block;
			data = player.data;
			blockAction = OnBlock;
			this.block.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(this.block.BlockAction, blockAction);
			if (data.view.IsMine)
			{
				cooldownUI = CooldownUI.Create(((Component)this).transform, 1f);
				cooldownUI.SetIcon("T", (Color?)new Color(1f, 0.36f, 0.8f));
			}
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			if ((Object)(object)data.healthHandler != (Object)null)
			{
				HealthHandler healthHandler = data.healthHandler;
				healthHandler.reviveAction = (Action)Delegate.Combine(healthHandler.reviveAction, new Action(OnRevive));
			}
		}

		private void OnRevive()
		{
			ResetState();
		}

		[IteratorStateMachine(typeof(<OnPointStart>d__11))]
		private IEnumerator OnPointStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPointStart>d__11(0)
			{
				<>4__this = this,
				gm = gm
			};
		}

		private void ResetState()
		{
			cooldownRemaining = 0f;
			isReady = true;
			CooldownUI obj = cooldownUI;
			if (obj != null)
			{
				obj.Hide();
			}
		}

		public void Cleanup()
		{
			if ((Object)(object)block != (Object)null && blockAction != null)
			{
				block.BlockAction = (Action<BlockTriggerType>)Delegate.Remove(block.BlockAction, blockAction);
			}
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			if ((Object)(object)data != (Object)null && (Object)(object)data.healthHandler != (Object)null)
			{
				HealthHandler healthHandler = data.healthHandler;
				healthHandler.reviveAction = (Action)Delegate.Remove(healthHandler.reviveAction, new Action(OnRevive));
			}
			if ((Object)(object)cooldownUI != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)cooldownUI).gameObject);
			}
		}

		private void OnDestroy()
		{
			Cleanup();
		}

		private void Update()
		{
			if ((Object)(object)player == (Object)null || (Object)(object)data == (Object)null)
			{
				return;
			}
			if (data.dead)
			{
				CooldownUI obj = cooldownUI;
				if (obj != null)
				{
					obj.Hide();
				}
				return;
			}
			if (!isReady)
			{
				cooldownRemaining -= Time.deltaTime;
				if (cooldownRemaining <= 0f)
				{
					cooldownRemaining = 0f;
					isReady = true;
				}
			}
			if (data.view.IsMine)
			{
				UpdateUI();
			}
		}

		private void UpdateUI()
		{
			if (!((Object)(object)cooldownUI == (Object)null))
			{
				if (!isReady && cooldownRemaining > 0f)
				{
					cooldownUI.ShowCooldown(cooldownRemaining, 4f);
				}
				else
				{
					cooldownUI.Hide();
				}
			}
		}

		private void OnBlock(BlockTriggerType trigger)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0114: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger > 0 || !isReady || (Object)(object)player == (Object)null || (Object)(object)data == (Object)null || data.dead || (!player.data.view.IsMine && !PhotonNetwork.OfflineMode))
			{
				return;
			}
			Vector2? val = FindSafeTeleportPoint();
			if (val.HasValue)
			{
				isReady = false;
				cooldownRemaining = 4f;
				if (PhotonNetwork.OfflineMode)
				{
					RPCA_Teleport(player.playerID, val.Value.x, val.Value.y);
					return;
				}
				NetworkingManager.RPC(typeof(RandomTeleportMono), "RPCA_Teleport", new object[3]
				{
					player.playerID,
					val.Value.x,
					val.Value.y
				});
			}
		}

		private Vector2? FindSafeTeleportPoint()
		{
			//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_003c: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			float num = Camera.main.orthographicSize * 0.85f;
			float num2 = num * Camera.main.aspect * 0.85f;
			Vector3 position = ((Component)Camera.main).transform.position;
			Vector2 val = default(Vector2);
			for (int i = 0; i < maxAttempts; i++)
			{
				((Vector2)(ref val))..ctor(position.x + Random.Range(0f - num2, num2), position.y + Random.Range(0f - num, num));
				if (IsPointSafe(val))
				{
					return val;
				}
			}
			return null;
		}

		private bool IsPointSafe(Vector2 point)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			float num = 1.2f;
			Collider2D val = Physics2D.OverlapCircle(point, num, LayerMask.GetMask(new string[2] { "Default", "IgnorePlayer" }));
			if ((Object)(object)val != (Object)null)
			{
				return false;
			}
			return true;
		}

		private static Player GetPlayerWithID(int playerID)
		{
			foreach (Player player in PlayerManager.instance.players)
			{
				if (player.playerID == playerID)
				{
					return player;
				}
			}
			return null;
		}

		[UnboundRPC]
		public static void RPCA_Teleport(int playerID, float x, float y)
		{
			//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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00cc: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			Player playerWithID = GetPlayerWithID(playerID);
			if (!((Object)(object)playerWithID == (Object)null) && !playerWithID.data.dead)
			{
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(x, y);
				Vector3 position = ((Component)playerWithID).transform.position;
				PlayerCollision component = ((Component)playerWithID).GetComponent<PlayerCollision>();
				if ((Object)(object)component != (Object)null)
				{
					component.IgnoreWallForFrames(2);
				}
				PlayerVelocity playerVel = playerWithID.data.playerVel;
				if ((Object)(object)playerVel != (Object)null)
				{
					ExtensionMethods.SetFieldValue((object)playerVel, "velocity", (object)Vector2.zero);
				}
				((Component)playerWithID).transform.position = Vector2.op_Implicit(val);
				TeleportPlayerGhostEffect.Create(playerWithID, position);
				TeleportPathEffect.Create(position, Vector2.op_Implicit(val), new Color(1f, 0.36f, 0.8f, 1f), ((Component)playerWithID).transform.localScale.x, 0.45f, playerWithID);
			}
		}
	}
	public class FriendlyBulletsDealtDamageEffect : HitEffect
	{
		public float multiplier = 1f;

		public override void DealtDamage(Vector2 damage, bool selfDamage, Player damagedPlayer = null)
		{
			Player component = ((Component)this).GetComponent<Player>();
			if ((Object)(object)component == (Object)null || (Object)(object)damagedPlayer == (Object)null || (!selfDamage && damagedPlayer.teamID != component.teamID))
			{
				return;
			}
			float healAmount = ((Vector2)(ref damage)).magnitude * (1f - multiplier);
			if (damagedPlayer.data.health - ((Vector2)(ref damage)).magnitude <= 0f)
			{
				damagedPlayer.data.healthHandler.Heal(healAmount);
				return;
			}
			Player targetPlayer = damagedPlayer;
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Unbound.Instance, 2, (Action)delegate
			{
				if ((Object)(object)targetPlayer != (Object)null && (Object)(object)targetPlayer.data != (Object)null && (Object)(object)targetPlayer.data.healthHandler != (Object)null)
				{
					targetPlayer.data.healthHandler.Heal(healAmount);
				}
			});
		}
	}
}
namespace MrFuntikMod.MonoBehaviors
{
	public class ComeToMeMono : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedTeleport>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int targetPlayerID;

			public ComeToMeMono <>4__this;

			private Player <target>5__1;

			private Vector3 <ownerPos>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!IsActiveCombatPlayer(<>4__this.player))
					{
						<>4__this.CancelPendingTeleport();
						return false;
					}
					<target>5__1 = GetPlayerWithID(targetPlayerID);
					if (!IsActiveCombatPlayer(<target>5__1))
					{
						<>4__this.CancelPendingTeleport();
						return false;
					}
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!IsActiveCombatPlayer(<>4__this.player))
					{
						<>4__this.CancelPendingTeleport();
						return false;
					}
					<target>5__1 = GetPlayerWithID(targetPlayerID);
					if (!IsActiveCombatPlayer(<target>5__1))
					{
						<>4__this.CancelPendingTeleport();
						return false;
					}
					<ownerPos>5__2 = ((Component)<>4__this.player).transform.position;
					if (PhotonNetwork.OfflineMode)
					{
						RPCA_TeleportToOwner(<>4__this.player.playerID, targetPlayerID, <ownerPos>5__2.x, <ownerPos>5__2.y);
					}
					else
					{
						NetworkingManager.RPC(typeof(ComeToMeMono), "RPCA_TeleportToOwner", new object[4]
						{
							<>4__this.player.playerID,
							targetPlayerID,
							<ownerPos>5__2.x,
							<ownerPos>5__2.y
						});
					}
					_ownersCasting.Remove(<>4__this.player.playerID);
					<>4__this.activeTargetPlayerID = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnPointEnd>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public ComeToMeMono <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.ResetState();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnPointStart>d__18 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gm;

			public ComeToMeMono <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.ResetState();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Player player;

		private Block block;

		private CharacterData data;

		private Action<BlockTriggerType> blockAction;

		private const float TELEPORT_COOLDOWN = 5f;

		private const float TELEPORT_DELAY = 2f;

		private const float TELEPORT_RANGE = 25f;

		private const float RANGE_PREVIEW_DURATION = 3f;

		private float cooldownRemaining = 0f;

		private bool isReady = true;

		private int activeTargetPlayerID = -1;

		private static readonly List<GameObject> _activeRunners = new List<GameObject>();

		private static readonly Dictionary<int, float> _ownerCooldownUntil = new Dictionary<int, float>();

		private static readonly HashSet<int> _ownersCasting = new HashSet<int>();

		private static readonly Dictionary<int, float> _lastTeleportByOwner = new Dictionary<int, float>();

		private CooldownUI cooldownUI;

		private bool wasDea