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 System.Text.RegularExpressions;
using AALUND13Card.Armors;
using AALUND13Card.Cards;
using AALUND13Card.Cards.Effects;
using AALUND13Card.Extensions;
using AALUND13Card.Handlers;
using AALUND13Card.Handlers.ExtraPickHandlers;
using AALUND13Card.MonoBehaviours;
using AALUND13Card.MonoBehaviours.Soulstreak;
using AALUND13Card.RandomStatGenerators;
using AALUND13Card.RandomStatGenerators.Generators;
using AALUND13Card.Scripts;
using AALUND13Card.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FancyCardBar;
using HarmonyLib;
using JARL;
using JARL.Armor;
using JARL.Armor.Bases;
using JARL.Armor.Utlis;
using JARL.Bases;
using JARL.Utils;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.GameModes;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.Patches;
using ModdingUtils.Utils;
using ModsPlus;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using SoundImplementation;
using TMPro;
using TabInfo.Utils;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
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 AALUND13_Card.MonoBehaviours
{
	public class CardFactoryMono : MonoBehaviour, IPickEndHookHandler
	{
		public Player Player;

		public Gun Gun;

		public GunAmmo GunAmmo;

		public CharacterData Data;

		public HealthHandler Health;

		public Gravity Gravity;

		public Block Block;

		public CharacterStatModifiers CharacterStats;

		public void Start()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			Player = ((Component)this).GetComponentInParent<Player>();
			Gun = Player.data.weaponHandler.gun;
			GunAmmo = (GunAmmo)ExtensionMethods.GetFieldValue((object)Gun, "gunAmmo");
			Data = Player.data;
			Health = Player.data.healthHandler;
			Gravity = ((Component)Player).GetComponent<Gravity>();
			Block = Player.data.block;
			CharacterStats = Player.data.stats;
			InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
		}

		public void OnDestroy()
		{
			InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
		}

		public void OnPickEnd()
		{
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			for (int i = 0; i < Player.data.GetAdditionalData().RandomCardsAtStart; i++)
			{
				if (Random.Range(0f, 1f) < 0.7f)
				{
					CardInfo val = Cards.instance.NORARITY_GetRandomCardWithCondition(Player, Gun, GunAmmo, Data, Health, Gravity, Block, CharacterStats, (Func<CardInfo, Player, Gun, GunAmmo, CharacterData, HealthHandler, Gravity, Block, CharacterStatModifiers, bool>)condition, 1000);
					Cards.instance.AddCardToPlayer(Player, val, false, "", 0f, 0f, true);
				}
				else
				{
					RandomStatManager.CreateRandomStatsCard("NegativeStatGenerator", "Defective Card", "A defective card", 1, 4, Player, "DC");
				}
			}
		}

		private bool condition(CardInfo card, Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			return true;
		}
	}
}
namespace AALUND13Card
{
	[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("com.aalund13.rounds.aalund13_cards", "AALUND13 Cards", "1.6.3")]
	[BepInProcess("Rounds.exe")]
	public class AALUND13_Cards : BaseUnityPlugin
	{
		internal const string ModInitials = "AAC";

		internal const string CurseInitials = "AAC (Curse)";

		internal const string ModId = "com.aalund13.rounds.aalund13_cards";

		internal const string ModName = "AALUND13 Cards";

		internal const string Version = "1.6.3";

		internal static List<BaseUnityPlugin> Plugins;

		internal static ManualLogSource ModLogger;

		internal static AssetBundle Assets;

		public static GameObject BlankCardPrefab;

		public static GameObject CorruptedCardFancyIconPrefab;

		public static CardResgester CardResgester;

		public static CardCategory SoulstreakClassCards;

		public static Material PixelateEffectMaterial;

		public static Material ScanEffectMaterial;

		public static AALUND13_Cards Instance { get; private set; }

		public void Awake()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			ModLogger = ((BaseUnityPlugin)this).Logger;
			ConfigHandler.RegesterMenu(((BaseUnityPlugin)this).Config);
			Assets = AssetUtils.LoadAssetBundleFromResources("aacardassets", typeof(AALUND13_Cards).Assembly);
			if ((Object)(object)Assets == (Object)null)
			{
				throw new Exception("Failed to load asset bundle");
			}
			BlankCardPrefab = Assets.LoadAsset<GameObject>("__AAC__Blank");
			CorruptedCardFancyIconPrefab = Assets.LoadAsset<GameObject>("I_Corrupted");
			PixelateEffectMaterial = Assets.LoadAsset<Material>("PixelateEffectMaterial");
			ScanEffectMaterial = Assets.LoadAsset<Material>("ScanEffectMaterial");
			NegativeStatGenerator.RegisterNegativeStatGenerators();
			CorruptedStatGenerator.RegisterCorruptedStatGenerators();
			new Harmony("com.aalund13.rounds.aalund13_cards").PatchAll();
		}

		public void Start()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			Plugins = (List<BaseUnityPlugin>)typeof(Chainloader).GetField("_plugins", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			Assets.LoadAsset<GameObject>("CorruptedCardManager").GetComponent<CorruptedCardManager>().Init();
			CardResgester = Assets.LoadAsset<GameObject>("ModCards").GetComponent<CardResgester>();
			CardResgester.RegisterCards<AALUND13_Cards>("AAC");
			DeathHandler.OnPlayerDeath += new DeathHandlerDelegate(OnPlayerDeath);
			ArmorFramework.RegisterArmorType<SoulArmor>();
			ArmorFramework.RegisterArmorType<BattleforgedArmor>();
			GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ExtraCardPickHandler.HandleExtraPicks()));
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
			GameModeManager.AddHook("PickStart", (Func<IGameModeHandler, IEnumerator>)OnPickStart);
			if (Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
			{
				TabinfoInterface.Setup();
			}
			((Component)this).gameObject.AddComponent<DelayDamageHandler>();
		}

		private IEnumerator OnGameStart(IGameModeHandler gameModeHandler)
		{
			foreach (Player player in PlayerManager.instance.players)
			{
				if (PhotonNetwork.IsMasterClient || PhotonNetwork.OfflineMode)
				{
					player.data.GetAdditionalData().Souls = 0u;
					player.data.GetAdditionalData().CorruptedCardSpawnChance = 0f;
				}
			}
			yield break;
		}

		private IEnumerator OnPickStart(IGameModeHandler gameModeHandler)
		{
			foreach (Player player in PlayerManager.instance.players)
			{
				if (PhotonNetwork.IsMasterClient || PhotonNetwork.OfflineMode)
				{
					bool flag = gameModeHandler.GetRoundWinners().Contains(player.teamID);
					if (player.data.GetAdditionalData().ExtraCardPicks > 0 && !flag)
					{
						ExtraCardPickHandler.AddExtraPick<ExtraPickHandler>(player, player.data.GetAdditionalData().ExtraCardPicks);
					}
				}
			}
			yield break;
		}

		private void OnPlayerDeath(Player player, Dictionary<Player, DamageInfo> playerDamageInfos)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Component)player).GetComponent<DelayDamageHandler>() != (Object)null)
			{
				((MonoBehaviour)((Component)player).GetComponent<DelayDamageHandler>()).StopAllCoroutines();
			}
			foreach (KeyValuePair<Player, DamageInfo> playerDamageInfo in playerDamageInfos)
			{
				if (playerDamageInfo.Value.TimeSinceLastDamage <= 5f && (Object)(object)((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>() != (Object)null && !playerDamageInfo.Key.data.dead)
				{
					((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>().AddSouls();
					if ((Object)(object)((Component)player).GetComponentInChildren<SoulstreakMono>() != (Object)null)
					{
						((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>().AddSouls((uint)((float)player.data.GetAdditionalData().Souls * 0.5f));
					}
				}
			}
			((Component)player).GetComponentInChildren<SoulstreakMono>()?.ResetSouls();
			if ((Object)(object)((Component)player).GetComponentInChildren<SoulstreakMono>() == (Object)null)
			{
				player.data.GetAdditionalData().Souls = 0u;
			}
		}
	}
	public class TabinfoInterface
	{
		public static void Setup()
		{
			StatCategory obj = TabInfoManager.RegisterCategory("AA Stats", 6);
			TabInfoManager.RegisterStat(obj, "Random Cards At Start", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().RandomCardsAtStart != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().RandomCardsAtStart}"));
			TabInfoManager.RegisterStat(obj, "Extra Card Picks", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().ExtraCardPicks != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().ExtraCardPicks}"));
			TabInfoManager.RegisterStat(obj, "Corrupted Card Spawn Chance", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().CorruptedCardSpawnChance != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().CorruptedCardSpawnChance * 100f:0}%"));
			TabInfoManager.RegisterStat(obj, "Corrupted Card Spawn Chance Per Pick", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().CorruptedCardSpawnChancePerPick != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().CorruptedCardSpawnChancePerPick * 100f:0}%"));
			TabInfoManager.RegisterStat(obj, "Delay Damage", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().secondToDealDamage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().secondToDealDamage} seconds"));
			TabInfoManager.RegisterStat(obj, "DPS", (Func<Player, bool>)((Player _) => true), (Func<Player, string>)((Player p) => $"{p.GetDPS()}"));
			StatCategory obj2 = TabInfoManager.RegisterCategory("Soulstreak Stats", 7);
			TabInfoManager.RegisterStat(obj2, "Max Health Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.MaxHealth != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.MaxHealth * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Player Size Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.PlayerSize != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.PlayerSize * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Movement Speed Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.MovementSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.MovementSpeed * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Attack Speed Pre Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.AttackSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.AttackSpeed * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Damage Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.Damage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.Damage * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Bullet Speed Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.BulletSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.BulletSpeed * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Soul Armor Percentage", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentage * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Soul Armor Percentage Regen Rate", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentageRegenRate != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentageRegenRate * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Soul Drain DPS Factor", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulDrainDPSFactor != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulDrainDPSFactor * 100f:0}%"));
			TabInfoManager.RegisterStat(obj2, "Souls", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().Souls != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().Souls}"));
		}
	}
	public static class LoggerUtils
	{
		public static bool logging = ConfigHandler.DebugMode.Value;

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

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

		public static void LogError(string message)
		{
			AALUND13_Cards.ModLogger.LogError((object)message);
		}
	}
}
namespace AALUND13Card.Utils
{
	public static class RandomSyncSeed
	{
		private static readonly Random Random = new Random();

		public static Dictionary<string, Action<SyncedRandomContext>> SyncedSeeds = new Dictionary<string, Action<SyncedRandomContext>>();

		public static void InvokeWithSeed(string target, int seed, params object[] additionalParams)
		{
			NetworkingManager.RPC(typeof(RandomSyncSeed), "RPCA_SyncSeed", new object[3] { seed, target, additionalParams });
		}

		public static void Invoke(string target, params object[] additionalParams)
		{
			NetworkingManager.RPC(typeof(RandomSyncSeed), "RPCA_SyncSeed", new object[3]
			{
				Random.Next(),
				target,
				additionalParams
			});
		}

		[UnboundRPC]
		private static void RPCA_SyncSeed(int seed, string target, object[] additionalParams)
		{
			if (SyncedSeeds.ContainsKey(target))
			{
				SyncedSeeds[target](new SyncedRandomContext(seed, additionalParams));
			}
		}

		public static void RegisterSyncedRandom(string target, Action<SyncedRandomContext> action)
		{
			SyncedSeeds.Add(target, action);
		}
	}
	public class SyncedRandomContext
	{
		public Random Random { get; private set; }

		public object[] Parameters { get; private set; }

		public SyncedRandomContext(int seed, object[] parameters)
		{
			Random = new Random(seed);
			Parameters = parameters;
		}
	}
}
namespace AALUND13Card.RandomStatGenerators
{
	public class BuildRandomStatCard : AACustomCard
	{
		public string CardName;

		public override void OnSetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
				if (componentsInChildren.Length != 0)
				{
					((TMP_Text)((Component)componentsInChildren.Where((TextMeshProUGUI obj) => ((Object)((Component)obj).gameObject).name == "Text_Name").FirstOrDefault()).GetComponent<TextMeshProUGUI>()).text = CardName;
				}
			});
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
		}
	}
	public class GlitchedCardSpawnedChanceStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Glitched Card Spawned Chance";

		public GlitchedCardSpawnedChanceStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			ExtensionMethods.GetOrAddComponent<AAStatModifers>(cardObj, false).CorruptedCardSpawnChance += value;
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public abstract class RandomStatGenerator
	{
		public abstract string StatName { get; }

		public float MinValue { get; private set; }

		public float MaxValue { get; private set; }

		public RandomStatGenerator(float minValue, float maxValue)
		{
			MinValue = minValue;
			MaxValue = maxValue;
		}

		public abstract void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block);

		public virtual string GetStatString(float value)
		{
			return GetStringValue(value * 100f);
		}

		public abstract bool IsPositive(float value);

		public virtual bool ShouldApply(float value)
		{
			return value != 0f;
		}

		protected string GetStringValue(float value, bool isPercentage = true)
		{
			return string.Format("{0}{1}{2}", (value > 0f) ? "+" : "", Mathf.Round(value), isPercentage ? "%" : "");
		}
	}
	public class DamageStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Damage";

		public DamageStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.damage += value;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class ReloadTimeStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Reload Time";

		public ReloadTimeStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.reloadTime += value;
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class AttackSpeedStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Attack Speed";

		public AttackSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.attackSpeed += value;
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class MovementSpeedStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Movement Speed";

		public MovementSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.movementSpeed += value;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class HealthStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Health";

		public HealthStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.health += value;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class BlockCooldownStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Block Cooldown";

		public BlockCooldownStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.025f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			block.cdMultiplier += value;
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class BulletSpeedStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Bullet Speed";

		public BulletSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.projectileSpeed += value;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class RegenStatGenerator : RandomStatGenerator
	{
		public float ThresholdToZero;

		public override string StatName => "Regen";

		public RegenStatGenerator(float minValue, float maxValue, float thresholdToZero = 1f)
			: base(minValue, maxValue)
		{
			ThresholdToZero = thresholdToZero;
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.Abs(value) >= ThresholdToZero;
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.regen += value;
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(value, isPercentage: false);
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class AmmoStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Ammo";

		public AmmoStatGenerator(float minValue, float maxValue)
			: base(minValue, maxValue)
		{
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.ammo += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.RoundToInt(value) != 0;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class AdditionalBlocksStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Additiona Block";

		public AdditionalBlocksStatGenerator(float minValue, float maxValue)
			: base(minValue, maxValue)
		{
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			block.additionalBlocks += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.RoundToInt(value) != 0;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class ExtraLiveStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Extra Live";

		public ExtraLiveStatGenerator(float minValue, float maxValue)
			: base(minValue, maxValue)
		{
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.respawns += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.RoundToInt(value) != 0;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public class JumpStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Jump";

		public JumpStatGenerator(float minValue, float maxValue)
			: base(minValue, maxValue)
		{
		}

		public override void Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.numberOfJumps += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldApply(float value)
		{
			return Mathf.RoundToInt(value) != 0;
		}

		public override bool IsPositive(float value)
		{
			return value > 0f;
		}
	}
	public static class RandomStatManager
	{
		public static readonly Dictionary<string, RandomStatHandler> RandomStatHandlers = new Dictionary<string, RandomStatHandler>();

		public static readonly Dictionary<string, List<CardInfo>> GeneratedCards = new Dictionary<string, List<CardInfo>>();

		public static void AddRandomStatHandler(string statGenName, List<RandomStatGenerator> statGenerators)
		{
			RandomStatHandlers.Add(statGenName, new RandomStatHandler(statGenName, statGenerators));
		}

		internal static void AddCardToGenerated(string statGenName, CardInfo cardInfo)
		{
			if (GeneratedCards.ContainsKey(statGenName))
			{
				GeneratedCards[statGenName].Add(cardInfo);
				return;
			}
			GeneratedCards.Add(statGenName, new List<CardInfo> { cardInfo });
		}

		internal static List<CardInfo> GetGeneratedCards(string statGenName)
		{
			if (GeneratedCards.ContainsKey(statGenName))
			{
				return GeneratedCards[statGenName];
			}
			return new List<CardInfo>();
		}

		public static void CreateRandomStatsCard(string statGenName, int seed, string cardName, string cardDescription, int minRandomStat, int maxRandomStat, Player player = null, string twoLetterCode = null)
		{
			RandomSyncSeed.InvokeWithSeed(statGenName, seed, cardName, cardDescription, minRandomStat, maxRandomStat, player?.playerID ?? (-1), twoLetterCode);
		}

		public static void CreateRandomStatsCard(string statGenName, string cardName, string cardDescription, int minRandomStat, int maxRandomStat, Player player = null, string twoLetterCode = null)
		{
			RandomSyncSeed.Invoke(statGenName, cardName, cardDescription, minRandomStat, maxRandomStat, player?.playerID ?? (-1), twoLetterCode);
		}
	}
	public class RandomStatHandler
	{
		public readonly string StatGenName;

		public List<RandomStatGenerator> StatGenerators { get; private set; }

		public event Action<CardInfo, Random> OnCardGenerated;

		public RandomStatHandler(string statGenName, List<RandomStatGenerator> statGenerators)
		{
			StatGenName = statGenName;
			StatGenerators = statGenerators;
			RandomStatManager.RandomStatHandlers.Add(statGenName, this);
			RandomSyncSeed.RegisterSyncedRandom(statGenName, SyncRandomSyncStats);
		}

		public CardInfoStat[] GetCardStatsFromSeed(int seed, int minRandomStat, int maxRandomStat)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			Random random = new Random(seed);
			int num = random.Next(minRandomStat, maxRandomStat);
			Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
			while (dictionary.Count < num)
			{
				int index = random.Next(StatGenerators.Count);
				if (!dictionary.ContainsKey(StatGenerators[index]))
				{
					float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
					if (StatGenerators[index].ShouldApply(value))
					{
						dictionary.Add(StatGenerators[index], value);
					}
				}
			}
			List<CardInfoStat> list = new List<CardInfoStat>();
			foreach (KeyValuePair<RandomStatGenerator, float> item in dictionary)
			{
				list.Add(new CardInfoStat
				{
					stat = item.Key.StatName,
					amount = item.Key.GetStatString(item.Value),
					positive = item.Key.IsPositive(item.Value)
				});
			}
			return list.ToArray();
		}

		public void ApplyRandomStats(CardInfo cardInfo, Random random, string cardName, int minRandomStat, int maxRandomStat)
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			int num = Mathf.Max(0, minRandomStat);
			int maxValue = Mathf.Clamp(maxRandomStat, num, StatGenerators.Count);
			((Component)cardInfo).gameObject.AddComponent<BuildRandomStatCard>().CardName = cardName;
			Gun component = ((Component)cardInfo).GetComponent<Gun>();
			CharacterStatModifiers component2 = ((Component)cardInfo).GetComponent<CharacterStatModifiers>();
			Block component3 = ((Component)cardInfo).GetComponent<Block>();
			LoggerUtils.LogInfo("Generating random stats for " + cardInfo.cardName + "...");
			int num2 = random.Next(num, maxValue);
			Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
			while (dictionary.Count < num2)
			{
				int index = random.Next(StatGenerators.Count);
				if (!dictionary.ContainsKey(StatGenerators[index]))
				{
					float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
					if (StatGenerators[index].ShouldApply(value))
					{
						dictionary.Add(StatGenerators[index], value);
					}
				}
			}
			List<CardInfoStat> list = new List<CardInfoStat>();
			foreach (KeyValuePair<RandomStatGenerator, float> item in dictionary)
			{
				item.Key.Apply(item.Value, ((Component)cardInfo).gameObject, component, component2, component3);
				list.Add(new CardInfoStat
				{
					stat = item.Key.StatName,
					amount = item.Key.GetStatString(item.Value),
					positive = item.Key.IsPositive(item.Value)
				});
			}
			cardInfo.cardStats = list.ToArray();
			LoggerUtils.LogInfo($"Generated {list.Count} stats for {cardInfo.cardName}.");
		}

		public void GenerateRandomStats(Random random, string cardName, string cardDescription, int minRandomStat, int maxRandomStat, Player player = null, string twoLetterCode = null, Action<CardInfo, Random> onCardGenerated = null)
		{
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			int num = Mathf.Max(0, minRandomStat);
			int maxValue = Mathf.Clamp(maxRandomStat, num, StatGenerators.Count);
			GameObject val = Object.Instantiate<GameObject>(AALUND13_Cards.BlankCardPrefab);
			Object.Destroy((Object)(object)((Component)val.transform.GetChild(0)).gameObject);
			Object.DontDestroyOnLoad((Object)(object)val);
			CardInfo component = val.GetComponent<CardInfo>();
			BuildRandomStatCard buildRandomStatCard = val.AddComponent<BuildRandomStatCard>();
			RandomStatManager.AddCardToGenerated(StatGenName, component);
			component.cardName = $"{StatGenName} Card ({RandomStatManager.GetGeneratedCards(StatGenName).Count})";
			component.cardDestription = cardDescription;
			buildRandomStatCard.CardName = cardName;
			((CustomUnityCard)buildRandomStatCard).IsHidden = true;
			Gun component2 = val.GetComponent<Gun>();
			CharacterStatModifiers component3 = val.GetComponent<CharacterStatModifiers>();
			Block component4 = val.GetComponent<Block>();
			LoggerUtils.LogInfo("Generating random stats for " + cardName + "...");
			int num2 = random.Next(num, maxValue);
			Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
			while (dictionary.Count < num2)
			{
				int index = random.Next(StatGenerators.Count);
				if (!dictionary.ContainsKey(StatGenerators[index]))
				{
					float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
					if (StatGenerators[index].ShouldApply(value))
					{
						dictionary.Add(StatGenerators[index], value);
					}
				}
			}
			List<CardInfoStat> list = new List<CardInfoStat>();
			foreach (KeyValuePair<RandomStatGenerator, float> item in dictionary)
			{
				item.Key.Apply(item.Value, val, component2, component3, component4);
				list.Add(new CardInfoStat
				{
					stat = item.Key.StatName,
					amount = item.Key.GetStatString(item.Value),
					positive = item.Key.IsPositive(item.Value)
				});
			}
			component.cardStats = list.ToArray();
			LoggerUtils.LogInfo($"Generated {list.Count} stats for {cardName}.");
			LoggerUtils.LogInfo("Building card...");
			((CustomCard)buildRandomStatCard).BuildUnityCard((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				((CustomUnityCard)buildRandomStatCard).Register(cardInfo);
				this.OnCardGenerated?.Invoke(cardInfo, random);
				onCardGenerated?.Invoke(cardInfo, random);
				if ((Object)(object)player != (Object)null)
				{
					ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)AALUND13_Cards.Instance, 0.2f, (Action)delegate
					{
						Cards.instance.AddCardToPlayer(player, cardInfo, false, twoLetterCode, 2f, 2f, true);
					});
				}
				LoggerUtils.LogInfo("Card built!");
			});
		}

		private void SyncRandomSyncStats(SyncedRandomContext context)
		{
			string cardName = (string)context.Parameters[0];
			string cardDescription = (string)context.Parameters[1];
			int num = Mathf.Max(0, (int)context.Parameters[2]);
			int maxRandomStat = Mathf.Clamp((int)context.Parameters[3], num, StatGenerators.Count);
			Player player = null;
			if (context.Parameters.Length > 4 && (int)context.Parameters[4] != -1)
			{
				player = PlayerManager.instance.players.Find((Player p) => p.playerID == (int)context.Parameters[4]);
			}
			string twoLetterCode = ((context.Parameters.Length > 5) ? ((string)context.Parameters[5]) : null);
			GenerateRandomStats(context.Random, cardName, cardDescription, num, maxRandomStat, player, twoLetterCode);
		}
	}
}
namespace AALUND13Card.RandomStatGenerators.Generators
{
	public static class CorruptedStatGenerator
	{
		public static List<CardInfo> CorruptedCards = new List<CardInfo>();

		public static void RegisterCorruptedStatGenerators()
		{
			new RandomStatHandler("CorruptedStatGenerator_Trinket", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.1f),
				new ReloadTimeStatGenerator(-0.1f, 0.1f),
				new AttackSpeedStatGenerator(-0.1f, 0.1f),
				new MovementSpeedStatGenerator(-0.05f, 0.05f, 0.01f),
				new HealthStatGenerator(-0.1f, 0.1f),
				new BulletSpeedStatGenerator(-0.1f, 0.1f),
				new AmmoStatGenerator(-1f, 1f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Trinket");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Common", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.3f),
				new ReloadTimeStatGenerator(-0.3f, 0.3f),
				new AttackSpeedStatGenerator(-0.3f, 0.3f),
				new MovementSpeedStatGenerator(-0.1f, 0.1f),
				new HealthStatGenerator(-0.3f, 0.3f),
				new BlockCooldownStatGenerator(-0.05f, 0.05f),
				new BulletSpeedStatGenerator(-0.3f, 0.3f),
				new AmmoStatGenerator(-2f, 2f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.05f, 0.05f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Common");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Scarce", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.4f),
				new ReloadTimeStatGenerator(-0.4f, 0.3f),
				new AttackSpeedStatGenerator(-0.4f, 0.3f),
				new MovementSpeedStatGenerator(-0.15f, 0.2f),
				new HealthStatGenerator(-0.3f, 0.4f),
				new BlockCooldownStatGenerator(-0.1f, 0.1f),
				new BulletSpeedStatGenerator(-0.3f, 0.35f),
				new AmmoStatGenerator(-2f, 3f),
				new RegenStatGenerator(0f, 10f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.075f, 0.075f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Scarce");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Uncommon", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.5f),
				new ReloadTimeStatGenerator(-0.45f, 0.3f),
				new AttackSpeedStatGenerator(-0.45f, 0.3f),
				new MovementSpeedStatGenerator(-0.15f, 0.25f),
				new HealthStatGenerator(-0.3f, 0.5f),
				new BlockCooldownStatGenerator(-0.15f, 0.15f),
				new BulletSpeedStatGenerator(-0.3f, 0.4f),
				new AmmoStatGenerator(-2f, 4f),
				new RegenStatGenerator(0f, 15f),
				new AdditionalBlocksStatGenerator(0f, 0.5882353f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.1f, 0.1f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Uncommon");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Exotic", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.6f),
				new ReloadTimeStatGenerator(-0.5f, 0.3f),
				new AttackSpeedStatGenerator(-0.5f, 0.3f),
				new MovementSpeedStatGenerator(-0.2f, 0.3f),
				new HealthStatGenerator(-0.3f, 0.6f),
				new BlockCooldownStatGenerator(-0.2f, 0.2f),
				new BulletSpeedStatGenerator(-0.3f, 0.5f),
				new AmmoStatGenerator(-3f, 5f),
				new RegenStatGenerator(0f, 20f),
				new AdditionalBlocksStatGenerator(0f, 0.625f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.15f, 0.15f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Exotic");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Rare", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.8f),
				new ReloadTimeStatGenerator(-0.6f, 0.3f),
				new AttackSpeedStatGenerator(-0.6f, 0.3f),
				new MovementSpeedStatGenerator(-0.2f, 0.35f),
				new HealthStatGenerator(-0.3f, 0.75f),
				new BlockCooldownStatGenerator(-0.25f, 0.2f),
				new BulletSpeedStatGenerator(-0.3f, 0.6f),
				new AmmoStatGenerator(-3f, 6f),
				new RegenStatGenerator(0f, 35f),
				new JumpStatGenerator(0f, 1f),
				new AdditionalBlocksStatGenerator(0f, 2f / 3f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.2f, 0.2f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Rare");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Epic", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 0.9f),
				new ReloadTimeStatGenerator(-0.7f, 0.3f),
				new AttackSpeedStatGenerator(-0.7f, 0.3f),
				new MovementSpeedStatGenerator(-0.25f, 0.4f),
				new HealthStatGenerator(-0.3f, 0.9f),
				new BlockCooldownStatGenerator(-0.3f, 0.25f),
				new BulletSpeedStatGenerator(-0.3f, 0.65f),
				new AmmoStatGenerator(-4f, 7f),
				new RegenStatGenerator(0f, 40f),
				new AdditionalBlocksStatGenerator(0f, 0.71428573f),
				new JumpStatGenerator(0f, 1.5f),
				new ExtraLiveStatGenerator(0f, 0.6896552f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.25f, 0.25f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Epic");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Legendary", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 1f),
				new ReloadTimeStatGenerator(-0.75f, 0.3f),
				new AttackSpeedStatGenerator(-0.75f, 0.3f),
				new MovementSpeedStatGenerator(-0.25f, 0.45f),
				new HealthStatGenerator(-0.3f, 1f),
				new BlockCooldownStatGenerator(-0.35f, 0.25f),
				new BulletSpeedStatGenerator(-0.3f, 0.75f),
				new AmmoStatGenerator(-4f, 8f),
				new RegenStatGenerator(0f, 50f),
				new AdditionalBlocksStatGenerator(0f, 5f / 6f),
				new JumpStatGenerator(0f, 2f),
				new ExtraLiveStatGenerator(0f, 0.7692308f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.35f, 0.35f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Legendary");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Mythical", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 1.125f),
				new ReloadTimeStatGenerator(-0.8f, 0.3f),
				new AttackSpeedStatGenerator(-0.8f, 0.3f),
				new MovementSpeedStatGenerator(-0.25f, 0.5f),
				new HealthStatGenerator(-0.3f, 1.25f),
				new BlockCooldownStatGenerator(-0.4f, 0.25f),
				new BulletSpeedStatGenerator(-0.3f, 0.8f),
				new AmmoStatGenerator(-5f, 10f),
				new RegenStatGenerator(0f, 65f),
				new AdditionalBlocksStatGenerator(0f, 1f),
				new JumpStatGenerator(0f, 2.5f),
				new ExtraLiveStatGenerator(0f, 1f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.4f, 0.4f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Mythical");
				CorruptedCards.Add(card);
			};
			new RandomStatHandler("CorruptedStatGenerator_Divine", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.3f, 1.5f),
				new ReloadTimeStatGenerator(-0.85f, 0.3f),
				new AttackSpeedStatGenerator(-0.85f, 0.3f),
				new MovementSpeedStatGenerator(-0.25f, 0.55f),
				new HealthStatGenerator(-0.3f, 1.5f),
				new BlockCooldownStatGenerator(-0.45f, 0.25f),
				new BulletSpeedStatGenerator(-0.3f, 0.85f),
				new AmmoStatGenerator(-6f, 15f),
				new RegenStatGenerator(0f, 100f),
				new AdditionalBlocksStatGenerator(0f, 1.25f),
				new JumpStatGenerator(0f, 3f),
				new ExtraLiveStatGenerator(0f, 2f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.5f, 0.5f)
			}).OnCardGenerated += delegate(CardInfo card, Random random)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				((Component)card).gameObject.AddComponent<FancyIcon>().fancyIcon = AALUND13_Cards.CorruptedCardFancyIconPrefab;
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Divine");
				CorruptedCards.Add(card);
			};
		}

		public static bool IsCorruptedCard(CardInfo card)
		{
			if ((Object)(object)card.sourceCard != (Object)null)
			{
				return CorruptedCards.Contains(card.sourceCard);
			}
			return CorruptedCards.Contains(card);
		}
	}
	internal class NegativeStatGenerator
	{
		public static void RegisterNegativeStatGenerators()
		{
			new RandomStatHandler("NegativeStatGenerator", new List<RandomStatGenerator>
			{
				new DamageStatGenerator(-0.5f, 0f),
				new ReloadTimeStatGenerator(0f, 0.5f),
				new AttackSpeedStatGenerator(0f, 0.5f),
				new MovementSpeedStatGenerator(-0.5f, 0f),
				new HealthStatGenerator(-0.5f, 0f),
				new BlockCooldownStatGenerator(0f, 0.5f),
				new BulletSpeedStatGenerator(-0.5f, 0f)
			});
		}
	}
}
namespace AALUND13Card.Patches
{
	[HarmonyPatch(typeof(Cards), "PlayerIsAllowedCard")]
	public class AllowedCardPatch
	{
		private static void Postfix(Player player, CardInfo card, ref bool __result, Cards __instance)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)card == (Object)null) && (Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(player) && ExtraCardPickHandler.extraPicks[player].Count > 0)
			{
				bool flag = ExtraCardPickHandler.extraPicks[player][0].OnExtraPickStart(player, card);
				__result &= flag;
			}
		}
	}
	[HarmonyPatch(typeof(ApplyCardStats), "ApplyStats")]
	public class ApplyCardStatsPatch
	{
		public static void Postfix(ApplyCardStats __instance, Player ___playerToUpgrade)
		{
			AAStatModifers component = ((Component)__instance).gameObject.GetComponent<AAStatModifers>();
			if ((Object)(object)component != (Object)null)
			{
				component.Apply(___playerToUpgrade);
			}
		}
	}
	[HarmonyPatch(typeof(CardChoice))]
	public class CardChoicePatch
	{
		[HarmonyPatch("IDoEndPick")]
		private static void Postfix(GameObject pickedCard, int theInt, int pickId)
		{
			Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickId);
			if (!((Object)(object)playerWithID == (Object)null) && (Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(playerWithID) && ExtraCardPickHandler.extraPicks[playerWithID].Count > 0)
			{
				ExtraCardPickHandler.extraPicks[playerWithID][0].OnExtraPick(playerWithID, pickedCard.GetComponent<CardInfo>());
			}
		}

		[HarmonyPatch("StartPick")]
		private static void Prefix(int pickerIDToSet)
		{
			Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickerIDToSet);
			playerWithID.data.GetAdditionalData().CorruptedCardSpawnChance += playerWithID.data.GetAdditionalData().CorruptedCardSpawnChancePerPick;
		}
	}
	[HarmonyPatch(typeof(CharacterStatModifiers))]
	public class CharacterStatModifiersPatch
	{
		[HarmonyPatch("ResetStats")]
		[HarmonyPrefix]
		public static void ResetStats(CharacterStatModifiers __instance)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
			val.GetAdditionalData().Reset();
			if (ExtraCardPickHandler.extraPicks.ContainsKey(val.player))
			{
				ExtraCardPickHandler.extraPicks[val.player].Clear();
			}
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null)
			{
				Effect[] components = ((Component)main).GetComponents<Effect>();
				for (int i = 0; i < components.Length; i++)
				{
					Object.Destroy((Object)(object)components[i]);
				}
			}
		}
	}
	[HarmonyPatch(typeof(HealthHandler))]
	public class HealthHandlerPatch
	{
		[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_001f: Expected O, but got Unknown
			//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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			AALUND13CardCharacterDataAdditionalData additionalData = CharacterDataExtensions.GetAdditionalData((CharacterData)Traverse.Create((object)__instance).Field("data").GetValue());
			if (additionalData.secondToDealDamage > 0f && !additionalData.dealDamage)
			{
				Vector2 damage2 = default(Vector2);
				((Vector2)(ref damage2))..ctor(damage.x, damage.y);
				ExtensionMethods.GetOrAddComponent<DelayDamageHandler>(((Component)__instance).gameObject, false).DelayDamage(damage2, position, blinkColor, damagingWeapon, damagingPlayer, healthRemoval, lethal, ignoreBlock);
				damage = Vector2.zero;
			}
			else if (additionalData.dealDamage)
			{
				additionalData.dealDamage = false;
			}
		}
	}
	[HarmonyPatch(typeof(CardChoice), "SpawnUniqueCard")]
	[HarmonyAfter(new string[] { "com.Root.Null" })]
	internal class SpawnUniqueCardPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(int ___pickrID, ref GameObject __result)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == ___pickrID);
			CardInfo component = __result.GetComponent<CardInfo>();
			if (!((Object)(object)val == (Object)null) && !((Component)component).GetComponents<MonoBehaviour>().Any((MonoBehaviour x) => ((object)x).GetType().Name == "NullCard") && Random.Range(0f, 1f) < val.data.GetAdditionalData().CorruptedCardSpawnChance)
			{
				GameObject val2 = CardChoicePatchGetRanomCard.OrignialGetRanomCard(CorruptedCardManager.Instance.CorruptedCardPrefabs);
				GameObject old = __result;
				ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Unbound.Instance, 3, (Action)delegate
				{
					PhotonNetwork.Destroy(old);
				});
				Vector2 val3 = Vector2Int.op_Implicit(val2.GetComponent<CorruptedCard>().RandomStatRange);
				__result = PhotonNetwork.Instantiate(((Object)val2).name, ((Component)__result.transform).transform.position, ((Component)__result.transform).transform.rotation, (byte)0, new object[4]
				{
					__result.transform.localScale,
					Random.Range(0, 1000000),
					((object)(CardRarity)(ref val2.GetComponent<CorruptedCard>().Rarity)).ToString(),
					val3
				});
			}
		}
	}
}
namespace AALUND13Card.MonoBehaviours
{
	[ExecuteInEditMode]
	[RequireComponent(typeof(Camera))]
	public class Effect : MonoBehaviour
	{
		public Material Material;

		private void OnRenderImage(RenderTexture src, RenderTexture dest)
		{
			if ((Object)(object)Material == (Object)null)
			{
				Graphics.Blit((Texture)(object)src, dest);
				return;
			}
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)src).width, ((Texture)src).height);
			Graphics.Blit((Texture)(object)src, temporary, Material, 0);
			Graphics.Blit((Texture)(object)temporary, dest);
			RenderTexture.ReleaseTemporary(temporary);
		}
	}
	public class GlitchingCardEffect : MonoBehaviour
	{
		private void Start()
		{
			if (((Component)this).gameObject.transform.childCount == 0)
			{
				return;
			}
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
			{
				GlitchingTextMono orAddComponent = ExtensionMethods.GetOrAddComponent<GlitchingTextMono>(((Component)this).gameObject, false);
				orAddComponent.EffectAllText = false;
				TextMeshProUGUI[] componentsInChildren = ((Component)((Component)this).gameObject.transform.GetChild(0).Find("Canvas/Front/Grid")).GetComponentsInChildren<TextMeshProUGUI>();
				foreach (TextMeshProUGUI textMesh in componentsInChildren)
				{
					orAddComponent.AddTextMesh(textMesh);
				}
				TextMeshProUGUI component = ((Component)((Component)this).gameObject.transform.GetChild(0).Find("Canvas/Front/Text_Name")).GetComponent<TextMeshProUGUI>();
				orAddComponent.AddTextMesh(component);
			});
		}
	}
	public class GlitchingTextMono : MonoBehaviour
	{
		public static Regex regex = new Regex("<glitch>(.*?)(<\\/glitch>|$)", RegexOptions.Compiled);

		public bool UseGlitchTag;

		public bool EffectAllText = true;

		private const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()_+-=<>?:\"{}|,./;'[]\\'~";

		private List<(TextMeshProUGUI, string)> textMeshes = new List<(TextMeshProUGUI, string)>();

		private List<char> characters = new List<char>();

		private void Start()
		{
			characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()_+-=<>?:\"{}|,./;'[]\\'~".ToList();
			if (EffectAllText)
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
				textMeshes.AddRange(componentsInChildren.Select((TextMeshProUGUI obj) => (obj, ((TMP_Text)obj).text)));
			}
		}

		public void AddTextMesh(TextMeshProUGUI textMesh)
		{
			textMeshes.Add((textMesh, ((TMP_Text)textMesh).text));
		}

		private void Update()
		{
			if (textMeshes.Count == 0)
			{
				return;
			}
			foreach (var (val, originalText) in textMeshes)
			{
				if (UseGlitchTag)
				{
					string text = ProcessTextWithGlitchTag(originalText);
					((TMP_Text)val).text = text;
				}
				else
				{
					GlitchCharacters(val, originalText);
				}
			}
		}

		private void GlitchCharacters(TextMeshProUGUI textMesh, string originalText)
		{
			((TMP_Text)textMesh).text = "<mspace=0.5em>";
			for (int i = 0; i < originalText.Length; i++)
			{
				((TMP_Text)textMesh).text = ((TMP_Text)textMesh).text + characters[Random.Range(0, characters.Count)];
			}
		}

		private string ProcessTextWithGlitchTag(string originalText)
		{
			return regex.Replace(originalText, delegate(Match match)
			{
				string value = match.Groups[1].Value;
				string text = GenerateGlitchedText(value.Length);
				return "<mspace=0.5em>" + text + "</mspace>";
			});
		}

		private string GenerateGlitchedText(int length)
		{
			char[] array = new char[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = characters[Random.Range(0, characters.Count)];
			}
			return new string(array);
		}
	}
	public class SoulstreakDrain : MonoBehaviour
	{
		[Header("Sounds")]
		public SoundEvent SoundDamage;

		private SoulStreakStats soulstreakStats;

		private PlayerInRangeTrigger playerInRangeTrigger;

		private Player player;

		public void Start()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			soulstreakStats = player.data.GetAdditionalData().SoulStreakStats;
			SoundDamage.variables.audioMixerGroup = SoundVolumeManager.Instance.audioMixer.FindMatchingGroups("SFX")[0];
			playerInRangeTrigger = ((Component)this).GetComponent<PlayerInRangeTrigger>();
		}

		public void TriggerDamage()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (soulstreakStats != null)
			{
				Player closestEnemy = GetClosestEnemy();
				if (!((Object)(object)closestEnemy == (Object)null))
				{
					float dPS = player.GetDPS();
					float num = dPS * soulstreakStats.SoulDrainDPSFactor * playerInRangeTrigger.cooldown;
					float num2 = Mathf.Min(num, closestEnemy.data.health);
					float num3 = Mathf.Max(0f, num2 * soulstreakStats.SoulDrainLifestealMultiply);
					((Damagable)closestEnemy.data.healthHandler).TakeDamage(num * Vector2.up, Vector2.op_Implicit(((Component)this).transform.position), (GameObject)null, player, true, true);
					player.data.healthHandler.Heal(num3);
					SoundManager.Instance.Play(SoundDamage, ((Component)closestEnemy).transform);
					LoggerUtils.LogInfo($"DPS: {dPS}, Damage: {num}, Lifesteal: {num3}");
				}
			}
		}

		private Player GetClosestEnemy()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Player result = null;
			float num = float.MaxValue;
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player != (Object)(object)this.player && player.data.isPlaying)
				{
					float num2 = Vector2.Distance(Vector2.op_Implicit(((Component)this.player).transform.position), Vector2.op_Implicit(((Component)player).transform.position));
					if (num2 < num)
					{
						num = num2;
						result = player;
					}
				}
			}
			return result;
		}
	}
	[Flags]
	public enum AbilityType
	{
		Armor = 1
	}
	[Serializable]
	public class SoulStreakStats
	{
		public float MaxHealth = 1f;

		public float PlayerSize = 1f;

		public float MovementSpeed = 1f;

		public float AttackSpeed = 1f;

		public float Damage = 1f;

		public float BulletSpeed = 1f;

		public float SoulArmorPercentage;

		public float SoulArmorPercentageRegenRate;

		public float SoulDrainDPSFactor;

		public float SoulDrainLifestealMultiply;

		public AbilityType AbilityType;
	}
	public class SoulstreakMono : MonoBehaviour, IBattleStartHookHandler, IPointEndHookHandler
	{
		private Player player;

		private ArmorHandler armorHandler;

		public bool CanResetKills = true;

		public bool AbilityActive;

		public float AbilityCooldown;

		public GameObject SoulsCounter;

		public GameObject SoulsCounterGUI;

		private SoulStreakStats SoulstreakStats => player.data.GetAdditionalData().SoulStreakStats;

		private string SoulsString => string.Format("{0}: {1}", (Souls > 1) ? "Souls" : "Soul", Souls);

		private uint Souls
		{
			get
			{
				return player.data.GetAdditionalData().Souls;
			}
			set
			{
				player.data.GetAdditionalData().Souls = value;
			}
		}

		private void Start()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			player = ((Component)((Component)this).gameObject.transform.parent).GetComponent<Player>();
			armorHandler = ((Component)player).GetComponent<ArmorHandler>();
			SoulsCounter = Object.Instantiate<GameObject>(SoulsCounter);
			if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
			{
				SoulsCounterGUI = Object.Instantiate<GameObject>(SoulsCounterGUI);
				SoulsCounterGUI.transform.SetParent(((Component)player).transform.parent);
			}
			player.data.SetWobbleObjectChild(SoulsCounter.transform);
			SoulsCounter.transform.localPosition = Vector2.op_Implicit(new Vector2(0f, 0.3f));
			InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
		}

		private void OnDestroy()
		{
			if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
			{
				Object.Destroy((Object)(object)SoulsCounterGUI);
			}
			Object.Destroy((Object)(object)SoulsCounter);
			if ((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>() != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>());
			}
			InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
		}

		private void Update()
		{
			if (player.data.isPlaying)
			{
				AbilityCooldown = Mathf.Max(AbilityCooldown - Time.deltaTime, 0f);
				if (armorHandler.GetArmorByType<SoulArmor>().CurrentArmorValue <= 0f && armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue > 0f)
				{
					armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue = 0f;
					AbilityCooldown = 10f;
					AbilityActive = false;
				}
			}
			((TMP_Text)SoulsCounter.GetComponent<TextMeshPro>()).text = SoulsString;
			if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
			{
				((TMP_Text)SoulsCounterGUI.GetComponentInChildren<TextMeshProUGUI>()).text = SoulsString;
			}
		}

		public void BlockAbility()
		{
			if (SoulstreakStats.AbilityType == AbilityType.Armor && !AbilityActive && AbilityCooldown == 0f)
			{
				ArmorBase armorByType = armorHandler.GetArmorByType<SoulArmor>();
				armorByType.MaxArmorValue = player.data.maxHealth * SoulstreakStats.SoulArmorPercentage * (float)(Souls + 1);
				armorByType.ArmorRegenerationRate = armorByType.MaxArmorValue * SoulstreakStats.SoulArmorPercentageRegenRate;
				armorByType.CurrentArmorValue = armorByType.MaxArmorValue;
				AbilityActive = true;
			}
		}

		public void ResetSouls()
		{
			if (CanResetKills)
			{
				LoggerUtils.LogInfo($"Resetting kill streak of player with ID {player.playerID}");
				if ((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>() != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>());
				}
				Souls = 0u;
				if (player.data.view.IsMine)
				{
					((TMP_Text)SoulsCounterGUI.GetComponentInChildren<TextMeshProUGUI>()).text = SoulsString;
				}
			}
		}

		public void AddSouls(uint kills = 1u)
		{
			if (CanResetKills)
			{
				LoggerUtils.LogInfo($"Adding {kills} kills for player with ID {player.playerID}");
				Souls += kills;
				ExtensionMethods.GetOrAddComponent<SoulstreakEffect>(((Component)player).gameObject, false).ApplyStats();
			}
		}

		public void OnBattleStart()
		{
			CanResetKills = true;
			ExtensionMethods.GetOrAddComponent<SoulstreakEffect>(((Component)player).gameObject, false).ApplyStats();
		}

		public void OnPointEnd()
		{
			CanResetKills = false;
			armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue = 0f;
		}
	}
}
namespace AALUND13Card.MonoBehaviours.Soulstreak
{
	public class SoulstreakEffect : ReversibleEffect, IPickStartHookHandler, IGameStartHookHandler
	{
		public override void OnStart()
		{
			InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
			((ReversibleEffect)this).SetLivesToEffect(int.MaxValue);
			base.applyImmediately = false;
			ApplyStats();
		}

		public void ApplyStats()
		{
			SoulStreakStats soulStreakStats = base.data.GetAdditionalData().SoulStreakStats;
			uint souls = base.data.GetAdditionalData().Souls;
			((ReversibleEffect)this).ClearModifiers(true);
			base.characterDataModifier.maxHealth_mult = 1f + (soulStreakStats.MaxHealth - 1f) * (float)souls;
			base.characterStatModifiersModifier.sizeMultiplier_mult = 1f + (soulStreakStats.PlayerSize - 1f) * (float)souls;
			base.characterStatModifiersModifier.movementSpeed_mult = 1f + (soulStreakStats.MovementSpeed - 1f) * (float)souls;
			base.gunStatModifier.attackSpeed_mult = 1f + (soulStreakStats.AttackSpeed - 1f) * (float)souls;
			base.gunStatModifier.damage_mult = 1f + (soulStreakStats.Damage - 1f) * (float)souls;
			base.gunStatModifier.projectileSpeed_mult = 1f + (soulStreakStats.BulletSpeed - 1f) * (float)souls;
			((ReversibleEffect)this).ApplyModifiers();
		}

		public void OnGameStart()
		{
			Object.Destroy((Object)(object)this);
		}

		public void OnPickStart()
		{
			Object.Destroy((Object)(object)this);
		}

		public override void OnOnDestroy()
		{
			InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
		}
	}
}
namespace AALUND13Card.MonoBehaviours.CardbarsScripts
{
	public class EnableTextFromCardbar : MonoBehaviour
	{
		public TextMeshProUGUI text;

		private void OnEnable()
		{
			text = ((Component)((Component)this).transform.parent).GetComponentInChildren<TextMeshProUGUI>();
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
			{
				((Behaviour)text).enabled = true;
			});
		}
	}
	[RequireComponent(typeof(EnableTextFromCardbar))]
	public class GlitchedTextCardbar : MonoBehaviour
	{
		public void Start()
		{
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
			{
				((Component)((Component)this).GetComponent<EnableTextFromCardbar>().text).gameObject.AddComponent<GlitchingTextMono>();
			});
		}
	}
}
namespace AALUND13Card.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", (UnityAction)obj, (Action<GameObject>)NewGui, (GameObject)null, false);
			DebugMode = config.Bind<bool>("AALUND13 Cards", "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 class DelayDamageHandler : MonoBehaviour, IBattleStartHookHandler
	{
		public Player player;

		public void Awake()
		{
			player = ((Component)this).GetComponent<Player>();
			InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
		}

		public void DelayDamage(Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon, Player damagingPlayer, bool healthRemoval, bool lethal, bool ignoreBlock)
		{
			//IL_000e: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)this, player.data.GetAdditionalData().secondToDealDamage, (Action)delegate
			{
				//IL_0031: 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_003d: Unknown result type (might be due to invalid IL or missing references)
				player.data.GetAdditionalData().dealDamage = true;
				player.data.healthHandler.DoDamage(damage, position, blinkColor, damagingWeapon, damagingPlayer, healthRemoval, lethal, ignoreBlock);
			});
		}

		public void OnDestroy()
		{
			InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
		}

		public void OnBattleStart()
		{
			((MonoBehaviour)this).StopAllCoroutines();
		}
	}
	public class ExtraPickHandler
	{
		public virtual bool OnExtraPickStart(Player player, CardInfo card)
		{
			return true;
		}

		public virtual void OnExtraPick(Player player, CardInfo card)
		{
		}
	}
	public static class ExtraCardPickHandler
	{
		internal static Dictionary<Player, List<ExtraPickHandler>> extraPicks = new Dictionary<Player, List<ExtraPickHandler>>();

		public static Player currentPlayer;

		public static void AddExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks)
		{
			NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[3]
			{
				player.playerID,
				extraPickHandler.GetType().AssemblyQualifiedName,
				picks
			});
		}

		public static void AddExtraPick<T>(Player player, int picks) where T : ExtraPickHandler
		{
			NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[3]
			{
				player.playerID,
				typeof(T).AssemblyQualifiedName,
				picks
			});
		}

		public static void RemoveExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks)
		{
			NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_RemoveExtraPick", new object[3]
			{
				player.playerID,
				extraPickHandler.GetType().AssemblyQualifiedName,
				picks
			});
		}

		public static void RemoveExtraPick<T>(Player player, int picks) where T : ExtraPickHandler
		{
			NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_RemoveExtraPick", new object[3]
			{
				player.playerID,
				typeof(T).AssemblyQualifiedName,
				picks
			});
		}

		[UnboundRPC]
		private static void RPCA_AddExtraPick(int playerId, string handlerType, int picks)
		{
			Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerId);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Type type = Type.GetType(handlerType);
			if (!(type == null))
			{
				ExtraPickHandler item = (ExtraPickHandler)Activator.CreateInstance(type);
				if (!extraPicks.ContainsKey(val))
				{
					extraPicks.Add(val, new List<ExtraPickHandler>());
				}
				for (int i = 0; i < picks; i++)
				{
					extraPicks[val].Add(item);
				}
			}
		}

		[UnboundRPC]
		public static void RPCA_RemoveExtraPick(int playerId, string handlerType, int picks)
		{
			Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerId);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Type type = Type.GetType(handlerType);
			if (type == null)
			{
				return;
			}
			ExtraPickHandler item = (ExtraPickHandler)Activator.CreateInstance(type);
			if (extraPicks.ContainsKey(val))
			{
				for (int i = 0; i < picks; i++)
				{
					extraPicks[val].Remove(item);
				}
			}
		}

		internal static IEnumerator HandleExtraPicks()
		{
			Player[] array = PlayerManager.instance.players.ToArray();
			foreach (Player val in array)
			{
				if (extraPicks.ContainsKey(val) && extraPicks[val].Count > 0)
				{
					yield return HandleExtraPickForPlayer(val);
				}
			}
			currentPlayer = null;
		}

		private static IEnumerator HandleExtraPickForPlayer(Player player)
		{
			currentPlayer = player;
			yield return GameModeManager.TriggerHook("PlayerPickStart");
			CardChoiceVisuals.instance.Show((from i in Enumerable.Range(0, PlayerManager.instance.players.Count)
				where PlayerManager.instance.players[i].playerID == player.playerID
				select i).First(), true);
			yield return CardChoice.instance.DoPick(1, player.playerID, (PickerType)1);
			yield return (object)new WaitForSecondsRealtime(0.1f);
			if (extraPicks.ContainsKey(player) && extraPicks[player].Count > 0)
			{
				extraPicks[player].RemoveAt(0);
			}
			yield return GameModeManager.TriggerHook("PlayerPickEnd");
		}
	}
}
namespace AALUND13Card.Handlers.ExtraPickHandlers
{
	public class SteelPickHandler : ExtraPickHandler
	{
		public override bool OnExtraPickStart(Player player, CardInfo card)
		{
			List<CardInfo> list = new List<CardInfo>();
			foreach (Player enemyPlayer in PlayerStatus.GetEnemyPlayers(player))
			{
				if ((Object)(object)enemyPlayer != (Object)(object)player)
				{
					list.AddRange(enemyPlayer.data.currentCards);
				}
			}
			return list.Contains(card);
		}

		public override void OnExtraPick(Player player, CardInfo card)
		{
			if (!PhotonNetwork.OfflineMode && !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			List<Player> list = new List<Player>();
			foreach (Player enemyPlayer in PlayerStatus.GetEnemyPlayers(player))
			{
				if (enemyPlayer.data.currentCards.Contains(CardChoice.instance.GetSourceCard(card)))
				{
					list.Add(enemyPlayer);
				}
			}
			if (list.Count != 0)
			{
				Player random = ExtensionMethods.GetRandom<Player>((IList)list);
				Cards.instance.RemoveCardFromPlayer(random, CardChoice.instance.GetSourceCard(card), (SelectionType)2);
			}
		}
	}
}
namespace AALUND13Card.Extensions
{
	public class AALUND13CardCharacterDataAdditionalData
	{
		public float secondToDealDamage;

		public bool dealDamage = true;

		public SoulStreakStats SoulStreakStats = new SoulStreakStats();

		public uint Souls;

		public int RandomCardsAtStart;

		public int ExtraCardPicks;

		public float CorruptedCardSpawnChance;

		public float CorruptedCardSpawnChancePerPick;

		public void Reset()
		{
			secondToDealDamage = 0f;
			dealDamage = true;
			SoulStreakStats = new SoulStreakStats();
			RandomCardsAtStart = 0;
			ExtraCardPicks = 0;
			CorruptedCardSpawnChancePerPick = 0f;
		}
	}
	public static class CharacterDataExtensions
	{
		public static readonly ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData> data = new ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData>();

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

		public static void AddData(this CharacterData block, AALUND13CardCharacterDataAdditionalData value)
		{
			try
			{
				data.Add(block, 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;
			GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
			int maxAmmo = componentInChildren.maxAmmo;
			int numberOfProjectiles = player.data.weaponHandler.gun.numberOfProjectiles;
			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 * numberOfProjectiles;
			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);
			float num9 = 1f / num8;
			return num * (float)num6 * (float)num5 * num9 / 1.33333f;
		}
	}
	public static class RandomExtension
	{
		public static float NextFloat(this Random random, float minValue, float maxValue)
		{
			return (float)random.NextDouble() * (maxValue - minValue) + minValue;
		}
	}
}
namespace AALUND13Card.Scripts
{
	public class CorruptedCardManager : MonoBehaviour
	{
		public CardInfo[] CorruptedCardPrefabs;

		public static CorruptedCardManager Instance;

		internal void Init()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			CardInfo[] corruptedCardPrefabs = CorruptedCardPrefabs;
			foreach (CardInfo val in corruptedCardPrefabs)
			{
				val.rarity = RarityUtils.GetRarity(((object)(CardRarity)(ref ((Component)val).GetComponent<CorruptedCard>().Rarity)).ToString());
				PhotonNetwork.PrefabPool.RegisterPrefab(((Object)val).name, ((Component)val).gameObject);
			}
		}

		public void GiveCorruptedCard(Player player, string rarity)
		{
			string text = "CorruptedStatGenerator_" + rarity;
			if (!RandomStatManager.RandomStatHandlers.ContainsKey(text))
			{
				throw new ArgumentException("Stat generator for rarity " + rarity + " not found");
			}
			RandomStatManager.CreateRandomStatsCard(text, "Corrupted Card", "A random description", 1, 3, player);
		}
	}
}
namespace AALUND13Card.Cards
{
	public class AACustomCard : CustomUnityCard
	{
		public override void OnSetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			LoggerUtils.LogInfo("[" + ((CustomCard)this).GetModName() + "][Card] " + ((CustomCard)this).GetTitle() + " has been setup.");
		}

		public override void OnReassignCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			AAStatModifers component = ((Component)this).GetComponent<AAStatModifers>();
			if ((Object)(object)component != (Object)null)
			{
				component.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 enum ExtraPicksType
	{
		None,
		Normal,
		Steel
	}
	public class AAStatModifers : MonoBehaviour
	{
		[Header("Soulstreak Stats")]
		public float MaxHealth;

		public float PlayerSize;

		public float MovementSpeed;

		public float AttackSpeed;

		public float Damage;

		public float BulletSpeed;

		public float SoulArmorPercentage;

		public float SoulArmorPercentageRegenRate;

		public float SoulDrainDamageMultiply;

		public float SoulDrainLifestealMultiply;

		public AbilityType AbilityType;

		[Header("Uncategorized Stats")]
		public float SecondToDealDamage;

		[Header("Armors Stats")]
		public float BattleforgedArmor;

		[Header("Extra Picks")]
		public int ExtraPicks;

		public ExtraPicksType ExtraPicksType;

		[Header("Extra Cards")]
		public int RandomCardsAtStart;

		public int ExtraCardPicks;

		[Header("Corrupted Cards")]
		public float CorruptedCardSpawnChance;

		public float CorruptedCardSpawnChancePerPick;

		public void Apply(Player player)
		{
			AALUND13CardCharacterDataAdditionalData additionalData = player.data.GetAdditionalData();
			additionalData.SoulStreakStats.MaxHealth += MaxHealth;
			additionalData.SoulStreakStats.PlayerSize += PlayerSize;
			additionalData.SoulStreakStats.MovementSpeed += MovementSpeed;
			additionalData.SoulStreakStats.AttackSpeed += AttackSpeed;
			additionalData.SoulStreakStats.Damage += Damage;
			additionalData.SoulStreakStats.BulletSpeed += BulletSpeed;
			additionalData.SoulStreakStats.SoulArmorPercentage += SoulArmorPercentage;
			additionalData.SoulStreakStats.SoulArmorPercentageRegenRate += SoulArmorPercentageRegenRate;
			additionalData.SoulStreakStats.SoulDrainDPSFactor += SoulDrainDamageMultiply;
			additionalData.SoulStreakStats.SoulDrainLifestealMultiply += SoulDrainLifestealMultiply;
			additionalData.SoulStreakStats.AbilityType |= AbilityType;
			if (SecondToDealDamage > 0f)
			{
				additionalData.dealDamage = false;
			}
			additionalData.secondToDealDamage += SecondToDealDamage;
			additionalData.RandomCardsAtStart += RandomCardsAtStart;
			additionalData.ExtraCardPicks += ExtraCardPicks;
			additionalData.CorruptedCardSpawnChance = Mathf.Max(additionalData.CorruptedCardSpawnChance + CorruptedCardSpawnChance, 0f);
			additionalData.CorruptedCardSpawnChancePerPick += CorruptedCardSpawnChancePerPick;
			if (BattleforgedArmor > 0f)
			{
				ArmorFramework.ArmorHandlers[player].AddArmor<BattleforgedArmor>(BattleforgedArmor, 0f, 0f, (ArmorReactivateType)0, 0.5f);
			}
			ExtraPickHandler extraPickHandler = GetExtraPickHandler(ExtraPicksType);
			if (extraPickHandler != null && ExtraPicks > 0 && player.data.view.IsMine)
			{
				ExtraCardPickHandler.AddExtraPick(extraPickHandler, player, ExtraPicks);
			}
		}

		public void OnReassign(Player player)
		{
			AALUND13CardCharacterDataAdditionalData additionalData = player.data.GetAdditionalData();
			additionalData.CorruptedCardSpawnChancePerPick += CorruptedCardSpawnChancePerPick;
			additionalData.ExtraCardPicks += ExtraCardPicks;
		}

		public ExtraPickHandler GetExtraPickHandler(ExtraPicksType type)
		{
			return type switch
			{
				ExtraPicksType.Normal => new ExtraPickHandler(), 
				ExtraPicksType.Steel => new SteelPickHandler(), 
				_ => null, 
			};
		}
	}
	public class CorruptedCard : MonoBehaviour, IPunInstantiateMagicCallback
	{
		public CardRarity Rarity;

		public Vector2Int RandomStatRange;

		public void OnPhotonInstantiate(PhotonMessageInfo info)
		{
			//IL_0000: 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_0018: 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_0033: 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_003f: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			object[] instantiationData = info.photonView.InstantiationData;
			if (instantiationData != null)
			{
				Vector3 localScale = (Vector3)instantiationData[0];
				int num = (int)instantiationData[1];
				string text = (string)instantiationData[2];
				Vector2 val = (Vector2)instantiationData[3];
				Vector2Int randomStatRange = default(Vector2Int);
				((Vector2Int)(ref randomStatRange))..ctor((int)val.x, (int)val.y);
				((Component)this).gameObject.transform.localScale = localScale;
				string text2 = "CorruptedStatGenerator_" + text;
				LoggerUtils.LogInfo($"Generating card with seed {num} and rarity {text} using stat generator {text2}");
				RandomStatHandler randomStatHandler = RandomStatManager.RandomStatHandlers[text2];
				GenerateCard(randomStatHandler, num, randomStatRange);
			}
		}

		private void GenerateCard(RandomStatHandler randomStatHandler, int seed, Vector2Int randomStatRange)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			CardInfo cardInfo = ((Component)this).GetComponent<CardInfo>();
			Random random = new Random(seed);
			randomStatHandler.GenerateRandomStats(random, "Corrupted Card", "A random description", ((Vector2Int)(ref randomStatRange)).x, ((Vector2Int)(ref randomStatRange)).y, null, null, delegate(CardInfo card, Random outputRandom)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				LoggerUtils.LogInfo($"Generated card with seed {seed} and rarity {Rarity} using stat generator {randomStatHandler.StatGenName}");
				CardInfoStat[] cardStats = card.cardStats;
				randomStatHandler.ApplyRandomStats(cardInfo, new Random(seed), "Corrupted Card", ((Vector2Int)(ref randomStatRange)).x, ((Vector2Int)(ref randomStatRange)).y);
				LoggerUtils.LogInfo($"Applied stats to card with seed {seed} and rarity {Rarity} using stat generator {randomStatHandler.StatGenName}");
				cardInfo.sourceCard = card;
				cardInfo.cardStats = cardStats;
				((Component)cardInfo).gameObject.AddComponent<GlitchingCardEffect>();
				((Component)cardInfo).GetComponentInChildren<CardInfoDisplayer>().DrawCard(cardStats, "Corrupted Card", "A random description", (Sprite)null, false);
				LoggerUtils.LogInfo($"Displayed card with seed {seed} and rarity {Rarity} using stat generator {randomStatHandler.StatGenName}");
			});
		}
	}
	public class CursesEffectCard : AACustomCard
	{
		public List<Material> PostProcessingEffects = new List<Material>();

		public override void OnRegister(CardInfo cardInfo)
		{
			CurseManager.instance.RegisterCurse(cardInfo);
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!player.data.view.IsMine)
			{
				return;
			}
			Camera main = Camera.main;
			if (!((Object)(object)main != (Object)null))
			{
				return;
			}
			foreach (Material postProcessingEffect in PostProcessingEffects)
			{
				((Component)main).gameObject.AddComponent<Effect>().Material = postProcessingEffect;
			}
		}

		public override string GetModName()
		{
			return "AAC (Curse)";
		}
	}
}
namespace AALUND13Card.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);
	}
	public class PickCardFromListEffect : OnAddedEffect
	{
		public List<GameObject> randomCardsToChoseFrom = new List<GameObject>();

		public int cardCount = 1;

		public override void OnAdded(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!PhotonNetwork.OfflineMode && !PhotonNetwork.IsMasterClient)
			{
				return;
			}
			for (int i = 0; i < cardCount; i++)
			{
				if (randomCardsToChoseFrom.Count == 0)
				{
					LoggerUtils.LogWarn("No cards to choose from. Please add cards to the list.");
					break;
				}
				CardInfo component = ExtensionMethods.GetRandom<GameObject>((IList)randomCardsToChoseFrom).GetComponent<CardInfo>();
				Cards.instance.AddCardToPlayer(player, component, true, "", 2f, 2f, true);
				CardBarUtils.instance.ShowAtEndOfPhase(player, component);
			}
		}
	}
}
namespace AALUND13Card.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 override void OnRegister()
		{
			base.ArmorTags.Add("CanArmorPierce");
			base.ArmorRegenCooldownSeconds = 5f;
		}
	}
	public class SoulArmor : 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.magenta * 0.6f, Color.magenta * 0.45f);
		}

		public override void OnRespawn()
		{
			SoulstreakMono componentInChildren = ((Component)((ArmorBase)this).ArmorHandler).GetComponentInChildren<SoulstreakMono>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				base.MaxArmorValue = 0f;
				base.CurrentArmorValue = 0f;
				componentInChildren.AbilityCooldown = 0f;
				componentInChildren.AbilityActive = false;
			}
		}

		public override void OnRegister()
		{
			base.ArmorRegenCooldownSeconds = 5f;
		}
	}
}