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 AALUND13Cards.Armors.Armors;
using AALUND13Cards.Armors.Armors.Processors;
using AALUND13Cards.Armors.Cards;
using AALUND13Cards.Armors.Utils;
using AALUND13Cards.Core;
using AALUND13Cards.Core.Cards;
using AALUND13Cards.Core.Cards.Conditions;
using AALUND13Cards.Core.Extensions;
using AALUND13Cards.Core.Utils;
using BepInEx;
using HarmonyLib;
using JARL.Armor;
using JARL.Armor.Bases;
using JARL.Armor.Builtin;
using JARL.Armor.Processors;
using JARL.Armor.Utlis;
using JARL.Extensions;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using TabInfo.Utils;
using UnboundLib;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AALUND13Cards.Armors
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("AALUND13.Cards.Armors", "AALUND13 Armors Cards", "1.0.0")]
	[BepInProcess("Rounds.exe")]
	internal class AAC_Armors : BaseUnityPlugin
	{
		internal const string ModId = "AALUND13.Cards.Armors";

		internal const string ModName = "AALUND13 Armors Cards";

		internal const string Version = "1.0.0";

		private static AssetBundle assets;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			assets = AssetUtils.LoadAssetBundleFromResources("aac_armors_assets", typeof(AAC_Armors).Assembly);
			if ((Object)(object)assets != (Object)null)
			{
				new Harmony("AALUND13.Cards.Armors").PatchAll();
			}
		}

		private void Start()
		{
			if ((Object)(object)assets == (Object)null)
			{
				Unbound.BuildModal("AALUND13 Cards Error", "The mod \"AALUND13 Armors Cards\" assets failled to load, All the cards will be disable in this mod");
				throw new NullReferenceException("Failled to load \"AALUND13 Armors Cards\" assets");
			}
			ArmorTypeGetterUtils.RegiterArmorType<TitaniumArmor>("Titanium");
			ArmorTypeGetterUtils.RegiterArmorType<BattleforgedArmor>("Battleforged");
			ArmorFramework.RegisterArmorProcessor<DamageAgainstArmorPercentageProcessor>();
			ArmorFramework.RegisterArmorProcessor<ArmorDamageReductionProcessor>();
			assets.LoadAsset<GameObject>("ArmorsModCards").GetComponent<CardResgester>().RegisterCards();
			if (AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
			{
				TabinfoInterface.Setup();
			}
		}
	}
	internal class TabinfoInterface
	{
		public static void Setup()
		{
			StatCategory orCreateCategory = TabinfoInterface.GetOrCreateCategory("AA Stats", 6);
			TabInfoManager.RegisterStat(orCreateCategory, "Damage Against Armor Percentage", (Func<Player, bool>)((Player p) => GetArmorStatsFromPlayer(p).DamageAgainstArmorPercentage != 1f), (Func<Player, string>)((Player p) => $"{GetArmorStatsFromPlayer(p).DamageAgainstArmorPercentage * 100f:0}%"));
			TabInfoManager.RegisterStat(orCreateCategory, "Armor Damage Reduction", (Func<Player, bool>)((Player p) => GetArmorStatsFromPlayer(p).ArmorDamageReduction != 0f), (Func<Player, string>)((Player p) => $"{GetArmorStatsFromPlayer(p).ArmorDamageReduction * 100f:0}%"));
		}

		private static ArmorStats GetArmorStatsFromPlayer(Player player)
		{
			return CharacterDataExtensions.GetCustomStatsRegistry(player.data).GetOrCreate<ArmorStats>();
		}
	}
}
namespace AALUND13Cards.Armors.Utils
{
	public class ArmorTypeGetterUtils
	{
		private static Dictionary<string, Type> registerArmorType = new Dictionary<string, Type>();

		public static ReadOnlyDictionary<string, Type> RegisterArmorType => new ReadOnlyDictionary<string, Type>(RegisterArmorType);

		public static void RegiterArmorType<T>(string armorId) where T : ArmorBase, new()
		{
			if (registerArmorType.ContainsKey(armorId))
			{
				throw new ArgumentException("Armor with the type '" + armorId + "' already register");
			}
			ArmorFramework.RegisterArmorType<T>();
			registerArmorType.Add(armorId, typeof(T));
		}

		public static Type GetArmorType(string armorId)
		{
			return registerArmorType[armorId];
		}
	}
}
namespace AALUND13Cards.Armors.CardsEffects
{
	public class RestorationMono : MonoBehaviour
	{
		public float MnRegenCooldown;

		private bool isActive;

		private float regenAmount;

		private CharacterData data;

		private ArmorHandler armorHandler;

		private void Start()
		{
			data = ((Component)this).GetComponentInParent<CharacterData>();
			armorHandler = ((Component)this).GetComponentInParent<ArmorHandler>();
		}

		private void Update()
		{
			if (!isActive && data.health >= data.maxHealth)
			{
				regenAmount = data.healthHandler.regeneration;
				AddRegenerationAmountToAllArmors(regenAmount);
				isActive = true;
			}
			else if (isActive && data.health >= data.maxHealth && regenAmount != data.healthHandler.regeneration)
			{
				AddRegenerationAmountToAllArmors(0f - regenAmount);
				regenAmount = data.healthHandler.regeneration;
				AddRegenerationAmountToAllArmors(regenAmount);
			}
			else if (isActive && data.health < data.maxHealth)
			{
				AddRegenerationAmountToAllArmors(0f - regenAmount);
				isActive = false;
			}
		}

		private void AddRegenerationAmountToAllArmors(float regenerationAmount)
		{
			foreach (ArmorBase activeArmor in armorHandler.ActiveArmors)
			{
				if (!activeArmor.HasArmorTag("NoRestorationRegen"))
				{
					if (activeArmor.ArmorRegenCooldownSeconds < MnRegenCooldown)
					{
						activeArmor.ArmorRegenCooldownSeconds = MnRegenCooldown;
					}
					activeArmor.ArmorRegenerationRate += regenerationAmount;
				}
			}
		}
	}
}
namespace AALUND13Cards.Armors.MonoBehaviours.CardsEffects
{
	public class HealthToArmorConversion : MonoBehaviour
	{
		public float HealthToArmorConversions = 0.5f;

		private Dictionary<ArmorBase, float> armorAdded = new Dictionary<ArmorBase, float>();

		private CharacterData characterData;

		private ArmorHandler armorHandler;

		private float oldHealth;

		private int oldArmorCount;

		private void Start()
		{
			characterData = ((Component)this).GetComponentInParent<CharacterData>();
			armorHandler = ((Component)this).GetComponentInParent<ArmorHandler>();
			CharacterData obj = characterData;
			obj.maxHealth *= HealthToArmorConversions;
			CharacterData obj2 = characterData;
			obj2.health *= HealthToArmorConversions;
			oldHealth = characterData.maxHealth;
			oldArmorCount = Mathf.Max(armorHandler.ActiveArmors.Count, 1);
			UpdateArmorStats();
		}

		private void Update()
		{
			if (characterData.maxHealth != oldHealth || armorHandler.ActiveArmors.Count != oldArmorCount)
			{
				oldHealth = characterData.maxHealth;
				oldArmorCount = Mathf.Max(armorHandler.ActiveArmors.Count, 1);
				UpdateArmorStats();
			}
		}

		private void OnDestroy()
		{
			foreach (KeyValuePair<ArmorBase, float> item in armorAdded)
			{
				ArmorBase key = item.Key;
				key.MaxArmorValue -= item.Value;
				ArmorBase key2 = item.Key;
				key2.CurrentArmorValue -= item.Value;
			}
		}

		private void UpdateArmorStats()
		{
			Dictionary<ArmorBase, float> dictionary = new Dictionary<ArmorBase, float>(armorAdded);
			foreach (KeyValuePair<ArmorBase, float> item in armorAdded)
			{
				ArmorBase key = item.Key;
				key.MaxArmorValue -= item.Value;
			}
			armorAdded.Clear();
			if (armorHandler.ActiveArmors.Count == 0)
			{
				float num = characterData.maxHealth * HealthToArmorConversions * 2f;
				ArmorBase armorByType = armorHandler.GetArmorByType<DefaultArmor>();
				float num2 = num;
				if (dictionary.ContainsKey(armorByType))
				{
					num2 = num - dictionary[armorByType];
				}
				armorByType.MaxArmorValue += num;
				armorByType.CurrentArmorValue += num2;
				armorAdded[armorByType] = num;
			}
			else
			{
				float num3 = characterData.maxHealth * HealthToArmorConversions * 2f / (float)armorHandler.ActiveArmors.Count;
				foreach (ArmorBase activeArmor in armorHandler.ActiveArmors)
				{
					float num4 = num3;
					if (dictionary.ContainsKey(activeArmor))
					{
						num4 = num3 - dictionary[activeArmor];
					}
					activeArmor.MaxArmorValue += num3;
					activeArmor.CurrentArmorValue += num4;
					armorAdded[activeArmor] = num3;
				}
			}
			LoggerUtils.LogInfo($"Added armors to player with a id of {characterData.player.playerID}");
		}
	}
}
namespace AALUND13Cards.Armors.Cards
{
	public class ArmorStats : ICustomStats
	{
		public float DamageAgainstArmorPercentage = 1f;

		public float ArmorDamageReduction;

		public void ResetStats()
		{
			DamageAgainstArmorPercentage = 1f;
			ArmorDamageReduction = 0f;
		}
	}
}
namespace AALUND13Cards.Armors.Cards.StatModifers
{
	public class ArmorStatModifers : CustomStatModifers
	{
		[Header("Armors Stats")]
		public float ArmorDamageReduction;

		[Space(10f)]
		public string ArmorTypeId = "";

		public float ArmorHealth;

		public float ArmorHealthMultiplier = 1f;

		public float ArmorRegenRate;

		public float ArmorRegenCooldown;

		public bool RemoveArmorPirceTag;

		[Space(10f)]
		public bool OverrideArmorDamagePatchType;

		public bool PatchDoDamage;

		public bool PatchTakeDamage;

		public bool PatchTakeDamageOverTime;

		[Space(10f)]
		public ArmorReactivateType ArmorReactivateType;

		public float ArmorReactivateValue;

		[Header("Armor Pierce Stats")]
		public float ArmorPiercePercent;

		public float DamageAgainstArmorPercentage = 1f;

		public override void Apply(Player player)
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			ArmorStats orCreate = CharacterDataExtensions.GetCustomStatsRegistry(player.data).GetOrCreate<ArmorStats>();
			JARLCharacterDataAdditionalData additionalData = CharacterDataExtensions.GetAdditionalData(player.data);
			orCreate.ArmorDamageReduction = Mathf.Min(orCreate.ArmorDamageReduction + ArmorDamageReduction, 0.8f);
			if (!Utility.IsNullOrWhiteSpace(ArmorTypeId))
			{
				ArmorBase val = ArmorFramework.ArmorHandlers[player].Armors.First((ArmorBase x) => ((object)x).GetType() == ArmorTypeGetterUtils.GetArmorType(ArmorTypeId));
				if (val != null)
				{
					val.MaxArmorValue += ArmorHealth;
					if (AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "Systems.R00t.AdditiveStats"))
					{
						val.MaxArmorValue += 100f * (ArmorHealthMultiplier - 1f);
					}
					else
					{
						val.MaxArmorValue *= ArmorHealthMultiplier;
					}
					val.ArmorRegenerationRate += ArmorRegenRate;
					val.ArmorRegenCooldownSeconds += ArmorRegenCooldown;
					if (ArmorReactivateValue > 0f)
					{
						val.reactivateArmorType = ArmorReactivateType;
						val.reactivateArmorValue = ArmorReactivateValue;
					}
					if (RemoveArmorPirceTag && val.HasArmorTag("CanArmorPierce"))
					{
						val.ArmorTags.Remove("CanArmorPierce");
					}
					if (OverrideArmorDamagePatchType)
					{
						val.ArmorDamagePatch = (ArmorDamagePatchType)0;
						if (PatchDoDamage)
						{
							val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 1);
						}
						if (PatchTakeDamage)
						{
							val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 2);
						}
						if (PatchTakeDamageOverTime)
						{
							val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 4);
						}
					}
				}
			}
			additionalData.ArmorPiercePercent = Mathf.Clamp(additionalData.ArmorPiercePercent + ArmorPiercePercent, 0f, 1f);
			orCreate.DamageAgainstArmorPercentage += DamageAgainstArmorPercentage - 1f;
		}
	}
}
namespace AALUND13Cards.Armors.Cards.Conditions
{
	public class PlayerHaveArmorCondition : CardCondition
	{
		public List<string> BlacklistedArmorTag = new List<string>();

		public override bool IsPlayerAllowedCard(Player player)
		{
			return ArmorFramework.ArmorHandlers[player].ActiveArmors.Any((ArmorBase armor) => !BlacklistedArmorTag.Any((string tag) => armor.ArmorTags.Contains(tag)));
		}
	}
}
namespace AALUND13Cards.Armors.Armors
{
	public class BattleforgedArmor : ArmorBase
	{
		public override BarColor GetBarColor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new BarColor(Color.yellow * 0.6f, Color.yellow * 0.45f);
		}

		public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			DamageArmorInfo val = ArmorUtils.ApplyDamage(base.CurrentArmorValue, damage);
			float num = base.CurrentArmorValue - val.Armor;
			base.MaxArmorValue += num * 0.1f;
			return val;
		}

		public BattleforgedArmor()
		{
			base.ArmorTags.Add("CanArmorPierce");
			base.ArmorRegenCooldownSeconds = 5f;
		}
	}
	public class TitaniumArmor : ArmorBase
	{
		public int SegmentsCount = 4;

		public float RegenThresholdPercent = 1.5f;

		private float segmentThresholdHealth;

		private Image segmentThresholdBar;

		public TitaniumArmor()
		{
			base.ArmorTags.Add("CanArmorPierce");
			base.ArmorRegenCooldownSeconds = 5f;
		}

		public override BarColor GetBarColor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new BarColor(Color.magenta * 0.6f, Color.magenta * 0.45f);
		}

		public override void OnUpdate()
		{
			TryCreateArmorMinBar();
			float num = base.MaxArmorValue / (float)SegmentsCount;
			while (base.CurrentArmorValue >= segmentThresholdHealth + num * RegenThresholdPercent)
			{
				segmentThresholdHealth += num;
			}
			if ((Object)(object)segmentThresholdBar != (Object)null)
			{
				segmentThresholdBar.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
			}
		}

		public override void OnRespawn()
		{
			segmentThresholdHealth = base.MaxArmorValue - base.MaxArmorValue / (float)SegmentsCount;
		}

		public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
		{
			//IL_0004: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			DamageArmorInfo val = ((ArmorBase)this).OnDamage(damage, DamagingPlayer, armorDamagePatchType);
			if (Mathf.Max(val.Armor, segmentThresholdHealth) <= segmentThresholdHealth + 0.1f && segmentThresholdHealth > 0f)
			{
				((DamageArmorInfo)(ref val))..ctor(0f, segmentThresholdHealth);
				segmentThresholdHealth = Mathf.Max(segmentThresholdHealth - base.MaxArmorValue / (float)SegmentsCount, 0f);
			}
			return val;
		}

		private void TryCreateArmorMinBar()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)segmentThresholdBar != (Object)null)
			{
				return;
			}
			Dictionary<ArmorBase, GameObject> dictionary = (Dictionary<ArmorBase, GameObject>)ExtensionMethods.GetFieldValue((object)((ArmorBase)this).ArmorHandler, "armorHealthBars");
			if (dictionary == null || !dictionary.ContainsKey((ArmorBase)(object)this))
			{
				return;
			}
			GameObject gameObject = ((Component)dictionary[(ArmorBase)(object)this].transform.Find("Healthbar(Clone)/Canvas/Image")).gameObject;
			if ((Object)(object)gameObject.transform.Find("MinArmorBar") == (Object)null)
			{
				gameObject.AddComponent<Mask>();
				GameObject obj = Object.Instantiate<GameObject>(((Component)gameObject.transform.Find("Health")).gameObject, gameObject.transform);
				((Object)obj).name = "MinArmorBar";
				obj.transform.SetAsLastSibling();
				Image component = obj.GetComponent<Image>();
				((Graphic)component).color = new Color(0.45f, 0f, 0.45f, 1f);
				component.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
				segmentThresholdBar = component;
				GameObject gameObject2 = ((Component)gameObject.transform.Find("Grid")).gameObject;
				gameObject2.transform.SetAsLastSibling();
				((HorizontalOrVerticalLayoutGroup)gameObject2.GetComponent<HorizontalLayoutGroup>()).spacing = -10f;
				GameObject[] array = (GameObject[])(object)new GameObject[gameObject2.transform.childCount];
				for (int i = 0; i < gameObject2.transform.childCount; i++)
				{
					array[i] = ((Component)gameObject2.transform.GetChild(i)).gameObject;
				}
				int num = 8 - SegmentsCount;
				for (int j = 0; j < num; j++)
				{
					array[j].SetActive(false);
				}
				gameObject2.SetActive(true);
			}
			else
			{
				segmentThresholdBar = ((Component)gameObject.transform.Find("MinArmorBar")).GetComponent<Image>();
				segmentThresholdBar.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
			}
		}
	}
}
namespace AALUND13Cards.Armors.Armors.Processors
{
	public class ArmorDamageReductionProcessor : ArmorProcessor
	{
		public override float BeforeArmorProcess(float remaindingDamage, float originalDamage)
		{
			if (!((ArmorProcessor)this).Armor.HasArmorTag("NoDamageReduction"))
			{
				if (CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).HurtPlayer.data).GetOrCreate<ArmorStats>().ArmorDamageReduction == 0f)
				{
					return remaindingDamage;
				}
				return remaindingDamage * (1f - CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).HurtPlayer.data).GetOrCreate<ArmorStats>().ArmorDamageReduction);
			}
			return remaindingDamage;
		}
	}
	internal class DamageAgainstArmorPercentageProcessor : ArmorProcessor
	{
		public override float AfterArmorProcess(float remaindingDamage, float originalDamage, float takenArmorDamage)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			if (((ArmorProcessor)this).Armor.HasArmorTag("CanArmorPierce"))
			{
				if ((Object)(object)((ArmorProcessor)this).DamagingPlayer == (Object)null || CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).DamagingPlayer.data).GetOrCreate<ArmorStats>().DamageAgainstArmorPercentage == 1f || takenArmorDamage <= 0f)
				{
					return remaindingDamage;
				}
				DamageArmorInfo val = ((ArmorProcessor)this).Armor.OnDamage(takenArmorDamage * (CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).DamagingPlayer.data).GetOrCreate<ArmorStats>().DamageAgainstArmorPercentage - 1f), ((ArmorProcessor)this).DamagingPlayer, (ArmorDamagePatchType?)((ArmorProcessor)this).ArmorDamagePatchType);
				((ArmorProcessor)this).Armor.CurrentArmorValue = val.Armor;
			}
			return remaindingDamage;
		}
	}
}

using System;
using System.Collections;
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 AALUND13Cards.Core.Cards;
using AALUND13Cards.Core.Cards.Conditions;
using AALUND13Cards.Core.Cards.Effects;
using AALUND13Cards.Core.Extensions;
using AALUND13Cards.Core.Handlers;
using AALUND13Cards.Core.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using HarmonyLib;
using JARL.Bases;
using JARL.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.GameModes;
using ModdingUtils.Utils;
using ModsPlus;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using TMPro;
using TabInfo.Utils;
using ToggleCardsCategories;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Utils;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using WillsWackyManagers.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.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 AALUND13Cards.Core
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("AALUND13.Cards.Core", "AALUND13 Cards Core", "1.0.0")]
	[BepInProcess("Rounds.exe")]
	public class AAC_Core : BaseUnityPlugin
	{
		public const string ModInitials = "AAC";

		internal const string ModId = "AALUND13.Cards.Core";

		internal const string ModName = "AALUND13 Cards Core";

		internal const string Version = "1.0.0";

		public static List<BaseUnityPlugin> Plugins;

		internal static ManualLogSource ModLogger;

		public static CardResgester CardMainResgester;

		public static CardCategory[] NoLotteryCategories;

		public static CardCategory[] NoSteelCategories;

		public static AAC_Core Instance { get; private set; }

		public void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			ModLogger = ((BaseUnityPlugin)this).Logger;
			new Harmony("AALUND13.Cards.Core").PatchAll();
			ToggleCardsCategoriesManager.instance.RegisterCategories("AAC");
			ConfigHandler.RegesterMenu(((BaseUnityPlugin)this).Config);
		}

		public void Start()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			Plugins = (List<BaseUnityPlugin>)typeof(Chainloader).GetField("_plugins", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			DeathHandler.OnPlayerDeath += new DeathHandlerDelegate(OnPlayerDeath);
			if (Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
			{
				TabinfoInterface.Setup();
			}
			((Component)this).gameObject.AddComponent<DelayDamageHandler>();
			((Component)this).gameObject.AddComponent<PickCardTracker>();
			((Component)this).gameObject.AddComponent<DamageEventHandler>();
			((Component)this).gameObject.AddComponent<ConstantDamageHandler>();
			NoLotteryCategories = (CardCategory[])(object)new CardCategory[2]
			{
				CustomCardCategories.instance.CardCategory("CardManipulation"),
				CustomCardCategories.instance.CardCategory("NoRandom")
			};
			NoSteelCategories = (CardCategory[])(object)new CardCategory[1] { CustomCardCategories.instance.CardCategory("NoRemove") };
		}

		private void OnPlayerDeath(Player player, Dictionary<Player, DamageInfo> playerDamageInfos)
		{
			if ((Object)(object)((Component)player).GetComponent<DelayDamageHandler>() != (Object)null)
			{
				((MonoBehaviour)((Component)player).GetComponent<DelayDamageHandler>()).StopAllCoroutines();
			}
		}
	}
	public class TabinfoInterface
	{
		public static StatCategory GetOrCreateCategory(string name, int priority)
		{
			if (!TabInfoManager.Categories.ContainsKey(name.ToLower()))
			{
				return TabInfoManager.RegisterCategory(name, 6);
			}
			return TabInfoManager.Categories[name.ToLower()];
		}

		internal static void Setup()
		{
			StatCategory orCreateCategory = GetOrCreateCategory("AA Stats", 6);
			TabInfoManager.RegisterStat(orCreateCategory, "Block Pierce Percent", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().BlockPircePercent != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().BlockPircePercent * 100f:0}%"));
			TabInfoManager.RegisterStat(orCreateCategory, "Damage Per Seconds", (Func<Player, bool>)((Player _) => true), (Func<Player, string>)((Player p) => $"{p.GetDPS()}"));
			TabInfoManager.RegisterStat(orCreateCategory, "Bullets Per Seconds", (Func<Player, bool>)((Player _) => true), (Func<Player, string>)((Player p) => $"{p.GetSPS()}"));
		}
	}
	public static class LoggerUtils
	{
		public static bool logging = ConfigHandler.DebugMode.Value;

		public static void LogInfo(string message)
		{
			if (logging)
			{
				AAC_Core.ModLogger.LogInfo((object)message);
			}
		}

		public static void LogWarn(string message)
		{
			AAC_Core.ModLogger.LogWarning((object)message);
		}

		public static void LogError(string message)
		{
			AAC_Core.ModLogger.LogError((object)message);
		}
	}
}
namespace AALUND13Cards.Core.VisualEffect
{
	public class AddAComponentToRandomObjects : MonoBehaviour
	{
		public int NumberOfObjectsToAdd = 1;

		public MonoBehaviour ComponentToAdd;

		public List<GameObject> TargetObjects;

		private void Start()
		{
			if (TargetObjects == null || TargetObjects.Count == 0)
			{
				Debug.LogWarning("No TargetObjects specified to add the component to.");
				return;
			}
			for (int i = 0; i < NumberOfObjectsToAdd; i++)
			{
				AddComponentToRandomObject();
			}
		}

		private void AddComponentToRandomObject()
		{
			if (TargetObjects == null || TargetObjects.Count == 0)
			{
				Debug.LogWarning("No TargetObjects specified to add the component to.");
				return;
			}
			int index = Random.Range(0, TargetObjects.Count);
			GameObject val = TargetObjects[index];
			if ((Object)(object)val.GetComponent(((object)ComponentToAdd).GetType()) != (Object)null)
			{
				Debug.LogWarning("Component " + ((object)ComponentToAdd).GetType().Name + " already exists on " + ((Object)val).name);
				return;
			}
			val.AddComponent(((object)ComponentToAdd).GetType());
			TargetObjects.RemoveAt(index);
		}
	}
	public class AddRandomCardArt : MonoBehaviour
	{
		public bool AddRandomArtAtStart = true;

		public bool AddRandomArtAtEnable;

		public GameObject ArtParent;

		private void Start()
		{
			if (AddRandomArtAtStart)
			{
				GenerateRandomArt();
			}
		}

		private void OnEnable()
		{
			if (AddRandomArtAtEnable)
			{
				GenerateRandomArt();
			}
		}

		private void OnDisable()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			foreach (Transform item in ArtParent.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
		}

		public void GenerateRandomArt()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (Application.isEditor)
			{
				Debug.LogWarning((object)"Random Card Art cannot be generated in editor mode.");
				return;
			}
			CardInfo[] array = (from c in CardManager.cards
				where (Object)(object)c.Value.cardInfo.cardArt != (Object)null
				select c.Value.cardInfo).ToArray();
			if (array.Length != 0)
			{
				GameObject obj = Object.Instantiate<GameObject>(array[Random.Range(0, array.Length)].cardArt, ArtParent.transform);
				obj.transform.localScale = Vector3.one;
				obj.transform.localPosition = Vector3.zero;
			}
		}
	}
	public class StartWithRandomRotationOffset : MonoBehaviour
	{
		[Tooltip("The maximum rotation offset in degrees that will be applied to the object at start.")]
		public float rotationOffset = 25f;

		private void Start()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(0f - rotationOffset, rotationOffset);
			Quaternion rotation = ((Component)this).transform.rotation;
			Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
			eulerAngles.z += num;
			((Component)this).transform.rotation = Quaternion.Euler(eulerAngles);
		}
	}
	[DisallowMultipleComponent]
	public class StartWithRandomSize : MonoBehaviour
	{
		public Vector2 sizeRange = new Vector2(0.75f, 1.25f);

		private void Start()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(sizeRange.x, sizeRange.y);
			((Component)this).transform.localScale = new Vector3(num, num, 1f);
		}
	}
	[ExecuteAlways]
	[RequireComponent(typeof(RectTransform))]
	public class StretchImageBetween : MonoBehaviour
	{
		public RectTransform pointA;

		public RectTransform pointB;

		private RectTransform rectTransform;

		private void Awake()
		{
			rectTransform = ((Component)this).GetComponent<RectTransform>();
		}

		private void Update()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)pointA == (Object)null) && !((Object)(object)pointB == (Object)null))
			{
				Vector3 val = ((Transform)rectTransform).parent.InverseTransformPoint(((Transform)pointA).position);
				Vector3 val2 = ((Transform)rectTransform).parent.InverseTransformPoint(((Transform)pointB).position);
				Vector3 localPosition = (val + val2) / 2f;
				((Transform)rectTransform).localPosition = localPosition;
				Vector3 val3 = val2 - val;
				float num = Mathf.Atan2(val3.y, val3.x) * 57.29578f;
				((Transform)rectTransform).localRotation = Quaternion.Euler(0f, 0f, num);
				float num2 = ((Vector3)(ref val3)).magnitude / ((Transform)rectTransform).localScale.x;
				rectTransform.sizeDelta = new Vector2(num2, rectTransform.sizeDelta.y);
			}
		}
	}
}
namespace AALUND13Cards.Core.Utils
{
	public interface ICustomStats
	{
		void ResetStats();
	}
	public class CustomStatsRegistry : IEnumerable<ICustomStats>, IEnumerable
	{
		private readonly Dictionary<Type, ICustomStats> statsMap = new Dictionary<Type, ICustomStats>();

		public bool Exist<T>() where T : ICustomStats
		{
			return statsMap.ContainsKey(typeof(T));
		}

		public T Get<T>() where T : ICustomStats
		{
			return (T)statsMap[typeof(T)];
		}

		public T Add<T>(T customStatsHandler) where T : ICustomStats
		{
			if (Exist<T>())
			{
				throw new ArgumentException("Item '" + typeof(T).FullName + "' already exists.", "customStatsHandler");
			}
			if (customStatsHandler == null)
			{
				throw new ArgumentNullException("customStatsHandler");
			}
			statsMap.Add(typeof(T), customStatsHandler);
			return customStatsHandler;
		}

		public T GetOrCreate<T>() where T : ICustomStats, new()
		{
			if (statsMap.TryGetValue(typeof(T), out var value))
			{
				return (T)value;
			}
			return Add(new T());
		}

		public void ResetAll()
		{
			foreach (ICustomStats value in statsMap.Values)
			{
				value.ResetStats();
			}
		}

		public IEnumerator<ICustomStats> GetEnumerator()
		{
			return statsMap.Values.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class PhotonPrefabPool : MonoBehaviour
	{
		public List<GameObject> Prefabs = new List<GameObject>();

		public void RegisterPrefabs()
		{
			foreach (GameObject prefab in Prefabs)
			{
				if ((Object)(object)prefab != (Object)null)
				{
					PhotonNetwork.PrefabPool.RegisterPrefab(((Object)prefab).name, prefab);
					LoggerUtils.LogInfo("Registered prefab: " + ((Object)prefab).name);
				}
			}
		}
	}
	public class PickCardTracker : MonoBehaviour, IPickStartHookHandler
	{
		public static PickCardTracker instance;

		private readonly List<CardInfo> cardPickedInPickPhase = new List<CardInfo>();

		public IReadOnlyList<CardInfo> CardPickedInPickPhase => cardPickedInPickPhase.AsReadOnly();

		public bool AlreadyPickedInPickPhase(CardInfo card)
		{
			if ((Object)(object)card == (Object)null)
			{
				return false;
			}
			return cardPickedInPickPhase.Contains(card);
		}

		public void OnPickStart()
		{
			cardPickedInPickPhase.Clear();
		}

		internal void AddCardPickedInPickPhase(CardInfo card)
		{
			if (!((Object)(object)card == (Object)null))
			{
				if ((Object)(object)card.sourceCard != (Object)null)
				{
					card = card.sourceCard;
				}
				if (!cardPickedInPickPhase.Contains(card))
				{
					cardPickedInPickPhase.Add(card);
				}
			}
		}

		private void Awake()
		{
			if ((Object)(object)instance != (Object)null)
			{
				Debug.LogWarning((object)"PickCardTracker instance already exists! Destroying the new one.");
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				instance = this;
				InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
			}
		}
	}
	public class RandomCardRarity : MonoBehaviour
	{
		public Image[] edges;

		public void OnEnable()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!Application.isEditor)
			{
				Rarity randomRarity = GetRandomRarity();
				Image[] array = edges;
				for (int i = 0; i < array.Length; i++)
				{
					((Graphic)array[i]).color = randomRarity.color;
				}
			}
			else
			{
				Debug.Log((object)"RandomCardRarity is running in the editor");
			}
		}

		public static Rarity GetRandomRarity()
		{
			float num = RarityUtils.Rarities.Sum((KeyValuePair<int, Rarity> r) => r.Value.calculatedRarity);
			float num2 = Random.Range(0f, num);
			Rarity result = null;
			foreach (KeyValuePair<int, Rarity> rarity in RarityUtils.Rarities)
			{
				num2 -= rarity.Value.calculatedRarity;
				if (num2 <= 0f)
				{
					result = rarity.Value;
					break;
				}
			}
			return result;
		}
	}
}
namespace AALUND13Cards.Core.Patches
{
	[HarmonyPatch(typeof(Cards), "PlayerIsAllowedCard")]
	internal class AllowedCardPatch
	{
		private static void Postfix(Player player, CardInfo card, ref bool __result)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)card == (Object)null)
			{
				return;
			}
			CardCondition[] components = ((Component)card).GetComponents<CardCondition>();
			if (components == null || components.Length == 0)
			{
				return;
			}
			CardCondition[] array = components;
			foreach (CardCondition cardCondition in array)
			{
				if (!((Object)(object)cardCondition == (Object)null) && !cardCondition.IsPlayerAllowedCard(player))
				{
					__result = false;
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ApplyCardStats), "ApplyStats")]
	internal class ApplyCardStatsPatch
	{
		public static void Postfix(ApplyCardStats __instance, Player ___playerToUpgrade)
		{
			CustomStatModifers[] components = ((Component)__instance).gameObject.GetComponents<CustomStatModifers>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].Apply(___playerToUpgrade);
			}
		}
	}
	[HarmonyPatch(typeof(Block))]
	internal class BlockPatch
	{
		[HarmonyPatch("blocked")]
		[HarmonyPrefix]
		public static void BlockedPrefix(Block __instance, GameObject projectile, Vector3 forward, Vector3 hitPos)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			ProjectileHit component = projectile.GetComponent<ProjectileHit>();
			HealthHandler val = (HealthHandler)ExtensionMethods.GetFieldValue((object)__instance, "health");
			float blockPircePercent = component.ownPlayer.data.GetAdditionalData().BlockPircePercent;
			if (blockPircePercent > 0f)
			{
				Vector2 val2 = Vector2.op_Implicit((component.bulletCanDealDeamage ? component.damage : 1f) * blockPircePercent * ((Vector3)(ref forward)).normalized);
				((Damagable)val).TakeDamage(val2, Vector2.op_Implicit(hitPos), component.projectileColor, component.ownWeapon, component.ownPlayer, true, true);
				Object.Destroy((Object)(object)projectile);
			}
		}
	}
	[HarmonyPatch(typeof(CardChoice))]
	internal class CardChoicePatch
	{
		[HarmonyPatch("IDoEndPick")]
		private static void Postfix(GameObject pickedCard, int pickId)
		{
			if (!((Object)(object)ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickId) == (Object)null))
			{
				PickCardTracker.instance.AddCardPickedInPickPhase(pickedCard.GetComponent<CardInfo>());
			}
		}
	}
	[HarmonyPatch(typeof(DamageOverTime))]
	internal class DamageOverTimePatch
	{
		[HarmonyPatch("TakeDamageOverTime")]
		[HarmonyPrefix]
		public static void TakeDamageOverTimePrefix(DamageOverTime __instance, Vector2 damage, Vector2 position, float time, float interval, Color color, SoundEvent soundDamageOverTime, GameObject damagingWeapon, Player damagingPlayer, bool lethal)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
			if (!HealthHandlerPatch.TakeDamageRunning)
			{
				DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamageOvertime, val.player, damagingPlayer, damage, lethal);
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler))]
	internal class HealthHandlerPatch
	{
		public static bool TakeDamageRunning;

		[HarmonyPatch("Revive")]
		[HarmonyPostfix]
		public static void RevivePrefix(HealthHandler __instance, CharacterData ___data)
		{
			ConstantDamageHandler.Instance.RemovePlayerFromAll(___data.player);
			((MonoBehaviour)DelayDamageHandler.Instance).StopAllCoroutines();
		}

		[HarmonyPatch("TakeDamage", new Type[]
		{
			typeof(Vector2),
			typeof(Vector2),
			typeof(Color),
			typeof(GameObject),
			typeof(Player),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPrefix]
		public static void TakeDamagePrefix(HealthHandler __instance, Player damagingPlayer, Vector2 damage, bool lethal)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			TakeDamageRunning = true;
			CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
			DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamage, val.player, damagingPlayer, damage, lethal);
		}

		[HarmonyPatch("TakeDamage", new Type[]
		{
			typeof(Vector2),
			typeof(Vector2),
			typeof(Color),
			typeof(GameObject),
			typeof(Player),
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		public static void TakeDamagePostfix(HealthHandler __instance, Vector2 damage)
		{
			TakeDamageRunning = false;
		}

		[HarmonyPatch("DoDamage")]
		[HarmonyPrefix]
		public static void DoDamage(HealthHandler __instance, ref Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon, Player damagingPlayer, bool healthRemoval, bool lethal, bool ignoreBlock)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
			val.GetAdditionalData();
			Vector2 damage2 = damage;
			DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnDoDamage, val.player, damagingPlayer, damage2, lethal);
		}
	}
}
namespace AALUND13Cards.Core.MonoBehaviours
{
	public class DamageSpawnedAttack : SpawnedAttack
	{
		public Vector2 Damage;
	}
	public class DamageSpawnObjects : SpawnObjects, IOnDoDamageEvent, IOnTakeDamageEvent, IOnTakeDamageOvertimeEvent
	{
		public float DamageThreshold = 0.5f;

		public bool TriggerOnDamage;

		public bool TriggerOnTakeDamage = true;

		public bool TriggerOnOvertimeDamage = true;

		private Player player;

		public void Start()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			DamageEventHandler.Instance.RegisterDamageEvent(this, player);
		}

		public void OnDestroy()
		{
			DamageEventHandler.Instance.UnregisterDamageEvent(this, player);
		}

		public void OnDamage(DamageInfo damage)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (TriggerOnDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
			{
				SpawnDamage(damage.Damage);
			}
		}

		public void OnTakeDamage(DamageInfo damage)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (TriggerOnTakeDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
			{
				SpawnDamage(damage.Damage);
			}
		}

		public void OnTakeDamageOvertime(DamageInfo damage)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (TriggerOnOvertimeDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
			{
				SpawnDamage(damage.Damage);
			}
		}

		public void SpawnDamage(Vector2 damage)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] objectToSpawn = base.objectToSpawn;
			for (int i = 0; i < objectToSpawn.Length; i++)
			{
				DamageSpawnedAttack component = objectToSpawn[i].GetComponent<DamageSpawnedAttack>();
				if ((Object)(object)component != (Object)null)
				{
					component.Damage = damage;
				}
			}
			((SpawnObjects)this).Spawn();
		}
	}
}
namespace AALUND13Cards.Core.MonoBehaviours.CardsEffects
{
	[RequireComponent(typeof(DamageSpawnedAttack), typeof(Explosion))]
	public class SetExplosionDamageOffTakennDamage : MonoBehaviour
	{
		public float ExplosionDamageMultiplier = 1f;

		private DamageSpawnedAttack damageSpawnedAttack;

		private Explosion explosion;

		private void Awake()
		{
			damageSpawnedAttack = ((Component)this).GetComponent<DamageSpawnedAttack>();
			explosion = ((Component)this).GetComponent<Explosion>();
		}

		private void Start()
		{
			explosion.damage = ((Vector2)(ref damageSpawnedAttack.Damage)).magnitude * ExplosionDamageMultiplier;
		}
	}
}
namespace AALUND13Cards.Core.Handlers
{
	internal class ConfigHandler
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__2_0;

			internal void <RegesterMenu>b__2_0()
			{
			}
		}

		public static ConfigEntry<bool> DetailsMode;

		public static ConfigEntry<bool> DebugMode;

		public static void RegesterMenu(ConfigFile config)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			Unbound.RegisterMenu("AALUND13 Cards Core", (UnityAction)obj, (Action<GameObject>)NewGui, (GameObject)null, false);
			DebugMode = config.Bind<bool>("AALUND13 Cards Core", "DebugMode", false, "Enabled or disabled Debug Mode");
		}

		public static void addBlank(GameObject menu)
		{
			TextMeshProUGUI val = default(TextMeshProUGUI);
			MenuHandler.CreateText(" ", menu, ref val, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
		}

		public static void NewGui(GameObject menu)
		{
			MenuHandler.CreateToggle(DebugMode.Value, "<#c41010> Debug Mode", menu, (UnityAction<bool>)DebugModeChanged, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
			static void DebugModeChanged(bool val)
			{
				DebugMode.Value = val;
			}
		}
	}
	public struct ConstantDamageInfo
	{
		public Player DamagingPlayer;

		public Color Color;

		public float Damage;

		public ConstantDamageInfo(Player damagingPlayer, Color color, float damage)
		{
			//IL_0008: 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)
			DamagingPlayer = damagingPlayer;
			Color = color;
			Damage = damage;
		}

		public ConstantDamageInfo AddDamage(float damage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new ConstantDamageInfo(DamagingPlayer, Color, Damage + damage);
		}
	}
	public class ConstantDamageHandler : MonoBehaviour
	{
		public Dictionary<Player, List<ConstantDamageInfo>> playerConstantDamages = new Dictionary<Player, List<ConstantDamageInfo>>();

		public Dictionary<Player, List<ConstantDamageInfo>> PlayerConstantPrecentageDamages = new Dictionary<Player, List<ConstantDamageInfo>>();

		public static ConstantDamageHandler Instance;

		public void AddConstantDamage(Player player, Player damagingPlayer, Color color, float damage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!playerConstantDamages.ContainsKey(player))
			{
				playerConstantDamages[player] = new List<ConstantDamageInfo>();
			}
			int num = playerConstantDamages[player].FindIndex((ConstantDamageInfo info) => info.Color == color);
			if (num != -1)
			{
				playerConstantDamages[player][num] = playerConstantDamages[player][num].AddDamage(damage);
			}
			else
			{
				playerConstantDamages[player].Add(new ConstantDamageInfo(damagingPlayer, color, damage));
			}
		}

		public void AddConstantPrecentageDamage(Player player, Player damagingPlayer, Color color, float precentage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!PlayerConstantPrecentageDamages.ContainsKey(player))
			{
				PlayerConstantPrecentageDamages[player] = new List<ConstantDamageInfo>();
			}
			int num = PlayerConstantPrecentageDamages[player].FindIndex((ConstantDamageInfo info) => info.Color == color);
			if (num != -1)
			{
				PlayerConstantPrecentageDamages[player][num] = PlayerConstantPrecentageDamages[player][num].AddDamage(precentage);
			}
			else
			{
				PlayerConstantPrecentageDamages[player].Add(new ConstantDamageInfo(damagingPlayer, color, precentage));
			}
		}

		internal void RemovePlayerFromAll(Player player)
		{
			if (playerConstantDamages.ContainsKey(player))
			{
				playerConstantDamages.Remove(player);
			}
			if (PlayerConstantPrecentageDamages.ContainsKey(player))
			{
				PlayerConstantPrecentageDamages.Remove(player);
			}
		}

		private void Start()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
			DeathHandler.OnPlayerDeath += (DeathHandlerDelegate)delegate(Player player, Dictionary<Player, DamageInfo> playerDamageInfo)
			{
				if (playerConstantDamages.ContainsKey(player))
				{
					playerConstantDamages.Remove(player);
				}
				if (PlayerConstantPrecentageDamages.ContainsKey(player))
				{
					PlayerConstantPrecentageDamages.Remove(player);
				}
			};
		}

		private void Update()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Player, List<ConstantDamageInfo>> item in playerConstantDamages.ToList())
			{
				foreach (ConstantDamageInfo item2 in item.Value)
				{
					Player key = item.Key;
					float num = item2.Damage * Time.deltaTime;
					if (num > 0f)
					{
						key.data.healthHandler.DoDamage(Vector2.down * num, Vector2.zero, item2.Color, (GameObject)null, item2.DamagingPlayer, false, true, true);
					}
				}
			}
			foreach (KeyValuePair<Player, List<ConstantDamageInfo>> item3 in PlayerConstantPrecentageDamages.ToList())
			{
				foreach (ConstantDamageInfo item4 in item3.Value)
				{
					Player key2 = item3.Key;
					float num2 = item4.Damage * Time.deltaTime;
					if (num2 > 0f)
					{
						key2.data.healthHandler.DoDamage(Vector2.down * (key2.data.maxHealth * num2), Vector2.zero, item4.Color, (GameObject)null, item4.DamagingPlayer, false, true, true);
					}
				}
			}
		}
	}
	public struct DamageInfo
	{
		public Vector2 Damage;

		public bool IsLethal;

		public Player DamagingPlayer;

		public Player HurtPlayer;

		public DamageInfo(Vector2 damage, bool isLethal, Player damagingPlayer, Player hurtPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Damage = damage;
			IsLethal = isLethal;
			DamagingPlayer = damagingPlayer;
			HurtPlayer = hurtPlayer;
		}
	}
	public interface IOnDoDamageEvent
	{
		void OnDamage(DamageInfo damage);
	}
	public interface IOnTakeDamageEvent
	{
		void OnTakeDamage(DamageInfo damage);
	}
	public interface IOnTakeDamageOvertimeEvent
	{
		void OnTakeDamageOvertime(DamageInfo damage);
	}
	public class DamageEventHandler : MonoBehaviour
	{
		public enum DamageEventType
		{
			OnDoDamage,
			OnTakeDamage,
			OnTakeDamageOvertime
		}

		internal Dictionary<Player, List<IOnDoDamageEvent>> OnDoDamageEvents = new Dictionary<Player, List<IOnDoDamageEvent>>();

		internal Dictionary<Player, List<IOnTakeDamageEvent>> OnTakeDamageEvents = new Dictionary<Player, List<IOnTakeDamageEvent>>();

		internal Dictionary<Player, List<IOnTakeDamageOvertimeEvent>> OnTakeDamageOvertimeEvents = new Dictionary<Player, List<IOnTakeDamageOvertimeEvent>>();

		internal Dictionary<Player, List<IOnDoDamageEvent>> OnDoDamageEventsOtherPlayer = new Dictionary<Player, List<IOnDoDamageEvent>>();

		internal Dictionary<Player, List<IOnTakeDamageEvent>> OnTakeDamageEventsOtherPlayer = new Dictionary<Player, List<IOnTakeDamageEvent>>();

		internal Dictionary<Player, List<IOnTakeDamageOvertimeEvent>> OnTakeDamageOvertimeEventsOtherPlayer = new Dictionary<Player, List<IOnTakeDamageOvertimeEvent>>();

		public static DamageEventHandler Instance;

		public void RegisterDamageEvent(object obj, Player player)
		{
			if (obj is IOnDoDamageEvent item)
			{
				if (!OnDoDamageEvents.ContainsKey(player))
				{
					OnDoDamageEvents[player] = new List<IOnDoDamageEvent>();
				}
				OnDoDamageEvents[player].Add(item);
			}
			if (obj is IOnTakeDamageEvent item2)
			{
				if (!OnTakeDamageEvents.ContainsKey(player))
				{
					OnTakeDamageEvents[player] = new List<IOnTakeDamageEvent>();
				}
				OnTakeDamageEvents[player].Add(item2);
			}
			if (obj is IOnTakeDamageOvertimeEvent item3)
			{
				if (!OnTakeDamageOvertimeEvents.ContainsKey(player))
				{
					OnTakeDamageOvertimeEvents[player] = new List<IOnTakeDamageOvertimeEvent>();
				}
				OnTakeDamageOvertimeEvents[player].Add(item3);
			}
		}

		public void RegisterDamageEventForOtherPlayers(object obj, Player player)
		{
			if (obj is IOnDoDamageEvent item)
			{
				if (!OnDoDamageEventsOtherPlayer.ContainsKey(player))
				{
					OnDoDamageEventsOtherPlayer[player] = new List<IOnDoDamageEvent>();
				}
				OnDoDamageEventsOtherPlayer[player].Add(item);
			}
			if (obj is IOnTakeDamageEvent item2)
			{
				if (!OnTakeDamageEventsOtherPlayer.ContainsKey(player))
				{
					OnTakeDamageEventsOtherPlayer[player] = new List<IOnTakeDamageEvent>();
				}
				OnTakeDamageEventsOtherPlayer[player].Add(item2);
			}
			if (obj is IOnTakeDamageOvertimeEvent item3)
			{
				if (!OnTakeDamageOvertimeEventsOtherPlayer.ContainsKey(player))
				{
					OnTakeDamageOvertimeEventsOtherPlayer[player] = new List<IOnTakeDamageOvertimeEvent>();
				}
				OnTakeDamageOvertimeEventsOtherPlayer[player].Add(item3);
			}
		}

		public void UnregisterDamageEvent(object obj, Player player)
		{
			if (obj is IOnDoDamageEvent item && OnDoDamageEvents.ContainsKey(player))
			{
				OnDoDamageEvents[player].Remove(item);
			}
			if (obj is IOnTakeDamageEvent item2 && OnTakeDamageEvents.ContainsKey(player))
			{
				OnTakeDamageEvents[player].Remove(item2);
			}
			if (obj is IOnTakeDamageOvertimeEvent item3 && OnTakeDamageOvertimeEvents.ContainsKey(player))
			{
				OnTakeDamageOvertimeEvents[player].Remove(item3);
			}
			if (obj is IOnDoDamageEvent item4 && OnDoDamageEventsOtherPlayer.ContainsKey(player))
			{
				OnDoDamageEventsOtherPlayer[player].Remove(item4);
			}
			if (obj is IOnTakeDamageEvent item5 && OnTakeDamageEventsOtherPlayer.ContainsKey(player))
			{
				OnTakeDamageEventsOtherPlayer[player].Remove(item5);
			}
			if (obj is IOnTakeDamageOvertimeEvent item6 && OnTakeDamageOvertimeEventsOtherPlayer.ContainsKey(player))
			{
				OnTakeDamageOvertimeEventsOtherPlayer[player].Remove(item6);
			}
		}

		internal static void TriggerDamageEvent(DamageEventType eventType, Player hurtPlayer, Player damagingPlayer, Vector2 damage, bool isLethal)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damage2 = new DamageInfo(damage, isLethal, damagingPlayer, hurtPlayer);
			switch (eventType)
			{
			case DamageEventType.OnDoDamage:
				if (!Instance.OnDoDamageEvents.ContainsKey(hurtPlayer))
				{
					break;
				}
				foreach (IOnDoDamageEvent item in Instance.OnDoDamageEvents[hurtPlayer])
				{
					item.OnDamage(damage2);
				}
				break;
			case DamageEventType.OnTakeDamage:
				if (!Instance.OnTakeDamageEvents.ContainsKey(hurtPlayer))
				{
					break;
				}
				foreach (IOnTakeDamageEvent item2 in Instance.OnTakeDamageEvents[hurtPlayer])
				{
					item2.OnTakeDamage(damage2);
				}
				break;
			case DamageEventType.OnTakeDamageOvertime:
				if (!Instance.OnTakeDamageOvertimeEvents.ContainsKey(hurtPlayer))
				{
					break;
				}
				foreach (IOnTakeDamageOvertimeEvent item3 in Instance.OnTakeDamageOvertimeEvents[hurtPlayer])
				{
					item3.OnTakeDamageOvertime(damage2);
				}
				break;
			}
			foreach (KeyValuePair<Player, List<IOnDoDamageEvent>> item4 in Instance.OnDoDamageEventsOtherPlayer)
			{
				if (!((Object)(object)item4.Key != (Object)(object)hurtPlayer))
				{
					continue;
				}
				foreach (IOnDoDamageEvent item5 in item4.Value)
				{
					if (eventType == DamageEventType.OnDoDamage)
					{
						item5.OnDamage(damage2);
					}
				}
			}
			foreach (KeyValuePair<Player, List<IOnTakeDamageEvent>> item6 in Instance.OnTakeDamageEventsOtherPlayer)
			{
				if (!((Object)(object)item6.Key != (Object)(object)hurtPlayer))
				{
					continue;
				}
				foreach (IOnTakeDamageEvent item7 in item6.Value)
				{
					if (eventType == DamageEventType.OnTakeDamage)
					{
						item7.OnTakeDamage(damage2);
					}
				}
			}
			foreach (KeyValuePair<Player, List<IOnTakeDamageOvertimeEvent>> item8 in Instance.OnTakeDamageOvertimeEventsOtherPlayer)
			{
				if (!((Object)(object)item8.Key != (Object)(object)hurtPlayer))
				{
					continue;
				}
				foreach (IOnTakeDamageOvertimeEvent item9 in item8.Value)
				{
					if (eventType == DamageEventType.OnTakeDamageOvertime)
					{
						item9.OnTakeDamageOvertime(damage2);
					}
				}
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				Instance = this;
			}
		}
	}
	public struct DelayDamageInfo
	{
		public Vector2 Damage;

		public Vector2 Position;

		public Color BlinkColor;

		public GameObject DamagingWeapon;

		public Player DamagingPlayer;

		public bool HealthRemoval;

		public bool Lethal;

		public bool IngnoreBlock;

		public DelayDamageInfo(Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon = null, Player damagingPlayer = null, bool healthRemoval = false, bool lethal = true, bool ignoreBlock = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Damage = damage;
			Position = position;
			BlinkColor = blinkColor;
			DamagingWeapon = damagingWeapon;
			DamagingPlayer = damagingPlayer;
			HealthRemoval = healthRemoval;
			Lethal = lethal;
			IngnoreBlock = ignoreBlock;
		}
	}
	public class DelayDamageHandler : MonoBehaviour
	{
		public Player player;

		public static DelayDamageHandler Instance { get; private set; }

		public void Awake()
		{
			player = ((Component)this).GetComponent<Player>();
			Instance = this;
		}

		public void DelayDamage(DelayDamageInfo delayDamageInfo, float delay, Action beforeDamageCall = null, Action afterDamageCall = null)
		{
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)this, delay, (Action)delegate
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				beforeDamageCall?.Invoke();
				player.data.healthHandler.DoDamage(delayDamageInfo.Damage, delayDamageInfo.Position, delayDamageInfo.BlinkColor, delayDamageInfo.DamagingWeapon, delayDamageInfo.DamagingPlayer, delayDamageInfo.HealthRemoval, delayDamageInfo.Lethal, delayDamageInfo.IngnoreBlock);
				afterDamageCall?.Invoke();
			});
		}
	}
}
namespace AALUND13Cards.Core.Extensions
{
	public class AALUND13CardCharacterDataAdditionalData
	{
		public float BlockPircePercent;

		public CustomStatsRegistry CustomStatsRegistry = new CustomStatsRegistry();

		public void Reset()
		{
			BlockPircePercent = 0f;
			CustomStatsRegistry.ResetAll();
		}
	}
	public static class CharacterDataExtensions
	{
		public static readonly ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData> data = new ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData>();

		public static AALUND13CardCharacterDataAdditionalData GetAdditionalData(this CharacterData characterData)
		{
			return data.GetOrCreateValue(characterData);
		}

		public static CustomStatsRegistry GetCustomStatsRegistry(this CharacterData characterData)
		{
			return data.GetOrCreateValue(characterData).CustomStatsRegistry;
		}

		public static void AddData(this CharacterData characterData, AALUND13CardCharacterDataAdditionalData value)
		{
			try
			{
				data.Add(characterData, value);
			}
			catch (Exception)
			{
			}
		}
	}
	public static class PlayerExtensions
	{
		public static float GetDPS(this Player player)
		{
			float num = player.data.weaponHandler.gun.damage * player.data.weaponHandler.gun.bulletDamageMultiplier * player.data.weaponHandler.gun.projectiles[0].objectToSpawn.GetComponent<ProjectileHit>().damage * player.data.weaponHandler.gun.chargeDamageMultiplier;
			GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
			int maxAmmo = componentInChildren.maxAmmo;
			int num2 = (int)((float)player.data.weaponHandler.gun.numberOfProjectiles + player.data.weaponHandler.gun.chargeNumberOfProjectilesTo);
			int num3 = Mathf.Max(player.data.weaponHandler.gun.bursts, 1);
			float timeBetweenBullets = player.data.weaponHandler.gun.timeBetweenBullets;
			float num4 = (float)ExtensionMethods.InvokeMethod((object)componentInChildren, "ReloadTime", Array.Empty<object>());
			float num5 = Mathf.Max(player.data.weaponHandler.gun.attackSpeed, 0.01f);
			int num6 = num3 * num2;
			int num7 = Mathf.Max(maxAmmo / num6, 1);
			float num8 = (float)(num3 - 1) * timeBetweenBullets;
			float num9 = (num5 + num8) * (float)(num7 - 1) + Mathf.Max(num4, num5 + num8);
			float num10 = 1f / num9;
			return num * (float)num7 * (float)num6 * num10 / 1.33333f;
		}

		public static float GetSPS(this Player player)
		{
			GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
			int maxAmmo = componentInChildren.maxAmmo;
			int num = (int)((float)player.data.weaponHandler.gun.numberOfProjectiles + player.data.weaponHandler.gun.chargeNumberOfProjectilesTo);
			int num2 = Mathf.Max(player.data.weaponHandler.gun.bursts, 1);
			float timeBetweenBullets = player.data.weaponHandler.gun.timeBetweenBullets;
			float num3 = (float)ExtensionMethods.InvokeMethod((object)componentInChildren, "ReloadTime", Array.Empty<object>());
			float num4 = Mathf.Max(player.data.weaponHandler.gun.attackSpeed, 0.01f);
			int num5 = num2 * num;
			int num6 = Mathf.Max(maxAmmo / num5, 1);
			float num7 = (float)(num2 - 1) * timeBetweenBullets;
			float num8 = (num4 + num7) * (float)(num6 - 1) + Mathf.Max(num3, num4 + num7);
			return (float)(num6 * num) / num8;
		}
	}
}
namespace AALUND13Cards.Core.Cards
{
	public enum CardListingCategory
	{
		Standard,
		ExtraCards,
		Curses,
		Armor,
		ClassesSoulstreak,
		ClassesReaper,
		ClassesExoArmor
	}
	public class AACustomCard : CustomUnityCard, IToggleCardCategory
	{
		public string RequireMod = "";

		public bool IsCursed;

		public CardListingCategory Category;

		public override void OnRegister(CardInfo cardInfo)
		{
			if (IsCursed)
			{
				CurseManager.instance.RegisterCurse(cardInfo);
				List<CardCategory> list = new List<CardCategory>(cardInfo.categories) { CustomCardCategories.instance.CardCategory("Curse") };
				cardInfo.categories = list.ToArray();
			}
		}

		public override void OnReassignCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			CustomStatModifers[] components = ((Component)this).GetComponents<CustomStatModifers>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].OnReassign(player);
			}
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			OnAddedEffect[] components = ((Component)this).GetComponents<OnAddedEffect>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].OnAdded(player, gun, gunAmmo, data, health, gravity, block, characterStats);
			}
		}

		public override string GetModName()
		{
			return "AAC";
		}

		public ToggleCardCategoryInfo GetCardCategoryInfo()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			return new ToggleCardCategoryInfo(Category switch
			{
				CardListingCategory.ExtraCards => "Extra Cards", 
				CardListingCategory.Armor => "Armors", 
				CardListingCategory.Curses => "Curses", 
				CardListingCategory.ClassesReaper => "Classes/Reaper", 
				CardListingCategory.ClassesSoulstreak => "Classes/Soulstreak", 
				CardListingCategory.ClassesExoArmor => "Classes/Exo Armor", 
				_ => "Standard", 
			}, (int?)null);
		}
	}
	public class CardResgester : MonoBehaviour
	{
		public static List<CardInfo> AllModCards = new List<CardInfo>();

		public List<GameObject> Cards;

		private Dictionary<string, CardInfo> ModCards = new Dictionary<string, CardInfo>();

		private void SetupCard(CustomCard customCard)
		{
			if (!((Object)(object)customCard == (Object)null))
			{
				customCard.cardInfo = ((Component)customCard).GetComponent<CardInfo>();
				customCard.gun = ((Component)customCard).GetComponent<Gun>();
				customCard.cardStats = ((Component)customCard).GetComponent<ApplyCardStats>();
				customCard.statModifiers = ((Component)customCard).GetComponent<CharacterStatModifiers>();
				customCard.block = ExtensionMethods.GetOrAddComponent<Block>(((Component)customCard).gameObject, false);
				customCard.SetupCard(customCard.cardInfo, customCard.gun, customCard.cardStats, customCard.statModifiers, customCard.block);
			}
		}

		public void RegisterCards()
		{
			foreach (GameObject card in Cards)
			{
				CardInfo component = card.GetComponent<CardInfo>();
				AACustomCard customCard = card.GetComponent<AACustomCard>();
				if ((Object)(object)component == (Object)null)
				{
					Debug.LogError((object)("[AALUND13 Cards Core][Card] " + ((Object)card).name + " does not have a 'CardInfo' component"));
					continue;
				}
				if ((Object)(object)customCard == (Object)null)
				{
					Debug.LogError((object)("[AALUND13 Cards Core][Card] " + component.cardName + " does not have a 'AACustomCard' component"));
					continue;
				}
				if (!Utility.IsNullOrWhiteSpace(customCard.RequireMod) && !AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == customCard.RequireMod))
				{
					Debug.LogWarning((object)("[AALUND13 Cards Core][Card] " + component.cardName + " does not have the require mod of '" + customCard.RequireMod + "'"));
					continue;
				}
				try
				{
					SetupCard((CustomCard)(object)customCard);
				}
				catch (Exception arg)
				{
					Debug.LogError((object)string.Format("[{0}][Card] {1} failed to setup the card: {2}", "AALUND13 Cards Core", component.cardName, arg));
					continue;
				}
				((CustomCard)customCard).RegisterUnityCard((Action<CardInfo>)delegate(CardInfo registerCardInfo)
				{
					try
					{
						((CustomUnityCard)customCard).Register(registerCardInfo);
					}
					catch (Exception arg2)
					{
						Debug.LogError((object)string.Format("[{0}][Card] {1} failed to execute the 'Register' method: {2}", "AALUND13 Cards Core", registerCardInfo.cardName, arg2));
					}
				});
				Debug.Log((object)("[AALUND13 Cards Core][Card] Registered Card: " + component.cardName));
				ModCards.Add(component.cardName, component);
				AllModCards.Add(component);
			}
		}
	}
	public abstract class CustomStatModifers : MonoBehaviour
	{
		public abstract void Apply(Player player);

		public virtual void OnReassign(Player player)
		{
		}
	}
}
namespace AALUND13Cards.Core.Cards.StatModifers
{
	public class AAStatModifers : CustomStatModifers
	{
		[Header("Blocks Stats")]
		public float BlockPircePercent;

		public override void Apply(Player player)
		{
			AALUND13CardCharacterDataAdditionalData additionalData = player.data.GetAdditionalData();
			additionalData.BlockPircePercent = Mathf.Clamp(additionalData.BlockPircePercent + BlockPircePercent, 0f, 1f);
		}
	}
}
namespace AALUND13Cards.Core.Cards.Effects
{
	public abstract class OnAddedEffect : MonoBehaviour
	{
		public abstract void OnAdded(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats);
	}
}
namespace AALUND13Cards.Core.Cards.Conditions
{
	public abstract class CardCondition : MonoBehaviour
	{
		public CardInfo CardInfo => ((Component)this).GetComponent<CardInfo>();

		public abstract bool IsPlayerAllowedCard(Player player);
	}
	public class CardLimitCondition : CardCondition
	{
		public int AllowedAmount = 1;

		public override bool IsPlayerAllowedCard(Player player)
		{
			if (PlayerManager.instance.players.SelectMany((Player p) => p.data.currentCards).ToArray().Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo) >= AllowedAmount)
			{
				return false;
			}
			return true;
		}
	}
	internal class MinEnemyPlayersCondition : CardCondition
	{
		public int MinEnemyPlayers = 2;

		public override bool IsPlayerAllowedCard(Player player)
		{
			return PlayerStatus.GetEnemyPlayers(player).Count >= MinEnemyPlayers;
		}
	}
	public class MinPlayersCondition : CardCondition
	{
		public int MinPlayers = 3;

		public override bool IsPlayerAllowedCard(Player player)
		{
			return PlayerManager.instance.players.Count >= MinPlayers;
		}
	}
	public class PickPhaseLimitCondition : CardCondition
	{
		public int AllowedPickCount = 1;

		public override bool IsPlayerAllowedCard(Player player)
		{
			if (PickCardTracker.instance.CardPickedInPickPhase.Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo) >= AllowedPickCount)
			{
				return false;
			}
			return true;
		}
	}
	public class PlayerHaveRegenCondition : CardCondition
	{
		public float MinRegen;

		public override bool IsPlayerAllowedCard(Player player)
		{
			return player.data.healthHandler.regeneration >= MinRegen;
		}
	}
}