Decompiled source of BFRM v1.26.1

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Get App
Decompiled source of BFRM v1.26.1

bellusfennec-BFRM.dll

Decompiled an hour ago
Download (1.0 MB)
The result has been truncated due to the large size, download it to view full contents!
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using CardThemeLib;
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.MonoBehaviors;
using MrFuntikMod.MonoBehaviours;
using MrFuntikMod.Patches;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
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("bellusfennec-BFRM")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c7cab5c499a4a2b66983ae6967a721dfa68e355b")]
[assembly: AssemblyProduct("bellusfennec-BFRM")]
[assembly: AssemblyTitle("bellusfennec-BFRM")]
[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 static AssetBundle _bundle;

		private static AssetBundle _bundle2;

		private static AssetBundle _bundleDron;

		private static bool _loadAttempted;

		private static readonly Dictionary<string, GameObject> _assetCache;

		private static readonly Dictionary<string, Sprite> _spriteCache;

		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");

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

		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;
					Debug.Log((object)"[MFM][Assets] isbundle already loaded, reusing");
				}
				if (((Object)item).name == "isbundlev2")
				{
					_bundle2 = item;
					Debug.Log((object)"[MFM][Assets] isbundlev2 already loaded, reusing");
				}
				if (((Object)item).name == "dron-asset-2")
				{
					_bundleDron = item;
					Debug.Log((object)"[MFM][Assets] dron-asset-2 already loaded, reusing");
				}
			}
			if ((Object)(object)_bundle == (Object)null)
			{
				try
				{
					_bundle = AssetUtils.LoadAssetBundleFromResources("isbundle", typeof(MrFuntikMod).Assembly);
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[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)
				{
					Debug.LogError((object)("[MFM][Assets] FAILED to load isbundlev2: " + ex2.Message));
				}
			}
			if (!((Object)(object)_bundleDron == (Object)null))
			{
				return;
			}
			try
			{
				_bundleDron = AssetUtils.LoadAssetBundleFromResources("dron-asset-2", typeof(MrFuntikMod).Assembly);
			}
			catch (Exception ex3)
			{
				Debug.LogError((object)("[MFM][Assets] FAILED to load dron-asset-2: " + ex3.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)
				{
					Debug.LogWarning((object)("[MFM][Assets] Asset '" + assetName + "' not found in '" + bundleName + "'"));
				}
				else
				{
					_assetCache[key] = val;
				}
				return val;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[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)
				{
					Debug.LogWarning((object)("[MFM][Assets] Sprite '" + assetName + "' not found in '" + bundleName + "'"));
				}
				else
				{
					_spriteCache[key] = val;
				}
				return val;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[MFM][Assets] Exception loading sprite '" + assetName + "': " + ex.Message));
				return null;
			}
		}
	}
	[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.bellusfennec.rounds.mod", "BFRM", "1.21.1")]
	[BepInProcess("Rounds.exe")]
	public class MrFuntikMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <GameStart>d__24 : 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__24(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;
				AntiRadarCard.ClearCache();
				DeathDefyMono.ClearStaticData();
				ExecutionerMono.ClearPendingExecutions();
				BurnEffectManager.ClearAll();
				NothingTimerManager.ClearAll();
				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);
						}
						<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__22 : 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__22(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();
				<>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();
			}
		}

		private const string ModId = "com.bellusfennec.rounds.mod";

		private const string ModName = "BFRM";

		public const string Version = "1.21.1";

		public const string ModInitials = "BFRM";

		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;

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

		private Harmony harmony;

		public static MrFuntikMod instance { get; private set; }

		private void Awake()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			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)
			});
			harmony = new Harmony("com.bellusfennec.rounds.mod");
			harmony.PatchAll();
		}

		private void Start()
		{
			Debug.Log((object)"[BFRM] Start.");
			AntiSlowExternalModsPatch.ApplyPatches(harmony);
			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");
			instance = this;
			DeathDefyHandler.RegisterHooks();
			CustomCard.BuildCard<WeakenedDebuffCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				Cards.instance.AddHiddenCard(cardInfo);
				hiddenCards.Add(cardInfo);
			});
			CustomCard.BuildCard<DrainedDebuffCard>((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<BlurredFocusDebuffCard>((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<BallisticDragDebuffCard>((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<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<SurpriseGiftCard>((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				SurpriseGiftCard.cardInfo = cardInfo;
			});
			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<VengefulSparkCard>();
			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<WeakeningAuraCard>();
			CustomCard.BuildCard<DrainAuraCard>();
			CustomCard.BuildCard<SoftRicochetAuraCard>();
			CustomCard.BuildCard<ColdWaterAuraCard>();
			CustomCard.BuildCard<HeavyHandsAuraCard>();
			CustomCard.BuildCard<OverheatedAuraCard>();
			CustomCard.BuildCard<BlurredFocusAuraCard>();
			CustomCard.BuildCard<DeathSentenceAuraCard>();
			CustomCard.BuildCard<BrokenBurstAuraCard>();
			CustomCard.BuildCard<BloodRotAuraCard>();
			CustomCard.BuildCard<BallisticDragAuraCard>();
			CustomCard.BuildCard<SlowStepAuraCard>();
			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>();
			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("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
			GameModeManager.AddHook("GameEnd", (Func<IGameModeHandler, IEnumerator>)ResetEffects);
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)ResetEffects);
			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);
					}
				}
			});
		}

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

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

		[IteratorStateMachine(typeof(<GameStart>d__24))]
		private IEnumerator GameStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GameStart>d__24(0)
			{
				<>4__this = this,
				gm = gm
			};
		}
	}
	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)
			{
				Debug.LogError((object)("[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)
			{
				Debug.LogError((object)("[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;
		}
	}
	public static class VengefulSparkConfig
	{
		public const float DAMAGE_REFLECT_PERCENT = 0.3f;

		public const float MIN_DAMAGE_THRESHOLD = 3f;

		public const float BULLET_SPEED = 1.3f;

		public const float BULLET_LIFETIME = 4f;

		public const float BULLET_SIZE = 0.75f;

		public const float BULLET_KNOCKBACK = 0.3f;

		public const float COOLDOWN = 0.5f;

		public static readonly Color BULLET_COLOR = new Color(0.6f, 0.15f, 0.7f, 1f);

		public static readonly Color SPARK_BRIGHT = new Color(1f, 0.5f, 1f, 1f);

		public static readonly Color SPARK_CORE = new Color(0.8f, 0.3f, 0.9f, 1f);

		public static readonly Color SPARK_MID = new Color(0.6f, 0.15f, 0.7f, 1f);

		public static readonly Color SPARK_TAIL = new Color(0.3f, 0.05f, 0.4f, 0.6f);

		public static readonly Color SPARK_GLOW = new Color(0.7f, 0.2f, 0.8f, 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);
				}
			}
		}
	}
}
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 CharacterStatModifiersAdditionalData()
		{
			piercingDamage = 0f;
			shuffles = 0;
			oneCutPending = 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 = 30;

		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.4f, 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((int)trigger <= 0 && isReady && (player.data.view.IsMine || PhotonNetwork.OfflineMode))
			{
				Vector2? val = FindSafeTeleportPoint(requireGround: true);
				if (!val.HasValue)
				{
					val = FindSafeTeleportPoint(requireGround: false);
				}
				if (!val.HasValue)
				{
					Vector2 val2 = Random.insideUnitCircle * 5f;
					val = Vector2.op_Implicit(((Component)player).transform.position) + val2;
				}
				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(bool requireGround)
		{
			//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_006f: 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, requireGround))
				{
					return val;
				}
			}
			return null;
		}

		private bool IsPointSafe(Vector2 point, bool requireGround)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			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;
			}
			if (requireGround)
			{
				RaycastHit2D val2 = Physics2D.Raycast(point, Vector2.down, 25f, LayerMask.GetMask(new string[1] { "Default" }));
				return (Object)(object)((RaycastHit2D)(ref val2)).collider != (Object)null;
			}
			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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Player playerWithID = GetPlayerWithID(playerID);
			if (!((Object)(object)playerWithID == (Object)null))
			{
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(x, y);
				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);
			}
		}
	}
	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__19 : 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__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Expected O, but got Unknown
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if ((Object)(object)<>4__this.player == (Object)null || <>4__this.player.data.dead)
					{
						return false;
					}
					<target>5__1 = GetPlayerWithID(targetPlayerID);
					if ((Object)(object)<target>5__1 == (Object)null || <target>5__1.data.dead)
					{
						return false;
					}
					Transform transform = ((Component)<target>5__1).transform;
					Color white = Color.white;
					CircleWaveEffect.CreatePulsingEffect(transform, default(Vector3), 2f, 3, 0.5f, 3.5f, 0.5f, white);
					Transform transform2 = ((Component)<>4__this.player).transform;
					white = Color.white;
					CircleWaveEffect.CreatePulsingEffect(transform2, default(Vector3), 2f, 3, 0.5f, 0.2f, 3.5f, white);
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					if ((Object)(object)<>4__this.player == (Object)null || <>4__this.player.data.dead)
					{
						return false;
					}
					<target>5__1 = GetPlayerWithID(targetPlayerID);
					if ((Object)(object)<target>5__1 == (Object)null || <target>5__1.data.dead)
					{
						return false;
					}
					<ownerPos>5__2 = ((Component)<>4__this.player).transform.position;
					if (PhotonNetwork.OfflineMode)
					{
						RPCA_TeleportToOwner(targetPlayerID, <ownerPos>5__2.x, <ownerPos>5__2.y);
					}
					else
					{
						NetworkingManager.RPC(typeof(ComeToMeMono), "RPCA_TeleportToOwner", new object[3] { targetPlayerID, <ownerPos>5__2.x, <ownerPos>5__2.y });
					}
					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 <OnBattleStart>d__12 : 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 <OnBattleStart>d__12(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__11 : 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__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 Action<BlockTriggerType> blockAction;

		private const float TELEPORT_COOLDOWN = 4f;

		private const float TELEPORT_DELAY = 2f;

		private float cooldownRemaining = 0f;

		private bool isReady = true;

		private CooldownUI cooldownUI;

		public void Initialize(Player player, Block block)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			this.player = player;
			this.block = block;
			data = player.data;
			blockAction = OnBlock;
			block.BlockAction = (Action<BlockTriggerType>)Delegate.Combine(block.BlockAction, blockAction);
			if (data.view.IsMine)
			{
				cooldownUI = CooldownUI.Create(((Component)this).transform, 1f);
				cooldownUI.SetIcon("C", (Color?)new Color(0.8f, 0.4f, 1f));
			}
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)OnPointStart);
			GameModeManager.AddHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)OnBattleStart);
			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
			};
		}

		[IteratorStateMachine(typeof(<OnBattleStart>d__12))]
		private IEnumerator OnBattleStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleStart>d__12(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);
			GameModeManager.RemoveHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)OnBattleStart);
			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
			if ((int)trigger <= 0 && isReady && (data.view.IsMine || PhotonNetwork.OfflineMode))
			{
				Player val = FindClosestEnemy();
				if (!((Object)(object)val == (Object)null) && !val.data.dead)
				{
					isReady = false;
					cooldownRemaining = 4f;
					((MonoBehaviour)this).StartCoroutine(DelayedTeleport(val.playerID));
				}
			}
		}

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

		private Player FindClosestEnemy()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			Player result = null;
			float num = float.MaxValue;
			foreach (Player player in PlayerManager.instance.players)
			{
				if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)this.player) && !player.data.dead && player.teamID != this.player.teamID)
				{
					float num2 = Vector2.Distance(Vector2.op_Implicit(((Component)this.player).transform.position), Vector2.op_Implicit(((Component)player).transform.position));
					if (num2 < num)
					{
						num = num2;
						result = player;
					}
				}
			}
			return result;
		}

		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_TeleportToOwner(int targetPlayerID, float ownerX, float ownerY)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Player playerWithID = GetPlayerWithID(targetPlayerID);
			if (!((Object)(object)playerWithID == (Object)null) && !playerWithID.data.dead)
			{
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(ownerX, ownerY);
				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);
				CircleWaveEffect.CreateEffect(Vector2.op_Implicit(val), 0.5f, 0f, 3f, Color.red);
			}
		}
	}
	public class CircleWaveEffect : MonoBehaviour
	{
		private class PulseRunner : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <RunPulses>d__1 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public Transform owner;

				public Vector3 worldPos;

				public float totalDur;

				public int count;

				public float pulseDur;

				public float startRad;

				public float endRad;

				public Color color;

				public PulseRunner <>4__this;

				private float <interval>5__1;

				private int <i>5__2;

				private GameObject <effect>5__3;

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

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

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

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

				private bool MoveNext()
				{
					//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
					//IL_005b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0065: Expected O, but got Unknown
					//IL_0088: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00fe: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<interval>5__1 = totalDur / (float)count;
						<i>5__2 = 0;
						break;
					case 1:
						<>1__state = -1;
						<i>5__2++;
						break;
					}
					if (<i>5__2 < count)
					{
						if ((Object)(object)owner != (Object)null)
						{
							<effect>5__3 = new GameObject("CircleWavePulse");
							<effect>5__3.transform.SetParent(owner, true);
							<effect>5__3.transform.localPosition = Vector3.zero;
							<>4__this.SetupEffect(<effect>5__3, pulseDur, startRad, endRad, color);
							<effect>5__3 = null;
						}
						else
						{
							CreateEffect(worldPos, pulseDur, startRad, endRad, color);
						}
						<>2__current = (object)new WaitForSeconds(<interval>5__1);
						<>1__state = 1;
						return true;
					}
					Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
					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();
				}
			}

			public void StartPulsing(Transform owner, Vector3 worldPos, float totalDur, int count, float pulseDur, float startRad, float endRad, Color color)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				((MonoBehaviour)this).StartCoroutine(RunPulses(owner, worldPos, totalDur, count, pulseDur, startRad, endRad, color));
			}

			[IteratorStateMachine(typeof(<RunPulses>d__1))]
			private IEnumerator RunPulses(Transform owner, Vector3 worldPos, float totalDur, int count, float pulseDur, float startRad, float endRad, Color color)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <RunPulses>d__1(0)
				{
					<>4__this = this,
					owner = owner,
					worldPos = worldPos,
					totalDur = totalDur,
					count = count,
					pulseDur = pulseDur,
					startRad = startRad,
					endRad = endRad,
					color = color
				};
			}

			private void SetupEffect(GameObject go, float dur, float startRad, float endRad, Color color)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				LineRenderer val = go.AddComponent<LineRenderer>();
				((Renderer)val).material = new Material(Shader.Find("Sprites/Default"));
				val.startColor = color;
				val.endColor = color;
				float startWidth = (val.endWidth = 0.1f);
				val.startWidth = startWidth;
				val.useWorldSpace = false;
				int num2 = 64;
				val.positionCount = num2 + 1;
				Vector3[] array = (Vector3[])(object)new Vector3[num2 + 1];
				for (int i = 0; i <= num2; i++)
				{
					float num3 = (float)i / (float)num2 * MathF.PI * 2f;
					array[i] = new Vector3(Mathf.Cos(num3) * startRad, Mathf.Sin(num3) * startRad, 0f);
				}
				val.SetPositions(array);
				CircleWaveEffect circleWaveEffect = go.AddComponent<CircleWaveEffect>();
				circleWaveEffect.Setup(val, num2, dur, startRad, endRad, color);
			}
		}

		private LineRenderer lineRenderer;

		private int segments;

		private float elapsed = 0f;

		private float duration = 0.5f;

		private float startRadius = 0f;

		private float endRadius = 3f;

		private Color startColor = Color.white;

		public void Setup(LineRenderer lr, int segs, float dur = 0.5f, float startRad = 0f, float endRad = 3f, Color color = default(Color))
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			lineRenderer = lr;
			segments = segs;
			duration = dur;
			startRadius = startRad;
			endRadius = endRad;
			startColor = ((color == default(Color)) ? Color.white : color);
		}

		private void Update()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			elapsed += Time.deltaTime;
			if (elapsed > duration)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			float num = startRadius + elapsed / duration * (endRadius - startRadius);
			Vector3[] array = (Vector3[])(object)new Vector3[segments + 1];
			for (int i = 0; i <= segments; i++)
			{
				float num2 = (float)i / (float)segments * MathF.PI * 2f;
				float num3 = Mathf.Cos(num2) * num;
				float num4 = Mathf.Sin(num2) * num;
				array[i] = new Vector3(num3, num4, 0f);
			}
			lineRenderer.SetPositions(array);
			float num5 = 1f - elapsed / duration;
			Color endColor = default(Color);
			((Color)(ref endColor))..ctor(startColor.r, startColor.g, startColor.b, num5);
			lineRenderer.startColor = endColor;
			lineRenderer.endColor = endColor;
		}

		public static GameObject CreateEffect(Vector3 position, float duration = 0.5f, float startRadius = 0f, float endRadius = 3f, Color color = default(Color))
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("CircleWaveEffect");
			val.transform.position = position;
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			((Renderer)val2).material = new Material(Shader.Find("Sprites/Default"));
			Color color2 = (val2.endColor = (val2.startColor = ((color == default(Color)) ? Color.white : color)));
			val2.startWidth = 0.1f;
			val2.endWidth = 0.1f;
			val2.useWorldSpace = false;
			int num = 64;
			Vector3[] array = (Vector3[])(object)new Vector3[num + 1];
			for (int i = 0; i <= num; i++)
			{
				float num2 = (float)i / (float)num * MathF.PI * 2f;
				float num3 = Mathf.Cos(num2) * startRadius;
				float num4 = Mathf.Sin(num2) * startRadius;
				array[i] = new Vector3(num3, num4, 0f);
			}
			val2.positionCount = num + 1;
			val2.SetPositions(array);
			CircleWaveEffect circleWaveEffect = val.AddComponent<CircleWaveEffect>();
			circleWaveEffect.Setup(val2, num, duration, startRadius, endRadius, color2);
			return val;
		}

		public static void CreatePulsingEffect(Transform owner = null, Vector3 position = default(Vector3), float totalDuration = 2f, int pulseCount = 3, float pulseDuration = 0.5f, float startRadius = 0.2f, float endRadius = 3.5f, Color color = default(Color))
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			PulseRunner pulseRunner = new GameObject("CircleWavePulseRunner").AddComponent<PulseRunner>();
			pulseRunner.StartPulsing(owner, position, totalDuration, pulseCount, pulseDuration, startRadius, endRadius, (color == default(Color)) ? Color.white : color);
		}
	}
	public class HealMeMono : MonoBehaviour
	{
		internal Player player;

		internal Gun gun;

		internal GunAmmo gunAmmo;

		internal Gravity gravity;

		internal HealthHandler healthHandler;

		internal CharacterData data;

		internal Block block;

		private readonly float updateDelay = 0.1f;

		private float startTime;

		public int numcheck;

		public bool active;

		private void Start()
		{
			data = ((Component)this).GetComponentInParent<CharacterData>();
			HealthHandler val = data.healthHandler;
			val.reviveAction = (Action)Delegate.Combine(val.reviveAction, new Action(ResetTimer));
		}

		private void OnDestroy()
		{
			HealthHandler val = data.healthHandler;
			val.reviveAction = (Action)Delegate.Combine(val.reviveAction, new Action(ResetTimer));
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)this);
		}

		public void Awake()
		{
			player = ((Component)this).gameObject.GetComponent<Player>();
			gun = ((Component)((Component)player).GetComponent<Holding>().holdable).GetComponent<Gun>();
			data = ((Component)player).GetComponent<CharacterData>();
			healthHandler = ((Component)player).GetComponent<HealthHandler>();
			gravity = ((Component)player).GetComponent<Gravity>();
			block = ((Component)player).GetComponent<Block>();
			gunAmmo = ((Component)gun).GetComponentInChildren<GunAmmo>();
			numcheck = 0;
		}

		private void Update()
		{
			if (!(Time.time >= startTime + updateDelay))
			{
				return;
			}
			ResetTimer();
			for (int i = 0; i <= player.data.currentCards.Count - 1; i++)
			{
				if (player.data.currentCards[i].cardName == "Heal me")
				{
					numcheck++;
				}
			}
			if (numcheck > 0)
			{
				ResetTimer();
				if (player.data.health < player.data.maxHealth && !active)
				{
					active = true;
					((Component)((Component)player).transform).gameObject.AddComponent<HealMeRegenMono>();
				}
			}
		}

		private void ResetTimer()
		{
			startTime = Time.time;
			numcheck = 0;
		}
	}
	public class HealMeRegenMono : ReversibleEffect
	{
		private readonly Color color = Color.blue;

		private ReversibleColorEffect colorEffect;

		private HealMeMono effect;

		private readonly float updateDelay = 0.1f;

		private float startTime;

		public override void OnOnEnable()
		{
		}

		public override void OnStart()
		{
			HealthHandler healthHandler = base.player.data.healthHandler;
			healthHandler.regeneration += 20f;
			effect = ((Component)base.player).GetComponent<HealMeMono>();
			ResetTimer();
		}

		public override void OnUpdate()
		{
			if (Time.time >= startTime + updateDelay)
			{
				ResetTimer();
				if (base.player.data.health >= base.player.data.maxHealth)
				{
					((ReversibleEffect)this).Destroy();
				}
				if (((Component)this).GetComponent<Player>().data.dead || ((Component)this).GetComponent<Player>().data.health <= 0f || !((Component)((Component)this).GetComponent<Player>()).gameObject.activeInHierarchy)
				{
					ResetTimer();
					((ReversibleEffect)this).Destroy();
				}
			}
		}

		public override void OnOnDisable()
		{
		}

		public override void OnOnDestroy()
		{
			effect.active = false;
			if (base.player.data.healthHandler.regeneration >= 20f)
			{
				HealthHandler healthHandler = base.player.data.healthHandler;
				healthHandler.regeneration -= 20f;
			}
		}

		private void ResetTimer()
		{
			startTime = Time.time;
		}
	}
	public class KamikazeMono : MonoBehaviour
	{
		private class KamikazeSpawner : MonoBehaviour
		{
			private void Start()
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				((Component)this).gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
				((Component)this).gameObject.AddComponent<RemoveAfterSeconds>().seconds = 1f;
				LineEffect component = ((Component)((Component)this).gameObject.transform.GetChild(1)).GetComponent<LineEffect>();
				if ((Object)(object)component != (Object)null)
				{
					ExtensionMethods.SetFieldValue((object)component, "inited", (object)false);
					typeof(LineEffect).InvokeMember("Init", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, component, new object[0]);
					component.radius = 9f;
					ExtensionMethods.SetFieldValue((object)component, "startWidth", (object)7.6f);
					component.Play();
				}
			}
		}

		private bool hasDied = false;

		private readonly float maxDistance = 18f;

		private readonly float updateDelay = 0.1f;

		private readonly float effectCooldown = 0f;

		public Block block;

		public Player player;

		public CharacterData data;

		public Gun gun;

		private Action<BlockTriggerType> basic;

		private static GameObject kamikazevisual;

		private float startTime;

		private float timeOfLastEffect;

		private bool canTrigger;

		private bool hasTriggered;

		private int numcheck;

		public static GameObject kamikazeVisual
		{
			get
			{
				//IL_0123: 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_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)kamikazevisual != (Object)null)
				{
					return kamikazevisual;
				}
				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);
				CardInfo val = first.Concat(second).FirstOrDefault((Func<CardInfo, bool>)((CardInfo card) => card.cardName.ToLower() == "overpower"));
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogError("[Kamikaze] Could not find Overpower card for visual effect!");
					return null;
				}
				CharacterStatModifiers component = ((Component)val).GetComponent<CharacterStatModifiers>();
				object obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					GameObject addObjectToPlayer = component.AddObjectToPlayer;
					obj = ((addObjectToPlayer != null) ? addObjectToPlayer.GetComponent<SpawnObjects>() : null);
				}
				SpawnObjects val2 = (SpawnObjects)obj;
				if ((Object)(object)val2 == (Object)null || val2.objectToSpawn == null || val2.objectToSpawn.Length == 0)
				{
					Debug.LogError("[Kamikaze] Could not get SpawnObjects from Overpower card!");
					return null;
				}
				kamikazevisual = Object.Instantiate<GameObject>(val2.objectToSpawn[0], new Vector3(0f, 100000f, 0f), Quaternion.identity);
				((Object)kamikazevisual).name = "E_Kamikaze";
				Object.DontDestroyOnLoad((Object)(object)kamikazevisual);
				ParticleSystem[] componentsInChildren = kamikazevisual.GetComponentsInChildren<ParticleSystem>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					MainModule main = componentsInChildren[i].main;
					((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.5f);
					((MainModule)(ref main)).startSpeed = MinMaxCurve.op_Implicit(15f);
					((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(2f);
					((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(1f, 0.3f, 0f, 1f));
				}
				LineEffect component2 = ((Component)kamikazevisual.transform.GetChild(1)).GetComponent<LineEffect>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.colorOverTime.colorKeys = (GradientColorKey[])(object)new GradientColorKey[1]
					{
						new GradientColorKey(new Color(1f, 0.4f, 0f, 1f), 0.3f)
					};
					component2.offsetMultiplier = 0f;
					component2.playOnAwake = true;
				}
				if (kamikazevisual.transform.childCount > 2)
				{
					Object.Destroy((Object)(object)((Component)kamikazevisual.transform.GetChild(2)).gameObject);
				}
				FollowPlayer component3 = kamikazevisual.GetComponent<FollowPlayer>();
				if ((Object)(object)component3 != (Object)null)
				{
					Object.Destroy((Object)(object)component3);
				}
				DelayEvent component4 = kamikazevisual.GetComponent<DelayEvent>();
				if ((Object)(object)component4 != (Object)null)
				{
					Object.Destroy((Object)(object)component4);
				}
				Explosion component5 = kamikazevisual.GetComponent<Explosion>();
				if ((Object)(object)component5 != (Object)null)
				{
					component5.hitPlayerAction = null;
					Object.Destroy((Object)(object)component5);
				}
				RemoveAfterSeconds component6 = kamikazevisual.GetComponent<RemoveAfterSeconds>();
				if ((Object)(object)component6 != (Object)null)
				{
					Object.Destroy((Object)(object)component6);
				}
				kamikazevisual.AddComponent<KamikazeSpawner>();
				return kamikazevisual;
			}
		}

		private void Start()
		{
			player = ((Component)this).GetComponent<Player>();
			block = ((Component)this).GetComponent<Block>();
			data = ((Component)this).GetComponent<CharacterData>();
			gun = ((Component)this).GetComponent<Gun>();
			ResetEffectTimer();
			ResetTimer();
			canTrigger = true;
			hasTriggered = false;
			basic = block.BlockAction;
		}

		public void OnDestroy()
		{
			if ((Object)(object)data != (Object)null && data.dead && !hasDied)
			{
				hasDied = true;
				OnPlayerDeath();
			}
			if ((Object)(object)block != (Object)null)
			{
				block.BlockAction = basic;
			}
		}

		private void OnPlayerDeath()
		{
			TriggerKamikazeEffect();
		}

		private void TriggerKamikazeEffect()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Object.Instantiate<GameObject>(kamikazeVisual, ((Component)player).transform.position, Quaternion.identity);
			Vector2 val = Vector2.op_Implicit(((Component)player).transform.position);
			Player[] array = PlayerManager.instance.players.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].teamID == player.teamID)
				{
					continue;
				}
				float num = Vector2.Distance(val, Vector2.op_Implicit(((Component)array[i]).transform.position));
				bool canSee = PlayerManager.instance.CanSeePlayer(Vector2.op_Implicit(((Component)player).transform.position), array[i]).canSee;
				if (num < maxDistance && canSee)
				{
					HealthHandler component = ((Component)array[i]).GetComponent<HealthHandler>();
					if ((Object)(object)component != (Object)null && canTrigger)
					{
						((Damagable)component).TakeDamage(200f * Vector2.down, Vector2.op_Implicit(((Component)array[i]).transform.position), ((Component)player.data.weaponHandler).gameObject, player, true, false);
						Vector3 val2 = ((Component)array[i]).transform.position - Vector2.op_Implicit(val);
						component.TakeForce(Vector2.op_Implicit(((Vector3)(ref val2)).normalized * 12000f), (ForceMode2D)1, true, false, 0.8f);
						hasTriggered = true;
					}
				}
			}
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)this);
		}

		private void Update()
		{
			if (!(Time.time >= startTime + updateDelay))
			{
				return;
			}
			numcheck = 0;
			for (int i = 0; i < player.data.currentCards.Count; i++)
			{
				if (player.data.currentCards[i].cardName == "Kamikaze")
				{
					numcheck++;
				}
			}
			if (numcheck > 0)
			{
				ResetTimer();
				if (Time.time >= timeOfLastEffect + effectCooldown)
				{
					canTrigger = true;
				}
				else
				{
					canTrigger = false;
				}
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
		}

		private void ResetTimer()
		{
			startTime = Time.time;
		}

		private void ResetEffectTimer()
		{
			timeOfLastEffect = Time.time;
		}
	}
	public class VengefulSparkEffect : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedInit>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public VengefulSparkEffect <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0049;
				case 1:
					<>1__state = -1;
					goto IL_0049;
				case 2:
					{
						<>1__state = -1;
						<>4__this.InitializeSparkGun();
						return false;
					}
					IL_0049:
					if ((Object)(object)<>4__this.player == (Object)null || (Object)(object)<>4__this.player.data == (Object)null || (Object)(object)<>4__this.player.data.weaponHandler == (Object)null || (Object)(object)<>4__this.player.data.weaponHandler.gun == (Object)null)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				}
			}

			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 <FireSparkCoroutine>d__18 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Vector3 position;

			public Vector3 direction;

			public float damage;

			public VengefulSparkEffect <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.isInitialized)
					{
						<>4__this.InitializeSparkGun();
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_0065;
				case 1:
					<>1__state = -1;
					goto IL_0065;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0065:
					if ((Object)(object)<>4__this.sparkGun == (Object)null || <>4__this.sparkGun.projectiles == null || <>4__this.sparkGun.projectiles.Length == 0)
					{
						<>4__this.RefreshProjectiles();
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					break;
				}
				if ((Object)(object)<>4__this.sparkGun == (Object)null || <>4__this.sparkGun.projectiles == null || <>4__this.sparkGun.projectiles.Length == 0)
				{
					return false;
				}
				<>4__this.sparkGun.attackID = <>4__this.player.playerID;
				<>4__this.ShootBullet(position, direction, damage);
				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 Gun playerGun;

		private float lastShootTime = -999f;

		private bool hasCard = false;

		private GameObject sparkGunObject;

		private Gun sparkGun;

		private bool isInitialized = false;

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

		private void Start()
		{
			if (hasCard)
			{
				((MonoBehaviour)this).StartCoroutine(DelayedInit());
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)sparkGunObject != (Object)null)
			{
				Object.Destroy((Object)(object)sparkGunObject);
				sparkGunObject = null;
				sparkGun = null;
			}
		}

		public void Initialize()
		{
			hasCard = true;
			((MonoBehaviour)this).StartCoroutine(DelayedInit());
		}

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

		private void InitializeSparkGun()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			if (isInitialized || (Object)(object)player == (Object)null || (Object)(object)player.data == (Object)null)
			{
				return;
			}
			playerGun = player.data.weaponHandler?.gun;
			if ((Object)(object
Get the Thunderstore App

Decompiled source of BFRM v1.26.1

bellusfennec-BFRM.dll

About

Developers
