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.Text.RegularExpressions;
using AALUND13Card.Armors;
using AALUND13Card.Cards;
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.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
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 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.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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++)
			{
				float num = Random.Range(0f, 1f);
				if (num < 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.*/)]
	[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 CardCategory SoulstreakClassCards;

		public static Material PixelateEffectMaterial;

		public static Material ScanEffectMaterial;

		public static AALUND13_Cards Instance { get; private set; }

		public void Awake()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			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");
			PixelateEffectMaterial = Assets.LoadAsset<Material>("PixelateEffectMaterial");
			ScanEffectMaterial = Assets.LoadAsset<Material>("ScanEffectMaterial");
			NegativeStatGenerator.RegisterNegativeStatGenerators();
			CorruptedStatGenerator.RegisterCorruptedStatGenerators();
			Harmony val = new Harmony("com.aalund13.rounds.aalund13_cards");
			val.PatchAll();
		}

		public void Start()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			Plugins = (List<BaseUnityPlugin>)typeof(Chainloader).GetField("_plugins", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			Assets.LoadAsset<GameObject>("ModCards").GetComponent<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();
			}
			CorruptedStatGenerator.BuildGlitchedCard();
			((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 isWinner = gameModeHandler.GetRoundWinners().Contains(player.teamID);
					if (player.data.GetAdditionalData().ExtraCardPicks > 0 && !isWinner)
					{
						ExtraCardPickHandler.AddExtraPick<ExtraPickHandler>(player, player.data.GetAdditionalData().ExtraCardPicks);
					}
				}
			}
			yield break;
		}

		private void OnPlayerDeath(Player player, Dictionary<Player, DamageInfo> playerDamageInfos)
		{
			//IL_0037: 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 val = TabInfoManager.RegisterCategory("AA Stats", 6);
			TabInfoManager.RegisterStat(val, "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(val, "Extra Card Picks", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().ExtraCardPicks != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().ExtraCardPicks}"));
			TabInfoManager.RegisterStat(val, "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(val, "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(val, "Delay Damage", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().secondToDealDamage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().secondToDealDamage} seconds"));
			StatCategory val2 = TabInfoManager.RegisterCategory("Soulstreak Stats", 7);
			TabInfoManager.RegisterStat(val2, "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(val2, "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(val2, "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(val2, "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(val2, "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(val2, "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(val2, "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(val2, "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(val2, "Soul Drain Multiply", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulDrainMultiply != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulDrainMultiply * 100f:0}%"));
			TabInfoManager.RegisterStat(val2, "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)
		{
			if (logging)
			{
				AALUND13_Cards.ModLogger.LogWarning((object)message);
			}
		}

		public static void LogError(string message)
		{
			if (logging)
			{
				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 override string StatName => "Glitched Card Spawned Chance";

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			AAStatModifers orAddComponent = ExtensionMethods.GetOrAddComponent<AAStatModifers>(cardObj, false);
			orAddComponent.CorruptedCardSpawnChance += value;
			return GetStringValue(value * 100f);
		}

		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 string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block);

		public abstract bool IsPositive(float value);

		public virtual bool ShouldAddStat(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 override string StatName => "Damage";

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.damage += value;
			return GetStringValue(value * 100f);
		}

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

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.reloadTime += value;
			return GetStringValue(value * 100f);
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class AttackSpeedStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Attack Speed";

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.attackSpeed += value;
			return GetStringValue(value * 100f);
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class MovementSpeedStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Movement Speed";

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.movementSpeed += value;
			return GetStringValue(value * 100f);
		}

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

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.health += value;
			return GetStringValue(value * 100f);
		}

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

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			block.cdMultiplier += value;
			return GetStringValue(value * 100f);
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class BulletSpeedStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Bullet Speed";

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.projectileSpeed += value;
			return GetStringValue(value * 100f);
		}

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

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

		public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.regen += 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 string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			gun.ammo += Mathf.RoundToInt(value);
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldAddStat(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 string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			block.additionalBlocks += Mathf.RoundToInt(value);
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldAddStat(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 string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
		{
			characterStats.respawns += Mathf.RoundToInt(value);
			return GetStringValue(value, isPercentage: false);
		}

		public override bool ShouldAddStat(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, SyncedRandomContext> OnCardGenerated;

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

		public void GetCardStatsFromSeed(int seed, int minRandomStat, int maxRandomStat, GameObject newCard, Gun gun, CharacterStatModifiers statModifiers, Block block)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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].ShouldAddStat(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.Apply(item.Value, newCard, gun, statModifiers, block),
					positive = item.Key.IsPositive(item.Value)
				});
			}
			CardInfo component = newCard.GetComponent<CardInfo>();
			component.cardStats = list.ToArray();
		}

		private void SyncRandomSyncStats(SyncedRandomContext context)
		{
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Expected O, but got Unknown
			string text = (string)context.Parameters[0];
			string cardDestription = (string)context.Parameters[1];
			int num = Mathf.Max(0, (int)context.Parameters[2]);
			int maxValue = 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);
			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 = cardDestription;
			buildRandomStatCard.CardName = text;
			((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 " + text + "...");
			int num2 = context.Random.Next(num, maxValue);
			Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
			while (dictionary.Count < num2)
			{
				int index = context.Random.Next(StatGenerators.Count);
				if (!dictionary.ContainsKey(StatGenerators[index]))
				{
					float value = context.Random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
					if (StatGenerators[index].ShouldAddStat(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.Apply(item.Value, val, component2, component3, component4),
					positive = item.Key.IsPositive(item.Value)
				});
			}
			component.cardStats = list.ToArray();
			LoggerUtils.LogInfo($"Generated {list.Count} stats for {text}.");
			LoggerUtils.LogInfo("Building card...");
			((CustomCard)buildRandomStatCard).BuildUnityCard((Action<CardInfo>)delegate(CardInfo cardInfo)
			{
				((CustomUnityCard)buildRandomStatCard).Register(cardInfo);
				this.OnCardGenerated?.Invoke(cardInfo, context);
				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!");
			});
		}
	}
}
namespace AALUND13Card.RandomStatGenerators.Generators
{
	internal class CorruptedStatGenerator
	{
		public static List<CardInfo> CorruptedCards = new List<CardInfo>();

		public static void RegisterCorruptedStatGenerators()
		{
			new RandomStatHandler("CorruptedStatGeneratorCommon", 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.1f, 0.1f),
				new BulletSpeedStatGenerator(-0.3f, 0.3f),
				new AmmoStatGenerator(-2f, 2f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.05f, 0.05f)
			}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
			{
				CorruptedCards.Add(card);
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
			};
			new RandomStatHandler("CorruptedStatGeneratorUncommon", 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.25f, 0.15f),
				new BulletSpeedStatGenerator(-0.3f, 0.4f),
				new AmmoStatGenerator(-2f, 4f),
				new RegenStatGenerator(0f, 15f),
				new AdditionalBlocksStatGenerator(0f, 0.6f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.1f, 0.1f)
			}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				CorruptedCards.Add(card);
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = (Rarity)1;
			};
			new RandomStatHandler("CorruptedStatGeneratorRare", 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.3f, 0.1f),
				new BulletSpeedStatGenerator(-0.3f, 0.6f),
				new AmmoStatGenerator(-3f, 6f),
				new RegenStatGenerator(0f, 35f),
				new AdditionalBlocksStatGenerator(0f, 0.625f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.2f, 0.2f)
			}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				CorruptedCards.Add(card);
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = (Rarity)2;
			};
			new RandomStatHandler("CorruptedStatGeneratorLegendary", 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.4f, 0.25f),
				new BulletSpeedStatGenerator(-0.3f, 0.75f),
				new AmmoStatGenerator(-4f, 8f),
				new RegenStatGenerator(0f, 50f),
				new AdditionalBlocksStatGenerator(0f, 5f / 6f),
				new ExtraLiveStatGenerator(0f, 0.7692308f),
				new GlitchedCardSpawnedChanceStatGenerator(-0.35f, 0.35f)
			}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				CorruptedCards.Add(card);
				((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
				card.rarity = RarityUtils.GetRarity("Legendary");
			};
		}

		public static void BuildGlitchedCard()
		{
			Random random = new Random("1.6.3".GetHashCode());
			for (int i = 0; i < 100; i++)
			{
				RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorCommon", random.Next(), "Corrupted Card", "A random description", 1, 3);
			}
			for (int j = 0; j < 75; j++)
			{
				RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorUncommon", random.Next(), "Corrupted Card", "A random description", 1, 4);
			}
			for (int k = 0; k < 50; k++)
			{
				RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorRare", random.Next(), "Corrupted Card", "A random description", 1, 5);
			}
			for (int l = 0; l < 25; l++)
			{
				RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorLegendary", random.Next(), "Corrupted Card", "A random description", 2, 6);
			}
		}
	}
	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)
			{
				ExtraPickHandler extraPickHandler = ExtraCardPickHandler.extraPicks[player][0];
				bool flag = extraPickHandler.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)
			{
				ExtraPickHandler extraPickHandler = ExtraCardPickHandler.extraPicks[playerWithID][0];
				extraPickHandler.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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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>();
				foreach (Effect effect in components)
				{
					Object.Destroy((Object)(object)effect);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CardChoicePatchGetRanomCard), "OrignialGetRanomCard", new Type[] { typeof(CardInfo[]) })]
	internal class GetRanomCardPatch
	{
		public static Random random = new Random();

		private static void Prefix(ref CardInfo[] cards)
		{
			Player val = PickingPlayer(CardChoice.instance);
			if ((Object)(object)val != (Object)null && random.NextFloat(0f, 1f) < val.data.GetAdditionalData().CorruptedCardSpawnChance)
			{
				cards = CorruptedStatGenerator.CorruptedCards.ToArray();
			}
		}

		internal static Player PickingPlayer(CardChoice cardChoice)
		{
			object? obj = typeof(CardChoicePatchGetRanomCard).GetMethod("PickingPlayer", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[1] { cardChoice });
			return (Player)((obj is Player) ? obj : null);
		}
	}
	[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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			CharacterData block = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
			AALUND13CardCharacterDataAdditionalData additionalData = block.GetAdditionalData();
			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;
			}
		}
	}
}
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>();
				TextMeshProUGUI[] array = componentsInChildren;
				foreach (TextMeshProUGUI textMesh in array)
				{
					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 = false;

		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
	{
		private SoulStreakStats soulstreakStats;

		private DealDamageToPlayer dealDamageToPlayer;

		private Player player;

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

		public void Update()
		{
			if (soulstreakStats != null)
			{
				dealDamageToPlayer.damage = player.data.weaponHandler.gun.damage * 55f * soulstreakStats.SoulDrainMultiply;
			}
		}

		public void Heal()
		{
			player.data.healthHandler.Heal(player.data.weaponHandler.gun.damage * 55f * soulstreakStats.SoulDrainMultiply * 0.25f);
		}
	}
	[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 = 0f;

		public float SoulArmorPercentageRegenRate = 0f;

		public float SoulDrainMultiply = 0f;

		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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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.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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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 player in array)
			{
				if (extraPicks.ContainsKey(player) && extraPicks[player].Count > 0)
				{
					yield return HandleExtraPickForPlayer(player);
				}
			}
			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 = 0f;

		public bool dealDamage = true;

		public SoulStreakStats SoulStreakStats = new SoulStreakStats();

		public uint Souls = 0u;

		public int RandomCardsAtStart = 0;

		public int ExtraCardPicks = 0;

		public float CorruptedCardSpawnChance = 0f;

		public float CorruptedCardSpawnChancePerPick = 0f;

		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 RandomExtension
	{
		public static float NextFloat(this Random random, float minValue, float maxValue)
		{
			return (float)random.NextDouble() * (maxValue - minValue) + minValue;
		}
	}
}
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 string GetModName()
		{
			return "AAC";
		}
	}
	public enum ExtraPicksType
	{
		None,
		Normal,
		Steel
	}
	public class AAStatModifers : MonoBehaviour
	{
		[Header("Soulstreak Stats")]
		public float MaxHealth = 0f;

		public float PlayerSize = 0f;

		public float MovementSpeed = 0f;

		public float AttackSpeed = 0f;

		public float Damage = 0f;

		public float BulletSpeed = 0f;

		public float SoulArmorPercentage = 0f;

		public float SoulArmorPercentageRegenRate = 0f;

		public float SoulDrainMultiply = 0f;

		public AbilityType AbilityType;

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

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

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

		public ExtraPicksType ExtraPicksType;

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

		public int ExtraCardPicks = 0;

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

		public float CorruptedCardSpawnChancePerPick = 0f;

		public void Apply(Player player)
		{
			CharacterData data = player.data;
			AALUND13CardCharacterDataAdditionalData additionalData = 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.SoulDrainMultiply += SoulDrainMultiply;
			additionalData.SoulStreakStats.AbilityType |= AbilityType;
			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)
		{
			CharacterData data = player.data;
			AALUND13CardCharacterDataAdditionalData additionalData = 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 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)";
		}
	}
	public class RandomPickerCard : AACustomCard
	{
		public List<GameObject> randomCardsToChoseFrom = new List<GameObject>();

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (PhotonNetwork.OfflineMode || PhotonNetwork.IsMasterClient)
			{
				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_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return new BarColor(Color.yellow * 0.6f, Color.yellow * 0.45f);
		}

		public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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)
			//IL_0034: 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_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			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;
		}
	}
}