using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Obeliskial_Essentials;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.binbin.PerkManager")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.6.4.0")]
[assembly: AssemblyInformationalVersion("1.6.4+6ec8748342cfc8fe717495bdf9cf14c61c96c347")]
[assembly: AssemblyProduct("Custom Perks")]
[assembly: AssemblyTitle("com.binbin.PerkManager")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.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]
	[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 PerkManager
{
	public class CustomFunctions
	{
		public enum AppliesTo
		{
			None,
			Global,
			Monsters,
			Heroes,
			ThisHero
		}

		public enum CharacterHas
		{
			Perk,
			Item,
			Trait
		}

		public static void TraitHeal(ref Character _character, ref Character _target, int healAmount, string traitName)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			int num = healAmount;
			if (_target.GetHpLeftForMax() < healAmount)
			{
				num = _target.GetHpLeftForMax();
			}
			if (num > 0)
			{
				_target.ModifyHp(num, true, true, (Character)null);
				CastResolutionForCombatText val = new CastResolutionForCombatText();
				val.heal = num;
				if (_target.HeroItem != null)
				{
					((CharacterItem)_target.HeroItem).ScrollCombatTextDamageNew(val);
					EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)_target.HeroItem).CharImageT, false, 0f, false);
				}
				else
				{
					((CharacterItem)_target.NPCItem).ScrollCombatTextDamageNew(val);
					EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)_target.NPCItem).CharImageT, false, 0f, false);
				}
				_target.SetEvent((EventActivation)15, (Character)null, 0, "", (Character)null);
				_character.SetEvent((EventActivation)14, _target, 0, "", (Character)null);
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void TraitHealHero(ref Character _character, ref Hero _target, int healAmount, string traitName)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if (_target == null || !((Character)_target).IsHero || !((Character)_target).Alive)
			{
				return;
			}
			int num = healAmount;
			if (((Character)_target).GetHpLeftForMax() < healAmount)
			{
				num = ((Character)_target).GetHpLeftForMax();
			}
			if (num > 0)
			{
				((Character)_target).ModifyHp(num, true, true, (Character)null);
				CastResolutionForCombatText val = new CastResolutionForCombatText();
				val.heal = num;
				if (((Character)_target).HeroItem != null)
				{
					((CharacterItem)((Character)_target).HeroItem).ScrollCombatTextDamageNew(val);
					EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)((Character)_target).HeroItem).CharImageT, false, 0f, false);
				}
				else
				{
					((CharacterItem)((Character)_target).NPCItem).ScrollCombatTextDamageNew(val);
					EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)((Character)_target).NPCItem).CharImageT, false, 0f, false);
				}
				((Character)_target).SetEvent((EventActivation)15, (Character)null, 0, "", (Character)null);
				_character.SetEvent((EventActivation)14, (Character)(object)_target, 0, "", (Character)null);
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void WhenYouPlayXRefund1Energy(CardType cardType, ref Character _character, string traitName, string traitID)
		{
		}

		public static void ApplyAuraCurseTo(string auraCurse, int amount, bool allHeroFlag, bool allNpcFlag, bool randomHeroFlag, bool randomNpcFlag, ref Character _character, ref Hero[] teamHeroes, ref NPC[] teamNpc, string traitName, string soundEffect)
		{
			if (allNpcFlag)
			{
				for (int i = 0; i < teamNpc.Length; i++)
				{
					if (teamNpc[i] != null && ((Character)teamNpc[i]).Alive)
					{
						((Character)teamNpc[i]).SetAuraTrait(_character, auraCurse, amount);
						if (((Character)teamNpc[i]).NPCItem != null)
						{
							((CharacterItem)((Character)teamNpc[i]).NPCItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
							EffectsManager.Instance.PlayEffectAC(soundEffect, true, ((CharacterItem)((Character)teamNpc[i]).NPCItem).CharImageT, false, 0f, false);
						}
					}
				}
			}
			if (!allHeroFlag)
			{
				return;
			}
			for (int j = 0; j < teamHeroes.Length; j++)
			{
				if (teamHeroes[j] != null && ((Character)teamHeroes[j]).Alive)
				{
					((Character)teamHeroes[j]).SetAuraTrait(_character, auraCurse, amount);
					if (((Character)teamHeroes[j]).NPCItem != null)
					{
						((CharacterItem)((Character)teamHeroes[j]).HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
						EffectsManager.Instance.PlayEffectAC(soundEffect, true, ((CharacterItem)((Character)teamHeroes[j]).NPCItem).CharImageT, false, 0f, false);
					}
				}
			}
		}

		public static void WhenYouGainXGainY(string gainedAuraCurse, string desiredAuraCurse, string appliedAuraCurse, int n_charges_incoming, int n_bonus_charges, float multiplier, ref Character _character, string traitName)
		{
			if ((Object)(object)MatchManager.Instance != (Object)null && gainedAuraCurse != null && (Object)(object)_character.HeroData != (Object)null && gainedAuraCurse == desiredAuraCurse)
			{
				int num = Mathf.RoundToInt((float)(n_charges_incoming + n_bonus_charges) * multiplier);
				_character.SetAuraTrait(_character, appliedAuraCurse, num);
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void WhenYouPlayXGainY(CardType desiredCardType, string desiredAuraCurse, int n_charges, CardData castedCard, ref Character _character, string traitName)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MatchManager.Instance != (Object)null && (Object)(object)castedCard != (Object)null && (Object)(object)_character.HeroData != (Object)null && castedCard.GetCardTypes().Contains(desiredCardType))
			{
				_character.SetAuraTrait(_character, desiredAuraCurse, n_charges);
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void ReduceCostByStacks(CardType cardType, string auraCurseName, int n_charges, ref Character _character, ref List<string> heroHand, ref List<CardData> cardDataList, string traitName, bool applyToAllCards)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_character.HeroData != (Object)null))
			{
				return;
			}
			int num = Mathf.FloorToInt((float)(_character.EffectCharges(auraCurseName) / n_charges));
			if (num <= 0)
			{
				return;
			}
			for (int i = 0; i < heroHand.Count; i++)
			{
				CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
				if (cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || applyToAllCards))
				{
					cardDataList.Add(cardData);
				}
			}
			for (int j = 0; j < cardDataList.Count; j++)
			{
				CardData obj = cardDataList[j];
				obj.EnergyReductionTemporal += num;
				MatchManager.Instance.UpdateHandCards();
				CardItem cardFromTableByIndex = MatchManager.Instance.GetCardFromTableByIndex(cardDataList[j].InternalId);
				cardFromTableByIndex.PlayDissolveParticle();
				cardFromTableByIndex.ShowEnergyModification(-num);
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
				MatchManager.Instance.CreateLogCardModification(cardDataList[j].InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
			}
		}

		public static void AddImmunityToHero(string immunity, ref Hero _character)
		{
			if (!((Character)_character).AuracurseImmune.Contains(immunity))
			{
				((Character)_character).AuracurseImmune.Add(immunity);
			}
		}

		public static void IncreaseChargesByStacks(string auraCurseToModify, float stacks_per_bonus, string auraCurseDependent, ref Character _character, string traitName)
		{
			int auraCharges = _character.GetAuraCharges(auraCurseDependent);
			int num = Mathf.FloorToInt((float)auraCharges / stacks_per_bonus);
			_character.ModifyAuraCurseQuantity(auraCurseToModify, num);
		}

		public static AuraCurseData GetAuraCurseData(string ac)
		{
			return Globals.Instance.GetAuraCurseData(ac);
		}

		public static string TextChargesLeft(int currentCharges, int chargesTotal)
		{
			int num = currentCharges;
			int num2 = chargesTotal;
			return "<br><color=#FFF>" + num + "/" + num2 + "</color>";
		}

		public static void Duality(ref Character _character, ref CardData _castedCard, CardClass class1, CardClass class2, string traitName)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			if (MatchManager.Instance == null || _castedCard == null)
			{
				return;
			}
			TraitData traitData = Globals.Instance.GetTraitData(traitName);
			if (MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(traitName) && MatchManager.Instance.activatedTraits[traitName] > traitData.TimesPerTurn - 1)
			{
				return;
			}
			for (int i = 0; i < 2; i++)
			{
				CardClass val;
				CardClass val2;
				if (i == 0)
				{
					val = class1;
					val2 = class2;
				}
				else
				{
					val = class2;
					val2 = class1;
				}
				if (_castedCard.CardClass != val)
				{
					continue;
				}
				if (MatchManager.Instance.CountHeroHand(-1) == 0 || _character.HeroData == null)
				{
					break;
				}
				List<CardData> list = new List<CardData>();
				List<string> heroHand = MatchManager.Instance.GetHeroHand(_character.HeroIndex);
				int num = 0;
				for (int j = 0; j < heroHand.Count; j++)
				{
					CardData cardData = MatchManager.Instance.GetCardData(heroHand[j], true);
					if (cardData != null && cardData.CardClass == val2 && _character.GetCardFinalCost(cardData) > num)
					{
						num = _character.GetCardFinalCost(cardData);
					}
				}
				if (num <= 0)
				{
					break;
				}
				for (int k = 0; k < heroHand.Count; k++)
				{
					CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[k], true);
					if (cardData2 != null && cardData2.CardClass == val2 && _character.GetCardFinalCost(cardData2) >= num)
					{
						list.Add(cardData2);
					}
				}
				if (list.Count <= 0)
				{
					break;
				}
				CardData val3 = ((list.Count != 1) ? list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "trait", "")] : list[0]);
				if (val3 != null)
				{
					if (!MatchManager.Instance.activatedTraits.ContainsKey(traitName))
					{
						MatchManager.Instance.activatedTraits.Add(traitName, 1);
					}
					else
					{
						Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
						int value = activatedTraits[traitName] + 1;
						activatedTraits[traitName] = value;
					}
					MatchManager.Instance.SetTraitInfoText();
					int num2 = 1;
					val3.EnergyReductionTemporal += num2;
					MatchManager.Instance.GetCardFromTableByIndex(val3.InternalId).ShowEnergyModification(-num2);
					MatchManager.Instance.UpdateHandCards();
					((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitName], traitData.TimesPerTurn), (CombatScrollEffectType)7);
					MatchManager.Instance.CreateLogCardModification(val3.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
				}
				break;
			}
		}

		public static void PermanentyReduceXWhenYouPlayY(ref Character _character, ref CardData _castedCard, CardType reduceThis, CardType whenYouPlayThis, int amountToReduce, string traitName)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (MatchManager.Instance == null || _castedCard == null)
			{
				return;
			}
			TraitData traitData = Globals.Instance.GetTraitData(traitName);
			if ((MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(traitName) && MatchManager.Instance.activatedTraits[traitName] > traitData.TimesPerTurn - 1) || !_castedCard.GetCardTypes().Contains(whenYouPlayThis) || MatchManager.Instance.CountHeroHand(-1) == 0 || _character.HeroData == null)
			{
				return;
			}
			List<CardData> list = new List<CardData>();
			List<string> heroHand = MatchManager.Instance.GetHeroHand(_character.HeroIndex);
			if ((int)reduceThis == 0)
			{
				for (int i = 0; i < heroHand.Count; i++)
				{
					CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
					if (cardData != null)
					{
						list.Add(cardData);
					}
				}
			}
			else
			{
				for (int j = 0; j < heroHand.Count; j++)
				{
					CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[j], true);
					if (cardData2 != null && cardData2.GetCardTypes().Contains(reduceThis))
					{
						list.Add(cardData2);
					}
				}
			}
			if (!MatchManager.Instance.activatedTraits.ContainsKey(traitName))
			{
				MatchManager.Instance.activatedTraits.Add(traitName, 1);
			}
			else
			{
				Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
				int value = activatedTraits[traitName] + 1;
				activatedTraits[traitName] = value;
			}
			CardData val = list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "trait", "")];
			val.EnergyReductionPermanent += amountToReduce;
			MatchManager.Instance.GetCardFromTableByIndex(val.InternalId).ShowEnergyModification(-amountToReduce);
			MatchManager.Instance.UpdateHandCards();
			((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitName], traitData.TimesPerTurn), (CombatScrollEffectType)7);
			MatchManager.Instance.CreateLogCardModification(val.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
		}

		public static int CountAllStacks(string auraCurse, Hero[] teamHero, NPC[] teamNpc)
		{
			int num = 0;
			for (int i = 0; i < teamHero.Length; i++)
			{
				if (teamHero[i] != null && (Object)(object)((Character)teamHero[i]).HeroData != (Object)null && ((Character)teamHero[i]).Alive)
				{
					num += ((Character)teamHero[i]).GetAuraCharges(auraCurse);
				}
			}
			for (int j = 0; j < teamNpc.Length; j++)
			{
				if (teamNpc[j] != null && ((Character)teamNpc[j]).Alive)
				{
					num += ((Character)teamNpc[j]).GetAuraCharges(auraCurse);
				}
			}
			return num;
		}

		public static void DealIndirectDamageToAllMonsters(DamageType damageType, int amount, Character source = null)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			foreach (NPC val in teamNPC)
			{
				if (val != null && ((Character)val).Alive && !((Character)val).IsHero)
				{
					((Character)val).IndirectDamage(damageType, amount, source, (AudioClip)null, "");
				}
			}
		}

		public static Character GetRandomCharacter(Character[] array)
		{
			if (array == null)
			{
				Plugin.LogDebug(Plugin.debugBase + "Null Array");
			}
			List<Character> list = new List<Character>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == null)
				{
					Plugin.LogDebug(Plugin.debugBase + "Null index");
					continue;
				}
				Character val = array[i];
				if (val.Alive && val != null)
				{
					list.Add(val);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			int randomIntRange = MatchManager.Instance.GetRandomIntRange(0, list.Count, "default", "");
			if (randomIntRange < list.Count)
			{
				return list[randomIntRange];
			}
			if (list[randomIntRange] == null)
			{
				return null;
			}
			return list[0];
		}

		public static bool IsLivingHero(Character _character)
		{
			return _character != null && _character.Alive && _character.IsHero;
		}

		public static bool IsLivingNPC(Character _character)
		{
			return _character != null && _character.Alive && !_character.IsHero;
		}

		public static bool CharacterHasPerkForSet(string perkName, bool flag, AtOManager __instance, Character _characterTarget)
		{
			return flag && _characterTarget != null && __instance.CharacterHavePerk(_characterTarget.SubclassName, Plugin.perkBase + perkName);
		}

		public static bool CharacterHasPerkForConsume(string perkName, bool flag, AtOManager __instance, Character _characterCaster)
		{
			return flag && _characterCaster != null && __instance.CharacterHavePerk(_characterCaster.SubclassName, Plugin.perkBase + perkName);
		}

		public static bool TeamHasPerkForSet(string perkName, bool flag, AtOManager __instance, Character _characterTarget)
		{
			return _characterTarget != null && __instance.TeamHavePerk(Plugin.perkBase + perkName) && flag;
		}

		public static bool TeamHasPerk(string perkName)
		{
			return AtOManager.Instance.TeamHavePerk(Plugin.perkBase + perkName);
		}

		public static bool TeamHasPerkForConsume(string perkName, bool flag, AtOManager __instance, Character _characterCaster)
		{
			return _characterCaster != null && __instance.TeamHavePerk(Plugin.perkBase + perkName) && flag;
		}

		public static bool CharacterObjectHavePerk(Character _character, string _perk_id)
		{
			if (_character == null)
			{
				return false;
			}
			return AtOManager.Instance.CharacterHavePerk(_character.SubclassName, Plugin.perkBase + _perk_id) || AtOManager.Instance.CharacterHavePerk(_character.SubclassName, _perk_id);
		}

		public static void CastTargetCard(string cardToCast)
		{
			CardData cardData = Globals.Instance.GetCardData(cardToCast, true);
			((MonoBehaviour)MatchManager.Instance).StartCoroutine(MatchManager.Instance.CastCard((CardItem)null, true, cardData, 0, -1, true, (Hero)null));
		}

		public static bool IfCharacterHas(Character characterOfInterest, CharacterHas characterHas, string id, AppliesTo appliesTo = AppliesTo.Global, string _type = "", string onlyThisType = "")
		{
			if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			if (_type != "" && onlyThisType != _type)
			{
				return false;
			}
			bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global || (appliesTo == AppliesTo.ThisHero && characterOfInterest.IsHero);
			bool flag2 = false;
			if (appliesTo == AppliesTo.ThisHero)
			{
				switch (characterHas)
				{
				case CharacterHas.Item:
					flag2 = AtOManager.Instance.CharacterHaveItem(characterOfInterest.SubclassName, Plugin.perkBase + id) || AtOManager.Instance.CharacterHaveItem(characterOfInterest.SubclassName, id);
					break;
				case CharacterHas.Perk:
					flag2 = AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, Plugin.perkBase + id) || AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, id);
					break;
				case CharacterHas.Trait:
					flag2 = AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, Plugin.perkBase + id) || AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, id);
					break;
				}
			}
			else
			{
				switch (characterHas)
				{
				case CharacterHas.Item:
					flag2 = AtOManager.Instance.TeamHaveItem(Plugin.perkBase + id, -1, false) || AtOManager.Instance.TeamHaveItem(id, -1, false);
					break;
				case CharacterHas.Perk:
					flag2 = AtOManager.Instance.TeamHavePerk(Plugin.perkBase + id) || AtOManager.Instance.TeamHavePerk(id);
					break;
				case CharacterHas.Trait:
					flag2 = AtOManager.Instance.TeamHaveTrait(Plugin.perkBase + id) || AtOManager.Instance.TeamHaveTrait(id);
					break;
				}
			}
			return flag2 && flag;
		}
	}
	[HarmonyPatch]
	public class PerkBackgroundExtension
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(PerkNodeAmplify), "SetForNodes")]
		public static bool SetForNodesPrefix(PerkNodeAmplify __instance, int _numNodes)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			PolygonCollider2D component = ((Component)__instance).GetComponent<PolygonCollider2D>();
			float num = -0.7f * (float)(_numNodes - 1);
			switch (_numNodes)
			{
			case 2:
				((Component)__instance.bg2).gameObject.SetActive(true);
				((Component)__instance.bg3).gameObject.SetActive(false);
				((Component)__instance.bg4).gameObject.SetActive(false);
				__instance.amplifyNodes.localPosition = new Vector3(num, __instance.amplifyNodes.localPosition.y, __instance.amplifyNodes.localPosition.z);
				component.points = ((Component)__instance.bg2).GetComponent<PolygonCollider2D>().points;
				break;
			case 3:
				((Component)__instance.bg2).gameObject.SetActive(false);
				((Component)__instance.bg3).gameObject.SetActive(true);
				((Component)__instance.bg4).gameObject.SetActive(false);
				__instance.amplifyNodes.localPosition = new Vector3(num, __instance.amplifyNodes.localPosition.y, __instance.amplifyNodes.localPosition.z);
				component.points = ((Component)__instance.bg3).GetComponent<PolygonCollider2D>().points;
				break;
			default:
			{
				((Component)__instance.bg2).gameObject.SetActive(false);
				((Component)__instance.bg3).gameObject.SetActive(false);
				((Component)__instance.bg4).gameObject.SetActive(true);
				__instance.amplifyNodes.localPosition = new Vector3(num, __instance.amplifyNodes.localPosition.y, __instance.amplifyNodes.localPosition.z);
				float num2 = (float)_numNodes / 4f;
				((Component)__instance.bg4).transform.localScale = new Vector3(num2, 1f, 1f);
				PolygonCollider2D component2 = ((Component)__instance.bg4).GetComponent<PolygonCollider2D>();
				Vector2[] points = component2.points;
				for (int i = 0; i < points.Length; i++)
				{
					points[i] = new Vector2(points[i].x * num2, points[i].y);
				}
				component.points = points;
				break;
			}
			}
			return false;
		}
	}
	[HarmonyPatch]
	public class PerkPatches
	{
		public static int[] paralyzeCounters = new int[4];

		public static bool blockShieldFlag = false;

		public static int blockCount = 0;

		public static int shieldCount = 0;

		public static bool mark1dFlag = true;

		public static bool poison2gFlag = true;

		public static bool bleed2gFlag = true;

		public static bool thorns1eFlag = true;

		public static bool shackle1fFlag = false;

		public static bool insulate1dFlag = false;

		public static bool isDamagePreviewActive = false;

		public static bool isCalculateDamageActive = false;

		public static int infiniteProctection = 0;

		public static int infiniteProctectionPowerful = 0;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "BeginAdventure")]
		public static void BeginAdventurePostfix(ref AtOManager __instance)
		{
			Hero[] value = Traverse.Create((object)__instance).Field("teamAtO").GetValue<Hero[]>();
			foreach (Hero hero in value)
			{
				HandleExpPerks(hero);
			}
		}

		public static void HandleExpPerks(Hero _hero)
		{
			int num = 0;
			int num2 = 10;
			int num3 = 40;
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "exp0"))
			{
				num += num2;
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "exp1"))
			{
				num += num2;
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "exp2"))
			{
				num += num2;
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "exp3"))
			{
				num += num3;
			}
			((Character)_hero).GrantExperience(num);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "HeroLevelUp")]
		public static void HeroLevelUpPrefix(ref AtOManager __instance, int heroIndex, string traitId)
		{
			Hero[] value = Traverse.Create((object)__instance).Field("teamAtO").GetValue<Hero[]>();
			Hero val = value[heroIndex];
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "health6b"))
			{
				int num = 12;
				((Character)value[heroIndex]).ModifyMaxHP(num);
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "health6c"))
			{
				int num2 = -14;
				((Character)value[heroIndex]).ModifyMaxHP(num2);
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "shards5b"))
			{
				int num3 = 125;
				AtOManager.Instance.GivePlayer(1, num3, "", "", true, false);
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "currency6b"))
			{
				int num4 = 125;
				AtOManager.Instance.GivePlayer(0, num4, "", "", true, false);
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "resistance5b"))
			{
				Plugin.LogDebug("Attempting to add resistances");
				int num5 = 4;
				string text = Plugin.perkBase + "resistance5b";
				PerkData perkData = Globals.Instance.GetPerkData(text);
				perkData.ResistModified = (DamageType)10;
				perkData.ResistModifiedValue += num5;
				Dictionary<string, PerkData> value2 = Traverse.Create((object)Globals.Instance).Field("_PerksSource").GetValue<Dictionary<string, PerkData>>();
				if (value2.ContainsKey(text))
				{
					Plugin.LogDebug("Setting perk dictionary");
					value2[text] = perkData;
				}
				Traverse.Create((object)Globals.Instance).Field("_PerksSource").SetValue((object)value2);
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "resistance5c"))
			{
				Plugin.LogDebug("Attempting to add resistances");
				int num6 = -4;
				string text2 = Plugin.perkBase + "resistance5b";
				PerkData perkData2 = Globals.Instance.GetPerkData(text2);
				perkData2.ResistModified = (DamageType)10;
				perkData2.ResistModifiedValue += num6;
				Dictionary<string, PerkData> value3 = Traverse.Create((object)Globals.Instance).Field("_PerksSource").GetValue<Dictionary<string, PerkData>>();
				if (value3.ContainsKey(text2))
				{
					Plugin.LogDebug("Setting perk dictionary");
					value3[text2] = perkData2;
				}
				Traverse.Create((object)Globals.Instance).Field("_PerksSource").SetValue((object)value3);
			}
			HandleExpPerks(val);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MatchManager), "GenerateHeroes")]
		public static void GenerateHeroesPostfix(ref MatchManager __instance)
		{
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			for (int i = 0; i < teamHero.Length; i++)
			{
				if (teamHero[i] != null)
				{
					Hero _character = teamHero[i];
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "weak1d"))
					{
						CustomFunctions.AddImmunityToHero("weak", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "disarm1a"))
					{
						CustomFunctions.AddImmunityToHero("disarm", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "silence1a"))
					{
						CustomFunctions.AddImmunityToHero("silence", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "shackle1b"))
					{
						CustomFunctions.AddImmunityToHero("shackle", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "stanza0e"))
					{
						CustomFunctions.AddImmunityToHero("stanzai", ref _character);
						CustomFunctions.AddImmunityToHero("stanzaiii", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "energize1e"))
					{
						CustomFunctions.AddImmunityToHero("fatigue", ref _character);
					}
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_character, "vulnerable0d"))
					{
						CustomFunctions.AddImmunityToHero("vulnerable", ref _character);
						CustomFunctions.AddImmunityToHero("reinforce", ref _character);
						CustomFunctions.AddImmunityToHero("insulate", ref _character);
						CustomFunctions.AddImmunityToHero("courage", ref _character);
					}
				}
			}
			Traverse.Create((object)MatchManager.Instance).Field("teamHero").SetValue((object)teamHero);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Globals), "GetCostReroll")]
		public static void GetRerollCostPostfix(ref int __result)
		{
			if (CustomFunctions.TeamHasPerk("currency6d"))
			{
				__result = Mathf.RoundToInt(0.75f * (float)__result);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Globals), "GetDivinationCost")]
		public static void GetDivinationCost(ref Globals __instance, ref int __result)
		{
			if (CustomFunctions.TeamHasPerk("currency6e"))
			{
				__result = Mathf.RoundToInt(0.85f * (float)__result);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitHealReceivedPercentBonus")]
		public static void GetTraitHealReceivedPercentBonusPostfix(ref Character __instance, ref float __result)
		{
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "heal5c") && __instance.IsHero && __instance.Alive && __instance != null)
			{
				__result += 35f;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "SetEvent")]
		public static void SetEventPrefix(ref Character __instance, EventActivation theEvent, ref int auxInt, Character target = null, string auxString = "")
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Invalid comparison between Unknown and I4
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Invalid comparison between Unknown and I4
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Invalid comparison between Unknown and I4
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Invalid comparison between Unknown and I4
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Invalid comparison between Unknown and I4
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Invalid comparison between Unknown and I4
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Invalid comparison between Unknown and I4
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Invalid comparison between Unknown and I4
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Invalid comparison between Unknown and I4
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Invalid comparison between Unknown and I4
			//IL_05ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Invalid comparison between Unknown and I4
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Invalid comparison between Unknown and I4
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Invalid comparison between Unknown and I4
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Invalid comparison between Unknown and I4
			//IL_0729: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Invalid comparison between Unknown and I4
			//IL_0774: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Invalid comparison between Unknown and I4
			//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Invalid comparison between Unknown and I4
			//IL_0855: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Invalid comparison between Unknown and I4
			//IL_08eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ee: Invalid comparison between Unknown and I4
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Invalid comparison between Unknown and I4
			//IL_09b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b9: Invalid comparison between Unknown and I4
			//IL_0a79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7b: Invalid comparison between Unknown and I4
			//IL_0afc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afe: Invalid comparison between Unknown and I4
			//IL_0b65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b68: Invalid comparison between Unknown and I4
			if ((int)theEvent == 18 || (int)theEvent == 26 || __instance == null || (int)theEvent == 0)
			{
				return;
			}
			Hero[] teamHeroes = MatchManager.Instance.GetTeamHero();
			NPC[] teamNpc = MatchManager.Instance.GetTeamNPC();
			string name = Enum.GetName(typeof(EventActivation), theEvent);
			if ((int)theEvent == 1)
			{
				infiniteProctection = 0;
				paralyzeCounters = new int[4];
				mark1dFlag = true;
			}
			if ((int)theEvent == 42 && auxString == "burn" && CustomFunctions.TeamHasPerk("burn2f") && CustomFunctions.IsLivingNPC(__instance) && target != null && CustomFunctions.IsLivingHero(target))
			{
				int auraCharges = target.GetAuraCharges("burn");
				int num = 2 * auraCharges;
				__instance.IndirectDamage((DamageType)4, num, (Character)null, (AudioClip)null, "");
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingNPC(__instance) && CustomFunctions.TeamHasPerk("mark1d") && __instance.HasEffect("mark") && auxString == "mark" && __instance.GetAuraCharges("mark") >= 10 && mark1dFlag)
			{
				__instance.SetAura(__instance, CustomFunctions.GetAuraCurseData("taunt"), 2, false, (CardClass)11, false, true);
				mark1dFlag = false;
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingNPC(target) && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "spark2g") && auxString == "spark")
			{
				target.SetAura((Character)null, CustomFunctions.GetAuraCurseData("crack"), 2, false, (CardClass)11, true, true);
			}
			if ((int)theEvent == 23 && auxString == "powerful" && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.TeamHasPerk("powerful1d") && __instance.HasEffect("powerful"))
			{
				AuraCurseData auraCurseData = CustomFunctions.GetAuraCurseData("powerful");
				if ((__instance.GetAuraCharges("powerful") == auraCurseData.MaxCharges || __instance.GetAuraCharges("powerful") == auraCurseData.MaxCharges + 7) && infiniteProctectionPowerful < 10)
				{
					__instance.SetAuraTrait(__instance, "vitality", 1);
					infiniteProctectionPowerful++;
				}
			}
			if ((int)theEvent == 23 && auxString == "shackle" && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "shackle1e") && __instance.HasEffect("shackle"))
			{
				int auraCharges2 = __instance.GetAuraCharges("shackle");
				__instance.ModifyAuraCurseQuantity("dark", auraCharges2);
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.IsLivingNPC(target) && CustomFunctions.CharacterObjectHavePerk(__instance, "poison2h") && auxString == "poison")
			{
				int auraCharges3 = target.GetAuraCharges("poison");
				float num2 = (target.HasEffect("rust") ? 0.3f : 0.2f);
				int num3 = Mathf.RoundToInt((float)auraCharges3 * num2);
				target.IndirectDamage((DamageType)7, num3, __instance, (AudioClip)null, "");
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingHero(target) && target.HasEffect("courage") && CustomFunctions.CharacterObjectHavePerk(target, "courage1d") && auxString == "shield")
			{
				int auraCharges4 = target.GetAuraCharges("courage");
				shieldCount++;
				if (shieldCount % 2 == 1 && shieldCount < 100)
				{
					target.SetAura(__instance, CustomFunctions.GetAuraCurseData("shield"), auraCharges4, false, (CardClass)11, false, true);
				}
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingHero(target) && target.HasEffect("reinforce") && CustomFunctions.CharacterObjectHavePerk(target, "reinforce1d") && auxString == "block")
			{
				int auraCharges5 = __instance.GetAuraCharges("reinforce");
				blockCount++;
				if (blockCount % 2 == 1 && blockCount < 100)
				{
					target.SetAura(__instance, CustomFunctions.GetAuraCurseData("block"), auraCharges5, false, (CardClass)11, false, true);
				}
			}
			if ((int)theEvent == 23 && CustomFunctions.IsLivingNPC(target) && CustomFunctions.TeamHasPerk("sight1e") && auxString == "sight" && target.HasEffect("sight") && target.GetAuraCharges("sight") >= 100)
			{
				target.HealCursesName((List<string>)null, "sight");
				target.DispelAuras(3);
			}
			if ((int)theEvent == 23 && __instance != null && CustomFunctions.IsLivingNPC(target) && CustomFunctions.TeamHasPerk("paralyze1c") && auxString == "spark")
			{
				int auraCharges6 = target.GetAuraCharges("spark");
				if (auraCharges6 >= 100 && paralyzeCounters[target.NPCIndex] <= 0)
				{
					AuraCurseData auraCurseData2 = CustomFunctions.GetAuraCurseData("paralyze");
					paralyzeCounters[target.NPCIndex]++;
					target.SetAura(__instance, auraCurseData2, 1, false, (CardClass)11, true, true);
				}
			}
			if ((int)theEvent == 23 && auxString == "block" && CustomFunctions.IsLivingHero(target) && CustomFunctions.CharacterObjectHavePerk(target, "block5d"))
			{
				int num4 = 1;
				DamageType val = (DamageType)2;
				int num5 = target.DamageWithCharacterBonus(num4, val, (CardClass)11, 0, -1000);
				Character[] array = (Character[])(object)teamNpc;
				Character randomCharacter = CustomFunctions.GetRandomCharacter(array);
				if (randomCharacter.Alive && randomCharacter != null && target.Alive && target != null)
				{
					randomCharacter.IndirectDamage(val, num5, target, (AudioClip)null, "");
					target.IndirectDamage(val, num5, target, (AudioClip)null, "");
				}
			}
			if ((int)theEvent == 23 && auxString == "rust" && CustomFunctions.IsLivingNPC(__instance) && CustomFunctions.CharacterObjectHavePerk(target, "rust0h"))
			{
				__instance.DispelAuras(1);
			}
			if ((int)theEvent == 23 && auxString == "decay" && CustomFunctions.IsLivingNPC(__instance) && CustomFunctions.IsLivingHero(target) && CustomFunctions.CharacterObjectHavePerk(target, "decay1g"))
			{
				target.SetAura(__instance, CustomFunctions.GetAuraCurseData("rust"), 1, false, (CardClass)11, true, true);
				target.SetAura(target, CustomFunctions.GetAuraCurseData("rust"), 1, false, (CardClass)11, true, true);
			}
			if ((int)theEvent == 1 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "block5c"))
			{
				bool allHeroFlag = true;
				bool allNpcFlag = false;
				CustomFunctions.ApplyAuraCurseTo("block", 2, allHeroFlag, allNpcFlag, randomHeroFlag: false, randomNpcFlag: false, ref __instance, ref teamHeroes, ref teamNpc, "", "");
			}
			if ((int)theEvent == 1 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "shield5c"))
			{
				bool allHeroFlag2 = true;
				bool allNpcFlag2 = false;
				CustomFunctions.ApplyAuraCurseTo("shield", 4, allHeroFlag2, allNpcFlag2, randomHeroFlag: false, randomNpcFlag: false, ref __instance, ref teamHeroes, ref teamNpc, "", "");
			}
			if ((int)theEvent == 1 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "fortify1f"))
			{
				bool allHeroFlag3 = true;
				bool allNpcFlag3 = false;
				CustomFunctions.ApplyAuraCurseTo("fortify", 2, allHeroFlag3, allNpcFlag3, randomHeroFlag: false, randomNpcFlag: false, ref __instance, ref teamHeroes, ref teamNpc, "", "");
			}
			if ((int)theEvent == 1 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "rust0g"))
			{
				bool allHeroFlag4 = true;
				bool allNpcFlag4 = false;
				CustomFunctions.ApplyAuraCurseTo("rust", 2, allHeroFlag4, allNpcFlag4, randomHeroFlag: false, randomNpcFlag: false, ref __instance, ref teamHeroes, ref teamNpc, "", "");
			}
			if ((int)theEvent == 35 && !target.IsHero && target != null && CustomFunctions.TeamHasPerk("poison2g") && target.HasEffect("poison") && poison2gFlag)
			{
				poison2gFlag = false;
				int auraCharges7 = target.GetAuraCharges("poison");
				int num6 = Mathf.RoundToInt((float)auraCharges7 * 0.5f);
				Character[] array = (Character[])(object)teamNpc;
				Character randomCharacter2 = CustomFunctions.GetRandomCharacter(array);
				if (CustomFunctions.IsLivingNPC(randomCharacter2))
				{
					randomCharacter2.SetAura(__instance, CustomFunctions.GetAuraCurseData("poison"), num6, false, (CardClass)11, false, true);
				}
			}
			if ((int)theEvent == 35 && !target.IsHero && target != null && CustomFunctions.TeamHasPerk("thorns1e") && target.HasEffect("thorns") && thorns1eFlag)
			{
				thorns1eFlag = false;
				int auraCharges8 = target.GetAuraCharges("thorns");
				int num7 = Mathf.RoundToInt((float)auraCharges8 * 1f);
				Character[] array = (Character[])(object)teamHeroes;
				Character randomCharacter3 = CustomFunctions.GetRandomCharacter(array);
				if (CustomFunctions.IsLivingHero(randomCharacter3))
				{
					randomCharacter3.SetAura(__instance, CustomFunctions.GetAuraCurseData("thorns"), num7, false, (CardClass)11, false, true);
				}
			}
			if ((int)theEvent == 35 && !target.IsHero && target != null && CustomFunctions.TeamHasPerk("bleed2g") && target.HasEffect("bleed") && bleed2gFlag)
			{
				bleed2gFlag = false;
				int auraCharges9 = target.GetAuraCharges("bleed");
				int amount = Mathf.RoundToInt((float)auraCharges9 * 0.25f);
				CustomFunctions.DealIndirectDamageToAllMonsters((DamageType)0, amount, __instance);
			}
			if ((int)theEvent == 9 && CustomFunctions.IsLivingNPC(__instance) && CustomFunctions.IsLivingHero(target) && CustomFunctions.CharacterObjectHavePerk(target, "bleed2e"))
			{
				int auraCharges10 = __instance.GetAuraCharges("bleed");
				int num8 = Mathf.RoundToInt((float)auraCharges10 * 0.25f);
				target.IndirectHeal(num8, (AudioClip)null, "", "");
			}
			if ((int)theEvent == 9 && CustomFunctions.IsLivingNPC(__instance) && CustomFunctions.IsLivingHero(target) && CustomFunctions.CharacterObjectHavePerk(target, "spark2f"))
			{
				int auraCharges11 = __instance.GetAuraCharges("spark");
				int num9 = Mathf.RoundToInt((float)auraCharges11 * 0.2f);
				int nPCIndex = __instance.NPCIndex;
				List<NPC> nPCSides = MatchManager.Instance.GetNPCSides(nPCIndex);
				for (int i = 0; i < nPCSides.Count; i++)
				{
					if (((Character)nPCSides[i]).Alive && nPCSides[i] != null)
					{
						((Character)nPCSides[i]).IndirectDamage((DamageType)6, num9, __instance, (AudioClip)null, "");
					}
				}
			}
			if ((int)theEvent == 7 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "spellsword1d"))
			{
				CardData value = Traverse.Create((object)__instance).Field("cardCasted").GetValue<CardData>();
				if ((Object)(object)value != (Object)null && MatchManager.Instance.energyJustWastedByHero >= 4 && (value.HasCardType((CardType)19) || value.HasCardType((CardType)20)))
				{
					__instance.SetAuraTrait(__instance, "spellsword", 1);
				}
			}
			if ((int)theEvent == 7 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "energy2e"))
			{
				CardData value2 = Traverse.Create((object)__instance).Field("cardCasted").GetValue<CardData>();
				if ((Object)(object)value2 != (Object)null && MatchManager.Instance.energyJustWastedByHero >= 4)
				{
					__instance.ModifyEnergy(1, false);
				}
			}
			if ((int)theEvent == 20 && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.CharacterObjectHavePerk(__instance, "taunt1g") && __instance.HasEffect("taunt"))
			{
				__instance.ConsumeEffectCharges("taunt", 1);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetEnergyTurn")]
		public static void GetEnergyTurnPostfix(Character __instance, ref int __result)
		{
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "energy2e") && __instance.IsHero && __instance.Alive && __instance != null)
			{
				__result--;
				if (__result < 0)
				{
					__result = 0;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "DamageReflected")]
		public static bool DamageReflectedPrefix(ref Character __instance, Hero theCasterHero, NPC theCasterNPC, int damageAmount = 0, int blockedAmount = 0)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.IsHero && theCasterHero != null)
			{
				return true;
			}
			List<Aura> auraList = __instance.AuraList;
			for (int i = 0; i < auraList.Count; i++)
			{
				if (auraList[i] == null)
				{
					continue;
				}
				AuraCurseData aCData = auraList[i].ACData;
				if (!((Object)(object)aCData != (Object)null) || aCData.DamageReflectedMultiplier <= 0 || __instance.GetAuraCharges(aCData.Id) < aCData.ChargesPreReqForDamageReflection)
				{
					continue;
				}
				RefectedDamageModifierType damageReflectedModifierType = aCData.DamageReflectedModifierType;
				RefectedDamageModifierType val = damageReflectedModifierType;
				if ((int)val == 0 && aCData.Id == "thorns" && theCasterNPC != null && CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Perk, "zeal0j", CustomFunctions.AppliesTo.Heroes) && __instance.HasEffect("zeal"))
				{
					((Character)theCasterNPC).SetAura(__instance, Globals.Instance.GetAuraCurseData("burn"), Functions.FuncRoundToInt((float)auraList[i].AuraCharges * 0.5f), false, (CardClass)11, true, true);
					if (aCData.DamageReflectedConsumeCharges > 0)
					{
						__instance.ConsumeEffectCharges(aCData.Id, aCData.DamageReflectedConsumeCharges);
					}
					return false;
				}
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "EndRound")]
		public static void EndRoundPostfix(ref Character __instance)
		{
			Plugin.LogDebug("EndRoundPostfix");
			if (__instance != null)
			{
				int auraCharges = __instance.GetAuraCharges("spark");
				if ((Object)(object)AtOManager.Instance != (Object)null && AtOManager.Instance.TeamHavePerk("mainperkspark2c"))
				{
					__instance.SetAuraTrait((Character)null, "slow", Mathf.FloorToInt(1f / 14f * (float)auraCharges));
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "DamageWithCharacterBonus")]
		public static void DamageWithCharacterBonusPostfix(ref Character __instance, ref int __result, int value, DamageType DT, CardClass CC, int energyCost = 0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Invalid comparison between Unknown and I4
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Invalid comparison between Unknown and I4
			if ((int)CC == 11 || !CustomFunctions.IsLivingHero(__instance) || value == 0 || __result == 0 || (int)DT == 0 || (Object)(object)AtOManager.Instance == (Object)null || (Object)(object)MatchManager.Instance == (Object)null || !CustomFunctions.CharacterObjectHavePerk(__instance, "energy2d"))
			{
				return;
			}
			float num = 4f;
			num += (float)__instance.GetAuraCharges("bless") * 0.25f;
			if ((int)DT == 1 || (int)DT == 3 || ((int)DT == 9 && AtOManager.Instance.CharacterHavePerk(__instance.SubclassName, "mainperkSharp1d")) || ((int)DT == 7 && AtOManager.Instance.TeamHaveTrait("shrilltone")))
			{
				num += (float)__instance.GetAuraCharges("sharp") * 0.2f;
			}
			if (((int)DT == 4 || (int)DT == 2) && AtOManager.Instance.CharacterHavePerk(__instance.SubclassName, "mainperkfortify1a"))
			{
				num += (float)__instance.GetAuraCharges("fortify") * 0.2f;
			}
			Dictionary<int, float> dictionary = new Dictionary<int, float>
			{
				{ 0, 0.4f },
				{ 1, 0.7f },
				{ 2, 1f },
				{ 3, 1.4f },
				{ 4, 1.8f },
				{ 5, 2.2f },
				{ 6, 2.7f },
				{ 7, 3.2f },
				{ 8, 3.9f },
				{ 9, 4.8f },
				{ 10, 6f }
			};
			int num2 = __result;
			if (dictionary.ContainsKey(energyCost))
			{
				int val = Mathf.RoundToInt(((float)__result - num * MathF.Sqrt(energyCost)) * dictionary[energyCost] + num);
				if (energyCost < 2)
				{
					__result = Math.Min(val, Mathf.RoundToInt((float)num2 * dictionary[energyCost]));
				}
				else
				{
					__result = Math.Max(val, num2);
				}
				if (__result < 0)
				{
					__result = 0;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "SetAura")]
		public static void SetAuraPrefix(ref Character __instance, Character theCaster, AuraCurseData _acData, ref int charges, bool fromTrait = false, CardClass CC = 11, bool useCharacterMods = true, bool canBePreventable = true)
		{
			if (CustomFunctions.TeamHasPerk("weak1b") && __instance != null && __instance.Alive && CustomFunctions.IsLivingNPC(theCaster) && theCaster.HasEffect("weak"))
			{
				charges = Functions.FuncRoundToInt(0.8f * (float)charges);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "BeginTurn")]
		public static void BeginTurnPrefix(ref Character __instance)
		{
			poison2gFlag = true;
			bleed2gFlag = true;
			thorns1eFlag = true;
			infiniteProctection = 0;
			infiniteProctectionPowerful = 0;
			if (!__instance.Alive || __instance == null || (Object)(object)MatchManager.Instance == (Object)null)
			{
				return;
			}
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "rust0f"))
			{
				int num = 2;
				__instance.SetAuraTrait(__instance, "rust", num);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "shackle1d"))
			{
				int auraCharges = __instance.GetAuraCharges("shackle");
				int num2 = 2;
				__instance.SetAuraTrait(__instance, "fortify", auraCharges * num2);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "mitigate1a"))
			{
				int num3 = 2;
				__instance.SetAuraTrait(__instance, "mitigate", num3);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "mitigate1c"))
			{
				int num4 = 7 * __instance.GetAuraCharges("mitigate");
				__instance.SetAuraTrait(__instance, "block", num4);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "health6c"))
			{
				Plugin.LogDebug("Health6c current: " + __instance.HpCurrent + " Max: " + __instance.GetMaxHP());
				if (__instance.GetMaxHP() <= __instance.HpCurrent || __instance.GetHpLeftForMax() <= 0)
				{
					int num5 = 2;
					__instance.SetAuraTrait(__instance, "vitality", num5);
				}
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "chill2f"))
			{
				int num6 = 3;
				__instance.SetAuraTrait(__instance, "chill", num6);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "sight1d"))
			{
				int num7 = 0;
				NPC[] array = teamNPC;
				foreach (NPC val in array)
				{
					if (CustomFunctions.IsLivingNPC((Character)(object)val) && ((Character)val).GetAuraCharges("sight") >= 100)
					{
						num7++;
					}
				}
				__instance.SetAuraTrait(__instance, "evasion", num7);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "energize1a") && MatchManager.Instance.GetCurrentRound() == 1)
			{
				__instance.SetAuraTrait(__instance, "energize", 1);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "spellsword1c"))
			{
				Hero[] array2 = teamHero;
				foreach (Hero val2 in array2)
				{
					if (CustomFunctions.IsLivingHero((Character)(object)val2) && (!(((Character)val2).SubclassName == "queen") || ((Character)val2).GetAuraCharges("spellsword") != 4))
					{
						((Character)val2).SetAuraTrait(__instance, "spellsword", 1);
					}
				}
				NPC[] array3 = teamNPC;
				foreach (NPC val3 in array3)
				{
					if (CustomFunctions.IsLivingNPC((Character)(object)val3))
					{
						((Character)val3).SetAuraTrait(__instance, "spellsword", 1);
					}
				}
			}
			if (CustomFunctions.TeamHasPerk("sanctify2e") && __instance.IsHero && __instance.HasEffect("sanctify"))
			{
				int auraCharges2 = __instance.GetAuraCharges("sanctify");
				int num8 = Mathf.FloorToInt((float)auraCharges2 * 0.05f);
				AuraCurseData auraCurseData = CustomFunctions.GetAuraCurseData("zeal");
				__instance.SetAura(__instance, auraCurseData, num8, false, (CardClass)11, false, true);
			}
			if (CustomFunctions.TeamHasPerk("insane2f") && __instance.HasEffect("insane"))
			{
				int num9 = Mathf.FloorToInt((float)(__instance.GetAuraCharges("insane") / 30));
				__instance.SetAuraTrait(__instance, "scourge", num9);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "stealh1d") && __instance.IsHero && !__instance.HasEffect("stealth"))
			{
				__instance.SetAura(__instance, CustomFunctions.GetAuraCurseData("stealth"), 1, false, (CardClass)11, false, true);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "stanza0d") && __instance.IsHero && MatchManager.Instance.GetCurrentRound() == 1)
			{
				__instance.SetAura(__instance, CustomFunctions.GetAuraCurseData("stanzai"), 1, false, (CardClass)11, false, true);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "stanza0e") && __instance.IsHero && MatchManager.Instance.GetCurrentRound() == 1)
			{
				__instance.SetAura(__instance, CustomFunctions.GetAuraCurseData("stanzaii"), 1, false, (CardClass)11, false, true);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitDamagePercentModifiers")]
		public static void GetTraitDamagePercentModifiersPostfix(ref Character __instance, ref float __result)
		{
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "currency6c"))
			{
				int playerGold = AtOManager.Instance.GetPlayerGold();
				int num = Mathf.FloorToInt((float)(10 * playerGold / 2000));
				__result += num;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MatchManager), "EndTurn")]
		public static void MatchManagerEndTurnPrefix(MatchManager __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Character characterActive = __instance.GetCharacterActive();
			if (!CustomFunctions.IsLivingHero(characterActive))
			{
				return;
			}
			if (CustomFunctions.CharacterObjectHavePerk(characterActive, "inspire0d") && __instance.CountHeroHand(-1) >= 4)
			{
				characterActive.SetAuraTrait(characterActive, "inspire", 1);
			}
			if (CustomFunctions.CharacterObjectHavePerk(characterActive, "health6d") && characterActive.GetHpLeftForMax() <= 0)
			{
				characterActive.SetAuraTrait(characterActive, "vitality", 2);
			}
			if (CustomFunctions.CharacterObjectHavePerk(characterActive, "leech0e"))
			{
				AtOManager.Instance.DoLeachExplosion(characterActive);
			}
			if (!CustomFunctions.TeamHasPerk("fury1d") || !characterActive.HasEffect("fury"))
			{
				return;
			}
			float num = 0.7f;
			if ((Object)(object)characterActive.HeroItem != (Object)null)
			{
				List<Hero> heroSides = MatchManager.Instance.GetHeroSides(characterActive.Position);
				for (int i = 0; i < heroSides.Count; i++)
				{
					((Character)heroSides[i]).SetAura((Character)null, Globals.Instance.GetAuraCurseData("fury"), Functions.FuncRoundToInt((float)characterActive.GetAuraCharges("fury") * num), false, (CardClass)11, true, true);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MatchManager), "SetDamagePreview")]
		public static void SetDamagePreviewPrefix()
		{
			isDamagePreviewActive = true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MatchManager), "SetDamagePreview")]
		public static void SetDamagePreviewPostfix()
		{
			isDamagePreviewActive = false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterItem), "CalculateDamagePrePostForThisCharacter")]
		public static void CalculateDamagePrePostForThisCharacterPrefix()
		{
			isCalculateDamageActive = true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CharacterItem), "CalculateDamagePrePostForThisCharacter")]
		public static void CalculateDamagePrePostForThisCharacterPostfix()
		{
			isCalculateDamageActive = false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "IndirectDamage")]
		public static void IndirectDamagePrefix(ref Character __instance, DamageType damageType, ref int damage, Character casterCharacter, AudioClip sound = null, string effect = "")
		{
			Plugin.LogDebug("IndirectDamagePrefix");
			if (!((Object)(object)MatchManager.Instance == (Object)null))
			{
				if (CustomFunctions.TeamHasPerk("thorns1f") && CustomFunctions.IsLivingHero(casterCharacter) && casterCharacter.HasEffect("bless") && effect == "thorns")
				{
					int auraCharges = casterCharacter.GetAuraCharges("rust");
					float num = 1f + 0.05f * (float)auraCharges;
					damage = Mathf.RoundToInt((float)damage * num);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "HealReceivedFinal")]
		public static void HealReceivedFinalPostfix(Character __instance, int __result, int heal, bool isIndirect = false)
		{
			if (infiniteProctection <= 100 && !isDamagePreviewActive && !isCalculateDamageActive && !((Object)(object)MatchManager.Instance == (Object)null) && CustomFunctions.IsLivingHero(__instance) && MatchManager.Instance.GetHeroHeroActive() != null)
			{
				infiniteProctection++;
				Hero heroHeroActive = MatchManager.Instance.GetHeroHeroActive();
				if (__result >= 0 && __instance.GetHpLeftForMax() <= 0 && CustomFunctions.CharacterObjectHavePerk((Character)(object)heroHeroActive, "heal5b") && CustomFunctions.IsLivingHero(__instance) && CustomFunctions.IsLivingHero((Character)(object)heroHeroActive) && heal > 0 && !isIndirect)
				{
					__instance.SetAura(__instance, CustomFunctions.GetAuraCurseData("powerful"), 2, false, (CardClass)11, false, true);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "EndTurn")]
		public static void CharacterEndTurnPrefix(Character __instance)
		{
			if (!__instance.Alive || __instance == null || (Object)(object)MatchManager.Instance == (Object)null)
			{
				return;
			}
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			if (CustomFunctions.CharacterHasPerkForConsume("zeal0h", __instance.IsHero, AtOManager.Instance, __instance))
			{
				Plugin.LogDebug("zeal0h");
				int auraCharges = __instance.GetAuraCharges("zeal");
				AuraCurseData auraCurseData = CustomFunctions.GetAuraCurseData("zeal");
				int num = ((!auraCurseData.ConsumeAll) ? auraCurseData.AuraConsumed : auraCharges);
				int num2 = 4 * num;
				int amount = __instance.DamageWithCharacterBonus(num2, (DamageType)8, (CardClass)11, 0, -1000);
				CustomFunctions.DealIndirectDamageToAllMonsters((DamageType)8, amount, __instance);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "paralyze1b"))
			{
				AuraCurseData auraCurseData2 = CustomFunctions.GetAuraCurseData("paralyze");
				Hero[] array = teamHero;
				foreach (Hero val in array)
				{
					if (((Character)val).Alive && val != null)
					{
						((Character)val).HealAuraCurse(auraCurseData2);
					}
				}
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "energize1d") && __instance.EnergyCurrent >= 4)
			{
				__instance.SetAuraTrait(__instance, "energize", 1);
			}
			if (CustomFunctions.CharacterObjectHavePerk(__instance, "fortify1d"))
			{
				int auraCharges2 = __instance.GetAuraCharges("fortify");
				int num3 = Mathf.RoundToInt((float)auraCharges2 * 0.5f);
				__instance.SetAuraTrait(__instance, "reinforce", num3);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GainEnergyTurn")]
		public static void GainEnergyTurn(ref Character __instance)
		{
			if (MatchManager.Instance.GetCurrentRound() > 3 && CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Perk, "energy2f", CustomFunctions.AppliesTo.ThisHero))
			{
				Plugin.LogDebug("Updated Energy2f perk");
				__instance.ModifyEnergy(1, true);
			}
			if (MatchManager.Instance.GetCurrentRound() == 4 && AtOManager.Instance.CharacterHavePerk(__instance.SubclassName, "mainperkenergy2c"))
			{
				Plugin.LogDebug("Updated Energy2c perk");
				__instance.ModifyEnergy(1, true);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GlobalAuraCurseModificationByTraitsAndItems")]
		public static void GlobalAuraCurseModificationByTraitsAndItemsPostfix(ref AtOManager __instance, ref AuraCurseData __result, string _type, string _acId, Character _characterCaster, Character _characterTarget)
		{
			//IL_0cf6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfc: Invalid comparison between Unknown and I4
			//IL_0d12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d18: Invalid comparison between Unknown and I4
			//IL_0d2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d34: Invalid comparison between Unknown and I4
			//IL_0d4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d50: Invalid comparison between Unknown and I4
			Character val = ((_type == "set") ? _characterTarget : _characterCaster);
			Character val2 = ((_type == "set") ? _characterCaster : _characterTarget);
			if (val == null)
			{
				return;
			}
			bool flag = false;
			if (val != null)
			{
				flag = val.HasEffect("rust");
			}
			float num = (flag ? 1.5f : 1f);
			if (CustomFunctions.TeamHasPerk("mainperkrust0b") && flag && (_acId == "crack" || _acId == "poison" || _acId == "slow"))
			{
				int auraCharges = val.GetAuraCharges("rust");
				num = 1f + 0.2f * (float)auraCharges;
			}
			switch (_acId)
			{
			case "leech":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "leech0d", CustomFunctions.AppliesTo.Heroes))
				{
					AuraCurseData obj32 = __result;
					obj32.HealPerChargeOnExplode *= 0.5f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "leech0g", CustomFunctions.AppliesTo.Heroes))
				{
					__result.HealPerChargeOnExplode = 0f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "leech0d", CustomFunctions.AppliesTo.Heroes))
				{
					AuraCurseData obj33 = __result;
					obj33.ACChargesPerStackChargeOnExplode *= 2;
					__result.ResistModified = (DamageType)0;
					__result.ResistModifiedValue = 0f;
				}
				break;
			case "infuse":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraConsumed = 3;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0e", CustomFunctions.AppliesTo.Heroes))
				{
					AuraCurseData obj36 = __result;
					obj36.MaxCharges += 4;
					AuraCurseData obj37 = __result;
					obj37.MaxMadnessCharges += 4;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0f", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraDamageConditionalBonuses = Array.Empty<AuraDamageBonus>();
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0h", CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData obj38 = __result;
					obj38.AuraConsumed -= 1;
				}
				break;
			case "evasion":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "evasion0b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ConsumeAll = true;
					__result.GainCharges = true;
					__result.ConsumedAtTurnBegin = true;
				}
				break;
			case "mark":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mark1e", CustomFunctions.AppliesTo.Monsters))
				{
					__result.IncreasedDamageReceivedType = (DamageType)3;
					__result.IncreasedDirectDamageReceivedPerStack = 1.5f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mark1g"))
				{
					AuraCurseData obj = __result;
					obj.IncreasedDirectDamageReceivedPerStack *= 0.5f;
					__result.CharacterStatModified = (CharacterStat)2;
					__result.CharacterStatModifiedValuePerStack = -1f;
				}
				break;
			case "disarm":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "disarm1b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.Removable = false;
					__result.ResistModified = (DamageType)10;
					__result.ResistModifiedValue = 10f;
				}
				break;
			case "silence":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "silence1b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.Removable = false;
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedTotal = 7;
				}
				break;
			case "stealth":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "stealth1d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraDamageIncreasedPercentPerStack = 0f;
				}
				break;
			case "fast":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "fast0b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.GainCharges = true;
					__result.ConsumeAll = true;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "fast0c", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ConsumedAtTurn = true;
					__result.ConsumedAtTurnBegin = false;
				}
				break;
			case "slow":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "slow0b", CustomFunctions.AppliesTo.Monsters))
				{
					__result.GainCharges = true;
					__result.MaxCharges = 10;
					__result.MaxMadnessCharges = 10;
					__result.CharacterStatModifiedValuePerStack = -1f * num;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "slow0c", CustomFunctions.AppliesTo.Heroes))
				{
					__result.GainCharges = true;
					__result.MaxCharges = 10;
					__result.MaxMadnessCharges = 10;
					__result.CharacterStatModifiedValuePerStack = -1f * num;
				}
				break;
			case "fortify":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "fortify1e", CustomFunctions.AppliesTo.Heroes))
				{
					__result.GainCharges = true;
					AuraCurseData obj13 = __result;
					int maxCharges = (__result.MaxMadnessCharges = 5);
					obj13.MaxCharges = maxCharges;
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)10, 0, -1, 0);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "fortify1f", CustomFunctions.AppliesTo.Heroes))
				{
					AuraCurseData obj14 = __result;
					int maxCharges = (__result.MaxMadnessCharges = 2);
					obj14.MaxCharges = maxCharges;
				}
				break;
			case "fury":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "fury1d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ConsumeAll = true;
				}
				break;
			case "sharp":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperksharp1d", CustomFunctions.AppliesTo.Heroes))
				{
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)9, 0, 1, 0);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "zeal0e", CustomFunctions.AppliesTo.ThisHero) && val.HasEffect("zeal"))
				{
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)8, 0, 1, 0);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "sharp1g", CustomFunctions.AppliesTo.ThisHero))
				{
					float num21 = (AtOManager.Instance.TeamHaveTrait("shrilltone") ? 1.5f : 1f);
					if (flag)
					{
						num21 *= 0.5f;
					}
					if (AtOManager.Instance.TeamHaveTrait("shrilltone"))
					{
						if ((int)__result.AuraDamageType == 7)
						{
							__result.AuraDamageIncreasedPerStack = num21;
						}
						if ((int)__result.AuraDamageType2 == 7)
						{
							__result.AuraDamageIncreasedPerStack2 = num21;
						}
						if ((int)__result.AuraDamageType3 == 7)
						{
							__result.AuraDamageIncreasedPerStack3 = num21;
						}
						if ((int)__result.AuraDamageType4 == 7)
						{
							__result.AuraDamageIncreasedPerStack4 = num21;
						}
					}
					else
					{
						__result.AuraDamageType4 = (DamageType)7;
						__result.AuraDamageIncreasedPerStack4 = num21;
					}
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "sharp1e", CustomFunctions.AppliesTo.Heroes))
				{
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)9, 0, 1, 0);
					__result.MaxCharges = 25;
					__result.MaxMadnessCharges = 25;
					__result.AuraDamageIncreasedPerStack = (flag ? 0.75f : 1.5f);
					__result.AuraDamageIncreasedPerStack2 = (flag ? 0.75f : 1.5f);
					__result.AuraDamageIncreasedPerStack3 = (flag ? 0.75f : 1.5f);
					__result.AuraDamageIncreasedPerStack4 = (flag ? 0.75f : 1.5f);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "insane2e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)9, 0, 1, 0);
					int auraCharges9 = val.GetAuraCharges("insane");
					AuraCurseData obj28 = __result;
					obj28.AuraDamageIncreasedPerStack *= 1f + 0.01f * (float)auraCharges9;
					AuraCurseData obj29 = __result;
					obj29.AuraDamageIncreasedPerStack2 *= 1f + 0.01f * (float)auraCharges9;
					AuraCurseData obj30 = __result;
					obj30.AuraDamageIncreasedPerStack3 *= 1f + 0.01f * (float)auraCharges9;
					AuraCurseData obj31 = __result;
					obj31.AuraDamageIncreasedPerStack4 *= 1f + 0.01f * (float)auraCharges9;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "sharp1f", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageIncreasedPerStack = 0f;
					__result.AuraDamageIncreasedPerStack2 = 0f;
					__result.AuraDamageIncreasedPerStack3 = 0f;
					__result.AuraDamageIncreasedPerStack4 = 0f;
					__result = AtOManager.Instance.GlobalAuraCurseModifyDamage(__result, (DamageType)9, 0, 1, 0);
				}
				break;
			case "crack":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "insane2d", CustomFunctions.AppliesTo.Monsters))
				{
					int auraCharges8 = val.GetAuraCharges("insane");
					AuraCurseData obj27 = __result;
					obj27.IncreasedDirectDamageReceivedPerStack += (float)Mathf.FloorToInt(0.02f * num * (float)auraCharges8);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2d", CustomFunctions.AppliesTo.Monsters))
				{
					__result.CharacterStatModified = (CharacterStat)2;
					__result.CharacterStatModifiedValuePerStack = -1f * num * 0.2f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2e", CustomFunctions.AppliesTo.Monsters))
				{
					float num19 = -0.2f * num;
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)6, 0, num19);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2f", CustomFunctions.AppliesTo.Monsters))
				{
					__result.IncreasedDamageReceivedType2 = (DamageType)4;
					__result.IncreasedDirectDamageReceivedPerStack2 = 0.75f * num;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2g"))
				{
					__result.IncreasedDamageReceivedType2 = (DamageType)7;
					__result.IncreasedDirectDamageReceivedPerStack2 = 0.75f * num;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2h"))
				{
					float num20 = -0.15f * num;
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)1, 0, num20);
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)3, 0, num20);
				}
				break;
			case "shackle":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "shackle1f", CustomFunctions.AppliesTo.Monsters))
				{
					shackle1fFlag = !shackle1fFlag;
					if (!shackle1fFlag)
					{
						break;
					}
					int num11 = val.GetSpeed()[1];
					__result.IncreasedDamageReceivedType = (DamageType)10;
					float num12 = 1f;
					__result.IncreasedDirectDamageReceivedPerStack = Mathf.RoundToInt((float)num11 * num12);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "shackle1c"))
				{
					__result.Preventable = false;
				}
				break;
			case "mitigate":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mitigate1a", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.MaxCharges = 5;
					__result.MaxMadnessCharges = 5;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mitigate1b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.ConsumedAtTurnBegin = false;
					__result.MaxCharges = 12;
					__result.MaxMadnessCharges = 12;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mitigate1d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.ConsumeAll = true;
					__result.IncreasedDirectDamageReceivedPerStack = -2f;
					__result.ChargesMultiplierDescription = 2;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mitigate1e"))
				{
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPercentPerStack = 10f;
				}
				break;
			case "poison":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkpoison2c", CustomFunctions.AppliesTo.Monsters))
				{
					__result.ConsumedAtTurnBegin = true;
					__result.ConsumedAtTurn = false;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "poison2d"))
				{
					__result.MaxMadnessCharges = Mathf.RoundToInt(300f * num);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "poison2e"))
				{
					__result.ResistModified3 = (DamageType)1;
					__result.ResistModifiedPercentagePerStack3 = -0.18f * num;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "poison2f", CustomFunctions.AppliesTo.Monsters))
				{
					__result.DamageTypeWhenConsumed = (DamageType)9;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "decay1e"))
				{
					int auraCharges2 = val.GetAuraCharges("decay");
					float num10 = 1f + 0.2f * (float)auraCharges2;
					AuraCurseData obj17 = __result;
					obj17.DamageWhenConsumedPerCharge *= num10;
				}
				break;
			case "bleed":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkbleed2b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.MaxCharges = 50;
					__result.MaxMadnessCharges = 50;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkbleed2c", CustomFunctions.AppliesTo.Monsters))
				{
					__result.Removable = false;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "bleed2d"))
				{
					__result.MaxMadnessCharges = 300;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "bleed2f"))
				{
					__result.ResistModified3 = (DamageType)3;
					__result.ResistModifiedPercentagePerStack3 = -0.2f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "decay1f"))
				{
					int auraCharges6 = val.GetAuraCharges("decay");
					float num17 = 1f + 0.2f * (float)auraCharges6;
					AuraCurseData obj25 = __result;
					obj25.DamageWhenConsumedPerCharge *= num17;
				}
				break;
			case "thorns":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "thorns1d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.Removable = false;
				}
				break;
			case "reinforce":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkreinforce1b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ResistModifiedValue = 40f;
					__result.ResistModifiedValue2 = 40f;
					__result.ResistModifiedValue3 = 40f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0f", CustomFunctions.AppliesTo.Heroes) && val.HasEffect("infuse"))
				{
					__result.AuraDamageType = (DamageType)1;
					__result.AuraDamageType = (DamageType)3;
					__result.AuraDamageType = (DamageType)2;
					AuraCurseData obj15 = __result;
					AuraCurseData obj16 = __result;
					float num4 = (__result.AuraDamageIncreasedPerStack3 = 1f);
					float auraDamageIncreasedPerStack = (obj16.AuraDamageIncreasedPerStack2 = num4);
					obj15.AuraDamageIncreasedPerStack = auraDamageIncreasedPerStack;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "reinforce1e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)7;
					__result.AuraDamageType = (DamageType)3;
					__result.AuraDamageType = (DamageType)6;
				}
				break;
			case "block":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "block5b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.MaxMadnessCharges = 600;
				}
				break;
			case "vulnerable":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "crack2i", CustomFunctions.AppliesTo.Monsters))
				{
					int num2 = Mathf.FloorToInt(0.04f * (float)val.GetAuraCharges("crack"));
					AuraCurseData obj4 = __result;
					obj4.MaxCharges += num2;
					AuraCurseData obj5 = __result;
					obj5.MaxMadnessCharges += num2;
				}
				break;
			case "taunt":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "taunt1h", CustomFunctions.AppliesTo.Monsters))
				{
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)10, 0, -5f);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "taunt1e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.GainCharges = true;
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPerStack = 1f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "taunt1g", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.ConsumedAtTurn = false;
				}
				break;
			case "rust":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "rust0f", CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData auraCurseData2 = CustomFunctions.GetAuraCurseData("None");
					__result.PreventedAuraCurse = auraCurseData2;
					__result.PreventedAuraCurseStackPerStack = 0;
					__result.RemoveAuraCurse = auraCurseData2;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "rust0e", CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData auraCurseData3 = CustomFunctions.GetAuraCurseData("None");
					__result.PreventedAuraCurse = auraCurseData3;
					__result.PreventedAuraCurseStackPerStack = 0;
					__result.RemoveAuraCurse = auraCurseData3;
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)1, 0, -5f);
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)3, 0, -5f);
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)2, 0, -5f);
				}
				break;
			case "powerful":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "taunt1f", CustomFunctions.AppliesTo.Heroes))
				{
					int auraCharges3 = val.GetAuraCharges("taunt");
					AuraCurseData obj20 = __result;
					obj20.MaxCharges += auraCharges3;
					AuraCurseData obj21 = __result;
					obj21.MaxMadnessCharges += auraCharges3;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "powerful1e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageIncreasedPercentPerStack = 2f;
					AuraCurseData obj22 = __result;
					int maxCharges = (__result.MaxMadnessCharges = -1);
					obj22.MaxCharges = maxCharges;
				}
				break;
			case "inspire":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "inspire0e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)8;
					__result.AuraDamageType2 = (DamageType)7;
					__result.AuraDamageIncreasedPerStack = 0.5f;
					__result.AuraDamageIncreasedPerStack2 = 0.5f;
				}
				break;
			case "insulate":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0f", CustomFunctions.AppliesTo.Heroes) && val.HasEffect("infuse"))
				{
					__result.AuraDamageType = (DamageType)4;
					__result.AuraDamageType = (DamageType)6;
					__result.AuraDamageType = (DamageType)5;
					AuraCurseData obj6 = __result;
					AuraCurseData obj7 = __result;
					float num4 = (__result.AuraDamageIncreasedPerStack3 = 1f);
					float auraDamageIncreasedPerStack = (obj7.AuraDamageIncreasedPerStack2 = num4);
					obj6.AuraDamageIncreasedPerStack = auraDamageIncreasedPerStack;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkinsulate1b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ResistModifiedValue = 40f;
					__result.ResistModifiedValue2 = 40f;
					__result.ResistModifiedValue3 = 40f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "insulate1e", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)4;
					__result.AuraDamageType2 = (DamageType)5;
					__result.AuraDamageType3 = (DamageType)6;
					__result.AuraDamageIncreasedPercentPerStack = 5f;
					__result.AuraDamageIncreasedPercentPerStack2 = 5f;
					__result.AuraDamageIncreasedPercentPerStack3 = 5f;
					__result.ResistModifiedValue = 15f;
					__result.ResistModifiedValue2 = 15f;
					__result.ResistModifiedValue3 = 15f;
					__result.GainCharges = true;
					__result.MaxCharges = 8;
					__result.MaxMadnessCharges = 8;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "insulate1f", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.ResistModified = (DamageType)2;
					__result.ResistModified2 = (DamageType)5;
					__result.ResistModified3 = (DamageType)9;
				}
				break;
			case "spellsword":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "spellsword1a", CustomFunctions.AppliesTo.Heroes))
				{
					AuraCurseData obj34 = __result;
					obj34.MaxCharges += 2;
					if (__result.MaxMadnessCharges != -1)
					{
						AuraCurseData obj35 = __result;
						obj35.MaxMadnessCharges += 2;
					}
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "spellsword1b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraDamageType = (DamageType)0;
					__result.AuraDamageIncreasedPerStack = 0f;
					__result.IncreasedDirectDamageReceivedPerStack = -2f;
					__result.ChargesMultiplierDescription = 2;
				}
				break;
			case "energize":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "energize1b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.MaxCharges = 1;
					__result.MaxMadnessCharges = 1;
					__result.CharacterStatModifiedValuePerStack = 2f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "energize1c", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPerStack = 1f;
				}
				break;
			case "burn":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkburn2d", CustomFunctions.AppliesTo.Monsters))
				{
					__result.DoubleDamageIfCursesLessThan = 4;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0h", CustomFunctions.AppliesTo.Heroes))
				{
					int auraCharges7 = val.GetAuraCharges("scourge");
					float num18 = 0.15f * (float)auraCharges7 + 1f;
					AuraCurseData obj26 = __result;
					obj26.DamageWhenConsumedPerCharge *= num18;
				}
				break;
			case "chill":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "chill2e"))
				{
					__result.ResistModified = (DamageType)5;
					__result.ResistModified2 = (DamageType)7;
					__result.ResistModifiedPercentagePerStack = -0.5f;
					__result.ResistModifiedPercentagePerStack2 = -0.5f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "chill2f", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.CharacterStatChargesMultiplierNeededForOne = 10;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "chill2g", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.CharacterStatChargesMultiplierNeededForOne = 3;
					__result.ResistModified = (DamageType)0;
					__result.ResistModifiedPercentagePerStack = 0f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "insulate1d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.CharacterStatModified = (CharacterStat)0;
					__result.CharacterStatAbsoluteValuePerStack = 0;
				}
				break;
			case "wet":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "zeal0g") && val.HasEffect("zeal"))
				{
					__result.ResistModified3 = (DamageType)10;
					__result = __instance.GlobalAuraCurseModifyResist(__result, (DamageType)10, 0, 0.5f);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "wet1d"))
				{
					AuraCurseData auraCurseData = CustomFunctions.GetAuraCurseData("None");
					__result.PreventedAuraCurse = auraCurseData;
					__result.PreventedAuraCurseStackPerStack = 0;
					__result.RemoveAuraCurse = auraCurseData;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "rust0d", CustomFunctions.AppliesTo.Monsters))
				{
					AuraCurseData obj8 = __result;
					obj8.IncreasedDirectDamageReceivedPerStack *= 2.25f;
					AuraCurseData obj9 = __result;
					obj9.IncreasedDirectDamageReceivedPerStack2 *= 2.25f;
					AuraCurseData obj10 = __result;
					obj10.ResistModifiedPercentagePerStack *= 2.25f;
					AuraCurseData obj11 = __result;
					obj11.ResistModifiedPercentagePerStack2 *= 2.25f;
					AuraCurseData obj12 = __result;
					obj12.ResistModifiedPercentagePerStack3 *= 2.25f;
				}
				break;
			case "spark":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "spark2d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)6;
					__result.AuraDamageIncreasedPerStack = 1f;
					__result.ChargesAuxNeedForOne1 = 5f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "spark2e", CustomFunctions.AppliesTo.Monsters))
				{
					__result.DamageTypeWhenConsumed = (DamageType)4;
					__result.ResistModified = (DamageType)6;
					__result.ResistModified2 = (DamageType)4;
					__result.ResistModifiedPercentagePerStack = -0.5f;
					__result.ResistModifiedPercentagePerStack2 = -0.5f;
				}
				break;
			case "shield":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "shield5b"))
				{
					__result.MaxMadnessCharges = 300;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "shield5d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraDamageType = (DamageType)8;
					__result.AuraDamageIncreasedPerStack = 0.2f;
				}
				break;
			case "regeneration":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "regeneration1d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.PreventedAuraCurse = CustomFunctions.GetAuraCurseData("vulnerable");
					__result.PreventedAuraCurseStackPerStack = 1;
				}
				break;
			case "dark":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkdark2b", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.Removable = false;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "dark2e"))
				{
					__result.DamageTypeWhenConsumed = (DamageType)4;
					__result.ResistModified2 = (DamageType)4;
					__result.ResistModifiedPercentagePerStack2 = -0.5f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "sanctify2d"))
				{
					int auraCharges4 = val.GetAuraCharges("sanctify");
					AuraCurseData obj23 = __result;
					obj23.ExplodeAtStacks += Mathf.FloorToInt(0.2f * (float)auraCharges4);
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "burn2e"))
				{
					int auraCharges5 = val.GetAuraCharges("burn");
					float num16 = 1f + 0.05f * (float)auraCharges5;
					AuraCurseData obj24 = __result;
					obj24.DamageWhenConsumedPerCharge *= num16;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0e"))
				{
					__result.ExplodeAtStacks = -1;
				}
				break;
			case "decay":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "decay1d"))
				{
					__result.RemoveAuraCurse = CustomFunctions.GetAuraCurseData("insulate");
				}
				break;
			case "courage":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "infuse0f", CustomFunctions.AppliesTo.Heroes) && val.HasEffect("infuse"))
				{
					__result.AuraDamageType = (DamageType)8;
					__result.AuraDamageType = (DamageType)9;
					__result.AuraDamageType = (DamageType)7;
					AuraCurseData obj18 = __result;
					AuraCurseData obj19 = __result;
					float num4 = (__result.AuraDamageIncreasedPerStack3 = 1f);
					float auraDamageIncreasedPerStack = (obj19.AuraDamageIncreasedPerStack2 = num4);
					obj18.AuraDamageIncreasedPerStack = auraDamageIncreasedPerStack;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "mainperkcourage1b", CustomFunctions.AppliesTo.Heroes))
				{
					__result.ResistModifiedValue = 40f;
					__result.ResistModifiedValue2 = 40f;
					__result.ResistModifiedValue3 = 40f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "courage1f", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.ResistModified = (DamageType)1;
					__result.ResistModified2 = (DamageType)4;
					__result.ResistModified3 = (DamageType)8;
				}
				break;
			case "zeal":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "zeal0d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPercent = Mathf.RoundToInt(1.5f * (float)val.GetAuraCharges("bleed"));
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "zeal0i", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.GainCharges = true;
					__result.ResistModified = (DamageType)0;
					__result.ResistModifiedPercentagePerStack = 0f;
					__result.GainAuraCurseConsumption = CustomFunctions.GetAuraCurseData("burn");
					__result.GainAuraCurseConsumptionPerCharge = 5;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "zeal0f", CustomFunctions.AppliesTo.Heroes))
				{
					__result.CharacterStatModified = (CharacterStat)2;
					__result.CharacterStatModifiedValuePerStack = 2f;
				}
				break;
			case "scourge":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0d", CustomFunctions.AppliesTo.Monsters))
				{
					__result.DamageTypeWhenConsumed = (DamageType)9;
					AuraCurseData obj2 = __result;
					obj2.DamageWhenConsumed += val.GetAuraCharges("sight");
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0f", CustomFunctions.AppliesTo.Monsters))
				{
					__result.GainCharges = true;
					__result.ResistModified2 = (DamageType)10;
					__result.ResistModifiedPercentagePerStack2 = 3f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0g"))
				{
					__result.ConsumedDamageChargesBasedOnACCharges = CustomFunctions.GetAuraCurseData("sight");
					__result.DamageWhenConsumedPerCharge = 2f;
				}
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0j") && val.GetCurseList().Count <= 2)
				{
					AuraCurseData obj3 = __result;
					obj3.DamageWhenConsumedPerCharge *= 4f;
				}
				break;
			case "weak":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "weak1c", CustomFunctions.AppliesTo.Monsters))
				{
					__result.Preventable = false;
					__result.AuraDamageIncreasedPercent = -20;
					__result.HealDonePercent = -20;
				}
				break;
			case "vitality":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "vitality1d", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.RemoveAuraCurse = CustomFunctions.GetAuraCurseData("poison");
				}
				break;
			case "bless":
				if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "bless1d", CustomFunctions.AppliesTo.Heroes))
				{
					__result.AuraDamageType = (DamageType)1;
					__result.AuraDamageType2 = (DamageType)4;
					__result.AuraDamageType3 = (DamageType)8;
					__result.AuraDamageIncreasedPercentPerStack = 3f;
					__result.AuraDamageIncreasedPercentPerStack2 = 3f;
					__result.AuraDamageIncreasedPercentPerStack3 = 3f;
					__result.AuraDamageIncreasedPerStack = 0f;
				}
				break;
			}
			if (CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "scourge0e", CustomFunctions.AppliesTo.Monsters))
			{
				__result.DamageWhenConsumed = Mathf.RoundToInt((float)val.GetAuraCharges("scourge") * 0.05f + 1f) * __result.DamageWhenConsumed;
				AuraCurseData obj39 = __result;
				obj39.DamageWhenConsumedPerCharge *= 1f + (float)val.GetAuraCharges("scourge") * 0.05f;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitAuraCurseModifiers")]
		public static void GetTraitAuraCurseModifiersPostfix(ref Character __instance, ref Dictionary<string, int> __result)
		{
			string text = Plugin.perkBase + "sharp1f";
			if (CustomFunctions.IsLivingHero(__instance) && AtOManager.Instance.CharacterHavePerk(__instance.SubclassName, text))
			{
				Plugin.LogDebug("Executing Perk " + text);
				int num = __instance.EffectCharges("sharp");
				int num2 = Mathf.FloorToInt((float)num * 0.125f);
				if (num2 != 0)
				{
					__result["bleed"] = num2;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "UpdateResistanceModifiersBasedOnInfuse")]
		private static bool UpdateResistanceModifiersBasedOnInfusePrefix(string _type, Character _characterCaster, Character _characterTarget, ref AuraCurseData AC)
		{
			int num = 0;
			if (_characterCaster != null && _type == "consume")
			{
				num = _characterCaster.GetAuraCharges("infuse");
			}
			else if (_characterTarget != null)
			{
				num = _characterTarget.GetAuraCharges("infuse");
			}
			if (num > 0 && _characterCaster != null && CustomFunctions.CharacterObjectHavePerk(_characterCaster, "infuse0g"))
			{
				float num2 = 1f + 0.1f * (float)num;
				AuraCurseData obj = AC;
				obj.ResistModifiedValue *= num2;
				AuraCurseData obj2 = AC;
				obj2.ResistModifiedValue2 *= num2;
				AuraCurseData obj3 = AC;
				obj3.ResistModifiedValue3 *= num2;
				AuraCurseData obj4 = AC;
				obj4.ResistModifiedPercentagePerStack *= num2;
				AuraCurseData obj5 = AC;
				obj5.ResistModifiedPercentagePerStack2 *= num2;
				AuraCurseData obj6 = AC;
				obj6.ResistModifiedPercentagePerStack3 *= num2;
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "DoLeachExplosion")]
		public static void DoLeachExplosionPostfix(Character target)
		{
			if (CustomFunctions.TeamHasPerk("leech0g") && (Object)(object)target.NpcData != (Object)null)
			{
				int auraCharges = target.GetAuraCharges("bleed");
				CustomFunctions.DealIndirectDamageToAllMonsters((DamageType)0, auraCharges);
			}
		}
	}
	[HarmonyPatch]
	public class PerkRewrites
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Functions), "GetCardByRarity")]
		public static bool GetCardByRarityPrefix(ref string __result, int rarity, CardData _cardData, bool isChallenge = false)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//