using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Obeliskial_Content;
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.binbinAndLeif.PerkManager")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1")]
[assembly: AssemblyProduct("Custom Perks")]
[assembly: AssemblyTitle("com.binbinAndLeif.PerkManager")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.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 DescriptionFunctions
	{
		public static List<string> cardsWithCustomDescriptions = new List<string>(2) { "manachargedboots", "soulcollectinglantern" };

		public static List<string> cardsToAppendDescription = new List<string>();

		public static List<string> cardsToPrependDescription = new List<string>(4) { "thulsreworkinnate", "breenaturepaladininnnate", "reworkedvamprism", "laiareworkinnate" };

		public static string NumFormatItem(int num, bool plus = false, bool percent = false)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(" <nobr>");
			if (num > 0)
			{
				stringBuilder.Append("<color=#263ABC><size=+.1>");
				if (plus)
				{
					stringBuilder.Append("+");
				}
			}
			else
			{
				stringBuilder.Append("<color=#720070><size=+.1>");
				if (plus)
				{
					stringBuilder.Append("-");
				}
			}
			stringBuilder.Append(Mathf.Abs(num));
			if (percent)
			{
				stringBuilder.Append("%");
			}
			stringBuilder.Append("</color></size></nobr>");
			return stringBuilder.ToString();
		}

		public static void BinbinNormalizeDescription(ref CardData __instance, StringBuilder stringBuilder)
		{
			stringBuilder.Replace("<c>", "<color=#5E3016>");
			stringBuilder.Replace("</c>", "</color>");
			stringBuilder.Replace("<nb>", "<nobr>");
			stringBuilder.Replace("</nb>", "</nobr>");
			stringBuilder.Replace("<br1>", "<br><line-height=15%><br></line-height>");
			stringBuilder.Replace("<br2>", "<br><line-height=30%><br></line-height>");
			stringBuilder.Replace("<br3>", "<br><line-height=50%><br></line-height>");
			string input = stringBuilder.ToString();
			input = Regex.Replace(input, "[,][ ]*(<(.*?)>)*(.)", (Match m) => m.ToString().ToLower());
			input = Regex.Replace(input, "<br>\\w", (Match m) => m.ToString().ToUpper());
			Globals.Instance.CardsDescriptionNormalized[__instance.Id] = stringBuilder.ToString();
			__instance.DescriptionNormalized = input;
			Traverse.Create((object)__instance).Field("descriptionNormalized").SetValue((object)input);
		}

		public static void HandleDamagePercentDescription(ref StringBuilder stringBuilder, ItemData itemData, DamageType damageType, float percentIncrease)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			if (itemData.Id == "battleaxerare")
			{
				Plugin.LogDebug(" battleaxerare");
			}
			if ((int)damageType != 0 && (int)damageType != 10 && percentIncrease != 0f)
			{
				string text = ((object)(DamageType)(ref damageType)).ToString().ToLower();
				int num = Functions.FuncRoundToInt(itemData.DamagePercentBonusValue);
				Plugin.LogDebug("damage type - " + text);
				string text2 = "item" + text + "Damages";
				Plugin.LogDebug("medsText - " + Essentials.medsTexts[text2]);
				Plugin.LogDebug("GetText - " + Texts.Instance.GetText(text2, ""));
				string value = string.Format(Essentials.medsTexts[text2], NumFormatItem(num, plus: true, percent: true)) + "\n";
				stringBuilder.Insert(0, value);
			}
		}

		public static void HandleAllDamagePercentDescriptions(ref CardData __instance)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0071: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			if (!((Object)(object)__instance.Item == (Object)null))
			{
				ItemData item = __instance.Item;
				if ((int)item.DamagePercentBonus != 0 || (int)item.DamagePercentBonus2 != 0 || (int)item.DamagePercentBonus3 != 0)
				{
					stringBuilder.Append(Globals.Instance.CardsDescriptionNormalized[__instance.Id]);
					HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus, __instance.Item.DamagePercentBonusValue);
					HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus2, __instance.Item.DamagePercentBonusValue2);
					HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus3, __instance.Item.DamagePercentBonusValue3);
					BinbinNormalizeDescription(ref __instance, stringBuilder);
				}
			}
		}

		public static void UpdateMaxMadnessChargesByItem(ref AuraCurseData __result, Character characterOfInterest, string itemID)
		{
			if ((Object)(object)__result == (Object)null)
			{
				Plugin.LogDebug("null AuraCurse");
				return;
			}
			CustomFunctions.AppliesTo appliesTo = (__result.IsAura ? CustomFunctions.AppliesTo.Heroes : CustomFunctions.AppliesTo.Monsters);
			if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, itemID + "rare", appliesTo))
			{
				Plugin.LogDebug("UpdateChargesByItem: " + itemID + "rare");
				ItemData itemData = Globals.Instance.GetItemData(itemID + "rare");
				if (!((Object)(object)itemData == (Object)null))
				{
					if (__result.MaxCharges != -1)
					{
						AuraCurseData obj = __result;
						obj.MaxCharges += itemData.AuracurseCustomModValue1;
					}
					if (__result.MaxMadnessCharges != -1)
					{
						AuraCurseData obj2 = __result;
						obj2.MaxMadnessCharges += itemData.AuracurseCustomModValue1;
					}
				}
			}
			else
			{
				if (!CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, itemID, appliesTo))
				{
					return;
				}
				Plugin.LogDebug("UpdateChargesByItem: " + itemID);
				ItemData itemData2 = Globals.Instance.GetItemData(itemID);
				if (!((Object)(object)itemData2 == (Object)null))
				{
					if (__result.MaxCharges != -1)
					{
						AuraCurseData obj3 = __result;
						obj3.MaxCharges += itemData2.AuracurseCustomModValue1;
					}
					if (__result.MaxMadnessCharges != -1)
					{
						AuraCurseData obj4 = __result;
						obj4.MaxMadnessCharges += itemData2.AuracurseCustomModValue1;
					}
					Plugin.LogDebug($"UpdateChargesByItem: {itemID} - post update max charges {__result.MaxMadnessCharges}");
				}
			}
		}

		public static string SpriteText(string sprite)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = sprite.ToLower().Replace(" ", "");
			switch (text)
			{
			case "block":
			case "card":
				stringBuilder.Append("<space=.2>");
				break;
			case "piercing":
				stringBuilder.Append("<space=.4>");
				break;
			case "bleed":
				stringBuilder.Append("<space=.1>");
				break;
			case "bless":
				stringBuilder.Append("<space=.1>");
				break;
			default:
				stringBuilder.Append("<space=.3>");
				break;
			}
			stringBuilder.Append(" <space=-.2>");
			stringBuilder.Append("<size=+.1><sprite name=");
			stringBuilder.Append(text);
			stringBuilder.Append("></size>");
			switch (text)
			{
			case "bleed":
				stringBuilder.Append("<space=-.4>");
				break;
			case "card":
				stringBuilder.Append("<space=-.2>");
				break;
			case "powerful":
			case "fury":
				stringBuilder.Append("<space=-.1>");
				break;
			default:
				stringBuilder.Append("<space=-.2>");
				break;
			case "reinforce":
			case "fire":
				break;
			}
			return stringBuilder.ToString();
		}

		public static string ColorTextArray(string type, params string[] text)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<nobr>");
			if (type == null || type.Length != 0)
			{
				switch (type)
				{
				case "damage":
					stringBuilder.Append("<color=#B00A00>");
					break;
				case "heal":
					stringBuilder.Append("<color=#1E650F>");
					break;
				case "aura":
					stringBuilder.Append("<color=#263ABC>");
					break;
				case "curse":
					stringBuilder.Append("<color=#720070>");
					break;
				case "system":
					stringBuilder.Append("<color=#5E3016>");
					break;
				default:
					stringBuilder.Append("<color=#5E3016");
					stringBuilder.Append(">");
					break;
				}
			}
			int num = 0;
			foreach (string value in text)
			{
				if (num > 0)
				{
					stringBuilder.Append(" ");
				}
				stringBuilder.Append(value);
				num++;
			}
			if (type != "")
			{
				stringBuilder.Append("</color>");
			}
			stringBuilder.Append("</nobr> ");
			return stringBuilder.ToString();
		}

		public static void AppendDescriptionsToCards(CardData __instance, ref StringBuilder stringBuilder1)
		{
			if (cardsToAppendDescription.Contains(__instance.Id))
			{
				Plugin.LogDebug("Creating description for " + __instance.Id);
				Plugin.LogDebug($"Current description {__instance.Id}: {stringBuilder1}");
				string text = "hcperks" + __instance.Id;
				stringBuilder1.Append(Functions.FormatStringCard(Texts.Instance.GetText(text, "")));
			}
		}

		public static void PrependDescriptionsToCards(CardData __instance, ref StringBuilder stringBuilder1)
		{
			if (cardsToPrependDescription.Contains(__instance.Id))
			{
				Plugin.LogDebug("Creating description for " + __instance.Id);
				Plugin.LogDebug($"Current description {__instance.Id}: {stringBuilder1}");
				string text = "hcperks" + __instance.Id;
				stringBuilder1.Insert(0, Functions.FormatStringCard(Texts.Instance.GetText(text, "")));
			}
		}
	}
	public class CharacterFunctions
	{
	}
	public class CustomFunctions
	{
		public enum AppliesTo
		{
			None,
			Global,
			Monsters,
			Heroes,
			ThisHero
		}

		public enum CharacterHas
		{
			Perk,
			Item,
			Trait
		}

		public static void PLog(string s)
		{
			Plugin.Log.LogDebug((object)(Plugin.debugBase + s));
		}

		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 Character GetRandomCharacter(Character[] array)
		{
			if (array == null)
			{
				Plugin.Log.LogDebug((object)(Plugin.debugBase + "Null Array"));
			}
			List<Character> list = new List<Character>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == null)
				{
					Plugin.Log.LogDebug((object)(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 bool CharacterObjectHaveTrait(Character _character, string _perk_id)
		{
			if (_character == null)
			{
				return false;
			}
			return AtOManager.Instance.CharacterHaveTrait(_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;
				}
			}
			if (flag2 && flag)
			{
				Plugin.LogDebug("Applying Perk - " + id);
			}
			return flag2 && flag;
		}

		public static bool CanIncrementTraitActivations(TraitData traitData, int bonusActivations = 0, bool useRound = false)
		{
			Plugin.LogDebug("canIncrementTraitActivations");
			if ((Object)(object)traitData == (Object)null)
			{
				return false;
			}
			string id = traitData.Id;
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				return false;
			}
			if (MatchManager.Instance.activatedTraits == null)
			{
				return false;
			}
			int num;
			if (useRound)
			{
				num = traitData.TimesPerRound - 1 + bonusActivations;
				if (MatchManager.Instance.activatedTraitsRound != null && MatchManager.Instance.activatedTraitsRound.ContainsKey(id) && MatchManager.Instance.activatedTraitsRound[id] > num)
				{
					return false;
				}
				return true;
			}
			num = traitData.TimesPerTurn - 1 + bonusActivations;
			if (MatchManager.Instance.activatedTraits.ContainsKey(id) && MatchManager.Instance.activatedTraits[id] > num)
			{
				return false;
			}
			if (!MatchManager.Instance.activatedTraits.ContainsKey(id))
			{
				MatchManager.Instance.activatedTraits.Add(id, 0);
			}
			return true;
		}

		public static bool CanIncrementTraitActivations(string traitId, int bonusActivations = 0, bool useRound = false)
		{
			TraitData traitData = Globals.Instance.GetTraitData(traitId);
			return CanIncrementTraitActivations(traitData, bonusActivations, useRound);
		}

		public static void IncrementTraitActivations(TraitData traitData, bool useRound = false)
		{
			string id = traitData.Id;
			if (useRound)
			{
				if (!MatchManager.Instance.activatedTraitsRound.ContainsKey(id))
				{
					MatchManager.Instance.activatedTraitsRound.Add(id, 1);
				}
				else
				{
					Dictionary<string, int> activatedTraitsRound = MatchManager.Instance.activatedTraitsRound;
					string key = id;
					int value = activatedTraitsRound[key] + 1;
					activatedTraitsRound[key] = value;
				}
			}
			else if (!MatchManager.Instance.activatedTraits.ContainsKey(id))
			{
				MatchManager.Instance.activatedTraits.Add(id, 1);
			}
			else
			{
				MatchManager.Instance.activatedTraits[id]++;
			}
			MatchManager.Instance.SetTraitInfoText();
		}

		public static void IncrementTraitActivations(string traitId, bool useRound = false)
		{
			TraitData traitData = Globals.Instance.GetTraitData(traitId);
			IncrementTraitActivations(traitData, useRound);
		}

		public static void ApplyAuraCurseToAll(string acToApply, int nToApply, AppliesTo appliesTo, Character sourceCharacter = null, bool useCharacterMods = false, bool isPreventable = true)
		{
			Plugin.LogInfo("ApplyAuraCurseToAll");
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				Plugin.LogError("No MatchManager");
				return;
			}
			if (sourceCharacter == null && useCharacterMods)
			{
				Plugin.LogError("No Source Character");
				return;
			}
			AuraCurseData auraCurseData = GetAuraCurseData(acToApply);
			if ((Object)(object)auraCurseData == (Object)null)
			{
				Plugin.LogError("Improper AuraCurse");
				return;
			}
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			switch (appliesTo)
			{
			case AppliesTo.Heroes:
			{
				Hero[] array2 = teamHero;
				foreach (Hero val2 in array2)
				{
					if (IsLivingHero((Character)(object)val2))
					{
						((Character)val2).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
					}
				}
				break;
			}
			case AppliesTo.Global:
			{
				Hero[] array3 = teamHero;
				foreach (Hero val3 in array3)
				{
					if (IsLivingHero((Character)(object)val3))
					{
						((Character)val3).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
					}
				}
				NPC[] array4 = teamNPC;
				foreach (NPC val4 in array4)
				{
					if (IsLivingNPC((Character)(object)val4))
					{
						((Character)val4).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
					}
				}
				break;
			}
			case AppliesTo.Monsters:
			{
				NPC[] array = teamNPC;
				foreach (NPC val in array)
				{
					if (IsLivingNPC((Character)(object)val))
					{
						((Character)val).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
					}
				}
				break;
			}
			}
		}
	}
	[HarmonyPatch]
	public class PerkBackgroundExtension
	{
		public static string subclassidstring = "";

		[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;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PerkTree), "DrawTree")]
		public static void DrawTreePrefix()
		{
			Plugin.Log.LogDebug((object)(Plugin.debugBase + "Draw Tree"));
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PerkTree), "Show")]
		public static void ShowPostfix(string _subClassId, int currentHeroIndex)
		{
			if (_subClassId != null)
			{
				subclassidstring = _subClassId;
				if (subclassidstring == "naturepaladin")
				{
					subclassidstring = "warden";
				}
				if (subclassidstring == "naturepaladin")
				{
					subclassidstring = "prophet";
				}
				if (subclassidstring == "tracker")
				{
					subclassidstring = "ranger";
				}
				Plugin.reworkPerkDesc = "No 'rework' setup for this character. There's no need to take this perk";
				Plugin.multiclassPerkDesc = "No 'multiclass' setup for this character. There's no need to take this perk";
				if (subclassidstring == "warlock")
				{
					Plugin.reworkPerkDesc = "Zek's soul lantern increases Zek's max hp for every kill. Vampirism instead buffs Zek's damage based on his max hp (1% more damage per 4 max hp Zek has).";
				}
				if (subclassidstring == "warden")
				{
					Plugin.multiclassPerkDesc = "Bree becomes a Nature Paladin (Warrior/Healer) with a new innate ability and starting deck. Perhaps more changes in the future";
				}
				if (subclassidstring == "engineer")
				{
					Plugin.reworkPerkDesc = "Nenukil starts with 'Mana Charged Boots', which allows fast to stack on Nenukil but removes fast at the END of Nenukil's turn. Note: Your mana charged boots may not appear until you enter combat.";
				}
				if (subclassidstring == "assassin")
				{
					Plugin.reworkPerkDesc = "Replaces Thuls' innate ability with 'Sneaky Sneaky' which increases stealth charges applied by 1";
				}
				if (subclassidstring == "paladin")
				{
					Plugin.reworkPerkDesc = "Replaces Laia's innate ability with 'Protecter' which heals allies whenever Laia applies 'block'";
				}
				if (subclassidstring == "minstrel")
				{
					Plugin.reworkPerkDesc = "Replaces Gustav's starting deck with a deck with more healing and speed support";
				}
				if (subclassidstring == "prophet")
				{
					Plugin.multiclassPerkDesc = "Nezglekt gets different starting stats, a new starting deck and a scout secondary class";
				}
				if (subclassidstring == "ranger")
				{
					Plugin.multiclassPerkDesc = "Andrin becomes a Scout/Warrior, getting a different starting deck but losing 1 speed to gain some max hp";
				}
				Essentials.medsTexts["custom_binbin_mainperk_rework0"] = Plugin.reworkPerkDesc;
				Essentials.medsTexts["custom_binbin_mainperk_multiclass0"] = Plugin.multiclassPerkDesc;
			}
			else
			{
				subclassidstring = "";
			}
		}
	}
	public struct Whatapain
	{
		public Hero hero;

		public string subclassname;

		public string subclassid;
	}
	[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;

		public static bool applyAuraAfter = false;

		public static Whatapain fingerscrossed;

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

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "BeginAdventure")]
		public static void BeginAdventurePrefix(ref AtOManager __instance)
		{
			Hero[] value = Traverse.Create((object)__instance).Field("teamAtO").GetValue<Hero[]>();
			for (int i = 0; i < value.Length; i++)
			{
				Hero hero = value[i];
				HandleMulticlassPerks(hero);
				HandleReworkPerks(hero, i);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CharacterReward), "Init")]
		public static void InitPrefix()
		{
			Hero[] value = Traverse.Create((object)RewardsManager.Instance).Field("theTeam").GetValue<Hero[]>();
			foreach (Hero hero in value)
			{
				HandleReloadofMulticlassPerks(hero);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "DoCardCraft")]
		public static void DoCardCraftPostfix()
		{
			Hero[] value = Traverse.Create((object)AtOManager.Instance).Field("teamAtO").GetValue<Hero[]>();
			foreach (Hero hero in value)
			{
				HandleReloadofMulticlassPerks(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);
		}

		public static void HandleReworkPerks(Hero _hero, int thisisanindex)
		{
			Plugin.LogDebug("BeginofAdvent handling of perks");
			for (int i = 0; i < ((Character)_hero).Traits.Length; i++)
			{
				Plugin.LogDebug(((Character)_hero).Traits[i] ?? "");
			}
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "rework0"))
			{
				if (((Character)_hero).SubclassName == "assassin")
				{
					ApplyTraitsViaPerks(_hero);
				}
				if (((Character)_hero).SubclassName == "engineer")
				{
					HandleSettingItemsViaPerks(_hero, thisisanindex);
				}
				if (((Character)_hero).SubclassName == "warlock")
				{
					ApplyTraitsViaPerks(_hero);
					HandleSettingItemsViaPerks(_hero, thisisanindex);
				}
				if (((Character)_hero).SubclassName == "paladin")
				{
					ApplyTraitsViaPerks(_hero);
				}
				if (((Character)_hero).SubclassName == "minstrel")
				{
					SubClassData subClassData = Globals.Instance.GetSubClassData("bard");
					((Character)_hero).HeroData.HeroSubClass.Cards = subClassData.Cards;
					((Character)_hero).InitData();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Hero), "SetInitialItems")]
		public static void SetInitialItemsPrefix(ref Hero __instance, ref CardData _cardData, ref int _rankLevel)
		{
			Plugin.LogDebug("SetInitialItemsPrefix " + _cardData.Id);
		}

		public static void HandleMulticlassPerks(Hero _hero)
		{
			string text = "";
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "multiclass0"))
			{
				if (((Character)_hero).SubclassName == "warden")
				{
					text = "naturepaladin";
				}
				if (((Character)_hero).SubclassName == "prophet")
				{
					text = "seer";
				}
				if (((Character)_hero).SubclassName == "ranger")
				{
					text = "tracker";
				}
			}
			if (text != "")
			{
				SubClassData subClassData = Globals.Instance.GetSubClassData(text);
				subClassData.SubClassName = ((Object)((Character)_hero).HeroData.HeroSubClass).name;
				subClassData.Id = ((Character)_hero).HeroData.HeroSubClass.Id;
				subClassData.Sprite = ((Character)_hero).HeroData.HeroSubClass.Sprite;
				subClassData.SpriteBorder = ((Character)_hero).HeroData.HeroSubClass.SpriteBorder;
				subClassData.SpriteBorderSmall = ((Character)_hero).HeroData.HeroSubClass.SpriteBorderSmall;
				subClassData.SpritePortrait = ((Character)_hero).HeroData.HeroSubClass.SpritePortrait;
				subClassData.SpriteSpeed = ((Character)_hero).HeroData.HeroSubClass.SpriteSpeed;
				((Character)_hero).HeroData.HeroSubClass = subClassData;
				((Character)_hero).InitData();
			}
		}

		public static void HandleReloadofMulticlassPerks(Hero _hero)
		{
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "multiclass0"))
			{
				if (((Character)_hero).SubclassName == "warden")
				{
					((Character)_hero).HeroData.HeroSubClass.HeroClassSecondary = (HeroClass)2;
				}
				if (((Character)_hero).SubclassName == "prophet")
				{
					((Character)_hero).HeroData.HeroSubClass.HeroClassSecondary = (HeroClass)3;
				}
				if (((Character)_hero).SubclassName == "ranger")
				{
					((Character)_hero).HeroData.HeroSubClass.HeroClassSecondary = (HeroClass)0;
				}
			}
		}

		public static void ApplyTraitsViaPerks(Hero _hero)
		{
			Plugin.LogDebug("ApplyInnateTraitsViaPerks for " + ((Character)_hero).SubclassName);
			if (((Character)_hero).SubclassName == "assassin")
			{
				((Character)_hero).Traits[0] = "thulsreworkinnate";
				((Character)_hero).HeroData.HeroSubClass.Trait0 = Globals.Instance.GetTraitData("thulsreworkinnate");
			}
			if (((Character)_hero).SubclassName == "warlock")
			{
				((Character)_hero).HeroData.HeroSubClass.Trait4B = Globals.Instance.GetTraitData("reworkedvampirism");
			}
			if (((Character)_hero).SubclassName == "paladin")
			{
				((Character)_hero).Traits[0] = "laiareworkinnate";
				((Character)_hero).HeroData.HeroSubClass.Trait0 = Globals.Instance.GetTraitData("laiareworkinnate");
			}
		}

		public static void HandleSettingItemsViaPerks(Hero _hero, int thisisanindex)
		{
			if (CustomFunctions.CharacterObjectHavePerk((Character)(object)_hero, "rework0"))
			{
				if (((Character)_hero).SubclassName == "engineer")
				{
					TryingToReassignStartingItemsWithPerks(_hero, thisisanindex, 1, "rocketboots", "manachargedboots");
				}
				if (((Character)_hero).SubclassName == "warlock")
				{
					TryingToReassignStartingItemsWithPerks(_hero, thisisanindex, 3, "soullantern", "soulcollectinglantern");
				}
			}
		}

		public static void TryingToReassignStartingItemsWithPerks(Hero _hero, int thisisanindex, int slotnumber, string replaceitemname, string newitemname)
		{
			ItemData itemDataBySlot = ((Character)_hero).GetItemDataBySlot(slotnumber, false);
			if (!((Object)(object)itemDataBySlot == (Object)null))
			{
				if (Object.op_Implicit((Object)(object)itemDataBySlot) && itemDataBySlot.Id == replaceitemname)
				{
					AtOManager.Instance.AddItemToHero(thisisanindex, newitemname, "");
				}
				else if (Object.op_Implicit((Object)(object)itemDataBySlot) && itemDataBySlot.Id == replaceitemname + "a")
				{
					AtOManager.Instance.AddItemToHero(thisisanindex, newitemname + "a", "");
				}
				else if (Object.op_Implicit((Object)(object)itemDataBySlot) && itemDataBySlot.Id == replaceitemname + "b")
				{
					AtOManager.Instance.AddItemToHero(thisisanindex, newitemname + "b", "");
				}
				else if (Object.op_Implicit((Object)(object)itemDataBySlot) && itemDataBySlot.Id == replaceitemname + "rare")
				{
					AtOManager.Instance.AddItemToHero(thisisanindex, newitemname + "rare", "");
				}
				else if (!Object.op_Implicit((Object)(object)itemDataBySlot))
				{
					Plugin.LogDebug(itemDataBySlot.Id);
				}
			}
		}

		[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 val = teamHero[i];
					Plugin.LogDebug(" PerkList for " + ((Character)val).SubclassName + ": " + string.Join(",", ((Character)val).PerkList.ToArray()));
					if (CustomFunctions.CharacterObjectHavePerk((Character)(object)val, "rework0"))
					{
						HandleSettingItemsViaPerks(val, i);
					}
					Traverse.Create((object)MatchManager.Instance).Field("teamHero").SetValue((object)teamHero);
					for (int j = 0; j < ((Character)val).Traits.Length; j++)
					{
						Plugin.LogDebug($"Trait {j + 1} - {((Character)val).Traits[j]}");
					}
				}
			}
		}

		[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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Invalid comparison between Unknown and I4
			if ((int)theEvent == 18 || (int)theEvent == 26 || __instance == null || (int)theEvent == 0)
			{
				return;
			}
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			string name = Enum.GetName(typeof(EventActivation), theEvent);
			Plugin.LogDebug("SETEVENTPREFIX - START - " + name);
			if ((int)theEvent == 1)
			{
				infiniteProctection = 0;
				paralyzeCounters = new int[4];
				mark1dFlag = true;
			}
			if ((int)theEvent == 35 && !target.IsHero && target != null && CustomFunctions.IsLivingHero(__instance) && (CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "soulcollectinglantern", CustomFunctions.AppliesTo.ThisHero) || CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "soulcollectinglanterna", CustomFunctions.AppliesTo.ThisHero) || CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "soulcollectinglanternb", CustomFunctions.AppliesTo.ThisHero) || CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "soulcollectinglanternrare", CustomFunctions.AppliesTo.ThisHero)) && CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Perk, "rework0") && __instance.SubclassName == "warlock")
			{
				ItemData itemDataBySlot = __instance.GetItemDataBySlot(3, true);
				if (!((Object)(object)itemDataBySlot == (Object)null) && Object.op_Implicit((Object)(object)itemDataBySlot))
				{
					if (itemDataBySlot.Id == "soullantern" || itemDataBySlot.Id == "soullanterna" || itemDataBySlot.Id == "soullanternb" || itemDataBySlot.Id == "soullanternrare")
					{
						for (int i = 0; i < 4; i++)
						{
							if (teamHero[i] != null && teamHero[i] == __instance)
							{
								AtOManager.Instance.AddItemToHero(i, "soulcollectinglantern", "");
							}
						}
					}
					if (itemDataBySlot.Id == "soulcollectinglantern" || itemDataBySlot.Id == "soulcollectinglanterna" || itemDataBySlot.Id == "soulcollectinglanternb" || itemDataBySlot.Id == "soulcollectinglanternrare")
					{
						itemDataBySlot.MaxHealth += 1;
						for (int j = 0; j < 4; j++)
						{
							if (teamHero[j] != null && teamHero[j] == __instance)
							{
								AtOManager.Instance.AddItemToHero(j, "soulcollectinglantern", "");
							}
						}
					}
				}
			}
			if ((int)theEvent == 7)
			{
				Traits.infiniteProctectionThorns = false;
				Traits.infiniteProctectionVitality = false;
				Traits.posiblytemporaryflatnumberofthornstodo = 0;
				Traits.yougotthorns = null;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitDamagePercentModifiers")]
		public static void GetTraitDamagePercentModifiersPostfix(ref Character __instance, ref float __result)
		{
			if (CustomFunctions.CharacterObjectHaveTrait(__instance, "reworkedvampirism"))
			{
				int maxHP = __instance.GetMaxHP();
				int num = Mathf.FloorToInt((float)(maxHP / 4));
				__result += num;
			}
		}

		[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;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GlobalAuraCurseModificationByTraitsAndItems")]
		public static void GlobalAuraCurseModificationByTraitsAndItemsPostfixGeneral(ref AtOManager __instance, ref AuraCurseData __result, string _type, string _acId, Character _characterCaster, Character _characterTarget)
		{
			Character val = ((_type == "set") ? _characterTarget : _characterCaster);
			Character val2 = ((_type == "set") ? _characterCaster : _characterTarget);
			if (val == null)
			{
				return;
			}
			if (_acId == "fast" && CustomFunctions.IfCharacterHas(val, CustomFunctions.CharacterHas.Perk, "rework0", CustomFunctions.AppliesTo.Heroes) && val.SubclassName == "engineer")
			{
				ItemData itemDataBySlot = val.GetItemDataBySlot(1, false);
				if (!((Object)(object)itemDataBySlot == (Object)null) && Object.op_Implicit((Object)(object)itemDataBySlot) && (itemDataBySlot.Id == "manachargedboots" || itemDataBySlot.Id == "manachargedbootsa" || itemDataBySlot.Id == "manachargedbootsb" || itemDataBySlot.Id == "manachargedbootsrare"))
				{
					__result.GainCharges = true;
					__result.ConsumeAll = true;
					__result.ConsumedAtTurn = true;
					__result.ConsumedAtTurnBegin = false;
				}
			}
		}
	}
	[HarmonyPatch]
	public class PerkRewrites
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Functions), "GetCardByRarity")]
		public static bool GetCardByRarityPrefix(ref string __result, int rarity, CardData _cardData, bool isChallenge = false)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Invalid comparison between Unknown and I4
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Invalid comparison between Unknown and I4
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Invalid comparison between Unknown and I4
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Invalid comparison between Unknown and I4
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Invalid comparison between Unknown and I4
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			int num = 78;
			int num2 = 88;
			int num3 = 98;
			int num4 = 0;
			if (!GameManager.Instance.IsObeliskChallenge())
			{
				num4 = AtOManager.Instance.GetMadnessDifficulty();
				if (num4 > 0)
				{
					num = 75;
					num2 = 85;
					num3 = 95;
				}
			}
			else
			{
				num4 = AtOManager.Instance.GetObeliskMadness();
			}
			CustomFunctions.PLog("GetCardByRarityPrefix - CardDataId - " + _cardData.Id);
			if (AtOManager.Instance.TeamHavePerk(Plugin.perkBase + "shards5c"))
			{
				int num5 = 2;
				num -= num5;
				num2 -= num5;
				num3 -= num5;
				Plugin.Log.LogDebug((object)(Plugin.debugBase + "Testing Perk shards5c: Modified value " + num3));
			}
			if (num4 > 0)
			{
				num -= num4;
				num2 -= Functions.FuncRoundToInt((float)num4 * 0.5f);
			}
			if (rarity < num)
			{
				__result = (((int)_cardData.CardUpgraded == 0 || !(_cardData.UpgradedFrom != "")) ? _cardData.Id.ToLower() : _cardData.UpgradedFrom.ToLower());
				CustomFunctions.PLog("GetCardByRarityPrefix Exit 1");
				return false;
			}
			if (rarity >= num && rarity < num2)
			{
				if ((int)_cardData.CardUpgraded == 1)
				{
					__result = _cardData.Id.ToLower();
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 2");
					return false;
				}
				if ((int)_cardData.CardUpgraded == 0)
				{
					__result = _cardData.UpgradesTo1.ToLower();
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 3");
					return false;
				}
				if ((int)_cardData.CardUpgraded == 2)
				{
					__result = (_cardData.UpgradedFrom + "A").ToLower();
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 4");
					return false;
				}
			}
			else
			{
				if (rarity >= num2 && rarity < num3)
				{
					if ((int)_cardData.CardUpgraded == 2)
					{
						__result = _cardData.Id.ToLower();
						CustomFunctions.PLog("GetCardByRarityPrefix Exit 5");
						return false;
					}
					__result = (((int)_cardData.CardUpgraded == 0) ? _cardData.UpgradesTo2.ToLower() : (_cardData.UpgradedFrom + "B").ToLower());
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 6");
					return false;
				}
				if ((int)_cardData.CardUpgraded == 0)
				{
					__result = (((Object)(object)_cardData.UpgradesToRare != (Object)null) ? _cardData.UpgradesToRare.Id.ToLower() : _cardData.Id.ToLower());
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 7");
					return false;
				}
				CardData cardData = Globals.Instance.GetCardData(_cardData.UpgradedFrom, false);
				if ((Object)(object)cardData != (Object)null && (Object)(object)cardData.UpgradesToRare != (Object)null)
				{
					__result = cardData.UpgradesToRare.Id.ToLower();
					CustomFunctions.PLog("GetCardByRarityPrefix Exit 8");
					return false;
				}
			}
			__result = _cardData.Id.ToLower();
			CustomFunctions.PLog("GetCardByRarityPrefix - END");
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "BonusResists")]
		public static bool BonusResistsPrefix(ref Character __instance, ref int __result, DamageType damageType, string acId = "", bool countChargesConsumedPre = false, bool countChargesConsumedPost = false)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected I4, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			switch (damageType - 1)
			{
			case 0:
				if (__instance.IsImmune((DamageType)1))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistSlashing").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("reinforcedmonsters"))
				{
					num += 10;
				}
				break;
			case 1:
				if (__instance.IsImmune((DamageType)2))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistBlunt").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("reinforcedmonsters"))
				{
					num += 10;
				}
				break;
			case 2:
				if (__instance.IsImmune((DamageType)3))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistPiercing").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("reinforcedmonsters"))
				{
					num += 10;
				}
				break;
			case 3:
				if (__instance.IsImmune((DamageType)4))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistFire").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("elementalmonsters"))
				{
					num += 10;
				}
				break;
			case 4:
				if (__instance.IsImmune((DamageType)5))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistCold").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("elementalmonsters"))
				{
					num += 10;
				}
				break;
			case 5:
				if (__instance.IsImmune((DamageType)6))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistLightning").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("elementalmonsters"))
				{
					num += 10;
				}
				break;
			case 6:
				if (__instance.IsImmune((DamageType)7))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistMind").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("spiritualmonsters"))
				{
					num += 10;
				}
				break;
			case 7:
				if (__instance.IsImmune((DamageType)8))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistHoly").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("spiritualmonsters"))
				{
					num += 10;
				}
				break;
			case 8:
				if (__instance.IsImmune((DamageType)9))
				{
					num = 1000;
					break;
				}
				num += Traverse.Create((object)__instance).Field("resistShadow").GetValue<int>();
				if (!__instance.IsHero && AtOManager.Instance.IsChallengeTraitActive("spiritualmonsters"))
				{
					num += 10;
				}
				break;
			}
			if (num < 1000)
			{
				if (!__instance.IsHero)
				{
					if (MadnessManager.Instance.IsMadnessTraitActive("resistantmonsters") || AtOManager.Instance.IsChallengeTraitActive("resistantmonsters"))
					{
						num += 10;
					}
					if (AtOManager.Instance.IsChallengeTraitActive("vulnerablemonsters"))
					{
						num -= 15;
					}
				}
				num = num + __instance.GetItemResistModifiers(damageType) + __instance.GetAuraResistModifiers(damageType, acId, countChargesConsumedPre, countChargesConsumedPost, (CardData)null);
			}
			if (AtOManager.Instance.TeamHavePerk(Plugin.perkBase + "resistance5d"))
			{
				Plugin.Log.LogDebug((object)(Plugin.debugBase + "Attemting to change max resists"));
			}
			int num2 = (AtOManager.Instance.TeamHavePerk(Plugin.perkBase + "resistance5d") ? 97 : 95);
			__result = Mathf.Clamp(num, -95, num2);
			return false;
		}
	}
	[BepInPlugin("com.binbinAndLeif.PerkManager", "Custom Perks", "0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("AcrossTheObelisk.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal const int ModDate = 20250220;

		private readonly Harmony harmony = new Harmony("com.binbinAndLeif.PerkManager");

		internal static ManualLogSource Log;

		public static string debugBase = "Leif - Testing Perks - ";

		public static string perkBase = "binbin_mainperk_";

		public static string reworkPerkDesc = "A mini rework for applicable characters";

		public static string multiclassPerkDesc = "A multiclass option for applicable characters";

		public static ConfigEntry<bool> EnableDebugging { get; set; }

		private void Awake()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0047: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"com.binbinAndLeif.PerkManager 0.1 has loaded!");
			EnableDebugging = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("TooManyPerks", "Enable Debugging"), false, new ConfigDescription("Enables debugging logs.", (AcceptableValueBase)null, Array.Empty<object>()));
			string text = "custom_binbin_mainperk_";
			Essentials.RegisterMod("Custom Perks", "Leif (and binbin)", "Hero Customization", "0.1", 20250220, "https://github.com/binbinmods/AtO-Perk-Manager", (string[])null, "Hero Customization", 100, new string[4] { "content", "perk", "perkNode", "trait" }, "", true);
			Essentials.medsTexts[text + "rework0"] = reworkPerkDesc;
			Essentials.medsTexts[text + "multiclass0"] = multiclassPerkDesc;
			harmony.PatchAll();
		}

		internal static void LogDebug(string msg)
		{
			if (EnableDebugging.Value)
			{
				Log.LogDebug((object)(debugBase + msg));
			}
		}

		internal static void LogInfo(string msg)
		{
			Log.LogInfo((object)(debugBase + msg));
		}

		internal static void LogError(string msg)
		{
			Log.LogError((object)(debugBase + msg));
		}
	}
	[HarmonyPatch]
	internal class Traits
	{
		public static string[] simpleTraitList = new string[9] { "trait0", "trait1a", "trait1b", "trait2a", "trait2b", "trait3a", "trait3b", "trait4a", "trait4b" };

		public static string[] myTraitList = new string[4] { "breenaturepaladininnate", "thulsreworkinnate", "reworkedvamprism", "laiareworkinnate" };

		public static bool isDamagePreviewActive = false;

		public static bool isCalculateDamageActive = false;

		public static bool infiniteProctectionThorns = false;

		public static bool infiniteProctectionVitality = false;

		public static int posiblytemporaryflatnumberofthornstodo = 0;

		public static Character yougotthorns;

		public static string debugBase = "Leif - Testing Traits - ";

		public static void DoCustomTrait(string _trait, ref Trait __instance, ref EventActivation _theEvent, ref Character _character, ref Character _target, ref int _auxInt, ref string _auxString, ref CardData _castedCard)
		{
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Expected O, but got Unknown
			TraitData traitData = Globals.Instance.GetTraitData(_trait);
			List<CardData> list = new List<CardData>();
			List<string> heroHand = MatchManager.Instance.GetHeroHand(_character.HeroIndex);
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			if (!CustomFunctions.IsLivingHero(_character))
			{
				return;
			}
			switch (_trait)
			{
			case "breenaturepaladininnate":
			{
				string traitName2 = traitData.TraitName;
				if (_auxString == "thorns" && !infiniteProctectionThorns)
				{
					infiniteProctectionVitality = true;
				}
				if (_auxString == "vitality" && !infiniteProctectionVitality)
				{
					infiniteProctectionThorns = true;
				}
				if (CustomFunctions.CanIncrementTraitActivations(_trait) && _auxString == "thorns" && CustomFunctions.IsLivingHero(_target) && CustomFunctions.IsLivingHero(_character) && !infiniteProctectionThorns)
				{
					Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName2);
					_target.SetAuraTrait(_character, "vitality", 1);
					if (CustomFunctions.IfCharacterHas(_character, CustomFunctions.CharacterHas.Item, "heartofthorns") || CustomFunctions.IfCharacterHas(_character, CustomFunctions.CharacterHas.Item, "heartofthornsrare"))
					{
						posiblytemporaryflatnumberofthornstodo++;
						if (posiblytemporaryflatnumberofthornstodo > 3)
						{
							infiniteProctectionThorns = true;
						}
						if (yougotthorns != null && _target == yougotthorns)
						{
							infiniteProctectionThorns = true;
						}
						yougotthorns = _target;
					}
				}
				if (CustomFunctions.CanIncrementTraitActivations(_trait) && _auxString == "vitality" && CustomFunctions.IsLivingHero(_target) && CustomFunctions.IsLivingHero(_character) && !infiniteProctectionVitality)
				{
					Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName2);
					_target.SetAuraTrait(_character, "thorns", 1);
				}
				break;
			}
			case "thulsreworkinnate":
			{
				string traitName3 = traitData.TraitName;
				break;
			}
			case "reworkedvampirism":
			{
				string traitName4 = traitData.TraitName;
				break;
			}
			case "laiareworkinnate":
			{
				string traitName = traitData.TraitName;
				if (!(_auxString == "block") || !CustomFunctions.IsLivingHero(_target) || !CustomFunctions.IsLivingHero(_character))
				{
					break;
				}
				int num = _target.HealReceivedFinal(Functions.FuncRoundToInt((float)_auxInt * 0.25f), false, (CardData)null);
				int num2 = num;
				if (_target.GetHpLeftForMax() < num2)
				{
					num2 = _target.GetHpLeftForMax();
				}
				if (num2 > 0)
				{
					_target.ModifyHp(num2, false, true, _character);
					CastResolutionForCombatText val = new CastResolutionForCombatText();
					val.heal = num2;
					if ((Object)(object)_target.HeroItem != (Object)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);
				}
				break;
			}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Trait), "DoTrait")]
		public static bool DoTrait(EventActivation _theEvent, string _trait, Character _character, Character _target, int _auxInt, string _auxString, CardData _castedCard, ref Trait __instance)
		{
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				return false;
			}
			if (Content.medsCustomTraitsSource.Contains(_trait) && myTraitList.Contains(_trait))
			{
				DoCustomTrait(_trait, ref __instance, ref _theEvent, ref _character, ref _target, ref _auxInt, ref _auxString, ref _castedCard);
				return false;
			}
			return true;
		}
	}
	public class PerkUnused
	{
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.binbinAndLeif.PerkManager";

		public const string PLUGIN_NAME = "Custom Perks";

		public const string PLUGIN_VERSION = "0.1";
	}
}