using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using 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.binbin.Barbarian")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Gork, The Barbarian")]
[assembly: AssemblyFileVersion("0.2.7.0")]
[assembly: AssemblyInformationalVersion("0.2.7+dcb494c94efcba3660200bfed959da3f93659b2f")]
[assembly: AssemblyProduct("Barbarian")]
[assembly: AssemblyTitle("com.binbin.Barbarian")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.7.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 Barbarian
{
	public class CustomFunctions
	{
		public enum AppliesTo
		{
			None,
			Global,
			Monsters,
			Heroes,
			ThisHero
		}

		public enum CharacterHas
		{
			Perk,
			Item,
			Trait,
			Enchantment
		}

		public enum IsAuraOrCurse
		{
			Aura,
			Curse,
			Both
		}

		public static string perkBase = Plugin.subclassname ?? "";

		public static string itemStem = Plugin.subclassname ?? "";

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

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

		public static void WhenYouGainXGainY(string ACGained, string targetAC, string ACtoApply, int nGained, int nToApply, float multiplier, ref Character _character, string traitName)
		{
			if ((!((Object)(object)MatchManager.Instance == (Object)null) || ACGained != null || IsLivingHero(_character)) && !(targetAC == ACtoApply) && ACGained == targetAC)
			{
				int num = Mathf.RoundToInt((float)(nGained + nToApply) * multiplier);
				_character.SetAuraTrait(_character, ACtoApply, 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 nCharges, 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) / nCharges));
			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 ReduceCardTypeCostUntilDiscarded(CardType cardType, int amountToReduce, ref Character _character, ref List<string> heroHand, ref List<CardData> cardDataList, string traitName)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (_character.HeroData == null)
			{
				return;
			}
			if (amountToReduce <= 0)
			{
				return;
			}
			for (int i = 0; i < heroHand.Count; i++)
			{
				CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
				if (cardData != null && cardData.GetCardFinalCost() > 0 && cardData.HasCardType(cardType))
				{
					cardDataList.Add(cardData);
				}
			}
			for (int j = 0; j < cardDataList.Count; j++)
			{
				CardData val = cardDataList[j];
				if (val != null)
				{
					val.EnergyReductionTemporal += amountToReduce;
					MatchManager.Instance.UpdateHandCards();
					CardItem cardFromTableByIndex = MatchManager.Instance.GetCardFromTableByIndex(val.InternalId);
					cardFromTableByIndex.PlayDissolveParticle();
					cardFromTableByIndex.ShowEnergyModification(-amountToReduce);
					((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
					MatchManager.Instance.CreateLogCardModification(val.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
				}
			}
		}

		public static void AddImmunityToHero(string immunity, ref Hero _character)
		{
			if (_character != null && !((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)
		{
			int auraCharges = _character.GetAuraCharges(auraCurseDependent);
			int num = Mathf.FloorToInt((float)auraCharges / stacks_per_bonus);
			_character.ModifyAuraCurseQuantity(auraCurseToModify, num);
		}

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

		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 traitId, int bonusActivations = 0)
		{
			//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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			if (MatchManager.Instance == null || _castedCard == null)
			{
				return;
			}
			TraitData traitData = Globals.Instance.GetTraitData(traitId);
			if (MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(traitId) && MatchManager.Instance.activatedTraits[traitId] > traitData.TimesPerTurn - 1 + bonusActivations)
			{
				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(traitId))
					{
						MatchManager.Instance.activatedTraits.Add(traitId, 1);
					}
					else
					{
						Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
						int value = activatedTraits[traitId] + 1;
						activatedTraits[traitId] = 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_" + traitData.TraitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitId], traitData.TimesPerTurn + bonusActivations), (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 _trait)
		{
			//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(_trait);
			if ((MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(_trait) && MatchManager.Instance.activatedTraits[_trait] > 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(_trait))
			{
				MatchManager.Instance.activatedTraits.Add(_trait, 1);
			}
			else
			{
				Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
				int value = activatedTraits[_trait] + 1;
				activatedTraits[_trait] = 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_" + _trait, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[_trait], traitData.TimesPerTurn), (CombatScrollEffectType)7);
			MatchManager.Instance.CreateLogCardModification(val.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
		}

		public static int CountAllStacks(string auraCurse, Hero[] teamHero = null, NPC[] teamNpc = null, bool includeHeroes = true, bool includeNpcs = true)
		{
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				return 0;
			}
			if (teamHero == null)
			{
				teamHero = MatchManager.Instance.GetTeamHero();
			}
			if (teamNpc == null)
			{
				teamNpc = MatchManager.Instance.GetTeamNPC();
			}
			int num = 0;
			if (includeHeroes)
			{
				for (int i = 0; i < teamHero.Length; i++)
				{
					if (IsLivingHero((Character)(object)teamHero[i]))
					{
						num += ((Character)teamHero[i]).GetAuraCharges(auraCurse);
					}
				}
			}
			if (includeNpcs)
			{
				for (int j = 0; j < teamNpc.Length; j++)
				{
					if (IsLivingNPC((Character)(object)teamNpc[j]))
					{
						num += ((Character)teamNpc[j]).GetAuraCharges(auraCurse);
					}
				}
			}
			return num;
		}

		public static void DealIndirectDamageToAllMonsters(DamageType damageType, int amount)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogDebug((object)(Plugin.debugBase + "Dealing Indirect Damage"));
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				return;
			}
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			foreach (NPC val in teamNPC)
			{
				if (IsLivingNPC((Character)(object)val))
				{
					((Character)val).IndirectDamage(damageType, amount, (AudioClip)null, "", "", "");
				}
			}
		}

		public static List<int> GetValidCharacters(Character[] characters)
		{
			List<int> list = new List<int>();
			for (int i = 0; i < characters.Length; i++)
			{
				Character val = characters[i];
				if (val.Alive && val != null)
				{
					list.Add(i);
				}
			}
			return list;
		}

		public static Character GetFrontCharacter(Character[] characters)
		{
			List<int> validCharacters = GetValidCharacters(characters);
			int num = validCharacters.First();
			return characters[num];
		}

		public static Character GetBackCharacter(Character[] characters)
		{
			List<int> validCharacters = GetValidCharacters(characters);
			int num = validCharacters.Last();
			return characters[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, perkBase + perkName);
		}

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

		public static bool TeamHasPerk(string perkName)
		{
			if ((Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			return AtOManager.Instance.TeamHavePerk(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
		}

		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, perkBase + id) || AtOManager.Instance.CharacterHaveItem(characterOfInterest.SubclassName, id);
					break;
				case CharacterHas.Perk:
					flag2 = AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkBase + id) || AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, id);
					break;
				case CharacterHas.Trait:
					flag2 = AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, perkBase + id) || AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, id);
					break;
				case CharacterHas.Enchantment:
					flag2 = CharacterHaveEnchantment(characterOfInterest, id);
					break;
				}
			}
			else
			{
				switch (characterHas)
				{
				case CharacterHas.Item:
					flag2 = AtOManager.Instance.TeamHaveItem(perkBase + id, -1, false) || AtOManager.Instance.TeamHaveItem(id, -1, false);
					break;
				case CharacterHas.Perk:
					flag2 = AtOManager.Instance.TeamHavePerk(perkBase + id) || AtOManager.Instance.TeamHavePerk(id);
					break;
				case CharacterHas.Trait:
					flag2 = AtOManager.Instance.TeamHaveTrait(perkBase + id) || AtOManager.Instance.TeamHaveTrait(id);
					break;
				case CharacterHas.Enchantment:
					flag2 = AtOManager.Instance.TeamHaveItem(itemStem + id, -1, false) || AtOManager.Instance.TeamHaveItem(itemStem + id + "a", -1, false) || AtOManager.Instance.TeamHaveItem(itemStem + id + "b", -1, false) || AtOManager.Instance.TeamHaveItem(id, -1, false) || AtOManager.Instance.TeamHaveItem(id + "a", -1, false) || AtOManager.Instance.TeamHaveItem(id + "b", -1, false);
					break;
				}
			}
			return flag2 && flag;
		}

		public static bool TeamHasPerkGACM(Character characterOfInterest, string perkName, 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;
			bool flag2 = AtOManager.Instance.TeamHavePerk(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
			return flag2 && flag;
		}

		public static bool CharacterHasPerkGACM(Character characterOfInterest, string perkName, AppliesTo appliesTo = AppliesTo.Global)
		{
			if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global;
			bool flag2 = AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkBase + perkName) || AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkName);
			return flag2 && flag;
		}

		public static bool TeamHasTraitGACM(Character characterOfInterest, string perkName, 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;
			bool flag2 = AtOManager.Instance.TeamHaveTrait(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
			return flag2 && flag;
		}

		public static bool CharacterHasTraitGACM(Character characterOfInterest, string perkName, 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;
			bool flag2 = AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
			return flag2 && flag;
		}

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

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

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

		public static void PlayCardForFree(string cardToCast)
		{
			if (cardToCast != null && !((Object)(object)Globals.Instance == (Object)null))
			{
				CardData cardData = Globals.Instance.GetCardData(cardToCast, true);
				if ((Object)(object)cardData == (Object)null)
				{
					PLog("Invalid CardName");
				}
				else
				{
					((MonoBehaviour)MatchManager.Instance).StartCoroutine(MatchManager.Instance.CastCard((CardItem)null, true, cardData, 0, -1, true));
				}
			}
		}

		public static void PlaySoundEffect(Character _character, string ACeffect)
		{
			if ((Object)(object)_character.HeroItem != (Object)null)
			{
				EffectsManager.Instance.PlayEffectAC(ACeffect, true, ((CharacterItem)_character.HeroItem).CharImageT, false, 0f);
			}
		}

		public static void DisplayRemainingChargesForTrait(ref Character _character, TraitData traitData)
		{
			if ((Object)(object)_character.HeroItem != (Object)null)
			{
				((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitData.TraitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitData.TraitName], traitData.TimesPerTurn), (CombatScrollEffectType)7);
			}
		}

		public static void DisplayTraitScroll(ref Character _character, TraitData traitData)
		{
			HeroItem heroItem = _character.HeroItem;
			if (heroItem != null)
			{
				((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitData.TraitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void DisplayTraitScroll(ref Character _character, string traitName)
		{
			HeroItem heroItem = _character.HeroItem;
			if (heroItem != null)
			{
				((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
			}
		}

		public static void IncrementTraitActivations(TraitData traitData)
		{
			string id = traitData.Id;
			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)
		{
			TraitData traitData = Globals.Instance.GetTraitData(traitId);
			IncrementTraitActivations(traitData);
		}

		public static bool CanIncrementTraitActivations(TraitData traitData, int bonusActivations = 0)
		{
			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;
			}
			if (MatchManager.Instance.activatedTraits.ContainsKey(id) && MatchManager.Instance.activatedTraits[id] > traitData.TimesPerTurn - 1 + bonusActivations)
			{
				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)
		{
			TraitData traitData = Globals.Instance.GetTraitData(traitId);
			return CanIncrementTraitActivations(traitData, bonusActivations);
		}

		public static void ModifyAllAurasOrCursesByPercent(int percentToModify, IsAuraOrCurse isAuraOrCurse, Character _characterTarget, Character _characterCaster)
		{
			if (percentToModify == 0 || _characterTarget == null || !_characterTarget.Alive)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			if ((isAuraOrCurse == IsAuraOrCurse.Aura || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify > 0)
			{
				num = percentToModify;
			}
			if ((isAuraOrCurse == IsAuraOrCurse.Aura || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify < 0)
			{
				num2 = Math.Abs(percentToModify);
			}
			if ((isAuraOrCurse == IsAuraOrCurse.Curse || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify > 0)
			{
				num3 = percentToModify;
			}
			if ((isAuraOrCurse == IsAuraOrCurse.Curse || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify < 0)
			{
				num4 = Math.Abs(percentToModify);
			}
			if (_characterTarget == null || !_characterTarget.Alive)
			{
				return;
			}
			for (int i = 0; i < 4; i++)
			{
				if ((i == 0 && num <= 0) || (i == 1 && num3 <= 0) || (i == 2 && num2 <= 0) || (i == 3 && num4 <= 0))
				{
					continue;
				}
				List<string> list = new List<string>();
				List<int> list2 = new List<int>();
				for (int j = 0; j < _characterTarget.AuraList.Count; j++)
				{
					if (_characterTarget.AuraList[j] != null && (Object)(object)_characterTarget.AuraList[j].ACData != (Object)null && _characterTarget.AuraList[j].GetCharges() > 0 && !(_characterTarget.AuraList[j].ACData.Id == "furnace"))
					{
						bool flag = false;
						if ((i == 0 || i == 2) && _characterTarget.AuraList[j].ACData.IsAura)
						{
							flag = true;
						}
						else if ((i == 1 || i == 3) && !_characterTarget.AuraList[j].ACData.IsAura)
						{
							flag = true;
						}
						if (flag)
						{
							list.Add(_characterTarget.AuraList[j].ACData.Id);
							list2.Add(_characterTarget.AuraList[j].GetCharges());
						}
					}
				}
				if (list.Count <= 0)
				{
					continue;
				}
				for (int k = 0; k < list.Count; k++)
				{
					int num5 = i switch
					{
						0 => Functions.FuncRoundToInt((float)((double)list2[k] * (double)num / 100.0)), 
						1 => Functions.FuncRoundToInt((float)((double)list2[k] * (double)num3 / 100.0)), 
						2 => list2[k] - Functions.FuncRoundToInt((float)((double)list2[k] * (double)num2 / 100.0)), 
						_ => list2[k] - Functions.FuncRoundToInt((float)((double)list2[k] * (double)num4 / 100.0)), 
					};
					switch (i)
					{
					case 0:
					case 1:
					{
						AuraCurseData val = AtOManager.Instance.GlobalAuraCurseModificationByTraitsAndItems("set", list[k], _characterCaster, _characterTarget);
						if ((Object)(object)val != (Object)null)
						{
							int maxCharges = val.GetMaxCharges();
							if (maxCharges > -1 && list2[k] + num5 > maxCharges)
							{
								num5 = maxCharges - list2[k];
							}
							_characterTarget.SetAura(_characterCaster, val, num5, false, (CardClass)11, false, false);
						}
						break;
					}
					case 2:
					case 3:
						if (num5 <= 0)
						{
							num5 = 1;
						}
						_characterTarget.ModifyAuraCurseCharges(list[k], num5);
						_characterTarget.UpdateAuraCurseFunctions((AuraCurseData)null, 0, -1);
						break;
					}
				}
			}
		}

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

		public static string CollectionToString(Collection<object> values)
		{
			return string.Join(",", values);
		}

		public static string CollectionToString(Dictionary<string, int> dictionary)
		{
			return "{" + string.Join(",", dictionary.Select((KeyValuePair<string, int> kv) => kv.Key + "=" + kv.Value).ToArray()) + "}";
		}

		public static void DrawCards(int numToDraw)
		{
			MatchManager.Instance.NewCard(numToDraw, (CardFrom)0, "");
		}

		public static void GainEnergy(Character _character, int energyToGain, TraitData traitData = null)
		{
			if (!IsLivingHero(_character))
			{
				Plugin.LogDebug("GainEnergy - Invalid Character");
				return;
			}
			Plugin.LogDebug("GainEnergy - Modifying Energy");
			_character.ModifyEnergy(energyToGain, true);
			if (_character.HeroItem != null)
			{
				Plugin.LogDebug("GainEnergy - Setting Effect AC");
				EffectsManager.Instance.PlayEffectAC("energy", true, ((CharacterItem)_character.HeroItem).CharImageT, false, 0f);
				if (!((Object)(object)traitData == (Object)null))
				{
				}
			}
		}

		public static void StealAuraCurses(ref Character characterStealing, ref Character characterToStealFrom, int nToSteal, IsAuraOrCurse isAuraOrCurse = IsAuraOrCurse.Aura)
		{
			if (isAuraOrCurse == IsAuraOrCurse.Both)
			{
				Plugin.LogDebug("Must Specify Aura or Curse to Steal");
				return;
			}
			if (characterStealing == null || characterToStealFrom == null || !characterStealing.Alive || !characterToStealFrom.Alive)
			{
				Plugin.LogDebug("Character to Steal from or Character Stealing is not a valid living character");
				return;
			}
			List<string> list = new List<string>();
			List<int> list2 = new List<int>();
			int num = 0;
			if (characterToStealFrom != null)
			{
				for (int i = 0; i < characterToStealFrom.AuraList.Count; i++)
				{
					if (num >= nToSteal)
					{
						break;
					}
					bool flag = characterToStealFrom.AuraList[i] != null && (Object)(object)characterToStealFrom.AuraList[i].ACData != (Object)null;
					bool flag2 = ((isAuraOrCurse == IsAuraOrCurse.Aura) ? characterToStealFrom.AuraList[i].ACData.IsAura : (!characterToStealFrom.AuraList[i].ACData.IsAura));
					bool flag3 = characterToStealFrom.AuraList[i].ACData.Removable && characterToStealFrom.AuraList[i].GetCharges() > 0;
					if (flag && flag2 && flag3)
					{
						list.Add(characterToStealFrom.AuraList[i].ACData.Id);
						list2.Add(characterToStealFrom.AuraList[i].GetCharges());
						num++;
					}
				}
			}
			if (num <= 0)
			{
				return;
			}
			characterToStealFrom.HealCursesName(list, "");
			for (int j = 0; j < list.Count; j++)
			{
				if (characterStealing != null && characterStealing.Alive)
				{
					characterStealing.SetAura(characterToStealFrom, Globals.Instance.GetAuraCurseData(list[j]), list2[j], false, (CardClass)11, true, true);
				}
			}
		}

		public static List<string> GetDeck(Character character)
		{
			return character.Cards;
		}

		public static List<CardData> GetDeckCardData(Character character)
		{
			List<CardData> list = new List<CardData>();
			foreach (string card in character.Cards)
			{
				list.Add(Globals.Instance.GetCardData(card, true));
			}
			return list;
		}

		public static int CountAllACOnCharacter(Character character, IsAuraOrCurse isAuraOrCurse)
		{
			int num = 0;
			foreach (Aura aura in character.AuraList)
			{
				bool flag = true;
				switch (isAuraOrCurse)
				{
				case IsAuraOrCurse.Aura:
					flag = aura.ACData.IsAura;
					break;
				case IsAuraOrCurse.Curse:
					flag = !aura.ACData.IsAura;
					break;
				case IsAuraOrCurse.Both:
					flag = true;
					break;
				}
				if (flag)
				{
					num += aura.AuraCharges;
				}
			}
			return num;
		}

		public static void ReduceCardCost(ref CardData cardData, Character currentCharacter = null, int amountToReduce = 1, bool isPermanent = false)
		{
			if ((Object)(object)MatchManager.Instance == (Object)null || (Object)(object)cardData == (Object)null)
			{
				Plugin.LogError("Null MatchManager/card");
				return;
			}
			Plugin.LogDebug("Reducing card Cost");
			if (currentCharacter == null)
			{
				currentCharacter = (Character)(object)MatchManager.Instance.GetHeroHeroActive();
			}
			if (currentCharacter == null)
			{
				Plugin.LogError("Null Current Character");
				return;
			}
			if (isPermanent)
			{
				Plugin.LogDebug("Reducing card Cost - permanent");
				CardData obj = cardData;
				obj.EnergyReductionPermanent += amountToReduce;
			}
			else
			{
				Plugin.LogDebug("Reducing card Cost - temporary");
				CardData obj2 = cardData;
				obj2.EnergyReductionTemporal += amountToReduce;
			}
			Plugin.LogDebug("Reducing card Cost - updates");
			MatchManager.Instance.GetCardFromTableByIndex(cardData.InternalId).ShowEnergyModification(-amountToReduce);
			MatchManager.Instance.UpdateHandCards();
			MatchManager.Instance.CreateLogCardModification(cardData.InternalId, MatchManager.Instance.GetHero(currentCharacter.HeroIndex));
			Plugin.LogDebug("Reducing card Cost - END");
		}

		public static CardData GetRandomHighestCostCard(CardType cardType, List<string> heroHand = null)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				Plugin.LogError("Null MatchManager");
				return null;
			}
			if (heroHand == null)
			{
				heroHand = MatchManager.Instance.GetHeroHand(MatchManager.Instance.GetHeroActive());
			}
			int num = 0;
			List<CardData> list = new List<CardData>();
			for (int i = 0; i < heroHand.Count; i++)
			{
				CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
				if (cardData != null && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() > num)
				{
					num = cardData.GetCardFinalCost();
				}
			}
			if (num <= 0)
			{
				return null;
			}
			for (int j = 0; j < heroHand.Count; j++)
			{
				CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[j], true);
				if (cardData2 != null && (cardData2.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData2.GetCardFinalCost() >= num)
				{
					list.Add(cardData2);
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return (list.Count != 1) ? list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "default", "")] : list[0];
		}

		public static List<CardData> GetCardsFromHand(CardType cardType = 0, int equalOrAboveCertainCost = 0, int lessThanOrEqualToThisCost = 100)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Character heroHeroActive = (Character)(object)MatchManager.Instance.GetHeroHeroActive();
			List<string> heroHand = MatchManager.Instance.GetHeroHand(heroHeroActive.HeroIndex);
			List<CardData> list = new List<CardData>();
			for (int i = 0; i < heroHand.Count; i++)
			{
				CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
				if ((Object)(object)cardData != (Object)null && cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() >= equalOrAboveCertainCost && cardData.GetCardFinalCost() <= lessThanOrEqualToThisCost)
				{
					list.Add(cardData);
				}
			}
			return list;
		}

		public static List<CardData> GetCardsFromHand(List<string> heroHand, CardType cardType = 0, int equalOrAboveCertainCost = 0, int lessThanOrEqualToThisCost = 100)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			List<CardData> list = new List<CardData>();
			for (int i = 0; i < heroHand.Count; i++)
			{
				CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
				if ((Object)(object)cardData != (Object)null && cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() >= equalOrAboveCertainCost && cardData.GetCardFinalCost() <= lessThanOrEqualToThisCost)
				{
					list.Add(cardData);
				}
			}
			return list;
		}

		public static CardData GetRightmostCard(List<string> heroHand)
		{
			return MatchManager.Instance.GetCardData(heroHand.Last(), true);
		}

		public static bool CharacterHaveEnchantment(Character character, string id)
		{
			if ((Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			string subclassName = character.SubclassName;
			return CharacterHaveEnchantment(subclassName, id);
		}

		public static bool CharacterHaveEnchantment(string characterId, string id)
		{
			if ((Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			return AtOManager.Instance.CharacterHaveItem(characterId, itemStem + id) || AtOManager.Instance.CharacterHaveItem(characterId, itemStem + id + "a") || AtOManager.Instance.CharacterHaveItem(characterId, itemStem + id + "b") || AtOManager.Instance.CharacterHaveItem(characterId, id) || AtOManager.Instance.CharacterHaveItem(characterId, id + "a") || AtOManager.Instance.CharacterHaveItem(characterId, id + "b");
		}

		public static bool TeamHaveEnchantment(string id)
		{
			if ((Object)(object)AtOManager.Instance == (Object)null)
			{
				return false;
			}
			return AtOManager.Instance.TeamHaveItem(itemStem + id, -1, false) || AtOManager.Instance.TeamHaveItem(itemStem + id + "a", -1, false) || AtOManager.Instance.TeamHaveItem(itemStem + id + "b", -1, false) || AtOManager.Instance.TeamHaveItem(id, -1, false) || AtOManager.Instance.TeamHaveItem(id + "a", -1, false) || AtOManager.Instance.TeamHaveItem(id + "b", -1, false);
		}
	}
	public class DescriptionFunctions
	{
		public static string itemStem = Plugin.subclassname ?? "";

		public static List<string> cardsWithCustomDescriptions = new List<string>(15)
		{
			"surprisebox", "surpriseboxrare", "surprisegiftbox", "surprisegiftboxrare", "bbbtreefellingaxe", "bbbtreefellingaxerare", "bbbcloakofthorns", "bbbcloakofthornsrare", "bbbportablewallofflames", "bbbportablewallofflamesrare",
			"bbbslimepoison", "bbbslimepoisonrare", "bbbscrollofpetimmortality", "bbbscrollofpetimmortalityrare", "rocketbootsrare"
		};

		public static List<string> cardsToAppendDescription = new List<string>(8) { "bbbrustedshield", "bbbrustedshieldrare", "soullanternrare", "boneclawsrare", "mozzy", "mozzyrare", "bbbmelancholicarmor", "bbbmelancholicarmorare" };

		public static List<string> cardsToPrependDescription = new List<string>(2) { "mimy", "mimyrare" };

		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 = itemStem + __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 = itemStem + __instance.Id;
				stringBuilder1.Insert(0, Functions.FormatStringCard(Texts.Instance.GetText(text, "")));
			}
		}
	}
	[BepInPlugin("com.binbin.Barbarian", "Barbarian", "0.2.7")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("AcrossTheObelisk.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal int ModDate = int.Parse(DateTime.Today.ToString("yyyyMMdd"));

		private readonly Harmony harmony = new Harmony("com.binbin.Barbarian");

		internal static ManualLogSource Log;

		public static string characterName = "Gork";

		public static string heroName = characterName;

		public static string subclassName = "Barbarian";

		public static string subclassname = subclassName.ToLower();

		public static string debugBase = "Binbin - Testing " + characterName + " ";

		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.binbin.Barbarian 0.2.7 has loaded!");
			EnableDebugging = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition(subclassName, "Enable Debugging"), true, new ConfigDescription("Enables debugging logs.", (AcceptableValueBase)null, Array.Empty<object>()));
			Essentials.RegisterMod("Barbarian", "binbin", "Gork, the Barbarian.", "0.2.7", ModDate, "https://github.com/binbinmods/heronamesubclass", (string[])null, "Barbarian", 100, new string[3] { "content", "hero", "trait" }, "", true);
			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 = simpleTraitList.Select((string trait) => Plugin.subclassname + trait).ToArray();

		private static string trait0 = myTraitList[0];

		private static string trait2a = myTraitList[3];

		private static string trait2b = myTraitList[4];

		private static string trait4a = myTraitList[7];

		private static string trait4b = myTraitList[8];

		public static int infiniteProctection = 0;

		public static int bleedInfiniteProtection = 0;

		public static string debugBase = "Binbin - Testing " + Plugin.heroName + " ";

		public static bool isDamagePreviewActive;

		public static bool isCalculateDamageActive;

		public static bool firstCast = true;

		public static void DoCustomTrait(string _trait, ref Trait __instance)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			EventActivation value = Traverse.Create((object)__instance).Field("theEvent").GetValue<EventActivation>();
			Character value2 = Traverse.Create((object)__instance).Field("character").GetValue<Character>();
			Character value3 = Traverse.Create((object)__instance).Field("target").GetValue<Character>();
			int value4 = Traverse.Create((object)__instance).Field("auxInt").GetValue<int>();
			string value5 = Traverse.Create((object)__instance).Field("auxString").GetValue<string>();
			CardData value6 = Traverse.Create((object)__instance).Field("castedCard").GetValue<CardData>();
			Traverse.Create((object)__instance).Field("character").SetValue((object)value2);
			Traverse.Create((object)__instance).Field("target").SetValue((object)value3);
			Traverse.Create((object)__instance).Field("theEvent").SetValue((object)value);
			Traverse.Create((object)__instance).Field("auxInt").SetValue((object)value4);
			Traverse.Create((object)__instance).Field("auxString").SetValue((object)value5);
			Traverse.Create((object)__instance).Field("castedCard").SetValue((object)value6);
			TraitData traitData = Globals.Instance.GetTraitData(_trait);
			List<CardData> list = new List<CardData>();
			List<string> heroHand = MatchManager.Instance.GetHeroHand(value2.HeroIndex);
			Hero[] teamHero = MatchManager.Instance.GetTeamHero();
			NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
			if (_trait == trait0)
			{
				string traitName = traitData.TraitName;
				Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName);
			}
			else if (_trait == trait2a)
			{
				string traitName2 = traitData.TraitName;
				Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName2);
				if (CustomFunctions.IsLivingHero(value2))
				{
					value2.SetAuraTrait(value2, "vitality", 2);
				}
			}
			else if (_trait == trait2b)
			{
				string traitName3 = traitData.TraitName;
				Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName3);
				if (CustomFunctions.IsLivingHero(value2))
				{
					CardData cardData = CustomFunctions.GetRandomHighestCostCard((CardType)0, heroHand);
					CustomFunctions.ReduceCardCost(ref cardData, value2, 3);
				}
			}
			else if (_trait == trait4a)
			{
				string traitName4 = traitData.TraitName;
				Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName4);
				if (CustomFunctions.IsLivingHero(value2) && value3.Alive && value3 != null && value4 != 0 && value5 == "vitality" && value3.SourceName != value2.SourceName)
				{
					value2.SetAura(value2, CustomFunctions.GetAuraCurseData("vitality"), value4, true, (CardClass)11, false, true);
				}
			}
			else if (_trait == trait4b)
			{
				string traitName5 = traitData.TraitName;
				Plugin.LogDebug("Handling Trait " + _trait + ": " + traitName5);
			}
		}

		[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)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MatchManager.Instance == (Object)null)
			{
				return false;
			}
			Traverse.Create((object)__instance).Field("character").SetValue((object)_character);
			Traverse.Create((object)__instance).Field("target").SetValue((object)_target);
			Traverse.Create((object)__instance).Field("theEvent").SetValue((object)_theEvent);
			Traverse.Create((object)__instance).Field("auxInt").SetValue((object)_auxInt);
			Traverse.Create((object)__instance).Field("auxString").SetValue((object)_auxString);
			Traverse.Create((object)__instance).Field("castedCard").SetValue((object)_castedCard);
			if (Content.medsCustomTraitsSource.Contains(_trait) && myTraitList.Contains(_trait))
			{
				DoCustomTrait(_trait, ref __instance);
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GlobalAuraCurseModificationByTraitsAndItems")]
		[HarmonyPriority(0)]
		public static void GlobalAuraCurseModificationByTraitsAndItemsPostfix(ref AtOManager __instance, ref AuraCurseData __result, string _type, string _acId, Character _characterCaster, Character _characterTarget)
		{
			Plugin.LogInfo("GACM " + Plugin.subclassName);
			Character characterOfInterest = ((_type == "set") ? _characterTarget : _characterCaster);
			switch (_acId)
			{
			case "bleed":
			{
				string id = trait0;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPercentPerStack = 2.5f;
				}
				string id2 = "barbariantrait1a";
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Enchantment, id2))
				{
					__result.Preventable = false;
					__result.Removable = false;
					__result.MaxCharges = -1;
					__result.MaxMadnessCharges = -1;
				}
				id = trait4b;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id))
				{
					AuraCurseData obj8 = __result;
					obj8.MaxMadnessCharges += 200;
				}
				id = trait4b;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.Monsters))
				{
					__result.DoubleDamageIfCursesLessThan = 100;
				}
				break;
			}
			case "vitality":
			{
				string id = trait4b;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData obj5 = __result;
					obj5.MaxMadnessCharges += 100;
				}
				id = trait2a;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData obj6 = __result;
					obj6.CharacterStatModifiedValuePerStack *= 2;
				}
				string text = "barbarianslasher";
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, text + "rare", CustomFunctions.AppliesTo.ThisHero))
				{
					__result.AuraDamageType = (DamageType)10;
					__result.AuraDamageIncreasedPerStack = 0.5f;
				}
				string id2 = "barbariantrait1a";
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Enchantment, id2, CustomFunctions.AppliesTo.ThisHero))
				{
					__result.RemoveAuraCurse = null;
				}
				break;
			}
			case "fury":
			{
				string id = trait0;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData obj7 = __result;
					obj7.AuraDamageIncreasedPercentPerStack *= 0.5f;
				}
				break;
			}
			case "sharp":
			{
				string id = trait0;
				if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Trait, id, CustomFunctions.AppliesTo.ThisHero))
				{
					AuraCurseData obj = __result;
					obj.AuraDamageIncreasedPerStack *= 0.5f;
					AuraCurseData obj2 = __result;
					obj2.AuraDamageIncreasedPerStack2 *= 0.5f;
					AuraCurseData obj3 = __result;
					obj3.AuraDamageIncreasedPerStack3 *= 0.5f;
					AuraCurseData obj4 = __result;
					obj4.AuraDamageIncreasedPerStack4 *= 0.5f;
				}
				break;
			}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Hero), "AssignTrait")]
		public static void AssignTraitPostfix(ref Hero __instance, bool __result, string traitName)
		{
			Plugin.LogDebug("AssignTraitPostfix");
			string text = trait2a;
			if (__result && traitName == text)
			{
				Plugin.LogDebug("AssignTraitPostfix - Doubling Max HP");
				int maxHP = ((Character)__instance).GetMaxHP();
				((Character)__instance).ModifyMaxHP(maxHP);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "BeginTurn")]
		public static void BeginTurnPrefix(ref Character __instance)
		{
			infiniteProctection = 0;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetTraitAuraCurseModifiers")]
		public static void GetTraitAuraCurseModifiersPostfix(ref Character __instance, ref Dictionary<string, int> __result)
		{
			Plugin.LogDebug("GetTraitAuraCurseModifiersPostfix");
			string text = trait4b;
			if (!CustomFunctions.IsLivingHero(__instance) || !__instance.HaveTrait(text) || isDamagePreviewActive || isCalculateDamageActive)
			{
				return;
			}
			int num = Mathf.RoundToInt((float)__instance.GetAuraCharges("sharp") * 0.5f);
			if (num > 0)
			{
				if (!__result.ContainsKey("bleed"))
				{
					__result["bleed"] = 0;
				}
				__result["bleed"] = num;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CardData), "SetDescriptionNew")]
		public static void SetDescriptionNewPostfix(ref CardData __instance, bool forceDescription = false, Character character = null, bool includeInSearch = true)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				Plugin.LogDebug("Null Card");
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string value = Globals.Instance.CardsDescriptionNormalized[__instance.Id];
			stringBuilder.Append(value);
			string text = "barbariantrait1a";
			if (__instance.Id == text || __instance.Id == text + "a" || __instance.Id == text + "b")
			{
				string value2 = DescriptionFunctions.SpriteText("bleed") + "  cannot be removed, prevented, or restricted in any way\n";
				stringBuilder.Insert(0, value2);
			}
			text = "barbariantrait3b";
			if (__instance.Id == text || __instance.Id == text + "a" || __instance.Id == text + "b")
			{
				string value3 = DescriptionFunctions.SpriteText("bleed") + "  received +3\n";
				stringBuilder.Insert(0, value3);
			}
			text = "barbarianslasher";
			if (__instance.Id == text + "rare")
			{
				string value4 = DescriptionFunctions.SpriteText("vitality") + "  on this hero increases All Damage by 0.5 per stack\n";
				stringBuilder.Insert(0, value4);
			}
			DescriptionFunctions.BinbinNormalizeDescription(ref __instance, stringBuilder);
		}

		[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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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
			if ((int)theEvent == 18 || (int)theEvent == 26 || __instance == null || (int)theEvent == 0)
			{
				return;
			}
			string id = "barbariantrait3b";
			if ((int)theEvent == 23 && CustomFunctions.IsLivingHero(target) && CustomFunctions.CharacterHaveEnchantment(target, id) && auxString == "bleed")
			{
				int num = 3;
				bleedInfiniteProtection++;
				if (bleedInfiniteProtection % 2 == 1 && bleedInfiniteProtection < 100)
				{
					Plugin.LogDebug("Handling barbariantrait3b");
					target.SetAura(__instance, CustomFunctions.GetAuraCurseData("bleed"), num, false, (CardClass)11, false, true);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Character), "HealAuraCurse")]
		public static bool HealAuraCursePrefix(ref Character __instance, AuraCurseData AC)
		{
			Plugin.LogInfo("HealAuraCursePrefix " + Plugin.subclassName);
			string id = "barbariantrait1a";
			if (CustomFunctions.TeamHaveEnchantment(id) && (Object)(object)AC == (Object)(object)CustomFunctions.GetAuraCurseData("bleed"))
			{
				return false;
			}
			return 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(Item), "DoItem")]
		public static bool DoItemPrefix(ref Character __instance, ref bool __result, EventActivation _theEvent, CardData _cardData, string _item, Character _character, Character _target, int _auxInt, string _auxString, int order, CardData castedCard, bool onlyCheckItemActivation = false)
		{
			switch (_item)
			{
			case "barbariantrait1b":
			case "barbariantrait1ba":
			case "barbariantrait1bb":
				if (castedCard.HasCardType((CardType)28) && firstCast)
				{
					__result = false;
					firstCast = false;
					return false;
				}
				break;
			}
			firstCast = true;
			return true;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.binbin.Barbarian";

		public const string PLUGIN_NAME = "Barbarian";

		public const string PLUGIN_VERSION = "0.2.7";
	}
}