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")]
[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.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.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.Saves;
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.19.4.0")]
[assembly: AssemblyInformationalVersion("2.19.4")]
[assembly: AssemblyProduct("InscryptionAPI")]
[assembly: AssemblyTitle("InscryptionAPI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.19.4.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.19.5")]
	[HarmonyPatch]
	public class InscryptionAPIPlugin : BaseUnityPlugin
	{
		public const string ModGUID = "cyantist.inscryption.api";

		public const string ModName = "InscryptionAPI";

		public const string ModVer = "2.19.5";

		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();
			EncounterManager.SyncEncounterList();
			RegionManager.SyncRegionList();
		}

		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();
			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
	{
		public static IEnumerator CustomTriggerSequence(this TriggerReceiver receiver, IEnumerator triggerCoroutine)
		{
			GlobalTriggerHandler self = Singleton<GlobalTriggerHandler>.Instance;
			if ((Object)(object)self != (Object)null)
			{
				self.NumTriggersThisBattle += 1;
				self.StackSize += 1;
				receiver.Activating = true;
				yield return triggerCoroutine;
				self.StackSize -= 1;
				receiver.Activating = false;
				if (receiver.DestroyAfterActivation)
				{
					receiver.Destroy();
				}
			}
		}

		public static IEnumerator TriggerAll<T>(bool triggerFacedown, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			IEnumerable<T> enumerable = FindGlobalTriggers<T>(triggerFacedown);
			foreach (T item in enumerable)
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					yield return ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(item));
				}
			}
			_ = triggerFacedown;
		}

		public static IEnumerator Trigger<T>(this CardTriggerHandler handler, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			IEnumerable<T> enumerable = handler.FindTriggersOnCard<T>();
			foreach (T item in enumerable)
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					yield return ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(item));
				}
			}
		}

		public static IEnumerator Trigger<T>(this PlayableCard card, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			yield return card.TriggerHandler.Trigger(respond, trigger);
		}

		public static IEnumerator TriggerOnBoard<T>(bool triggerFacedown, Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			IEnumerable<T> enumerable = FindTriggersOnBoard<T>(triggerFacedown);
			foreach (T item in enumerable)
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					yield return ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(item));
				}
			}
		}

		public static IEnumerator TriggerInHand<T>(Func<T, bool> respond, Func<T, IEnumerator> trigger)
		{
			IEnumerable<T> enumerable = FindTriggersInHand<T>();
			foreach (T item in enumerable)
			{
				object obj = item;
				if ((Object)((obj is TriggerReceiver) ? obj : null) != (Object)null && respond(item))
				{
					object obj2 = item;
					yield return ((TriggerReceiver)((obj2 is TriggerReceiver) ? obj2 : null)).CustomTriggerSequence(trigger(item));
				}
			}
		}

		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);
			return (from x in source2
				where !UnityExtensions.SafeIsUnityNull((Object)(object)x)
				where x.TriggerBeforeCards
				select 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>);
		}

		public static IEnumerable<T> FindTriggersOnCard<T>(this PlayableCard card)
		{
			foreach (T item in card.TriggerHandler.GetAllReceivers().OfType<T>())
			{
				yield return item;
			}
		}

		public static IEnumerable<T> FindTriggersOnCard<T>(this CardTriggerHandler card)
		{
			foreach (T item in card.GetAllReceivers().OfType<T>())
			{
				yield return item;
			}
		}

		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
	{
		private static Type scaleChangedCoroutine;

		private static FieldInfo scaleChangedDamage;

		private static FieldInfo scaleChangedToPlayer;

		private static FieldInfo scaleChangedNumWeights;

		private static FieldInfo triggerField;

		private static readonly Type triggerType = AccessTools.TypeByName("DiskCardGame.GlobalTriggerHandler+<TriggerCardsOnBoard>d__16");

		[HarmonyPatch(typeof(PlayerHand), "AddCardToHand")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnAddedToHand(IEnumerator result, PlayableCard card)
		{
			yield return result;
			yield return card.TriggerHandler.Trigger((IOnAddedToHand x) => x.RespondsToAddedToHand(), (IOnAddedToHand x) => x.OnAddedToHand());
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnOtherCardAddedToHand x) => x.RespondsToOtherCardAddedToHand(card), (IOnOtherCardAddedToHand x) => x.OnOtherCardAddedToHand(card));
		}

		[HarmonyPatch(typeof(CombatPhaseManager), "DoCombatPhase")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnBellRung(IEnumerator result, bool playerIsAttacker)
		{
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnBellRung x) => x.RespondsToBellRung(playerIsAttacker), (IOnBellRung x) => x.OnBellRung(playerIsAttacker));
			yield return result;
		}

		[HarmonyPatch(typeof(CombatPhaseManager), "SlotAttackSequence")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnSlotAttackSequence(IEnumerator result, CardSlot slot)
		{
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreSlotAttackSequence x) => x.RespondsToPreSlotAttackSequence(slot), (IOnPreSlotAttackSequence x) => x.OnPreSlotAttackSequence(slot));
			yield return result;
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostSlotAttackSequence x) => x.RespondsToPostSlotAttackSequence(slot), (IOnPostSlotAttackSequence x) => x.OnPostSlotAttackSequence(slot));
		}

		[HarmonyPatch(typeof(CombatPhaseManager), "SlotAttackSlot")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnPostSingularSlotAttackSlot(IEnumerator result, CardSlot attackingSlot, CardSlot opposingSlot)
		{
			yield return result;
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostSingularSlotAttackSlot x) => x.RespondsToPostSingularSlotAttackSlot(attackingSlot, opposingSlot), (IOnPostSingularSlotAttackSlot x) => x.OnPostSingularSlotAttackSlot(attackingSlot, opposingSlot));
		}

		[HarmonyPatch(typeof(LifeManager), "ShowDamageSequence")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnScalesChanged(IEnumerator result, int damage, int numWeights, bool toPlayer)
		{
			int initialDamage = damage;
			bool initialToPlayer = toPlayer;
			CustomTriggerFinder.CollectDataAll(collectFromFacedown: false, (IOnPreScalesChangedRef x) => x.RespondsToPreScalesChangedRef(damage, numWeights, toPlayer), delegate(IOnPreScalesChangedRef x)
			{
				damage = x.CollectPreScalesChangedRef(damage, ref numWeights, ref toPlayer);
				if (damage < 0)
				{
					damage = -damage;
					toPlayer = !toPlayer;
				}
				return damage;
			});
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreScalesChanged x) => x.RespondsToPreScalesChanged(damage, toPlayer, initialDamage, initialToPlayer), (IOnPreScalesChanged x) => x.OnPreScalesChanged(damage, toPlayer, initialDamage, initialToPlayer));
			(scaleChangedDamage ?? (scaleChangedDamage = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("damage")))?.SetValue(result, damage);
			(scaleChangedToPlayer ?? (scaleChangedToPlayer = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("toPlayer")))?.SetValue(result, toPlayer);
			(scaleChangedNumWeights ?? (scaleChangedNumWeights = (scaleChangedCoroutine ?? (scaleChangedCoroutine = result?.GetType()))?.GetField("numWeights")))?.SetValue(result, numWeights);
			yield return result;
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostScalesChanged x) => x.RespondsToPostScalesChanged(damage, toPlayer, initialDamage, initialToPlayer), (IOnPostScalesChanged x) => x.OnPostScalesChanged(damage, toPlayer, initialDamage, initialToPlayer));
		}

		[HarmonyPatch(typeof(TurnManager), "DoUpkeepPhase")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnUpkeepInHand(IEnumerator result, bool playerUpkeep)
		{
			yield return result;
			yield return CustomTriggerFinder.TriggerInHand((IOnUpkeepInHand x) => x.RespondsToUpkeepInHand(playerUpkeep), (IOnUpkeepInHand x) => x.OnUpkeepInHand(playerUpkeep));
		}

		[HarmonyPatch(typeof(BoardManager), "ResolveCardOnBoard")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnOtherCardResolveInHand(IEnumerator result, PlayableCard card, bool resolveTriggers = true)
		{
			yield return result;
			if (resolveTriggers)
			{
				yield return CustomTriggerFinder.TriggerInHand((IOnOtherCardResolveInHand x) => x.RespondsToOtherCardResolveInHand(card), (IOnOtherCardResolveInHand x) => x.OnOtherCardResolveInHand(card));
			}
		}

		[HarmonyPatch(typeof(TurnManager), "PlayerTurn")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnTurnEndInHandPlayer(IEnumerator result)
		{
			yield return result;
			yield return CustomTriggerFinder.TriggerInHand((IOnTurnEndInHand x) => x.RespondsToTurnEndInHand(playerTurn: true), (IOnTurnEndInHand x) => x.OnTurnEndInHand(playerTurn: true));
		}

		[HarmonyPatch(typeof(TurnManager), "OpponentTurn")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnTurnEndInHandOpponent(IEnumerator result, TurnManager __instance)
		{
			bool turnSkipped = __instance.Opponent.SkipNextTurn;
			yield return result;
			if (!turnSkipped)
			{
				yield return CustomTriggerFinder.TriggerInHand((IOnTurnEndInHand x) => x.RespondsToTurnEndInHand(playerTurn: false), (IOnTurnEndInHand x) => x.OnTurnEndInHand(playerTurn: false));
			}
		}

		[HarmonyPatch(typeof(BoardManager), "AssignCardToSlot")]
		[HarmonyPostfix]
		private static IEnumerator TriggerOnOtherCardAssignedToSlotInHand(IEnumerator result, PlayableCard card, bool resolveTriggers)
		{
			CardSlot slot2 = card.Slot;
			yield return result;
			if (resolveTriggers && (Object)(object)slot2 != (Object)(object)card.Slot)
			{
				yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnCardAssignedToSlotContext x) => x.RespondsToCardAssignedToSlotContext(card, slot2, card.Slot), (IOnCardAssignedToSlotContext x) => x.OnCardAssignedToSlotContext(card, slot2, card.Slot));
			}
			if (resolveTriggers && (Object)(object)slot2 != (Object)(object)card.Slot)
			{
				yield return CustomTriggerFinder.TriggerInHand((IOnOtherCardAssignedToSlotInHand x) => x.RespondsToOtherCardAssignedToSlotInHand(card), (IOnOtherCardAssignedToSlotInHand x) => x.OnOtherCardAssignedToSlotInHand(card));
			}
			if (resolveTriggers && (Object)(object)slot2 != (Object)(object)card.Slot && (Object)(object)slot2 != (Object)null)
			{
				yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnCardAssignedToSlotNoResolve x) => x.RespondsToCardAssignedToSlotNoResolve(card), (IOnCardAssignedToSlotNoResolve x) => x.OnCardAssignedToSlotNoResolve(card));
			}
		}

		[HarmonyPatch(typeof(PlayableCard), "Die")]
		[HarmonyPostfix]
		private static IEnumerator TriggerDeathTriggers(IEnumerator result, PlayableCard __instance, bool wasSacrifice, PlayableCard killer = null)
		{
			CardSlot slotBeforeDeath = __instance.Slot;
			while (result.MoveNext())
			{
				yield return result.Current;
				if (!(result.Current.GetType() == triggerType))
				{
					continue;
				}
				Trigger val = (Trigger)21;
				try
				{
					val = (Trigger)(triggerField ?? (triggerField = triggerType.GetField("trigger"))).GetValue(result.Current);
				}
				catch
				{
				}
				if ((int)val == 17)
				{
					yield return CustomTriggerFinder.TriggerInHand((IOnOtherCardPreDeathInHand x) => x.RespondsToOtherCardPreDeathInHand(slotBeforeDeath, !wasSacrifice, killer), (IOnOtherCardPreDeathInHand x) => x.OnOtherCardPreDeathInHand(slotBeforeDeath, !wasSacrifice, killer));
				}
				else if ((int)val == 11)
				{
					yield return CustomTriggerFinder.TriggerInHand((IOnOtherCardDieInHand x) => x.RespondsToOtherCardDieInHand(__instance, slotBeforeDeath, !wasSacrifice, killer), (IOnOtherCardDieInHand x) => x.OnOtherCardDieInHand(__instance, slotBeforeDeath, !wasSacrifice, killer));
				}
			}
		}

		[HarmonyPatch(typeof(ConsumableItemSlot), "ConsumeItem")]
		[HarmonyPostfix]
		private static IEnumerator TriggerItemUse(IEnumerator result, ConsumableItemSlot __instance)
		{
			bool itemCanBeUsed = true;
			ConsumableItemSlot obj = __instance;
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				ConsumableItem consumable = obj.Consumable;
				if (consumable == null)
				{
					obj2 = null;
				}
				else
				{
					ItemData data = ((Item)consumable).Data;
					obj2 = ((data != null) ? ((Object)data).name : null);
				}
			}
			string consumableName = (string)obj2;
			if (!string.IsNullOrEmpty(consumableName))
			{
				CustomTriggerFinder.CollectDataAll(collectFromFacedown: false, (IItemCanBeUsed x) => x.RespondsToItemCanBeUsed(consumableName, itemCanBeUsed), (IItemCanBeUsed x) => itemCanBeUsed = x.CollectItemCanBeUsed(consumableName, itemCanBeUsed));
			}
			if (itemCanBeUsed)
			{
				bool successInActivation = false;
				Type activationtype = __instance.Consumable.ActivateSequence().GetType();
				if (!string.IsNullOrEmpty(consumableName))
				{
					yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPreItemUsed x) => x.RespondsToPreItemUsed(consumableName, __instance is HammerItemSlot), (IOnPreItemUsed x) => x.OnPreItemUsed(consumableName, __instance is HammerItemSlot));
				}
				while (result.MoveNext())
				{
					yield return result.Current;
					if (result.Current.GetType() == activationtype && !string.IsNullOrEmpty(consumableName) && (Object)(object)__instance.Consumable != (Object)null)
					{
						successInActivation = !__instance.Consumable.ActivationCancelled;
					}
				}
				if (!string.IsNullOrEmpty(consumableName))
				{
					yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnPostItemUsed x) => x.RespondsToPostItemUsed(consumableName, successInActivation, __instance is HammerItemSlot), (IOnPostItemUsed x) => x.OnPostItemUsed(consumableName, successInActivation, __instance is HammerItemSlot));
				}
				yield break;
			}
			ConsumableItemSlot obj3 = __instance;
			if (obj3 != null)
			{
				ConsumableItem consumable2 = obj3.Consumable;
				if (consumable2 != null)
				{
					consumable2.PlayShakeAnimation();
				}
			}
			if (!string.IsNullOrEmpty(consumableName))
			{
				yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnItemPreventedFromUse x) => x.RespondsToItemPreventedFromUse(consumableName), (IOnItemPreventedFromUse x) => x.OnItemPreventedFromUse(consumableName));
			}
		}

		[HarmonyPatch(typeof(PlayableCard), "GetPassiveAttackBuffs")]
		[HarmonyPostfix]
		private static void PassiveAttackBuffs(PlayableCard __instance, ref int __result)
		{
			int dummyResult = __result;
			CustomTriggerFinder.CollectDataAll(collectFromFacedown: true, (IOnCardPassiveAttackBuffs x) => x.RespondsToCardPassiveAttackBuffs(__instance, dummyResult), (IOnCardPassiveAttackBuffs x) => dummyResult = x.CollectCardPassiveAttackBuffs(__instance, dummyResult));
			if (__instance.OnBoard)
			{
				CustomTriggerFinder.CollectDataAll(collectFromFacedown: true, (IPassiveAttackBuff x) => true, (IPassiveAttackBuff x) => dummyResult += x.GetPassiveAttackBuff(__instance));
			}
			__result = dummyResult;
		}

		[HarmonyPatch(typeof(PlayableCard), "GetPassiveHealthBuffs")]
		[HarmonyPostfix]
		private static void PassiveHealthBuffs(PlayableCard __instance, ref int __result)
		{
			int dummyResult = __result;
			CustomTriggerFinder.CollectDataAll(collectFromFacedown: true, (IOnCardPassiveHealthBuffs x) => x.RespondsToCardPassiveHealthBuffs(__instance, dummyResult), (IOnCardPassiveHealthBuffs x) => dummyResult = x.CollectCardPassiveHealthBuffs(__instance, dummyResult));
			if (__instance.OnBoard)
			{
				CustomTriggerFinder.CollectDataAll(collectFromFacedown: true, (IPassiveHealthBuff x) => true, (IPassiveHealthBuff x) => dummyResult += x.GetPassiveHealthBuff(__instance));
			}
			__result = dummyResult;
		}

		[HarmonyPatch(typeof(PlayableCard), "GetOpposingSlots")]
		[HarmonyPrefix]
		private static bool OpposingSlotsPrefix(PlayableCard __instance, ref List<CardSlot> __result, ref int __state)
		{
			List<ISetupAttackSequence> list = CustomTriggerFinder.FindGlobalTriggers<ISetupAttackSequence>(findFacedown: true).ToList();
			list.RemoveAll((ISetupAttackSequence x) => (Object)((x is TriggerReceiver) ? x : null) == (Object)null);
			list.Sort((ISetupAttackSequence x, ISetupAttackSequence x2) => x.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.ReplacesDefaultOpposingSlot, new List<CardSlot>(), new List<CardSlot>(), 0, didRemoveDefaultSlot: false) - x2.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.ReplacesDefaultOpposingSlot, new List<CardSlot>(), new List<CardSlot>(), 0, didRemoveDefaultSlot: false));
			bool flag = false;
			bool didRemoveDefaultSlot = false;
			__state = 1;
			foreach (ISetupAttackSequence item in list)
			{
				if (item.RespondsToModifyAttackSlots(__instance, OpposingSlotTriggerPriority.ReplacesDefaultOpposingSlot, new List<CardSlot>(), __result ?? new List<CardSlot>(), __state, didRemoveDefaultSlot: false))
				{
					flag = true;
					__result = item.CollectModifyAttackSlots(__instance, OpposingSlotTriggerPriority.ReplacesDefaultOpposingSlot, new List<CardSlot>(), __result ?? new List<CardSlot>(), ref __state, ref didRemoveDefaultSlot);
					didRemoveDefaultSlot = false;
				}
			}
			if (!flag && __instance.HasAbility((Ability)33))
			{
				__state = Mathf.Max(1, (__instance.OpponentCard ? Singleton<BoardManager>.Instance.PlayerSlotsCopy : Singleton<BoardManager>.Instance.OpponentSlotsCopy).FindAll((CardSlot x) => (Object)(object)x.Card != (Object)null && !__instance.CanAttackDirectly(x)).Count);
			}
			if (flag)
			{
				if (__instance.HasAbility((Ability)24))
				{
					ProgressionData.SetAbilityLearned((Ability)24);
					__result.Remove(__instance.Slot.opposingSlot);
					__result.AddRange(Singleton<BoardManager>.Instance.GetAdjacentSlots(__instance.Slot.opposingSlot));
				}
				if (__instance.HasTriStrike())
				{
					ProgressionData.SetAbilityLearned((Ability)25);
					__result.AddRange(Singleton<BoardManager>.Instance.GetAdjacentSlots(__instance.Slot.opposingSlot));
					if (!__result.Contains(__instance.Slot.opposingSlot))
					{
						__result.Add(__instance.Slot.opposingSlot);
					}
				}
				if (__instance.HasAbility((Ability)100))
				{
					ProgressionData.SetAbilityLearned((Ability)100);
					__result.Add(__instance.slot.opposingSlot);
				}
			}
			if (__instance.HasAbility((Ability)24))
			{
				__state++;
			}
			if (__instance.HasTriStrike())
			{
				__state += 2;
				if (__instance.HasAbility((Ability)24))
				{
					__state++;
				}
			}
			if (__instance.HasAbility((Ability)100))
			{
				__state++;
			}
			__result?.Sort((CardSlot a, CardSlot b) => a.Index - b.Index);
			return !flag;
		}

		[HarmonyPatch(typeof(PlayableCard), "GetOpposingSlots")]
		[HarmonyPostfix]
		private static void OpposingSlots(PlayableCard __instance, ref List<CardSlot> __result, int __state)
		{
			List<CardSlot> original = new List<CardSlot>(__result);
			bool flag = !__instance.HasTriStrike() && !__instance.HasAbility((Ability)24);
			CardSlot opposingSlot = __instance.Slot.opposingSlot;
			List<CardSlot> list = new List<CardSlot>();
			bool flag2 = false;
			foreach (IGetOpposingSlots item in __instance.FindTriggersOnCard<IGetOpposingSlots>())
			{
				if ((Object)((item is TriggerReceiver) ? item : null) != (Object)null && item.RespondsToGetOpposingSlots())
				{
					list.AddRange(item.GetOpposingSlots(__result, new List<CardSlot>(list)));
					flag2 = flag2 || item.RemoveDefaultAttackSlot();
				}
			}
			if (list.Count > 0)
			{
				__result.AddRange(list);
			}
			if (flag && flag2)
			{
				__result.Remove(opposingSlot);
			}
			bool didRemoveOriginalSlot = __instance.HasAbility((Ability)24) && (!__instance.HasTriStrike() || flag2);
			List<ISetupAttackSequence> list2 = CustomTriggerFinder.FindGlobalTriggers<ISetupAttackSequence>(findFacedown: true).ToList();
			list2.RemoveAll((ISetupAttackSequence x) => (Object)((x is TriggerReceiver) ? x : null) == (Object)null);
			List<CardSlot> dummyresult = __result;
			list2.Sort((ISetupAttackSequence x, ISetupAttackSequence x2) => x.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.Normal, original, dummyresult, __state, didRemoveOriginalSlot) - x2.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.Normal, original, dummyresult, __state, didRemoveOriginalSlot));
			foreach (ISetupAttackSequence item2 in list2)
			{
				if (item2.RespondsToModifyAttackSlots(__instance, OpposingSlotTriggerPriority.Normal, original, __result ?? new List<CardSlot>(), __state, didRemoveOriginalSlot))
				{
					__result = item2.CollectModifyAttackSlots(__instance, OpposingSlotTriggerPriority.Normal, original, __result ?? new List<CardSlot>(), ref __state, ref didRemoveOriginalSlot);
				}
			}
			dummyresult = __result;
			list2.Sort((ISetupAttackSequence x, ISetupAttackSequence x2) => x.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.BringsBackOpposingSlot, original, dummyresult, __state, didRemoveOriginalSlot) - x2.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.BringsBackOpposingSlot, original, dummyresult, __state, didRemoveOriginalSlot));
			foreach (ISetupAttackSequence item3 in list2)
			{
				if (item3.RespondsToModifyAttackSlots(__instance, OpposingSlotTriggerPriority.BringsBackOpposingSlot, original, __result ?? new List<CardSlot>(), __state, didRemoveOriginalSlot))
				{
					__result = item3.CollectModifyAttackSlots(__instance, OpposingSlotTriggerPriority.BringsBackOpposingSlot, original, __result ?? new List<CardSlot>(), ref __state, ref didRemoveOriginalSlot);
				}
			}
			dummyresult = __result;
			list2.Sort((ISetupAttackSequence x, ISetupAttackSequence x2) => x.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.PostAdditionModification, original, dummyresult, __state, didRemoveOriginalSlot) - x2.GetTriggerPriority(__instance, OpposingSlotTriggerPriority.PostAdditionModification, original, dummyresult, __state, didRemoveOriginalSlot));
			foreach (ISetupAttackSequence item4 in list2)
			{
				if (item4.RespondsToModifyAttackSlots(__instance, OpposingSlotTriggerPriority.PostAdditionModification, original, __result ?? new List<CardSlot>(), __state, didRemoveOriginalSlot))
				{
					__result = item4.CollectModifyAttackSlots(__instance, OpposingSlotTriggerPriority.PostAdditionModification, original, __result ?? new List<CardSlot>(), ref __state, ref didRemoveOriginalSlot);
				}
			}
			if (didRemoveOriginalSlot && __instance.HasTriStrike())
			{
				__result.Add(__instance.Slot.opposingSlot);
			}
			__result.Sort((CardSlot a, CardSlot b) => a.Index - b.Index);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> TriggerOnTurnEndInQueuePlayer(IEnumerable<CodeInstruction> instructions)
		{
			return TriggerOnTurnEndInQueue(instructions, playerTurn: true);
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> TriggerOnTurnEndInQueueOpponent(IEnumerable<CodeInstruction> instructions)
		{
			return TriggerOnTurnEndInQueue(instructions, playerTurn: false);
		}

		private static IEnumerable<CodeInstruction> TriggerOnTurnEndInQueue(IEnumerable<CodeInstruction> instructions, bool playerTurn)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			int num = list.IndexOf(list.First((CodeInstruction code) => code.opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(code, (MemberInfo)AccessTools.Method(typeof(GlobalTriggerHandler), "TriggerCardsOnBoard", (Type[])null, (Type[])null))));
			num++;
			list.Insert(num++, new CodeInstruction(playerTurn ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0, (object)null));
			list.Insert(num++, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CustomTriggerPatches), "TriggerOnTurnEndInQueueCoro", (Type[])null, (Type[])null)));
			return list;
		}

		private static IEnumerator TriggerOnTurnEndInQueueCoro(IEnumerator originalTrigger, bool playerTurn)
		{
			yield return originalTrigger;
			foreach (IOnTurnEndInQueue item in CustomTriggerFinder.FindTriggersInQueue<IOnTurnEndInQueue>())
			{
				if ((Object)((item is TriggerReceiver) ? item : null) != (Object)null && item.RespondsToTurnEndInQueue(playerTurn))
				{
					yield return item.OnTurnEndInQueue(playerTurn);
				}
			}
		}
	}
	[HarmonyPatch]
	public static class DoCombatPhasePatches
	{
		private const string name_GetDamageDealt = "Int32 get_DamageDealtThisPhase()";

		private const string name_PlayerAttacker = "System.Boolean playerIsAttacker";

		private const string name_SpecialSequencer = "DiskCardGame.SpecialBattleSequencer specialSequencer";

		private const string name_SquirrelAttacker = "System.Boolean <attackedWithSquirrel>5__4";

		private const string name_CombatCurrent = "System.Object <>2__current";

		public static IEnumerator NegativeDamageSupport(CombatPhaseManager __instance, bool playerIsAttacker, SpecialBattleSequencer specialSequencer, bool attackedWithSquirrel)
		{
			if (__instance.DamageDealtThisPhase == 0)
			{
				yield break;
			}
			bool targetOfDamage = ((__instance.DamageDealtThisPhase < 0) ? (!playerIsAttacker) : playerIsAttacker);
			yield return (object)new WaitForSeconds(0.4f);
			yield return __instance.VisualizeDamageMovingToScales(targetOfDamage);
			int overkillDamage = 0;
			if (playerIsAttacker && __instance.DamageDealtThisPhase > 0)
			{
				overkillDamage = Singleton<LifeManager>.Instance.Balance + __instance.DamageDealtThisPhase - 5;
				if (attackedWithSquirrel && overkillDamage >= 0)
				{
					AchievementManager.Unlock((Achievement)14);
				}
				overkillDamage = Mathf.Max(0, overkillDamage);
			}
			int num = Math.Abs(__instance.DamageDealtThisPhase);
			int damage = num - overkillDamage;
			AscensionStatsData.TryIncreaseStat((Type)4, num);
			if (num >= 666)
			{
				AchievementManager.Unlock((Achievement)25);
			}
			bool canDealDamage = (Object)(object)specialSequencer == (Object)null || !specialSequencer.PreventDamageAddedToScales;
			if (canDealDamage)
			{
				yield return Singleton<LifeManager>.Instance.ShowDamageSequence(damage, damage, !targetOfDamage, 0f, (GameObject)null, 0f, true);
			}
			if ((Object)(object)specialSequencer != (Object)null)
			{
				yield return specialSequencer.DamageAddedToScale(damage + overkillDamage, targetOfDamage);
			}
			if (canDealDamage && overkillDamage > 0 && Singleton<TurnManager>.Instance.Opponent.NumLives == 1 && Singleton<TurnManager>.Instance.Opponent.GiveCurrencyOnDefeat)
			{
				yield return Singleton<TurnManager>.Instance.Opponent.TryRevokeSurrender();
				RunState run = RunState.Run;
				run.currency += overkillDamage;
				yield return __instance.VisualizeExcessLethalDamage(overkillDamage, specialSequencer);
			}
		}

		public static List<CardSlot> ModifyAttackingSlots(bool playerIsAttacker)
		{
			List<CardSlot> originalSlots = Singleton<BoardManager>.Instance.GetSlotsCopy(playerIsAttacker);
			List<CardSlot> list = new List<CardSlot>(originalSlots);
			List<IGetAttackingSlots> list2 = CustomTriggerFinder.FindTriggersOnBoard<IGetAttackingSlots>(findFacedown: false).ToList();
			list2.Sort((IGetAttackingSlots a, IGetAttackingSlots b) => b.TriggerPriority(playerIsAttacker, originalSlots) - a.TriggerPriority(playerIsAttacker, originalSlots));
			foreach (IGetAttackingSlots item in list2)
			{
				if ((Object)((item is TriggerReceiver) ? item : null) != (Object)null && item.RespondsToGetAttackingSlots(playerIsAttacker, originalSlots, list))
				{
					List<CardSlot> attackingSlots = item.GetAttackingSlots(playerIsAttacker, originalSlots, list);
					if (attackingSlots != null && attackingSlots.Count > 0)
					{
						list.AddRange(attackingSlots);
					}
				}
			}
			return list;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> SelfDamage(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Expected O, but got Unknown
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Expected O, but got Unknown
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			object obj = null;
			object obj2 = null;
			object obj3 = null;
			for (int i = 0; i < list.Count; i++)
			{
				if (!(list[i].opcode == OpCodes.Brtrue))
				{
					continue;
				}
				MethodBase methodBase = AccessTools.Method(typeof(DoCombatPhasePatches), "ModifyAttackingSlots", new Type[1] { typeof(bool) }, (Type[])null);
				for (int j = i; j < list.Count; j++)
				{
					if (list[j].opcode == OpCodes.Stfld)
					{
						list.RemoveRange(i, j - i);
						break;
					}
				}
				list.Insert(i, new CodeInstruction(OpCodes.Call, (object)methodBase));
				break;
			}
			for (int k = 0; k < list.Count; k++)
			{
				if (obj == null && list[k].operand?.ToString() == "System.Boolean playerIsAttacker")
				{
					obj = list[k].operand;
				}
				else if (obj2 == null && list[k].operand?.ToString() == "DiskCardGame.SpecialBattleSequencer specialSequencer")
				{
					obj2 = list[k].operand;
				}
				else if (obj3 == null && list[k].operand?.ToString() == "System.Boolean <attackedWithSquirrel>5__4")
				{
					obj3 = list[k].operand;
				}
				else
				{
					if (!(list[k].operand?.ToString() == "Int32 get_DamageDealtThisPhase()"))
					{
						continue;
					}
					int num = k - 1;
					for (int l = k; l < list.Count; l++)
					{
						if (list[l + 2].opcode == OpCodes.Ldc_I4_S && list[l + 2].operand.ToString() == "11")
						{
							MethodBase methodBase2 = AccessTools.Method(typeof(DoCombatPhasePatches), "NegativeDamageSupport", new Type[4]
							{
								typeof(CombatPhaseManager),
								typeof(bool),
								typeof(SpecialBattleSequencer),
								typeof(bool)
							}, (Type[])null);
							list.RemoveAll((CodeInstruction x) => x.opcode == OpCodes.Nop);
							list[num].opcode = OpCodes.Ldarg_0;
							list.Insert(num + 1, new CodeInstruction(OpCodes.Ldloc_2, (object)null));
							list.Insert(num + 2, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							list.Insert(num + 3, new CodeInstruction(OpCodes.Ldfld, obj));
							list.Insert(num + 4, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							list.Insert(num + 5, new CodeInstruction(OpCodes.Ldfld, obj2));
							list.Insert(num + 6, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							list.Insert(num + 7, new CodeInstruction(OpCodes.Ldfld, obj3));
							list.Insert(num + 8, new CodeInstruction(OpCodes.Callvirt, (object)methodBase2));
							return list;
						}
						CodeInstructionExtensions.MoveLabelsTo(list[l], list[num]);
						list[l].opcode = OpCodes.Nop;
					}
				}
			}
			return list;
		}
	}
	public interface IOnAddedToHand
	{
		bool RespondsToAddedToHand();

		IEnumerator OnAddedToHand();
	}
	public interface IOnOtherCardAddedToHand
	{
		bool RespondsToOtherCardAddedToHand(PlayableCard card);

		IEnumerator OnOtherCardAddedToHand(PlayableCard card);
	}
	public interface IOnCardAssignedToSlotNoResolve
	{
		bool RespondsToCardAssignedToSlotNoResolve(PlayableCard card);

		IEnumerator OnCardAssignedToSlotNoResolve(PlayableCard card);
	}
	public interface IOnCardAssignedToSlotContext
	{
		bool RespondsToCardAssignedToSlotContext(PlayableCard card, CardSlot oldSlot, CardSlot newSlot);

		IEnumerator OnCardAssignedToSlotContext(PlayableCard card, CardSlot oldSlot, CardSlot newSlot);
	}
	public interface IOnBellRung
	{
		bool RespondsToBellRung(bool playerCombatPhase);

		IEnumerator OnBellRung(bool playerCombatPhase);
	}
	public interface IOnPreSlotAttackSequence
	{
		bool RespondsToPreSlotAttackSequence(CardSlot attackingSlot);

		IEnumerator OnPreSlotAttackSequence(CardSlot attackingSlot);
	}
	public interface IOnPostSlotAttackSequence
	{
		bool RespondsToPostSlotAttackSequence(CardSlot attackingSlot);

		IEnumerator OnPostSlotAttackSequence(CardSlot attackingSlot);
	}
	public interface IOnPostSingularSlotAttackSlot
	{
		bool RespondsToPostSingularSlotAttackSlot(CardSlot attackingSlot, CardSlot targetSlot);

		IEnumerator OnPostSingularSlotAttackSlot(CardSlot attackingSlot, CardSlot targetSlot);
	}
	public interface IOnPreScalesChangedRef
	{
		bool RespondsToPreScalesChangedRef(int damage, int numWeights, bool toPlayer);

		int CollectPreScalesChangedRef(int damage, ref int numWeights, ref bool toPlayer);
	}
	public interface IOnPreScalesChanged
	{
		bool RespondsToPreScalesChanged(int damage, bool toPlayer, int originalDamage, bool originalToPlayer);

		IEnumerator OnPreScalesChanged(int damage, bool toPlayer, int originalDamage, bool originalToPlayer);
	}
	public interface IOnPostScalesChanged
	{
		bool RespondsToPostScalesChanged(int damage, bool toPlayer, int originalDamage, bool originalToPlayer);

		IEnumerator OnPostScalesChanged(int damage, bool toPlayer, int originalDamage, bool originalToPlayer);
	}
	public interface IOnUpkeepInHand
	{
		bool RespondsToUpkeepInHand(bool playerUpkeep);

		IEnumerator OnUpkeepInHand(bool playerUpkeep);
	}
	public interface IOnOtherCardResolveInHand
	{
		bool RespondsToOtherCardResolveInHand(PlayableCard resolvingCard);

		IEnumerator OnOtherCardResolveInHand(PlayableCard resolvingCard);
	}
	public interface IOnTurnEndInHand
	{
		bool RespondsToTurnEndInHand(bool playerTurn);

		IEnumerator OnTurnEndInHand(bool playerTurn);
	}
	public interface IOnOtherCardAssignedToSlotInHand
	{
		bool RespondsToOtherCardAssignedToSlotInHand(PlayableCard card);

		IEnumerator OnOtherCardAssignedToSlotInHand(PlayableCard card);
	}
	public interface IOnOtherCardPreDeathInHand
	{
		bool RespondsToOtherCardPreDeathInHand(CardSlot deathSlot, bool fromCombat, PlayableCard killer);

		IEnumerator OnOtherCardPreDeathInHand(CardSlot deathSlot, bool fromCombat, PlayableCard killer);
	}
	public interface IOnOtherCardDealtDamageInHand
	{
		bool RespondsToOtherCardDealtDamageInHand(PlayableCard attacker, int amount, PlayableCard target);

		IEnumerator OnOtherCardDealtDamageInHand(PlayableCard attacker, int amount, PlayableCard target);
	}
	public interface IOnOtherCardDieInHand
	{
		bool RespondsToOtherCardDieInHand(PlayableCard card, CardSlot deathSlot, bool fromCombat, PlayableCard killer);

		IEnumerator OnOtherCardDieInHand(PlayableCard card, CardSlot deathSlot, bool fromCombat, PlayableCard killer);
	}
	public interface IOnPreItemUsed
	{
		bool RespondsToPreItemUsed(string itemName, bool isHammer);

		IEnumerator OnPreItemUsed(string itemName, bool isHammer);
	}
	public interface IOnPostItemUsed
	{
		bool RespondsToPostItemUsed(string itemName, bool success, bool isHammer);

		IEnumerator OnPostItemUsed(string itemName, bool success, bool isHammer);
	}
	public interface IGetOpposingSlots
	{
		bool RespondsToGetOpposingSlots();

		List<CardSlot> GetOpposingSlots(List<CardSlot> originalSlots, List<CardSlot> otherAddedSlots);

		bool RemoveDefaultAttackSlot();
	}
	public interface ISetupAttackSequence
	{
		bool RespondsToModifyAttackSlots(PlayableCard card, OpposingSlotTriggerPriority modType, List<CardSlot> originalSlots, List<CardSlot> currentSlots, int attackCount, bool didRemoveDefaultSlot);

		List<CardSlot> CollectModifyAttackSlots(PlayableCard card, OpposingSlotTriggerPriority modType, List<CardSlot> originalSlots, List<CardSlot> currentSlots, ref int attackCount, ref bool didRemoveDefaultSlot);

		int GetTriggerPriority(PlayableCard card, OpposingSlotTriggerPriority modType, List<CardSlot> originalSlots, List<CardSlot> currentSlots, int attackCount, bool didRemoveDefaultSlot);
	}
	public enum OpposingSlotTriggerPriority
	{
		Normal,
		BringsBackOpposingSlot,
		PostAdditionModification,
		ReplacesDefaultOpposingSlot
	}
	public interface IItemCanBeUsed
	{
		bool RespondsToItemCanBeUsed(string itemname, bool currentValue);

		bool CollectItemCanBeUsed(string itemname, bool currentValue);
	}
	public interface IOnItemPreventedFromUse
	{
		bool RespondsToItemPreventedFromUse(string itemName);

		IEnumerator OnItemPreventedFromUse(string itemName);
	}
	public interface IOnCardPassiveAttackBuffs
	{
		bool RespondsToCardPassiveAttackBuffs(PlayableCard card, int currentValue);

		int CollectCardPassiveAttackBuffs(PlayableCard card, int currentValue);
	}
	public interface IOnCardPassiveHealthBuffs
	{
		bool RespondsToCardPassiveHealthBuffs(PlayableCard card, int currentValue);

		int CollectCardPassiveHealthBuffs(PlayableCard card, int currentValue);
	}
	public interface IPassiveHealthBuff
	{
		int GetPassiveHealthBuff(PlayableCard target);
	}
	public interface IPassiveAttackBuff
	{
		int GetPassiveAttackBuff(PlayableCard target);
	}
	[Obsolete("Use IModifyDamageTaken instead.")]
	public interface ICardTakenDamageModifier
	{
		bool RespondsToCardTakenDamageModifier(PlayableCard card, int currentValue);

		int CollectCardTakenDamageModifier(PlayableCard card, int currentValue);
	}
	public interface IGetAttackingSlots
	{
		bool RespondsToGetAttackingSlots(bool playerIsAttacker, List<CardSlot> originalSlots, List<CardSlot> currentSlots);

		List<CardSlot> GetAttackingSlots(bool playerIsAttacker, List<CardSlot> originalSlots, List<CardSlot> currentSlots);

		int TriggerPriority(bool playerIsAttacker, List<CardSlot> originalSlots);
	}
	public interface IModifyDamageTaken
	{
		bool RespondsToModifyDamageTaken(PlayableCard target, int damage, PlayableCard attacker, int originalDamage);

		int OnModifyDamageTaken(PlayableCard target, int damage, PlayableCard attacker, int originalDamage);

		int TriggerPriority(PlayableCard target, int damage, PlayableCard attacker);
	}
	public interface IPreTakeDamage
	{
		bool RespondsToPreTakeDamage(PlayableCard source, int damage);

		IEnumerator OnPreTakeDamage(PlayableCard source, int damage);
	}
	public interface IModifyDirectDamage
	{
		bool RespondsToModifyDirectDamage(CardSlot target, int damage, PlayableCard attacker, int originalDamage);

		int OnModifyDirectDamage(CardSlot target, int damage, PlayableCard attacker, int originalDamage);

		int TriggerPriority(CardSlot target, int damage, PlayableCard attacker);
	}
	public interface IOnTurnEndInQueue
	{
		bool RespondsToTurnEndInQueue(bool playerTurn);

		IEnumerator OnTurnEndInQueue(bool playerTurn);
	}
	public interface IOnCardDealtDamageDirectly
	{
		bool RespondsToCardDealtDamageDirectly(PlayableCard attacker, CardSlot opposingSlot, int damage);

		IEnumerator OnCardDealtDamageDirectly(PlayableCard attacker, CardSlot opposingSlot, int damage);
	}
	[HarmonyPatch]
	public static class SlotAttackSlotPatches
	{
		private const string name_GlobalTrigger = "DiskCardGame.GlobalTriggerHandler get_Instance()";

		private const string name_GetCard = "DiskCardGame.PlayableCard get_Card()";

		private const string name_GetAttack = "Int32 get_Attack()";

		private const string name_OpposingSlot = "DiskCardGame.CardSlot opposingSlot";

		private const string name_CombatPhase = "DiskCardGame.CombatPhaseManager+<>c__DisplayClass5_0 <>8__1";

		private const string name_AttackingSlot = "DiskCardGame.CardSlot attackingSlot";

		private const string name_CanAttackDirectly = "Boolean CanAttackDirectly(DiskCardGame.CardSlot)";

		private const string name_VisualizeCardAttackingDirectly = "System.Collections.IEnumerator VisualizeCardAttackingDirectly(DiskCardGame.CardSlot, DiskCardGame.CardSlot, Int32)";

		private const string modifiedAttackCustomField = "modifiedAttack";

		private static readonly MethodInfo method_GetCard = AccessTools.PropertyGetter(typeof(CardSlot), "Card");

		private static readonly MethodInfo method_NewDamage = AccessTools.Method(typeof(SlotAttackSlotPatches), "DamageToDealThisPhase", new Type[2]
		{
			typeof(CardSlot),
			typeof(CardSlot)
		}, (Type[])null);

		private static readonly MethodInfo method_NewTriggers = AccessTools.Method(typeof(SlotAttackSlotPatches), "TriggerOnDirectDamageTriggers", new Type[2]
		{
			typeof(PlayableCard),
			typeof(CardSlot)
		}, (Type[])null);

		private static readonly MethodInfo method_SetCustomField = AccessTools.Method(typeof(CustomFields), "Set", (Type[])null, (Type[])null);

		private static readonly MethodInfo method_GetCustomField = AccessTools.Method(typeof(CustomFields), "Get", new Type[2]
		{
			typeof(object),
			typeof(string)
		}, new Type[1] { typeof(int) });

		public static int DamageToDealThisPhase(CardSlot attackingSlot, CardSlot opposingSlot)
		{
			int damage;
			int originalDamage = (damage = attackingSlot.Card.Attack);
			List<IModifyDirectDamage> list = CustomTriggerFinder.FindGlobalTriggers<IModifyDirectDamage>(findFacedown: true).ToList();
			list.Sort((IModifyDirectDamage a, IModifyDirectDamage b) => b.TriggerPriority(opposingSlot, damage, attackingSlot.Card) - a.TriggerPriority(opposingSlot, damage, attackingSlot.Card));
			foreach (IModifyDirectDamage item in list)
			{
				if (item.RespondsToModifyDirectDamage(opposingSlot, damage, attackingSlot.Card, originalDamage))
				{
					damage = item.OnModifyDirectDamage(opposingSlot, damage, attackingSlot.Card, originalDamage);
				}
			}
			if (attackingSlot.IsPlayerSlot == opposingSlot.IsPlayerSlot)
			{
				return -damage;
			}
			if (Singleton<TurnManager>.Instance.IsPlayerTurn)
			{
				if (attackingSlot.IsOpponentSlot())
				{
					if (!opposingSlot.IsPlayerSlot)
					{
						return damage;
					}
					return -damage;
				}
			}
			else if (attackingSlot.IsPlayerSlot)
			{
				if (!opposingSlot.IsOpponentSlot())
				{
					return damage;
				}
				return -damage;
			}
			return damage;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (!ModifyDirectDamageCheck(list, ref i))
				{
					continue;
				}
				for (int j = i; j < list.Count; j++)
				{
					if (CallTriggerOnDirectDamage(list, ref j))
					{
						for (int k = j; k < list.Count && !OpposingCardNullCheck(list, k); k++)
						{
						}
						break;
					}
				}
				break;
			}
			return list;
		}

		private static bool OpposingCardNullCheck(List<CodeInstruction> codes, int i)
		{
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			if (codes[i].opcode == OpCodes.Call && codes[i].operand.ToString() == "DiskCardGame.GlobalTriggerHandler get_Instance()" && codes[i + 1].opcode == OpCodes.Ldc_I4_7)
			{
				MethodInfo methodInfo = null;
				object obj = null;
				object obj2 = null;
				object obj3 = null;
				for (int j = i + 1; j < codes.Count; j++)
				{
					if (codes[j].opcode == OpCodes.Ldfld && codes[j].operand.ToString() == "DiskCardGame.CardSlot opposingSlot" && obj == null)
					{
						obj = codes[j].operand;
					}
					if (codes[j].opcode == OpCodes.Callvirt && codes[j].operand.ToString() == "DiskCardGame.PlayableCard get_Card()" && obj2 == null)
					{
						obj2 = codes[j].operand;
					}
					if (!(codes[j].opcode == OpCodes.Stfld) || !(codes[j - 1].opcode == OpCodes.Ldc_I4_M1))
					{
						continue;
					}
					for (int k = j + 1; k < codes.Count; k++)
					{
						if (codes[k].opcode == OpCodes.Call && methodInfo == null)
						{
							methodInfo = (MethodInfo)codes[k].operand;
						}
						if (obj3 == null && codes[k].opcode == OpCodes.Brfalse)
						{
							obj3 = codes[k].operand;
						}
						if (codes[k].opcode == OpCodes.Stfld)
						{
							codes.Insert(k + 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
							codes.Insert(k + 2, new CodeInstruction(OpCodes.Ldfld, obj));
							codes.Insert(k + 3, new CodeInstruction(OpCodes.Callvirt, obj2));
							codes.Insert(k + 4, new CodeInstruction(OpCodes.Ldnull, (object)null));
							codes.Insert(k + 5, new CodeInstruction(OpCodes.Call, (object)methodInfo));
							codes.Insert(k + 6, new CodeInstruction(OpCodes.Brfalse, obj3));
							return true;
						}
					}
					break;
				}
			}
			return false;
		}

		private static bool ModifyDirectDamageCheck(List<CodeInstruction> codes, ref int index)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Expected O, but got Unknown
			if (codes[index].opcode == OpCodes.Callvirt && codes[index].operand.ToString() == "Boolean CanAttackDirectly(DiskCardGame.CardSlot)")
			{
				int num = index + 2;
				object obj = null;
				object obj2 = null;
				object obj3 = null;
				for (int num2 = index - 1; num2 > 0; num2--)
				{
					if (obj == null && codes[num2].operand?.ToString() == "DiskCardGame.CardSlot opposingSlot")
					{
						obj = codes[num2].operand;
						break;
					}
				}
				for (int i = num; i < codes.Count; i++)
				{
					if (obj2 == null && codes[i].operand?.ToString() == "DiskCardGame.CombatPhaseManager+<>c__DisplayClass5_0 <>8__1")
					{
						obj2 = codes[i].operand;
						obj3 = codes[i + 1].operand;
						break;
					}
				}
				int j = num;
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldfld, obj2));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldfld, obj3));
				codes.Insert(j++, new CodeInstruction(OpCodes.Callvirt, (object)method_GetCard));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldstr, (object)"modifiedAttack"));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldfld, obj2));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldfld, obj3));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(j++, new CodeInstruction(OpCodes.Ldfld, obj));
				codes.Insert(j++, new CodeInstruction(OpCodes.Callvirt, (object)method_NewDamage));
				codes.Insert(j++, new CodeInstruction(OpCodes.Box, (object)typeof(int)));
				codes.Insert(j++, new CodeInstruction(OpCodes.Call, (object)method_SetCustomField));
				index = j;
				for (int k = 0; k < 2; k++)
				{
					for (; j < codes.Count; j++)
					{
						if (!(codes[j].opcode != OpCodes.Callvirt) && !(codes[j].operand.ToString() != "Int32 get_Attack()"))
						{
							codes[j++] = new CodeInstruction(OpCodes.Ldstr, (object)"modifiedAttack");
							codes.Insert(j++, new CodeInstruction(OpCodes.Callvirt, (object)method_GetCustomField));
							index = j;
							break;
						}
					}
				}
				return true;
			}
			return false;
		}

		private static bool CallTriggerOnDirectDamage(List<CodeInstruction> codes, ref int index)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			if (codes[index].opcode != OpCodes.Callvirt || codes[index].operand.ToString() != "DiskCardGame.PlayableCard get_Card()")
			{
				return false;
			}
			int num = ++index;
			object obj = null;
			for (int num2 = num - 1; num2 > 0; num2--)
			{
				if (obj == null && codes[num2].operand?.ToString() == "DiskCardGame.CardSlot opposingSlot")
				{
					obj = codes[num2].operand;
					break;
				}
			}
			for (int num3 = num - 1; num3 > 0; num3--)
			{
				if (codes[num3].opcode == OpCodes.Ldarg_0)
				{
					codes.Insert(num3, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					index++;
					num++;
					break;
				}
			}
			for (int i = num; i < codes.Count; i++)
			{
				if (!(codes[i].opcode != OpCodes.Ldc_I4_7))
				{
					codes.RemoveRange(num, i - num - 2);
					codes.Insert(index++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes.Insert(index++, new CodeInstruction(OpCodes.Ldfld, obj));
					codes.Insert(index++, new CodeInstruction(OpCodes.Callvirt, (object)method_NewTriggers));
					break;
				}
			}
			return true;
		}

		private static IEnumerator TriggerOnDirectDamageTriggers(PlayableCard attacker, CardSlot opposingSlot)
		{
			int damage = CustomFields.Get<int>(attacker, "modifiedAttack");
			if (attacker.TriggerHandler.RespondsToTrigger((Trigger)20, new object[1] { damage }))
			{
				yield return attacker.TriggerHandler.OnTrigger((Trigger)20, new object[1] { damage });
			}
			yield return CustomTriggerFinder.TriggerAll(triggerFacedown: false, (IOnCardDealtDamageDirectly x) => x.RespondsToCardDealtDamageDirectly(attacker, opposingSlot, damage), (IOnCardDealtDamageDirectly x) => x.OnCardDealtDamageDirectly(attacker, opposingSlot, damage));
		}
	}
	[HarmonyPatch]
	public static class TakeDamagePatches
	{
		private const string name_Damage = "System.Int32 damage";

		private const string name_TriggerHandler = "DiskCardGame.CardTriggerHandler get_TriggerHandler()";

		private const string name_CardAttacker = "DiskCardGame.PlayableCard attacker";

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayableCard), "TakeDamage")]
		private static bool AddModifyDamageTrigger(PlayableCard __instance, ref int damage, PlayableCard attacker)
		{
			int originalDamage = damage;
			List<IModifyDamageTaken> list = CustomTriggerFinder.FindGlobalTriggers<IModifyDamageTaken>(findFacedown: true).ToList();
			list.Sort((IModifyDamageTaken a, IModifyDamageTaken b) => b.TriggerPriority(__instance, originalDamage, attacker) - a.TriggerPriority(__instance, originalDamage, attacker));
			foreach (IModifyDamageTaken item in list)
			{
				if (item != null && item.RespondsToModifyDamageTaken(__instance, damage, attacker, originalDamage))
				{
					damage = item.OnModifyDamageTaken(__instance, damage, attacker, originalDamage);
				}
			}
			if (damage < 0)
			{
				damage = 0;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayableCard), "TakeDamage")]
		private static IEnumerator AddTakeDamageTriggers(IEnumerator enumerator, PlayableCard __instance, int damage, PlayableCard attacker)
		{
			IEnumerable<IPreTakeDamage> enumerable = __instance.FindTriggersOnCard<IPreTakeDamage>();
			foreach (IPreTakeDamage item in enumerable)
			{
				if (item.RespondsToPreTakeDamage(attacker, damage))
				{
					yield return item.OnPreTakeDamage