using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx.Logging;
using InscryptionAPI;
using Microsoft.CodeAnalysis;
using MonoMod;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("APIPatcher")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d56bf5bd89588fb2fb73251c71d60ea43ecc7959")]
[assembly: AssemblyProduct("APIPatcher")]
[assembly: AssemblyTitle("APIPatcher")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace APIPatcher
{
	[MonoModPatch("global::ScriptableObjectLoader`1")]
	internal class patch_ScriptableObjectLoader<T> : ScriptableObjectLoader<T> where T : Object
	{
		public static List<T> AllData
		{
			get
			{
				InscryptionAPIPlugin.InvokeSOLEvent(typeof(T));
				ScriptableObjectLoader<T>.LoadData("");
				return ScriptableObjectLoader<T>.allData;
			}
		}
	}
	[MonoModPatch("global::Singleton`1")]
	internal class patch_Singleton<T> : Singleton<T> where T : ManagedBehaviour
	{
		protected static void FindInstance()
		{
			if ((Object)(object)Singleton<T>.m_Instance == (Object)null)
			{
				T val = Object.FindObjectOfType<T>();
				if ((Object)(object)val == (Object)null)
				{
					Singleton.SingletonLogSource.LogWarning((object)("Got null in Singleton<" + typeof(T).FullName + ">.FindInstance"));
				}
				Singleton<T>.m_Instance = val;
			}
		}
	}
	internal static class Singleton
	{
		internal static readonly ManualLogSource SingletonLogSource = Logger.CreateLogSource("Singleton");
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DiskCardGame;
using GBC;
using HarmonyLib;
using InscryptionAPI;
using InscryptionAPI.Boons;
using InscryptionAPI.Card;
using InscryptionAPI.Card.CostProperties;
using InscryptionAPI.CardCosts;
using InscryptionAPI.Dialogue;
using InscryptionAPI.Encounters;
using InscryptionAPI.Guid;
using InscryptionAPI.Helpers;
using InscryptionAPI.Helpers.Extensions;
using InscryptionAPI.Items;
using InscryptionAPI.Items.Extensions;
using InscryptionAPI.Masks;
using InscryptionAPI.Nodes;
using InscryptionAPI.Pelts;
using InscryptionAPI.PixelCard;
using InscryptionAPI.Regions;
using InscryptionAPI.RuleBook;
using InscryptionAPI.Saves;
using InscryptionAPI.Slots;
using InscryptionAPI.Sound;
using InscryptionAPI.TalkingCards.Animation;
using InscryptionAPI.TalkingCards.Create;
using InscryptionAPI.TalkingCards.Helpers;
using InscryptionAPI.Totems;
using InscryptionAPI.Triggers;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.Utils;
using Pixelplacement;
using Sirenix.Serialization.Utilities;
using Sirenix.Utilities;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using VolumetricFogAndMist;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Assembly-CSharp")]
[assembly: InternalsVisibleTo("Assembly-CSharp.APIPatcher.mm")]
[assembly: InternalsVisibleTo("APIPatcher")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("InscryptionAPI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.23.1.0")]
[assembly: AssemblyInformationalVersion("2.23.1+d56bf5bd89588fb2fb73251c71d60ea43ecc7959")]
[assembly: AssemblyProduct("InscryptionAPI")]
[assembly: AssemblyTitle("InscryptionAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.23.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace APIPlugin
{
	[Obsolete("Use AbilityManager instead", true)]
	public class AbilityIdentifier
	{
		internal string guid;

		private string name;

		public Ability id;

		internal Ability realID;

		private AbilityIdentifier(string guid, string name)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			this.guid = guid;
			this.name = name;
			realID = (id = GuidManager.GetEnumValue<Ability>(guid, name));
		}

		public static AbilityIdentifier GetAbilityIdentifier(string guid, string name)
		{
			return GetID(guid, name);
		}

		public static AbilityIdentifier GetID(string guid, string name)
		{
			return new AbilityIdentifier(guid, name);
		}

		public override string ToString()
		{
			return guid + "(" + name + ")";
		}
	}
	[Obsolete("Use AbilityManager and extension methods instead", true)]
	public class AbilityInfoUtils
	{
		public static AbilityInfo CreateInfoWithDefaultSettings(string rulebookName, string rulebookDescription)
		{
			AbilityInfo obj = ScriptableObject.CreateInstance<AbilityInfo>();
			obj.powerLevel = 0;
			obj.rulebookName = rulebookName;
			obj.rulebookDescription = rulebookDescription;
			obj.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)1,
				(AbilityMetaCategory)0
			};
			return obj;
		}
	}
	[Obsolete("Use CardManager and extension methods instead", true)]
	public static class CardUtils
	{
		public static readonly Vector2 DefaultVector2 = new Vector2(0.5f, 0.5f);

		public static readonly Rect DefaultCardArtRect = new Rect(0f, 0f, 114f, 94f);

		public static readonly Rect DefaultCardPixelArtRect = new Rect(0f, 0f, 41f, 28f);

		public static Predicate<CardInfo> IsNonLivingCard = (CardInfo card) => card.traits.Exists((Trait t) => t - 12 <= 1);

		public static List<CardMetaCategory> getNormalCardMetadata = new List<CardMetaCategory>
		{
			(CardMetaCategory)0,
			(CardMetaCategory)1
		};

		public static List<CardMetaCategory> getRareCardMetadata = new List<CardMetaCategory>
		{
			(CardMetaCategory)0,
			(CardMetaCategory)1,
			(CardMetaCategory)3
		};

		public static List<CardMetaCategory> getGBCCardMetadata = new List<CardMetaCategory>
		{
			(CardMetaCategory)4,
			(CardMetaCategory)5
		};

		public static List<CardMetaCategory> getGBCRareCardMetadata = new List<CardMetaCategory>
		{
			(CardMetaCategory)4,
			(CardMetaCategory)5,
			(CardMetaCategory)3
		};

		public static List<CardMetaCategory> getAllActsCardMetadata = new List<CardMetaCategory>
		{
			(CardMetaCategory)0,
			(CardMetaCategory)3,
			(CardMetaCategory)1,
			(CardMetaCategory)3,
			(CardMetaCategory)4,
			(CardMetaCategory)5,
			(CardMetaCategory)2
		};

		public static List<Appearance> getRareAppearance = new List<Appearance> { (Appearance)7 };

		public static List<Appearance> getTerrainBackgroundAppearance = new List<Appearance> { (Appearance)2 };

		public static List<Appearance> getTerrainLayoutAppearance = new List<Appearance> { (Appearance)9 };

		public static List<Appearance> getTerrainAppearance = new List<Appearance>
		{
			(Appearance)2,
			(Appearance)9
		};

		public static List<Appearance> getHologramAppearance = new List<Appearance> { (Appearance)12 };

		public static List<Appearance> getAnimatedAppearance = new List<Appearance> { (Appearance)5 };

		public static List<Appearance> getGoldAppearance = new List<Appearance> { (Appearance)6 };

		public static List<Appearance> getBloodDecalAppearance = new List<Appearance> { (Appearance)8 };

		public static List<Appearance> getDynamicAppearance = new List<Appearance> { (Appearance)10 };

		public static byte[] ReadArtworkFileAsBytes(string nameOfCardArt)
		{
			return File.ReadAllBytes(Directory.GetFiles(Paths.PluginPath, nameOfCardArt, SearchOption.AllDirectories)[0]);
		}

		public static Texture2D getAndloadImageAsTexture(string pathCardArt)
		{
			return TextureHelper.GetImageAsTexture(pathCardArt, (FilterMode)0);
		}
	}
	[Obsolete("Use CardManager instead", true)]
	public class CustomCard
	{
		public static List<CustomCard> cards = new List<CustomCard>();

		public static Dictionary<int, List<AbilityIdentifier>> abilityIds = new Dictionary<int, List<AbilityIdentifier>>();

		public static Dictionary<int, List<SpecialAbilityIdentifier>> specialAbilityIds = new Dictionary<int, List<SpecialAbilityIdentifier>>();

		public static Dictionary<int, EvolveIdentifier> evolveIds = new Dictionary<int, EvolveIdentifier>();

		public static Dictionary<int, IceCubeIdentifier> iceCubeIds = new Dictionary<int, IceCubeIdentifier>();

		public static Dictionary<int, TailIdentifier> tailIds = new Dictionary<int, TailIdentifier>();

		public static Dictionary<string, Sprite> emissions = new Dictionary<string, Sprite>();

		public string name;

		public List<CardMetaCategory> metaCategories;

		public CardComplexity? cardComplexity;

		public CardTemple? temple;

		public string displayedName;

		public int? baseAttack;

		public int? baseHealth;

		public string description;

		public bool? hideAttackAndHealth;

		public int? cost;

		public int? bonesCost;

		public int? energyCost;

		public List<GemType> gemsCost;

		public SpecialStatIcon? specialStatIcon;

		public List<Tribe> tribes;

		public List<Trait> traits;

		public List<SpecialTriggeredAbility> specialAbilities;

		public List<Ability> abilities;

		public EvolveParams evolveParams;

		public string defaultEvolutionName;

		public TailParams tailParams;

		public IceCubeParams iceCubeParams;

		public bool? flipPortraitForStrafe;

		public bool? onePerDeck;

		public List<Appearance> appearanceBehaviour;

		[IgnoreMapping]
		public Texture2D tex;

		[IgnoreMapping]
		public Texture2D altTex;

		public Texture titleGraphic;

		[IgnoreMapping]
		public Texture2D pixelTex;

		[IgnoreMapping]
		public Texture2D emissionTex;

		public GameObject animatedPortrait;

		public List<Texture> decals;

		[IgnoreMapping]
		private List<AbilityIdentifier> abilityIdParam;

		[IgnoreMapping]
		private List<SpecialAbilityIdentifier> specialAbilityIdParam;

		[IgnoreMapping]
		private EvolveIdentifier evolveId;

		[IgnoreMapping]
		private IceCubeIdentifier iceCubeId;

		[IgnoreMapping]
		private TailIdentifier tailId;

		public CustomCard(string name, List<AbilityIdentifier> abilityIdParam = null, List<SpecialAbilityIdentifier> specialAbilityIdParam = null, EvolveIdentifier evolveId = null, IceCubeIdentifier iceCubeId = null, TailIdentifier tailId = null)
		{
			this.name = name;
			this.abilityIdParam = abilityIdParam;
			this.specialAbilityIdParam = specialAbilityIdParam;
			this.evolveId = evolveId;
			this.iceCubeId = iceCubeId;
			this.tailId = tailId;
			CardManager.ModifyCardList += delegate(List<CardInfo> cards)
			{
				CardInfo val = cards.CardByName(this.name);
				if ((Object)(object)val != (Object)null)
				{
					AdjustCard(val, cards);
				}
				return cards;
			};
		}

		public CardInfo AdjustCard(CardInfo card, List<CardInfo> cardsToSearch)
		{
			TypeMapper<CustomCard, CardInfo>.Convert(this, card);
			if (tex != null)
			{
				card.SetPortrait(tex);
			}
			if (altTex != null)
			{
				card.SetAltPortrait(altTex);
			}
			if (pixelTex != null)
			{
				card.SetPixelPortrait(pixelTex);
			}
			if (decals != null)
			{
				card.AddDecal(decals.ToArray());
			}
			if (abilityIdParam != null)
			{
				card.AddAbilities(abilityIdParam.Select((AbilityIdentifier ai) => ai.realID).ToArray());
			}
			if (specialAbilityIdParam != null)
			{
				card.AssignSpecialAbilities(specialAbilityIdParam);
			}
			if (evolveId != null)
			{
				CardInfo val = cardsToSearch.CardByName(evolveId.name);
				if ((Object)(object)val != (Object)null)
				{
					card.SetEvolve(val, evolveId.turnsToEvolve, new List<CardModificationInfo> { evolveId.mods });
				}
			}
			if (tailId != null)
			{
				CardInfo val2 = cardsToSearch.CardByName(tailId.name);
				if ((Object)(object)val2 != (Object)null)
				{
					Texture2D tailLostTex = tailId.tailLostTex;
					IEnumerable<CardModificationInfo> mods = new List<CardModificationInfo> { tailId.mods };
					card.SetTail(val2, tailLostTex, null, mods);
				}
			}
			if (iceCubeId != null)
			{
				CardInfo val3 = cardsToSearch.CardByName(iceCubeId.name);
				if ((Object)(object)val3 != (Object)null)
				{
					card.SetIceCube(val3, new List<CardModificationInfo> { iceCubeId.mods });
				}
			}
			return card;
		}
	}
	[Obsolete("Use RegionManager instead", true)]
	public class CustomRegion
	{
		public string name;

		public int? tier;

		public List<CardInfo> terrainCards;

		public List<ConsumableItemData> consumableItems;

		public List<EncounterBlueprintData> encounters;

		public List<Type> bosses;

		public List<CardInfo> likelyCards;

		public List<Tribe> dominantTribes;

		public PredefinedNodes predefinedNodes;

		public EncounterBlueprintData bossPrepEncounter;

		public StoryEventCondition bossPrepCondition;

		public List<ScarceSceneryEntry> scarceScenery;

		public List<FillerSceneryEntry> fillerScenery;

		public PredefinedScenery predefinedScenery;

		public string ambientLoopId;

		public bool? silenceCabinAmbience;

		public Color? boardLightColor;

		public Color? cardsLightColor;

		public bool? dustParticlesDisabled;

		public bool? fogEnabled;

		public VolumetricFogProfile fogProfile;

		public float? fogAlpha;

		public Texture mapAlbedo;

		public Texture mapEmission;

		public Color? mapEmissionColor;

		public List<GameObject> mapParticlesPrefabs;

		public CustomRegion(string name)
		{
			this.name = name;
			RegionManager.ModifyRegionsList += ModifyRegions;
		}

		public List<RegionData> ModifyRegions(List<RegionData> regions)
		{
			RegionData val = ((IEnumerable<RegionData>)regions).FirstOrDefault((Func<RegionData, bool>)((RegionData r) => ((Object)r).name.Equals(name)));
			if ((Object)(object)val != (Object)null)
			{
				AdjustRegion(val);
			}
			return regions;
		}

		public RegionData AdjustRegion(RegionData region)
		{
			TypeMapper<CustomRegion, RegionData>.Convert(this, region);
			return region;
		}
	}
	[Obsolete("Use CardManager and CardInfo extension methods instead", true)]
	public class EvolveIdentifier
	{
		internal string name;

		internal int turnsToEvolve;

		internal CardModificationInfo mods;

		private EvolveParams evolution;

		public EvolveParams Evolution
		{
			get
			{
				if (evolution == null)
				{
					SetParams(CardLoader.GetCardByName(name));
				}
				return evolution;
			}
		}

		public EvolveIdentifier(string name, int turnsToEvolve, CardModificationInfo mods = null)
		{
			this.name = name;
			this.turnsToEvolve = turnsToEvolve;
			this.mods = mods;
		}

		private void SetParams(CardInfo card)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			evolution = new EvolveParams();
			evolution.turnsToEvolve = turnsToEvolve;
			evolution.evolution = card;
			if (mods != null)
			{
				evolution.evolution.mods.Add(mods);
			}
		}

		public override string ToString()
		{
			return name;
		}
	}
	[Obsolete("Use CardManager and CardInfo extension methods instead", true)]
	public class IceCubeIdentifier
	{
		internal string name;

		internal CardModificationInfo mods;

		private IceCubeParams iceCube;

		public IceCubeParams IceCube
		{
			get
			{
				if (iceCube == null)
				{
					SetParams(CardLoader.GetCardByName(name));
				}
				return iceCube;
			}
		}

		public IceCubeIdentifier(string name, CardModificationInfo mods = null)
		{
			this.name = name;
			this.mods = mods;
		}

		private void SetParams(CardInfo card)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			iceCube = new IceCubeParams();
			iceCube.creatureWithin = card;
			if (mods != null)
			{
				iceCube.creatureWithin.mods.Add(mods);
			}
		}

		public override string ToString()
		{
			return name;
		}
	}
	[Obsolete("Use AbilityManager instead", true)]
	public class NewAbility
	{
		public Ability ability;

		public AbilityInfo info;

		public Type abilityBehaviour;

		public Texture tex;

		public AbilityIdentifier id;

		public NewAbility(AbilityInfo info, Type abilityBehaviour, Texture tex, AbilityIdentifier id = null)
		{
			//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)
			string guid = ((id == null) ? abilityBehaviour.Namespace : id.guid);
			AbilityManager.FullAbility fullAbility = AbilityManager.Add(guid, info, abilityBehaviour, tex);
			ability = fullAbility.Id;
			this.info = fullAbility.Info;
			this.abilityBehaviour = fullAbility.AbilityBehavior;
			this.tex = fullAbility.Texture;
			this.id = AbilityIdentifier.GetID(guid, fullAbility.Info.rulebookName);
		}
	}
	[Obsolete("Use CardManager instead", true)]
	public static class NewCard
	{
		public static List<CardInfo> cards = new List<CardInfo>();

		public static Dictionary<int, List<AbilityIdentifier>> abilityIds = new Dictionary<int, List<AbilityIdentifier>>();

		public static Dictionary<int, List<SpecialAbilityIdentifier>> specialAbilityIds = new Dictionary<int, List<SpecialAbilityIdentifier>>();

		public static Dictionary<int, EvolveIdentifier> evolveIds = new Dictionary<int, EvolveIdentifier>();

		public static Dictionary<int, IceCubeIdentifier> iceCubeIds = new Dictionary<int, IceCubeIdentifier>();

		public static Dictionary<int, TailIdentifier> tailIds = new Dictionary<int, TailIdentifier>();

		public static Dictionary<string, Sprite> emissions = new Dictionary<string, Sprite>();

		public static void Add(CardInfo card, List<AbilityIdentifier> abilityIdsParam = null, List<SpecialAbilityIdentifier> specialAbilitiesIdsParam = null, EvolveIdentifier evolveId = null, IceCubeIdentifier iceCubeId = null, TailIdentifier tailId = null)
		{
			if (abilityIdsParam != null)
			{
				card.AddAbilities(abilityIdsParam.Select((AbilityIdentifier a) => a.realID).ToArray());
			}
			if (specialAbilitiesIdsParam != null)
			{
				card.AssignSpecialAbilities(specialAbilitiesIdsParam);
			}
			if (evolveId != null)
			{
				card.evolveParams = evolveId.Evolution;
			}
			if (iceCubeId != null)
			{
				card.iceCubeParams = iceCubeId.IceCube;
			}
			if (tailId != null)
			{
				card.tailParams = tailId.Tail;
			}
			CardManager.Add(card);
		}

		public static void Add(string name, string displayedName, int baseAttack, int baseHealth, List<CardMetaCategory> metaCategories, CardComplexity cardComplexity, CardTemple temple, string description = null, bool hideAttackAndHealth = false, int bloodCost = 0, int bonesCost = 0, int energyCost = 0, List<GemType> gemsCost = null, SpecialStatIcon specialStatIcon = 0, List<Tribe> tribes = null, List<Trait> traits = null, List<SpecialTriggeredAbility> specialAbilities = null, List<Ability> abilities = null, List<AbilityIdentifier> abilityIdsParam = null, List<SpecialAbilityIdentifier> specialAbilitiesIdsParam = null, EvolveParams evolveParams = null, string defaultEvolutionName = null, TailParams tailParams = null, IceCubeParams iceCubeParams = null, bool flipPortraitForStrafe = false, bool onePerDeck = false, List<Appearance> appearanceBehaviour = null, Texture2D defaultTex = null, Texture2D altTex = null, Texture titleGraphic = null, Texture2D pixelTex = null, Texture2D emissionTex = null, GameObject animatedPortrait = null, List<Texture> decals = null, EvolveIdentifier evolveId = null, IceCubeIdentifier iceCubeId = null, TailIdentifier tailId = null)
		{
			//IL_0059: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			CardInfo val = ScriptableObject.CreateInstance<CardInfo>();
			val.SetOldApiCard();
			((Object)val).name = name;
			val.displayedName = displayedName;
			val.baseAttack = baseAttack;
			val.baseHealth = baseHealth;
			val.description = description;
			val.SetCost(bloodCost, bonesCost, energyCost, gemsCost);
			val.hideAttackAndHealth = hideAttackAndHealth;
			val.cardComplexity = cardComplexity;
			val.temple = temple;
			val.AddMetaCategories(metaCategories.ToArray());
			val.specialStatIcon = specialStatIcon;
			if (tribes != null)
			{
				val.AddTribes(tribes.ToArray());
			}
			if (traits != null)
			{
				val.AddTraits(traits.ToArray());
			}
			if (specialAbilities != null)
			{
				val.AddSpecialAbilities(specialAbilities.ToArray());
			}
			if (specialAbilitiesIdsParam != null)
			{
				val.AssignSpecialAbilities(specialAbilitiesIdsParam);
			}
			if (abilities != null)
			{
				val.AddAbilities(abilities.ToArray());
			}
			if (abilityIdsParam != null)
			{
				val.AddAbilities(abilityIdsParam.Select((AbilityIdentifier a) => a.realID).ToArray());
			}
			val.evolveParams = evolveParams;
			val.tailParams = tailParams;
			val.iceCubeParams = iceCubeParams;
			val.defaultEvolutionName = defaultEvolutionName;
			val.flipPortraitForStrafe = flipPortraitForStrafe;
			val.onePerDeck = onePerDeck;
			if (appearanceBehaviour != null)
			{
				val.AddAppearances(appearanceBehaviour.ToArray());
			}
			if ((Object)(object)defaultTex != (Object)null)
			{
				val.SetPortrait(defaultTex);
			}
			if ((Object)(object)altTex != (Object)null)
			{
				val.SetAltPortrait(altTex);
			}
			val.titleGraphic = titleGraphic;
			if ((Object)(object)pixelTex != (Object)null)
			{
				val.SetPixelPortrait(pixelTex);
			}
			if ((Object)(object)emissionTex != (Object)null)
			{
				val.SetEmissivePortrait(emissionTex);
			}
			val.animatedPortrait = animatedPortrait;
			if (decals != null)
			{
				val.decals = new List<Texture>(decals);
			}
			if (evolveId != null)
			{
				val.SetEvolve(evolveId.name, evolveId.turnsToEvolve, new List<CardModificationInfo> { evolveId.mods });
			}
			if (iceCubeId != null)
			{
				val.SetIceCube(iceCubeId.name, new List<CardModificationInfo> { iceCubeId.mods });
			}
			if (tailId != null)
			{
				string name2 = tailId.name;
				Texture2D tailLostTex = tailId.tailLostTex;
				IEnumerable<CardModificationInfo> mods = new List<CardModificationInfo> { tailId.mods };
				val.SetTail(name2, tailLostTex, null, mods);
			}
			CardManager.Add(val);
		}

		internal static void AssignSpecialAbilities(this CardInfo info, IEnumerable<SpecialAbilityIdentifier> ids)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			info.AddSpecialAbilities((from a in ids
				where !a.ForStatIcon
				select a.specialTriggerID).ToArray());
			SpecialAbilityIdentifier specialAbilityIdentifier = ids.FirstOrDefault((SpecialAbilityIdentifier a) => a.ForStatIcon);
			if (specialAbilityIdentifier != null)
			{
				info.specialStatIcon = specialAbilityIdentifier.statIconID;
			}
		}
	}
	[Obsolete("Use CardAppearanceBehaviourManager instead", true)]
	public class NewCardAppearanceBehaviour
	{
		public static Dictionary<Appearance, NewCardAppearanceBehaviour> behaviours = new Dictionary<Appearance, NewCardAppearanceBehaviour>();

		public static List<NewCardAppearanceBehaviour> allBehaviours = new List<NewCardAppearanceBehaviour>();

		public Appearance Appearance;

		public string Name;

		public Type Behaviour;

		public static NewCardAppearanceBehaviour AddNewBackground(Type type, string name)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			CardAppearanceBehaviourManager.FullCardAppearanceBehaviour fullCardAppearanceBehaviour = CardAppearanceBehaviourManager.Add(type.Namespace, name, type);
			return new NewCardAppearanceBehaviour
			{
				Appearance = fullCardAppearanceBehaviour.Id,
				Name = name,
				Behaviour = type
			};
		}
	}
	[Obsolete("Use EncounterManager instead", true)]
	public class NewEncounter
	{
		public static List<NewEncounter> encounters = new List<NewEncounter>();

		public string name;

		public string regionName;

		public bool regular;

		public bool bossPrep;

		public EncounterBlueprintData encounterBlueprintData;

		private List<RegionData> SyncRegion(List<RegionData> region)
		{
			EncounterBlueprintData curClone = ((IEnumerable<EncounterBlueprintData>)EncounterManager.AllEncountersCopy).FirstOrDefault((Func<EncounterBlueprintData, bool>)((EncounterBlueprintData e) => ((Object)e).name.Equals(((Object)encounterBlueprintData).name)));
			if ((Object)(object)curClone == (Object)null)
			{
				InscryptionAPIPlugin.Logger.LogDebug((object)("Could not attach encounter named " + ((Object)encounterBlueprintData).name));
				return region;
			}
			if (curClone.regionSpecific)
			{
				if (!string.IsNullOrEmpty(regionName))
				{
					RegionData val = ((IEnumerable<RegionData>)region).FirstOrDefault((Func<RegionData, bool>)((RegionData r) => ((Object)r).name.Equals(regionName)));
					if ((Object)(object)val != (Object)null)
					{
						if (!bossPrep && !val.encounters.Any((EncounterBlueprintData e) => ((Object)e).name.Equals(((Object)curClone).name)))
						{
							InscryptionAPIPlugin.Logger.LogDebug((object)("Attaching encounter named " + ((Object)encounterBlueprintData).name + " to region " + ((Object)val).name));
							val.encounters.Add(curClone);
						}
						if (bossPrep)
						{
							val.bossPrepEncounter = curClone;
						}
					}
				}
			}
			else
			{
				foreach (RegionData item in region)
				{
					if (!item.encounters.Any((EncounterBlueprintData e) => ((Object)e).name.Equals(((Object)curClone).name)))
					{
						InscryptionAPIPlugin.Logger.LogDebug((object)("Attaching encounter named " + ((Object)encounterBlueprintData).name + " to region " + ((Object)item).name));
						item.encounters.Add(curClone);
					}
				}
			}
			return region;
		}

		public NewEncounter(string name, EncounterBlueprintData encounterBlueprintData, string regionName, bool regular, bool bossPrep)
		{
			this.name = name;
			this.encounterBlueprintData = encounterBlueprintData;
			((Object)this.encounterBlueprintData).name = name;
			this.regionName = regionName;
			this.bossPrep = bossPrep;
			this.regular = regular;
			EncounterManager.Add(encounterBlueprintData);
			RegionManager.ModifyRegionsList += SyncRegion;
			RegionManager.SyncRegionList();
		}

		public static void Add(string name, string regionName, List<TurnModBlueprint> turnMods = null, List<Tribe> dominantTribes = null, List<Ability> redundantAbilities = null, List<CardInfo> unlockedCardPrerequisites = null, bool regionSpecific = true, int minDifficulty = 0, int maxDifficulty = 30, List<CardInfo> randomReplacementCards = null, List<List<CardBlueprint>> turns = null, bool regular = true, bool bossPrep = false, int oldPreviewDifficulty = 0)
		{
			EncounterBlueprintData val = ScriptableObject.CreateInstance<EncounterBlueprintData>();
			if (turnMods != null)
			{
				val.turnMods = turnMods;
			}
			if (dominantTribes != null)
			{
				val.dominantTribes = dominantTribes;
			}
			if (redundantAbilities != null)
			{
				val.redundantAbilities = redundantAbilities;
			}
			if (unlockedCardPrerequisites != null)
			{
				val.unlockedCardPrerequisites = unlockedCardPrerequisites;
			}
			val.regionSpecific = regionSpecific;
			val.minDifficulty = minDifficulty;
			val.maxDifficulty = maxDifficulty;
			if (randomReplacementCards != null)
			{
				val.randomReplacementCards = randomReplacementCards;
			}
			if (turns != null)
			{
				val.turns = turns;
			}
			val.oldPreviewDifficulty = oldPreviewDifficulty;
			new NewEncounter(name, val, regionName, regular, bossPrep);
		}
	}
	[Obsolete("Use RegionManager instead", true)]
	public class NewRegion
	{
		public NewRegion(RegionData region, int tier)
		{
			RegionManager.Add(region, tier);
		}
	}
	[Obsolete("Use SpecialTriggeredAbilityManager instead", true)]
	public class NewSpecialAbility
	{
		public static List<NewSpecialAbility> specialAbilities = new List<NewSpecialAbility>();

		public SpecialTriggeredAbility specialTriggeredAbility;

		public StatIconInfo statIconInfo;

		public Type abilityBehaviour;

		public SpecialAbilityIdentifier id;

		public NewSpecialAbility(Type abilityBehaviour, SpecialAbilityIdentifier id, StatIconInfo statIconInfo = null)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)statIconInfo == (Object)null)
			{
				SpecialTriggeredAbilityManager.FullSpecialTriggeredAbility fullSpecialTriggeredAbility = SpecialTriggeredAbilityManager.Add(id.guid, id.name, abilityBehaviour);
				specialTriggeredAbility = fullSpecialTriggeredAbility.Id;
				this.abilityBehaviour = abilityBehaviour;
				this.id = id;
			}
			if ((Object)(object)statIconInfo != (Object)null)
			{
				StatIconManager.Add(id.guid, statIconInfo, abilityBehaviour);
				id.ForStatIcon = true;
				this.statIconInfo = statIconInfo;
				this.abilityBehaviour = abilityBehaviour;
			}
		}
	}
	[Obsolete("Use SpecialTriggeredAbilityManager instead", true)]
	public class SpecialAbilityIdentifier
	{
		internal string guid;

		internal string name;

		public SpecialTriggeredAbility id;

		internal SpecialTriggeredAbility specialTriggerID;

		internal SpecialStatIcon statIconID;

		internal bool ForStatIcon;

		private SpecialAbilityIdentifier(string guid, string name)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			this.guid = guid;
			this.name = name;
			specialTriggerID = (id = GuidManager.GetEnumValue<SpecialTriggeredAbility>(guid, name));
			statIconID = GuidManager.GetEnumValue<SpecialStatIcon>(guid, name);
		}

		public static SpecialAbilityIdentifier GetID(string guid, string name)
		{
			return new SpecialAbilityIdentifier(guid, name);
		}

		public override string ToString()
		{
			return guid + "(" + name + ")";
		}
	}
	[Obsolete("Use CardManager and CardInfo extension methods", true)]
	public class TailIdentifier
	{
		internal string name;

		internal CardModificationInfo mods;

		internal Texture2D tailLostTex;

		private TailParams tail;

		public TailParams Tail
		{
			get
			{
				if (tail == null)
				{
					SetParams(CardLoader.GetCardByName(name));
				}
				return tail;
			}
		}

		public TailIdentifier(string name, Texture2D tailLostTex = null, CardModificationInfo mods = null)
		{
			this.name = name;
			this.mods = mods;
			this.tailLostTex = tailLostTex;
		}

		private void SetParams(CardInfo card)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			TailParams val = new TailParams();
			if (tailLostTex != null)
			{
				((Object)tailLostTex).name = name;
				((Texture)tailLostTex).filterMode = (FilterMode)0;
				val.tailLostPortrait = tailLostTex.ConvertTexture(TextureHelper.SpriteType.CardPortrait, (FilterMode)0);
				((Object)val.tailLostPortrait).name = name;
			}
			val.tail = card;
			if (mods != null)
			{
				val.tail.mods.Add(mods);
			}
			tail = val;
		}

		public override string ToString()
		{
			return name;
		}
	}
	[Obsolete("Unncessary", true)]
	[AttributeUsage(AttributeTargets.Field)]
	public class IgnoreMappingAttribute : Attribute
	{
	}
	[Obsolete("Unnecessary", true)]
	public static class TypeMapper<S, D> where S : class where D : class
	{
		private static Dictionary<string, MethodInfo> _accessors;

		private static Dictionary<string, MethodInfo> _setters;

		private static Dictionary<string, MethodInfo> FieldAccessors
		{
			get
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				//IL_0094: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				if (_accessors == null)
				{
					_accessors = new Dictionary<string, MethodInfo>();
					foreach (FieldInfo item in from x in AccessTools.GetDeclaredFields(typeof(S))
						where !x.GetCustomAttributes(typeof(IgnoreMappingAttribute), inherit: false).Any()
						select x)
					{
						DynamicMethodDefinition val = new DynamicMethodDefinition("get_" + item.Name, typeof(object), new Type[1] { typeof(S) });
						ILProcessor iLProcessor = val.GetILProcessor();
						iLProcessor.Emit(OpCodes.Ldarg_0);
						iLProcessor.Emit(OpCodes.Ldfld, val.Module.ImportReference(item));
						if (item.FieldType.IsValueType)
						{
							Extensions.Emit(iLProcessor, OpCodes.Box, item.FieldType);
						}
						iLProcessor.Emit(OpCodes.Ret);
						_accessors.Add(item.Name, val.Generate());
					}
				}
				return _accessors;
			}
		}

		private static Dictionary<string, MethodInfo> FieldSetters
		{
			get
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Expected O, but got Unknown
				//IL_007d: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				if (_setters == null)
				{
					_setters = new Dictionary<string, MethodInfo>();
					foreach (FieldInfo declaredField in AccessTools.GetDeclaredFields(typeof(D)))
					{
						DynamicMethodDefinition val = new DynamicMethodDefinition("set_" + declaredField.Name, typeof(void), new Type[2]
						{
							typeof(D),
							typeof(object)
						});
						ILProcessor iLProcessor = val.GetILProcessor();
						iLProcessor.Emit(OpCodes.Ldarg_0);
						iLProcessor.Emit(OpCodes.Ldarg_1);
						iLProcessor.Emit(OpCodes.Unbox_Any, val.Module.ImportReference(declaredField.FieldType));
						iLProcessor.Emit(OpCodes.Stfld, val.Module.ImportReference(declaredField));
						iLProcessor.Emit(OpCodes.Ret);
						_setters.Add(declaredField.Name, val.Generate());
					}
				}
				return _setters;
			}
		}

		public static D Convert(S source, D destination)
		{
			foreach (KeyValuePair<string, MethodInfo> fieldAccessor in FieldAccessors)
			{
				object obj = fieldAccessor.Value.Invoke(null, new object[1] { source });
				if (obj != null && FieldSetters.ContainsKey(fieldAccessor.Key))
				{
					FieldSetters[fieldAccessor.Key].Invoke(null, new object[2] { destination, obj });
				}
			}
			return destination;
		}
	}
}
namespace InscryptionAPI
{
	[BepInPlugin("cyantist.inscryption.api", "InscryptionAPI", "2.23.1")]
	[HarmonyPatch]
	public class InscryptionAPIPlugin : BaseUnityPlugin
	{
		public const string ModGUID = "cyantist.inscryption.api";

		public const string ModName = "InscryptionAPI";

		public const string ModVer = "2.23.1";

		public static string Directory;

		internal static ConfigEntry<bool> configOverrideArrows;

		internal static ConfigEntry<bool> configRandomChoiceOrder;

		internal static ConfigEntry<bool> configHideAct1BossScenery;

		internal static ConfigEntry<TotemManager.TotemTopState> configCustomTotemTopTypes;

		internal static ConfigEntry<ConsumableItemManager.ConsumableState> configCustomItemTypes;

		internal static ManualLogSource Logger;

		private readonly Harmony HarmonyInstance = new Harmony("cyantist.inscryption.api");

		public static event Action<Type> ScriptableObjectLoaderLoad;

		static InscryptionAPIPlugin()
		{
			Directory = "";
			AppDomain.CurrentDomain.AssemblyResolve += (object _, ResolveEventArgs e) => e.Name.StartsWith("API, Version=1") ? typeof(InscryptionAPIPlugin).Assembly : null;
		}

		internal static void InvokeSOLEvent(Type type)
		{
			InscryptionAPIPlugin.ScriptableObjectLoaderLoad?.Invoke(type);
		}

		private void OnEnable()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Directory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			HarmonyInstance.PatchAll(typeof(InscryptionAPIPlugin).Assembly);
		}

		private void OnDisable()
		{
			HarmonyInstance.UnpatchSelf();
		}

		internal static void ResyncAll()
		{
			CardManager.SyncCardList();
			CardCostManager.SyncCustomCostList();
			CardModificationInfoManager.SyncCardMods();
			AbilityManager.SyncAbilityList();
			SlotModificationManager.SyncSlotModificationList();
			EncounterManager.SyncEncounterList();
			RegionManager.SyncRegionList();
			RuleBookManager.SyncRuleBookList();
		}

		internal static void CheckForOutdatedPlugins()
		{
			string text = "";
			foreach (Assembly item in Chainloader.PluginInfos.Values.Select((PluginInfo p) => ((object)p.Instance).GetType().Assembly).Distinct())
			{
				AssemblyName[] referencedAssemblies = item.GetReferencedAssemblies();
				for (int i = 0; i < referencedAssemblies.Length; i++)
				{
					if (referencedAssemblies[i].Name.Equals("API"))
					{
						text = text + " - " + item.GetName().Name + "\n";
					}
				}
			}
			if (text != "")
			{
				Logger.LogWarning((object)("The following mods use an outdated version of the API:\n" + text + "\nThese mods may not work correctly. If problems arise, please update or disable them!"));
			}
		}

		private void Awake()
		{
			configCustomTotemTopTypes = ((BaseUnityPlugin)this).Config.Bind<TotemManager.TotemTopState>("Totems", "Top Types", TotemManager.TotemTopState.CustomTribes, "If Vanilla, don't change totem tops; if CustomTribes, added custom tribes will use custom totem tops; if AllTribes then all totem tops will use a custom top.");
			configCustomItemTypes = ((BaseUnityPlugin)this).Config.Bind<ConsumableItemManager.ConsumableState>("Items", "Types", ConsumableItemManager.ConsumableState.Custom, "If Vanilla, only vanilla items will be used; if Custom, added custom items will use custom models; if All then all items will use a custom model.");
			configOverrideArrows = ((BaseUnityPlugin)this).Config.Bind<bool>("Menus", "Override Arrows", false, "When true, forces the challenge screen arrows to appear at the top of the screen instead of the sides.");
			configRandomChoiceOrder = ((BaseUnityPlugin)this).Config.Bind<bool>("Miscellaneous", "Randomise Cost Choice Order", false, "When true, randomises the order card cost choices are presented in Act 1.");
			configHideAct1BossScenery = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimization", "Hide Act 1 Scenery", false, "When true bosses will not spawn their scenery. (eg: Prospector's trees) This can improve performance on low-end machines.");
		}

		private void Start()
		{
			CheckForOutdatedPlugins();
			DeathCardManager.AddCustomDeathCards();
			CardManager.ActivateEvents();
			CardManager.ResolveMissingModPrefixes();
			ResyncAll();
			CardManager.AuditCardList();
			PixelCardManager.Initialise();
			PeltManager.CreateDialogueEvents();
			DialogueManager.CustomDialogue.Exists((DialogueManager.Dialogue x) => x.DialogueEvent.id == "Hint_NotEnoughSameColourGemsHint");
			Logger.LogDebug((object)$"Inserted {DialogueManager.CustomDialogue.Count} dialogue event(s)!");
		}

		[HarmonyPatch(typeof(AscensionMenuScreens), "TransitionToGame")]
		[HarmonyPrefix]
		private static void SyncCardsAndAbilitiesWhenTransitioningToAscensionGame()
		{
			ResyncAll();
		}

		[HarmonyPatch(typeof(MenuController), "TransitionToGame")]
		[HarmonyPrefix]
		private static void SyncCardsAndAbilitiesWhenTransitioningToGame()
		{
			ResyncAll();
		}
	}
}
namespace InscryptionAPI.Triggers
{
	public static class CustomTriggerFinder
	{
		[CompilerGenerated]
		private sealed class <CustomTriggerSequence>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public TriggerReceiver receiver;

			public IEnumerator triggerCoroutine;

			private GlobalTriggerHandler <self>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<self>5__2 = Singleton<GlobalTriggerHandler>.Instance;
					if ((Object)(object)<self>5__2 != (Object)null)
					{
						GlobalTriggerHandler obj2 = <self>5__2;
						obj2.NumTriggersThisBattle += 1;
						GlobalTriggerHandler obj3 = <self>5__2;
						obj3.StackSize += 1;
						receiver.Activating = true;
						<>2__current = triggerCoroutine;
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
				{
					<>1__state = -1;
					GlobalTriggerHandler obj = <self>5__2;
					obj.StackSize -= 1;
					receiver.Activating = false;
					if (receiver.DestroyAfterActivation)
					{
						receiver.Destroy();
					}
					break;
				}
				}
				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 <FindTriggersOnCard>d__22<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private PlayableCard card;

			public PlayableCard <>3__card;

			private IEnumerator<T> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <FindTriggersOnCard>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = card.TriggerHandler.GetAllReceivers().OfType<T>().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<FindTriggersOnCard>d__22<T> <FindTriggersOnCard>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindTriggersOnCard>d__ = this;
				}
				else
				{
					<FindTriggersOnCard>d__ = new <FindTriggersOnCard>d__22<T>(0);
				}
				<FindTriggersOnCard>d__.card = <>3__card;
				return <FindTriggersOnCard>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <FindTriggersOnCard>d__23<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			private CardTriggerHandler card;

			public CardTriggerHandler <>3__card;

			private IEnumerator<T> <>7__wrap1;

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

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

			[DebuggerHidden]
			public <FindTriggersOnCard>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = card.GetAllReceivers().OfType<T>().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<FindTriggersOnCard>d__23<T> <FindTriggersOnCard>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<FindTriggersOnCard>d__ = this;
				}
				else
				{
					<FindTriggersOnCard>d__ = new <FindTriggersOnCard>d__23<T>(0);
				}
				<FindTriggersOnCard>d__.card = <>3__card;
				return <FindTriggersOnCard>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <Trigger>d__2<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CardTriggerHandler handler;

			public Func<T, bool> respond;

			public Func<T, IEnumerator> trigger;

			private IEnumerator<T> <>7__wrap1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<T> enumerable = handler.FindTriggersOnCard<T>();
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						object obj = current;
						if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(current))
						{
							ref object reference = ref <>2__current;
							object obj2 = current;
							reference = ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(current));
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <Trigger>d__3<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayableCard card;

			public Func<T, bool> respond;

			public Func<T, IEnumerator> trigger;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = card.TriggerHandler.Trigger(respond, trigger);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <TriggerAll>d__1<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool triggerFacedown;

			public Func<T, bool> respond;

			public Func<T, IEnumerator> trigger;

			private IEnumerator<T> <>7__wrap1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<T> enumerable = FindGlobalTriggers<T>(triggerFacedown);
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						object obj = current;
						if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(current))
						{
							ref object reference = ref <>2__current;
							object obj2 = current;
							reference = ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(current));
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					_ = triggerFacedown;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <TriggerInHand>d__5<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Func<T, bool> respond;

			public Func<T, IEnumerator> trigger;

			private IEnumerator<T> <>7__wrap1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<T> enumerable = FindTriggersInHand<T>();
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						object obj = current;
						if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(current))
						{
							ref object reference = ref <>2__current;
							object obj2 = current;
							reference = ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(current));
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		[CompilerGenerated]
		private sealed class <TriggerOnBoard>d__4<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool triggerFacedown;

			public Func<T, bool> respond;

			public Func<T, IEnumerator> trigger;

			private IEnumerator<T> <>7__wrap1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IEnumerable<T> enumerable = FindTriggersOnBoard<T>(triggerFacedown);
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						T current = <>7__wrap1.Current;
						object obj = current;
						if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(current))
						{
							ref object reference = ref <>2__current;
							object obj2 = current;
							reference = ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(current));
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

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

		[IteratorStateMachine(typeof(<CustomTriggerSequence>d__0))]
		public static IEnumerator CustomTriggerSequence(this TriggerReceiver receiver, IEnumerator triggerCoroutine)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CustomTriggerSequence>d__0(0)
			{
				receiver = receiver,
				triggerCoroutine = triggerCoroutine
			};
		}

		[IteratorStateMachine(typeof(<TriggerAll>d__1<>))]
		public static IEnumerator TriggerAll<T>(bool triggerFacedown, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TriggerAll>d__1<T>(0)
			{
				triggerFacedown = triggerFacedown,
				respond = respond,
				trigger = trigger
			};
		}

		[IteratorStateMachine(typeof(<Trigger>d__2<>))]
		public static IEnumerator Trigger<T>(this CardTriggerHandler handler, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Trigger>d__2<T>(0)
			{
				handler = handler,
				respond = respond,
				trigger = trigger
			};
		}

		[IteratorStateMachine(typeof(<Trigger>d__3<>))]
		public static IEnumerator Trigger<T>(this PlayableCard card, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Trigger>d__3<T>(0)
			{
				card = card,
				respond = respond,
				trigger = trigger
			};
		}

		[IteratorStateMachine(typeof(<TriggerOnBoard>d__4<>))]
		public static IEnumerator TriggerOnBoard<T>(bool triggerFacedown, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TriggerOnBoard>d__4<T>(0)
			{
				triggerFacedown = triggerFacedown,
				respond = respond,
				trigger = trigger
			};
		}

		[IteratorStateMachine(typeof(<TriggerInHand>d__5<>))]
		public static IEnumerator TriggerInHand<T>(Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TriggerInHand>d__5<T>(0)
			{
				respond = respond,
				trigger = trigger
			};
		}

		public static List<(TriggerReceiver, T2)> CollectDataAll<T, T2>(bool collectFromFacedown, Func<T, bool> respond, Func<T, T2> collect)
		{
			List<(TriggerReceiver, T2)> list = new List<(TriggerReceiver, T2)>();
			foreach (T item in FindGlobalTriggers<T>(collectFromFacedown))
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add(((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null), collect(item)));
				}
			}
			return list;
		}

		public static List<(TriggerReceiver, T2)> CollectDataOnBoard<T, T2>(bool collectFromFacedown, Func<T, bool> respond, Func<T, T2> collect)
		{
			List<(TriggerReceiver, T2)> list = new List<(TriggerReceiver, T2)>();
			foreach (T item in FindTriggersOnBoard<T>(collectFromFacedown))
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add(((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null), collect(item)));
				}
			}
			return list;
		}

		public static List<(TriggerReceiver, T2)> CollectDataInHand<T, T2>(Func<T, bool> respond, Func<T, T2> collect)
		{
			List<(TriggerReceiver, T2)> list = new List<(TriggerReceiver, T2)>();
			foreach (T item in FindTriggersInHand<T>())
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add(((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null), collect(item)));
				}
			}
			return list;
		}

		public static List<(TriggerReceiver, T2)> CollectData<T, T2>(this PlayableCard self, Func<T, bool> respond, Func<T, T2> collect)
		{
			return self.TriggerHandler.CollectData(respond, collect);
		}

		public static List<(TriggerReceiver, T2)> CollectData<T, T2>(this CardTriggerHandler self, Func<T, bool> respond, Func<T, T2> collect)
		{
			List<(TriggerReceiver, T2)> list = new List<(TriggerReceiver, T2)>();
			foreach (T item in self.FindTriggersOnCard<T>())
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add(((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null), collect(item)));
				}
			}
			return list;
		}

		public static List<TriggerReceiver> CallAll<T>(bool triggerFacedown, Func<T, bool> respond, Action<T> call)
		{
			List<TriggerReceiver> list = new List<TriggerReceiver>();
			foreach (T item in FindGlobalTriggers<T>(triggerFacedown))
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null));
					call(item);
				}
			}
			return list;
		}

		public static List<TriggerReceiver> CallOnBoard<T>(bool triggerFacedown, Func<T, bool> respond, Action<T> call)
		{
			List<TriggerReceiver> list = new List<TriggerReceiver>();
			foreach (T item in FindTriggersOnBoard<T>(triggerFacedown))
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null));
					call(item);
				}
			}
			return list;
		}

		public static List<TriggerReceiver> CallInHand<T>(Func<T, bool> respond, Action<T> call)
		{
			List<TriggerReceiver> list = new List<TriggerReceiver>();
			foreach (T item in FindTriggersInHand<T>())
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null));
					call(item);
				}
			}
			return list;
		}

		public static List<TriggerReceiver> Call<T>(this PlayableCard self, Func<T, bool> respond, Action<T> call)
		{
			return self.TriggerHandler.Call(respond, call);
		}

		public static List<TriggerReceiver> Call<T>(this CardTriggerHandler self, Func<T, bool> respond, Action<T> call)
		{
			List<TriggerReceiver> list = new List<TriggerReceiver>();
			foreach (T item in self.FindTriggersOnCard<T>())
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					list.Add((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null));
					call(item);
				}
			}
			return list;
		}

		public static IEnumerable<T> FindGlobalTriggers<T>(bool findFacedown, PlayableCard excluding = null)
		{
			IEnumerable<T> enumerable = Enumerable.Empty<T>();
			if (Object.op_Implicit((Object)(object)Singleton<BoardManager>.Instance))
			{
				enumerable = enumerable.Concat(FindTriggersOnBoard<T>(findFacedown));
			}
			if (Object.op_Implicit((Object)(object)Singleton<PlayerHand>.Instance))
			{
				enumerable = enumerable.Concat(FindTriggersInHandExcluding<T>(excluding));
			}
			return enumerable;
		}

		public static IEnumerable<T> FindGlobalTriggers<T>(PlayableCard excluding = null)
		{
			return FindGlobalTriggers<T>(findFacedown: true, excluding);
		}

		public static IEnumerable<T> FindTriggersInHand<T>()
		{
			return new List<PlayableCard>(Singleton<PlayerHand>.Instance.CardsInHand).Where((PlayableCard c) => (Object)(object)c != (Object)null && c.InHand).SelectMany(FindTriggersOnCard<T>);
		}

		public static IEnumerable<T> FindTriggersOnBoard<T>()
		{
			return FindTriggersOnBoard<T>(findFacedown: true);
		}

		public static IEnumerable<T> FindTriggersOnBoard<T>(bool findFacedown)
		{
			List<PlayableCard> source = new List<PlayableCard>(Singleton<BoardManager>.Instance.CardsOnBoard);
			List<NonCardTriggerReceiver> source2 = new List<NonCardTriggerReceiver>(Singleton<GlobalTriggerHandler>.Instance.nonCardReceivers);
			List<SlotModificationBehaviour> source3 = new List<SlotModificationBehaviour>(SlotModificationManager.Instance?.SlotReceivers?.Select((KeyValuePair<CardSlot, Tuple<SlotModificationManager.ModificationType, SlotModificationBehaviour>> kvp) => kvp.Value.Item2) ?? Enumerable.Empty<SlotModificationBehaviour>());
			return (from x in source2
				where !UnityExtensions.SafeIsUnityNull((Object)(object)x)
				where x.TriggerBeforeCards
				select x).OfType<T>().Concat(source3.Where((SlotModificationBehaviour x) => !UnityExtensions.SafeIsUnityNull((Object)(object)x)).OfType<T>()).Concat(source.Where((PlayableCard x) => (Object)(object)x != (Object)null && x.OnBoard && (!((Card)x).FaceDown || findFacedown)).SelectMany(FindTriggersOnCard<T>))
				.Concat((from x in source2
					where !UnityExtensions.SafeIsUnityNull((Object)(object)x)
					where !x.TriggerBeforeCards
					select x).OfType<T>())
				.Concat(from x in source.Where((PlayableCard x) => (Object)(object)x != (Object)null && x.OnBoard && ((Card)x).FaceDown && !findFacedown).SelectMany(FindTriggersOnCard<T>)
					where x is IActivateWhenFacedown && (x as IActivateWhenFacedown).ShouldTriggerCustomWhenFaceDown(typeof(T))
					select x);
		}

		public static IEnumerable<T> FindTriggersInHandExcluding<T>(PlayableCard card)
		{
			return new List<PlayableCard>(Singleton<PlayerHand>.Instance.CardsInHand).Where((PlayableCard x) => (Object)(object)x != (Object)null && x.InHand && (Object)(object)x != (Object)(object)card).SelectMany(FindTriggersOnCard<T>);
		}

		[IteratorStateMachine(typeof(<FindTriggersOnCard>d__22<>))]
		public static IEnumerable<T> FindTriggersOnCard<T>(this PlayableCard card)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindTriggersOnCard>d__22<T>(-2)
			{
				<>3__card = card
			};
		}

		[IteratorStateMachine(typeof(<FindTriggersOnCard>d__23<>))]
		public static IEnumerable<T> FindTriggersOnCard<T>(this CardTriggerHandler card)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FindTriggersOnCard>d__23<T>(-2)
			{
				<>3__card = card
			};
		}

		public static IEnumerable<T> FindTriggersInQueue<T>()
		{
			TurnManager instance = Singleton<TurnManager>.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Opponent opponent = instance.Opponent;
				T val = default(T);
				obj = ((opponent != null) ? (from card in opponent.Queue
					where ((Component)card).TryGetComponent<T>(ref val)
					select ((Component)card).GetComponent<T>()) : null);
			}
			if (obj == null)
			{
				obj = new T[0];
			}
			return (IEnumerable<T>)obj;
		}
	}
	[HarmonyPatch]
	internal static class CustomTriggerPatches
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0
		{
			public PlayableCard card;

			internal bool <TriggerOnAddedToHand>b__2(IOnOtherCardAddedToHand x)
			{
				return x.RespondsToOtherCardAddedToHand(card);
			}

			internal IEnumerator <TriggerOnAddedToHand>b__3(IOnOtherCardAddedToHand x)
			{
				return x.OnOtherCardAddedToHand(card);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public PlayableCard card;

			internal bool <TriggerOnOtherCardResolveInHand>b__0(IOnOtherCardResolveInHand x)
			{
				return x.RespondsToOtherCardResolveInHand(card);
			}

			internal IEnumerator <TriggerOnOtherCardResolveInHand>b__1(IOnOtherCardResolveInHand x)
			{
				return x.OnOtherCardResolveInHand(card);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_0
		{
			public PlayableCard card;

			public CardSlot slot2;

			internal bool <TriggerOnOtherCardAssignedToSlotInHand>b__0(IOnCardAssignedToSlotContext x)
			{
				return x.RespondsToCardAssignedToSlotContext(card, slot2, card.Slot);
			}

			internal IEnumerator <TriggerOnOtherCardAssignedToSlotInHand>b__1(IOnCardAssignedToSlotContext x)
			{
				return x.OnCardAssignedToSlotContext(card, slot2, card.Slot);
			}

			internal bool <TriggerOnOtherCardAssignedToSlotInHand>b__2(IOnOtherCardAssignedToSlotInHand x)
			{
				return x.RespondsToOtherCardAssignedToSlotInHand(card);
			}

			internal IEnumerator <TriggerOnOtherCardAssignedToSlotInHand>b__3(IOnOtherCardAssignedToSlotInHand x)
			{
				return x.OnOtherCardAssignedToSlotInHand(card);
			}

			internal bool <TriggerOnOtherCardAssignedToSlotInHand>b__4(IOnCardAssignedToSlotNoResolve x)
			{
				return x.RespondsToCardAssignedToSlotNoResolve(card);
			}

			internal IEnumerator <TriggerOnOtherCardAssignedToSlotInHand>b__5(IOnCardAssignedToSlotNoResolve x)
			{
				return x.OnCardAssignedToSlotNoResolve(card);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass15_0
		{
			public CardSlot slotBeforeDeath;

			public bool wasSacrifice;

			public PlayableCard killer;

			public PlayableCard __instance;

			public Func<IOnOtherCardPreDeathInHand, bool> <>9__0;

			public Func<IOnOtherCardPreDeathInHand, IEnumerator> <>9__1;

			public Func<IOnOtherCardDieInHand, bool> <>9__2;

			public Func<IOnOtherCardDieInHand, IEnumerator> <>9__3;

			internal bool <TriggerDeathTriggers>b__0(IOnOtherCardPreDeathInHand x)
			{
				return x.RespondsToOtherCardPreDeathInHand(slotBeforeDeath, !wasSacrifice, killer);
			}

			internal IEnumerator <TriggerDeathTriggers>b__1(IOnOtherCardPreDeathInHand x)
			{
				return x.OnOtherCardPreDeathInHand(slotBeforeDeath, !wasSacrifice, killer);
			}

			internal bool <TriggerDeathTriggers>b__2(IOnOtherCardDieInHand x)
			{
				return x.RespondsToOtherCardDieInHand(__instance, slotBeforeDeath, !wasSacrifice, killer);
			}

			internal IEnumerator <TriggerDeathTriggers>b__3(IOnOtherCardDieInHand x)
			{
				return x.OnOtherCardDieInHand(__instance, slotBeforeDeath, !wasSacrifice, killer);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_0
		{
			public string consumableName;

			public bool itemCanBeUsed;

			public ConsumableItemSlot __instance;

			internal bool <TriggerItemUse>b__0(IItemCanBeUsed x)
			{
				return x.RespondsToItemCanBeUsed(consumableName, itemCanBeUsed);
			}

			internal bool <TriggerItemUse>b__1(IItemCanBeUsed x)
			{
				return itemCanBeUsed = x.CollectItemCanBeUsed(consumableName, itemCanBeUsed);
			}

			internal bool <TriggerItemUse>b__4(IOnPreItemUsed x)
			{
				return x.RespondsToPreItemUsed(consumableName, __instance is HammerItemSlot);
			}

			internal IEnumerator <TriggerItemUse>b__5(IOnPreItemUsed x)
			{
				return x.OnPreItemUsed(consumableName, __instance is HammerItemSlot);
			}

			internal bool <TriggerItemUse>b__2(IOnItemPreventedFromUse x)
			{
				return x.RespondsToItemPreventedFromUse(consumableName);
			}

			internal IEnumerator <TriggerItemUse>b__3(IOnItemPreventedFromUse x)
			{
				return x.OnItemPreventedFromUse(consumableName);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_1
		{
			public bool successInActivation;

			public <>c__DisplayClass16_0 CS$<>8__locals1;

			internal bool <TriggerItemUse>b__6(IOnPostItemUsed x)
			{
				return x.RespondsToPostItemUsed(CS$<>8__locals1.consumableName, successInActivation, CS$<>8__locals1.__instance is HammerItemSlot);
			}

			internal IEnumerator <TriggerItemUse>b__7(IOnPostItemUsed x)
			{
				return x.OnPostItemUsed(CS$<>8__locals1.consumableName, successInActivation, CS$<>8__locals1.__instance is HammerItemSlot);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0
		{
			public bool playerIsAttacker;

			internal bool <TriggerOnBellRung>b__0(IOnBellRung x)
			{
				return x.RespondsToBellRung(playerIsAttacker);
			}

			internal IEnumerator <TriggerOnBellRung>b__1(IOnBellRung x)
			{
				return x.OnBellRung(playerIsAttacker);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0
		{
			public CardSlot slot;

			internal bool <TriggerOnSlotAttackSequence>b__0(IOnPreSlotAttackSequence x)
			{
				return x.RespondsToPreSlotAttackSequence(slot);
			}

			internal IEnumerator <TriggerOnSlotAttackSequence>b__1(IOnPreSlotAttackSequence x)
			{
				return x.OnPreSlotAttackSequence(slot);
			}

			internal bool <TriggerOnSlotAttackSequence>b__2(IOnPostSlotAttackSequence x)
			{
				return x.RespondsToPostSlotAttackSequence(slot);
			}

			internal IEnumerator <TriggerOnSlotAttackSequence>b__3(IOnPostSlotAttackSequence x)
			{
				return x.OnPostSlotAttackSequence(slot);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public CardSlot attackingSlot;

			public CardSlot opposingSlot;

			internal bool <TriggerOnPostSingularSlotAttackSlot>b__0(IOnPostSingularSlotAttackSlot x)
			{
				return x.RespondsToPostSingularSlotAttackSlot(attackingSlot, opposingSlot);
			}

			internal IEnumerator <TriggerOnPostSingularSlotAttackSlot>b__1(IOnPostSingularSlotAttackSlot x)
			{
				return x.OnPostSingularSlotAttackSlot(attackingSlot, opposingSlot);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass8_0
		{
			public int damage;

			public int numWeights;

			public bool toPlayer;

			public int initialDamage;

			public bool initialToPlayer;

			internal bool <TriggerOnScalesChanged>b__0(IOnPreScalesChangedRef x)
			{
				return x.RespondsToPreScalesChangedRef(damage, numWeights, toPlayer);
			}

			internal int <TriggerOnScalesChanged>b__1(IOnPreScalesChangedRef x)
			{
				damage = x.CollectPreScalesChangedRef(damage, ref numWeights, ref toPlayer);
				if (damage < 0)
				{
					damage = -damage;
					toPlayer = !toPlayer;
				}
				return damage;
			}

			internal bool <TriggerOnScalesChanged>b__2(IOnPreScalesChanged x)
			{
				return x.RespondsToPreScalesChanged(damage, toPlayer, initialDamage, initialToPlayer);
			}

			internal IEnumerator <TriggerOnScalesChanged>b__3(IOnPreScalesChanged x)
			{
				return x.OnPreScalesChanged(damage, toPlayer, initialDamage, initialToPlayer);
			}

			internal bool <TriggerOnScalesChanged>b__4(IOnPostScalesChanged x)
			{
				return x.RespondsToPostScalesChanged(damage, toPlayer, initialDamage, initialToPlayer);
			}

			internal IEnumerator <TriggerOnScalesChanged>b__5(IOnPostScalesChanged x)
			{
				return x.OnPostScalesChanged(damage, toPlayer, initialDamage, initialToPlayer);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass9_0
		{
			public bool playerUpkeep;

			internal bool <TriggerOnUpkeepInHand>b__0(IOnUpkeepInHand x)
			{
				return x.RespondsToUpkeepInHand(playerUpkeep);
			}

			internal IEnumerator <TriggerOnUpkeepInHand>b__1(IOnUpkeepInHand x)
			{
				return x.OnUpkeepInHand(playerUpkeep);
			}
		}

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

			private object <>2__current;

			public bool wasSacrifice;

			public PlayableCard killer;

			public PlayableCard __instance;

			public IEnumerator result;

			private <>c__DisplayClass15_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Invalid comparison between Unknown and I4
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Invalid comparison between Unknown and I4
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass15_0();
					<>8__1.wasSacrifice = wasSacrifice;
					<>8__1.killer = killer;
					<>8__1.__instance = __instance;
					<>8__1.slotBeforeDeath = <>8__1.__instance.Slot;
					break;
				case 1:
				{
					<>1__state = -1;
					if (!(result.Current.GetType() == triggerType))
					{
						break;
					}
					Trigger val = (Trigger)21;
					try
					{
						val = (Trigger)(triggerField ?? (triggerField = triggerType.GetField("trigger"))).GetValue(result.Current);
					}
					catch
					{
					}
					if ((int)val == 17)
					{
						<>2__current = CustomTriggerFinder.TriggerInHand((IOnOtherCardPreDeathInHand x) => x.RespondsToOtherCardPreDeathInHand(<>8__1.slotBeforeDeath, !<>8__1.wasSacrifice, <>8__1.killer), (IOnOtherCardPreDeathInHand x) => x.OnOtherCardPreDeathInHand(<>8__1.slotBeforeDeath, !<>8__1.wasSacrifice, <>8__1.killer));
						<>1__state = 2;
						return true;
					}
					if ((int)val == 11)
					{
						<>2__current = CustomTriggerFinder.TriggerInHand((IOnOtherCardDieInHand x) => x.RespondsToOtherCardDieInHand(<>8__1.__instance, <>8__1.slotBeforeDeath, !<>8__1.wasSacrifice, <>8__1.killer), (IOnOtherCardDieInHand x) => x.OnOtherCardDieInHand(<>8__1.__instance, <>8__1.slotBeforeDeath, !<>8__1.wasSacrifice, <>8__1.killer));
						<>1__state = 3;
						return true;
					}
					break;
				}
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					break;
				}
				if (result.MoveNext())
				{
					<>2__current = result.Current;
					<>1__state = 1;
					return true;
				}
				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 <TriggerItemUse>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ConsumableItemSlot __instance;

			public IEnumerator result;

			private <>c__DisplayClass16_1 <>8__1;

			private Type <activationtype>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass16_0 CS$<>8__locals0 = new <>c__DisplayClass16_0
					{
						__instance = __instance,
						itemCanBeUsed = true
					};
					ConsumableItemSlot _instance = CS$<>8__locals0.__instance;
					object consumableName;
					if (_instance == null)
					{
						consumableName = null;
					}
					else
					{
						ConsumableItem consumable = _instance.Consumable;
						if (consumable == null)
						{
							consumableName = null;
						}
						else
						{
							ItemData data = ((Item)consumable).Data;
							consumableName = ((data != null) ? ((Object)data).name : null);
						}
					}
					CS$<>8__locals0.consumableName = (string)consumableName;
					if (!string.IsNullOrEmpty(CS$<>8__locals0.consumableName))
					{
						CustomTriggerFinder.CollectDataAll(collectFromFacedown: false, (IItemCanBeUsed x) => x.RespondsToItemCanBeUsed(CS$<>8__locals0.consumableName, CS$<>8__locals0.itemCanBeUsed), (IItemCanBeUsed x) => CS$<>8__locals0.itemCanBeUsed = x.CollectItemCanBeUsed(CS$<>8__locals0.consumableName, CS$<>8__locals0.itemCanBeUsed));
					}
					if (CS$<>8__locals0.itemCanBeUsed)
					{
						<>8__1 = new <>c__DisplayClass16_1();
						<>8__1.CS$<>8__locals1 = CS$<>8__locals0;
						<>8__1.successInActivation = false;
						<activationtype>5__2 = <>8__1.CS$<>8__locals1.__instance.Consumable.ActivateSequence().GetType();
						if (!string.IsNullOrEmpty(<>8__1.CS$<>8__locals1.consumableName))
						{
							<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreItemUsed x) => x.RespondsToPreItemUsed(<>8__1.CS$<>8__locals1.consumableName, <>8__1.CS$<>8__locals1.__instance is HammerItemSlot), (IOnPreItemUsed x) => x.OnPreItemUsed(<>8__1.CS$<>8__locals1.consumableName, <>8__1.CS$<>8__locals1.__instance is HammerItemSlot));
							<>1__state = 1;
							return true;
						}
						goto IL_01f3;
					}
					ConsumableItemSlot _instance2 = CS$<>8__locals0.__instance;
					if (_instance2 != null)
					{
						ConsumableItem consumable2 = _instance2.Consumable;
						if (consumable2 != null)
						{
							consumable2.PlayShakeAnimation();
						}
					}
					if (!string.IsNullOrEmpty(CS$<>8__locals0.consumableName))
					{
						<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnItemPreventedFromUse x) => x.RespondsToItemPreventedFromUse(CS$<>8__locals0.consumableName), (IOnItemPreventedFromUse x) => x.OnItemPreventedFromUse(CS$<>8__locals0.consumableName));
						<>1__state = 4;
						return true;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					goto IL_01f3;
				case 2:
					<>1__state = -1;
					if (result.Current.GetType() == <activationtype>5__2 && !string.IsNullOrEmpty(<>8__1.CS$<>8__locals1.consumableName) && (Object)(object)<>8__1.CS$<>8__locals1.__instance.Consumable != (Object)null)
					{
						<>8__1.successInActivation = !<>8__1.CS$<>8__locals1.__instance.Consumable.ActivationCancelled;
					}
					goto IL_01f3;
				case 3:
					<>1__state = -1;
					goto IL_0258;
				case 4:
					{
						<>1__state = -1;
						break;
					}
					IL_0258:
					<>8__1 = null;
					<activationtype>5__2 = null;
					break;
					IL_01f3:
					if (result.MoveNext())
					{
						<>2__current = result.Current;
						<>1__state = 2;
						return true;
					}
					if (!string.IsNullOrEmpty(<>8__1.CS$<>8__locals1.consumableName))
					{
						<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostItemUsed x) => x.RespondsToPostItemUsed(<>8__1.CS$<>8__locals1.consumableName, <>8__1.successInActivation, <>8__1.CS$<>8__locals1.__instance is HammerItemSlot), (IOnPostItemUsed x) => x.OnPostItemUsed(<>8__1.CS$<>8__locals1.consumableName, <>8__1.successInActivation, <>8__1.CS$<>8__locals1.__instance is HammerItemSlot));
						<>1__state = 3;
						return true;
					}
					goto IL_0258;
				}
				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 <TriggerOnAddedToHand>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayableCard card;

			public IEnumerator result;

			private <>c__DisplayClass0_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass0_0();
					<>8__1.card = card;
					<>2__current = result;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = <>8__1.card.TriggerHandler.Trigger((IOnAddedToHand x) => x.RespondsToAddedToHand(), (IOnAddedToHand x) => x.OnAddedToHand());
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnOtherCardAddedToHand x) => x.RespondsToOtherCardAddedToHand(<>8__1.card), (IOnOtherCardAddedToHand x) => x.OnOtherCardAddedToHand(<>8__1.card));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public bool playerIsAttacker;

			public IEnumerator result;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass1_0 CS$<>8__locals0 = new <>c__DisplayClass1_0
					{
						playerIsAttacker = playerIsAttacker
					};
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnBellRung x) => x.RespondsToBellRung(CS$<>8__locals0.playerIsAttacker), (IOnBellRung x) => x.OnBellRung(CS$<>8__locals0.playerIsAttacker));
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = result;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public PlayableCard card;

			public IEnumerator result;

			public bool resolveTriggers;

			private <>c__DisplayClass13_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass13_0();
					<>8__1.card = card;
					<>8__1.slot2 = <>8__1.card.Slot;
					<>2__current = result;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (resolveTriggers && (Object)(object)<>8__1.slot2 != (Object)(object)<>8__1.card.Slot)
					{
						<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnCardAssignedToSlotContext x) => x.RespondsToCardAssignedToSlotContext(<>8__1.card, <>8__1.slot2, <>8__1.card.Slot), (IOnCardAssignedToSlotContext x) => x.OnCardAssignedToSlotContext(<>8__1.card, <>8__1.slot2, <>8__1.card.Slot));
						<>1__state = 2;
						return true;
					}
					goto IL_00e5;
				case 2:
					<>1__state = -1;
					goto IL_00e5;
				case 3:
					<>1__state = -1;
					goto IL_014c;
				case 4:
					{
						<>1__state = -1;
						break;
					}
					IL_014c:
					if (resolveTriggers && (Object)(object)<>8__1.slot2 != (Object)(object)<>8__1.card.Slot && (Object)(object)<>8__1.slot2 != (Object)null)
					{
						<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnCardAssignedToSlotNoResolve x) => x.RespondsToCardAssignedToSlotNoResolve(<>8__1.card), (IOnCardAssignedToSlotNoResolve x) => x.OnCardAssignedToSlotNoResolve(<>8__1.card));
						<>1__state = 4;
						return true;
					}
					break;
					IL_00e5:
					if (resolveTriggers && (Object)(object)<>8__1.slot2 != (Object)(object)<>8__1.card.Slot)
					{
						<>2__current = CustomTriggerFinder.TriggerInHand((IOnOtherCardAssignedToSlotInHand x) => x.RespondsToOtherCardAssignedToSlotInHand(<>8__1.card), (IOnOtherCardAssignedToSlotInHand x) => x.OnOtherCardAssignedToSlotInHand(<>8__1.card));
						<>1__state = 3;
						return true;
					}
					goto IL_014c;
				}
				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 <TriggerOnOtherCardResolveInHand>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayableCard card;

			public IEnumerator result;

			public bool resolveTriggers;

			private <>c__DisplayClass10_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass10_0();
					<>8__1.card = card;
					<>2__current = result;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (resolveTriggers)
					{
						<>2__current = CustomTriggerFinder.TriggerInHand((IOnOtherCardResolveInHand x) => x.RespondsToOtherCardResolveInHand(<>8__1.card), (IOnOtherCardResolveInHand x) => x.OnOtherCardResolveInHand(<>8__1.card));
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				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 <TriggerOnPostSingularSlotAttackSlot>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CardSlot attackingSlot;

			public CardSlot opposingSlot;

			public IEnumerator result;

			private <>c__DisplayClass3_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass3_0();
					<>8__1.attackingSlot = attackingSlot;
					<>8__1.opposingSlot = opposingSlot;
					<>2__current = result;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostSingularSlotAttackSlot x) => x.RespondsToPostSingularSlotAttackSlot(<>8__1.attackingSlot, <>8__1.opposingSlot), (IOnPostSingularSlotAttackSlot x) => x.OnPostSingularSlotAttackSlot(<>8__1.attackingSlot, <>8__1.opposingSlot));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public int damage;

			public int numWeights;

			public bool toPlayer;

			public IEnumerator result;

			private <>c__DisplayClass8_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass8_0();
					<>8__1.damage = damage;
					<>8__1.numWeights = numWeights;
					<>8__1.toPlayer = toPlayer;
					<>8__1.initialDamage = <>8__1.damage;
					<>8__1.initialToPlayer = <>8__1.toPlayer;
					CustomTriggerFinder.CollectDataAll(collectFromFacedown: false, (IOnPreScalesChangedRef x) => x.RespondsToPreScalesChangedRef(<>8__1.damage, <>8__1.numWeights, <>8__1.toPlayer), delegate(IOnPreScalesChangedRef x)
					{
						<>8__1.damage = x.CollectPreScalesChangedRef(<>8__1.damage, ref <>8__1.numWeights, ref <>8__1.toPlayer);
						if (<>8__1.damage < 0)
						{
							<>8__1.damage = -<>8__1.damage;
							<>8__1.toPlayer = !<>8__1.toPlayer;
						}
						return <>8__1.damage;
					});
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreScalesChanged x) => x.RespondsToPreScalesChanged(<>8__1.damage, <>8__1.toPlayer, <>8__1.initialDamage, <>8__1.initialToPlayer), (IOnPreScalesChanged x) => x.OnPreScalesChanged(<>8__1.damage, <>8__1.toPlayer, <>8__1.initialDamage, <>8__1.initialToPlayer));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					(scaleChangedDamage ?? (scaleChangedDamage = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("damage")))?.SetValue(result, <>8__1.damage);
					(scaleChangedToPlayer ?? (scaleChangedToPlayer = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("toPlayer")))?.SetValue(result, <>8__1.toPlayer);
					(scaleChangedNumWeights ?? (scaleChangedNumWeights = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("numWeights")))?.SetValue(result, <>8__1.numWeights);
					<>2__current = result;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostScalesChanged x) => x.RespondsToPostScalesChanged(<>8__1.damage, <>8__1.toPlayer, <>8__1.initialDamage, <>8__1.initialToPlayer), (IOnPostScalesChanged x) => x.OnPostScalesChanged(<>8__1.damage, <>8__1.toPlayer, <>8__1.initialDamage, <>8__1.initialToPlayer));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public CardSlot slot;

			public IEnumerator result;

			private <>c__DisplayClass2_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass2_0();
					<>8__1.slot = slot;
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreSlotAttackSequence x) => x.RespondsToPreSlotAttackSequence(<>8__1.slot), (IOnPreSlotAttackSequence x) => x.OnPreSlotAttackSequence(<>8__1.slot));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = result;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostSlotAttackSequence x) => x.RespondsToPostSlotAttackSequence(<>8__1.slot), (IOnPostSlotAttackSequence x) => x.OnPostSlotAttackSequence(<>8__1.slot));
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public TurnManager __instance;

			public IEnumerator result;

			private bool <turnSkipped>5__2;

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

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

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

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