using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Patches;
using ModdingUtils.Utils;
using Photon.Pun;
using PickPhaseImprovements;
using RandomCardsGenerators.Cards;
using RandomCardsGenerators.Extensions;
using RandomCardsGenerators.Utils;
using TMPro;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Utils;
using UnityEngine;

[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 RandomCardsGenerators
{
	[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.random_cards_generator", "Random Cards Generator", "1.3.2")]
	[BepInProcess("Rounds.exe")]
	public class Main : BaseUnityPlugin
	{
		private const string modId = "com.aalund13.rounds.random_cards_generator";

		private const string modName = "Random Cards Generator";

		internal const string modInitials = "RCG";

		internal static Main instance;

		internal static ManualLogSource ModLogger;

		internal static AssetBundle assets;

		internal static GameObject blankCardPrefab;

		internal static Type RarityTextType;

		internal static Dictionary<string, float> ModRarities;

		private static Harmony harmony;

		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			instance = this;
			ModLogger = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("com.aalund13.rounds.random_cards_generator");
			harmony.PatchAll();
			assets = AssetUtils.LoadAssetBundleFromResources("randomcardsgenerator_assets", typeof(Main).Assembly);
			blankCardPrefab = assets.LoadAsset<GameObject>("__RCG__BlankCard");
		}

		private void Start()
		{
			Cards.instance.AddCardValidationFunction((Func<Player, CardInfo, bool>)((Player player, CardInfo card) => ToggleCard.IsCardEnabled(card) ? true : false));
			if (Chainloader.PluginInfos.TryGetValue("pykess.rounds.plugins.deckcustomization", out var value))
			{
				Assembly assembly = ((object)value.Instance).GetType().Assembly;
				RarityTextType = assembly.GetType("DeckCustomization.RarityText");
				ModRarities = (Dictionary<string, float>)assembly.GetType("DeckCustomization.DeckCustomization").GetField("ModRarities", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
				DeckCustomizationPatch.Patch(harmony, assembly);
			}
			PickManager.RegisterHandModificationFunction((Func<CardInfo[], CardInfo[]>)RandomCardsResolver.ResolveRandomCards, 200);
		}
	}
	internal static class GeneratedCardHolder
	{
		public static readonly Dictionary<string, List<GeneratedCardInfo>> GeneratedCardsMap = new Dictionary<string, List<GeneratedCardInfo>>();

		public static readonly List<GeneratedCardInfo> GeneratedCards = new List<GeneratedCardInfo>();

		public static List<GeneratedCardInfo> GetGeneratedCards(string statGenName)
		{
			if (GeneratedCardsMap.ContainsKey(statGenName))
			{
				return GeneratedCardsMap[statGenName];
			}
			return new List<GeneratedCardInfo>();
		}

		public static GeneratedCardInfo IsCardGenerated(CardInfo cardInfo)
		{
			return GeneratedCards.FirstOrDefault((GeneratedCardInfo c) => (Object)(object)c.CardInfo == (Object)(object)cardInfo);
		}

		public static void AddCardToGenerated(string statGenName, GeneratedCardInfo cardInfo)
		{
			if (GeneratedCardsMap.ContainsKey(statGenName))
			{
				GeneratedCardsMap[statGenName].Add(cardInfo);
			}
			else
			{
				GeneratedCardsMap.Add(statGenName, new List<GeneratedCardInfo> { cardInfo });
			}
			GeneratedCards.Add(cardInfo);
		}
	}
	public class ModRandomCardsGenerators
	{
		protected readonly Dictionary<string, RandomCardsGenerator> CardsGenerators = new Dictionary<string, RandomCardsGenerator>();

		public ModRandomCardsGenerators(List<RandomCardsGenerator> cardsGenerators)
		{
			foreach (RandomCardsGenerator cardsGenerator in cardsGenerators)
			{
				if (cardsGenerators == null || cardsGenerators.Count == 0)
				{
					throw new Exception("No handlers provided.");
				}
				if (CardsGenerators.ContainsKey(cardsGenerator.CardGenName))
				{
					throw new Exception("Handler for " + cardsGenerator.CardGenName + " already exists.");
				}
				CardsGenerators.Add(cardsGenerator.CardGenName, cardsGenerator);
			}
		}

		public void CreateRandomCard(string cardGenName, int seed, Player player = null)
		{
			GetHandler(cardGenName).CreateRandomCard(seed, player);
		}

		public void CreateRandomCard(string cardGenName, Player player = null)
		{
			GetHandler(cardGenName).CreateRandomCard(player);
		}

		public RandomCardsGenerator GetHandler(string statGenName)
		{
			return CardsGenerators[statGenName];
		}

		public IEnumerable<RandomCardsGenerator> GetAllHandlers()
		{
			return CardsGenerators.Values;
		}

		public void AddGenerator(string cardGenName, RandomCardsGenerator handler)
		{
			if (!CardsGenerators.ContainsKey(cardGenName))
			{
				CardsGenerators.Add(cardGenName, handler);
				return;
			}
			throw new Exception("Handler for " + cardGenName + " already exists.");
		}

		public void RemoveGenerator(string cardGenName)
		{
			if (CardsGenerators.ContainsKey(cardGenName))
			{
				CardsGenerators.Remove(cardGenName);
			}
		}
	}
	public class ModRandomCardsGenerators<T> : ModRandomCardsGenerators where T : Enum
	{
		protected readonly Dictionary<T, RandomCardsGenerator> TypedCardsGenerators = new Dictionary<T, RandomCardsGenerator>();

		public ModRandomCardsGenerators(Dictionary<T, RandomCardsGenerator> cardsGenerators)
			: base(new List<RandomCardsGenerator>(cardsGenerators.Values))
		{
			foreach (KeyValuePair<T, RandomCardsGenerator> cardsGenerator in cardsGenerators)
			{
				if (TypedCardsGenerators.ContainsKey(cardsGenerator.Key))
				{
					throw new Exception($"Handler for {cardsGenerator.Key} already exists.");
				}
				TypedCardsGenerators.Add(cardsGenerator.Key, cardsGenerator.Value);
			}
		}

		public void CreateRandomCard(T stats, int seed, Player player = null)
		{
			RandomCardsGenerator handler = GetHandler(stats);
			NetworkingManager.RaiseEvent($"{handler.CardGenName}_SyncEvent", new object[3]
			{
				seed,
				player?.playerID ?? (-1),
				true
			});
		}

		public void CreateRandomCard(T stats, Player player = null)
		{
			RandomCardsGenerator handler = GetHandler(stats);
			int num = Random.Range(0, int.MaxValue);
			NetworkingManager.RaiseEvent($"{handler.CardGenName}_SyncEvent", new object[3]
			{
				num,
				player?.playerID ?? (-1),
				true
			});
		}

		public RandomCardsGenerator GetHandler(T stat)
		{
			return TypedCardsGenerators[stat];
		}

		public void AddGenerator(T stat, RandomCardsGenerator handler)
		{
			if (!TypedCardsGenerators.ContainsKey(stat) && !CardsGenerators.ContainsKey(handler.CardGenName))
			{
				TypedCardsGenerators.Add(stat, handler);
				CardsGenerators.Add(handler.CardGenName, handler);
				return;
			}
			throw new Exception($"Handler for {stat} already exists or the handler is already registered with another stat generator.");
		}

		public void RemoveGenerator(T stat)
		{
			if (TypedCardsGenerators.ContainsKey(stat))
			{
				TypedCardsGenerators.Remove(stat);
				CardsGenerators.Remove(stat.ToString());
			}
		}
	}
	internal class DeckCustomizationPatch
	{
		public static void Patch(Harmony harmony, Assembly assembly)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			harmony.Patch((MethodBase)assembly.GetType("DeckCustomization.RarityUtils").GetMethod("GetRelativeRarity", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), new HarmonyMethod(typeof(DeckCustomizationPatch), "GetRelativeRarityPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static bool GetRelativeRarityPrefix(string modName, ref float __result)
		{
			if (!Main.ModRarities.ContainsKey(modName))
			{
				__result = 0.5f;
				return false;
			}
			return true;
		}
	}
	public struct RandomStatInfo
	{
		public RandomStatGenerator StatGenerator;

		public float Value;

		public RandomStatInfo(RandomStatGenerator statGenerator, float value)
		{
			StatGenerator = statGenerator;
			Value = value;
		}

		public override string ToString()
		{
			return $"RandomStatInfo: {StatGenerator.StatName} | Value: {Value}";
		}
	}
	public struct RandomCardOption
	{
		public string CardName;

		public string ModInitials;

		public string CardDescription;

		public string TwoLetterCode;

		public Rarity CardRarity;

		public CardThemeColorType ColorTheme;

		public int Min;

		public int Max;

		public RandomCardOption(string cardName, string modInitials, string cardDescription, string twoLetterCode, int min, int max, Rarity cardRarity, CardThemeColorType colorTheme = 3)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			CardName = cardName;
			ModInitials = modInitials;
			CardDescription = cardDescription;
			TwoLetterCode = twoLetterCode;
			CardRarity = cardRarity;
			ColorTheme = colorTheme;
			Min = min;
			Max = max;
		}

		public override string ToString()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return $"RandomCardOption: {CardName} | Rarity: {CardRarity} | ModInitials: {ModInitials} | Description: {CardDescription} | TwoLetterCode: {TwoLetterCode} | Min: {Min} | Max: {Max}";
		}
	}
	public struct GeneratedCardInfo
	{
		public RandomCardsGenerator RandomCardsGenerator;

		public CardInfo CardInfo;

		public RandomStatInfo[] RandomStatInfos;

		public Random Random;

		public int Seed;

		public Player Player;

		public bool HasValue
		{
			get
			{
				if (RandomCardsGenerator != null && (Object)(object)CardInfo != (Object)null && RandomStatInfos != null)
				{
					return RandomStatInfos.Length != 0;
				}
				return false;
			}
		}

		public GeneratedCardInfo(RandomCardsGenerator randomCardsGenerator, CardInfo cardInfo, RandomStatInfo[] randomStatInfos, Random random, int seed, Player player = null)
		{
			RandomCardsGenerator = randomCardsGenerator;
			CardInfo = cardInfo;
			RandomStatInfos = randomStatInfos;
			Player = player;
			Random = random;
			Seed = seed;
		}

		public override string ToString()
		{
			return string.Format("GeneratedCardInfo: {0} | CardName: {1} | Seed: {2} | RandomStatInfos: {3}", RandomCardsGenerator.CardGenName, CardInfo.cardName, Seed, string.Join(", ", RandomStatInfos.Select((RandomStatInfo x) => x.StatGenerator.StatName)));
		}
	}
	public class GeneratorEventsActions
	{
		public Action<GeneratedCardInfo> OnCardGenerated;

		public Action<GeneratedCardInfo> OnCardBuilt;
	}
	public class RandomCardsGenerator
	{
		internal const string SYNC_EVENT_FORMAT = "{0}_SyncEvent";

		internal const string CARD_NAME_FORMAT = "{0} (Seed : {1})";

		internal static readonly Dictionary<string, RandomCardsGenerator> RandomStatCardGenerators = new Dictionary<string, RandomCardsGenerator>();

		public readonly List<RandomStatGenerator> StatGenerators;

		public readonly GeneratorEventsActions GeneratorActions;

		public readonly RandomCardOption RandomCardOption;

		public readonly string CardGenName;

		[Obsolete("This event is obsolete, please swith to the new 'Generator Actions' system")]
		public Action<GeneratedCardInfo> OnCardGenerated;

		private readonly Dictionary<int, GeneratedCardInfo> GeneratedCards;

		public RandomCardsGenerator(string cardGenName, RandomCardOption randomCardOption, List<RandomStatGenerator> statGenerators)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			if (RandomStatCardGenerators.ContainsKey(cardGenName))
			{
				throw new Exception("A RandomCardsGenerators with the name " + cardGenName + " already exists!");
			}
			if (string.IsNullOrEmpty(cardGenName) || string.IsNullOrWhiteSpace(cardGenName))
			{
				throw new Exception("Card generator name cannot be null or empty!");
			}
			string sanitizedName = randomCardOption.ModInitials + "_" + ExtensionMethods.Sanitize(cardGenName, (string[])null);
			GeneratedCards = new Dictionary<int, GeneratedCardInfo>();
			RandomStatCardGenerators.Add(sanitizedName, this);
			StatGenerators = statGenerators;
			GeneratorActions = new GeneratorEventsActions();
			GeneratorEventsActions generatorActions = GeneratorActions;
			generatorActions.OnCardGenerated = (Action<GeneratedCardInfo>)Delegate.Combine(generatorActions.OnCardGenerated, (Action<GeneratedCardInfo>)delegate(GeneratedCardInfo card)
			{
				OnCardGenerated?.Invoke(card);
			});
			RandomCardOption = randomCardOption;
			CardGenName = sanitizedName;
			NetworkingManager.RegisterEvent($"{sanitizedName}_SyncEvent", (PhotonEvent)delegate(object[] data)
			{
				try
				{
					int seed = (int)data[0];
					int playerID = (int)data[1];
					bool flag = data.Length > 2 && (bool)data[2];
					Player player = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
					CardInfo generatedCard = GenerateRandomCard(player, seed).GetComponent<CardInfo>();
					if ((Object)(object)player != (Object)null && flag)
					{
						ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)Main.instance, 0.2f, (Action)delegate
						{
							Cards.instance.AddCardToPlayer(player, generatedCard, false, RandomCardOption.TwoLetterCode, 2f, 2f, true);
						});
					}
				}
				catch (Exception arg)
				{
					LoggerUtils.LogError($"Error generating random stats for {sanitizedName}: {arg}");
				}
			});
		}

		public void CreateRandomCard(int seed, Player player = null)
		{
			NetworkingManager.RaiseEvent($"{CardGenName}_SyncEvent", new object[3] { seed, player.playerID, true });
		}

		public void CreateRandomCard(Player player = null)
		{
			int num = Random.Range(0, int.MaxValue);
			NetworkingManager.RaiseEvent($"{CardGenName}_SyncEvent", new object[3] { num, player.playerID, true });
		}

		public GameObject CreateRandomCardForOther(Player player = null)
		{
			int num = Random.Range(0, int.MaxValue);
			GameObject result = GenerateRandomCard(player, num);
			NetworkingManager.RaiseEventOthers($"{CardGenName}_SyncEvent", new object[3] { num, player.playerID, false });
			return result;
		}

		public GameObject GenerateRandomCard(Player requestPlayer, int seed, GeneratorEventsActions generatorActions)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			if (GeneratedCards.ContainsKey(seed))
			{
				LoggerUtils.LogInfo($"Card with seed {seed} already generated for {CardGenName}. Returning existing card.");
				generatorActions?.OnCardGenerated?.Invoke(GeneratedCards[seed]);
				generatorActions?.OnCardBuilt?.Invoke(GeneratedCards[seed]);
				return ((Component)GeneratedCards[seed].CardInfo).gameObject;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Generating card from " + CardGenName);
			stringBuilder.AppendLine(string.Format("Receive Data: \nSeed: {0}\nPlayer Id: {1}", seed, requestPlayer.playerID.ToString() ?? "None"));
			LoggerUtils.LogInfo(stringBuilder.ToString());
			GameObject obj = Object.Instantiate<GameObject>(Main.blankCardPrefab);
			Object.DestroyImmediate((Object)(object)((Component)obj.transform.GetChild(0)).gameObject);
			Object.DontDestroyOnLoad((Object)(object)obj);
			CardInfo component = obj.GetComponent<CardInfo>();
			BuiltRandomCard builtRandomCard = obj.AddComponent<BuiltRandomCard>();
			component.cardName = $"{RandomCardOption.CardName} (Seed : {seed})";
			component.cardDestription = RandomCardOption.CardDescription;
			component.rarity = RandomCardOption.CardRarity;
			component.colorTheme = RandomCardOption.ColorTheme;
			Cards.instance.AddHiddenCard(component);
			Random random = new Random(seed);
			RandomStatInfo[] randomStatInfos = ApplyRandomStats(component, random);
			GeneratedCardInfo generatedCardInfo = new GeneratedCardInfo(this, component, randomStatInfos, random, seed, requestPlayer);
			GeneratedCardHolder.AddCardToGenerated(CardGenName, generatedCardInfo);
			GeneratedCards[seed] = generatedCardInfo;
			((CustomCard)builtRandomCard).BuildUnityCard((Action<CardInfo>)delegate
			{
				generatorActions?.OnCardBuilt?.Invoke(GeneratedCards[seed]);
				GeneratorActions.OnCardBuilt?.Invoke(GeneratedCards[seed]);
				LoggerUtils.LogInfo("Card built!");
			});
			((Object)obj).name = ExtensionMethods.Sanitize($"___RANDOM___{CardGenName}_({seed})", (string[])null);
			generatorActions?.OnCardGenerated?.Invoke(GeneratedCards[seed]);
			Action<GeneratedCardInfo> onCardGenerated = GeneratorActions.OnCardGenerated;
			if (onCardGenerated != null)
			{
				onCardGenerated(GeneratedCards[seed]);
				return obj;
			}
			return obj;
		}

		public GameObject GenerateRandomCard(Player requestPlayer, int seed)
		{
			return GenerateRandomCard(requestPlayer, seed, null);
		}

		public GameObject GenerateRandomCard(int seed)
		{
			return GenerateRandomCard(null, seed, null);
		}

		[Obsolete("this 'GenerateRandomCard(Int, Player, Action<GeneratedCardInfo>)' method is obsolete, use 'GenerateRandomCard(Player requestPlayer, int seed, GeneratorEventsActions generatorActions)' or the other non-obsolete one insteads")]
		public GameObject GenerateRandomCard(int seed, Player requestPlayer = null, Action<GeneratedCardInfo> onCardGenerated = null)
		{
			GeneratorEventsActions generatorEventsActions = new GeneratorEventsActions();
			generatorEventsActions.OnCardGenerated = (Action<GeneratedCardInfo>)Delegate.Combine(generatorEventsActions.OnCardGenerated, (Action<GeneratedCardInfo>)delegate(GeneratedCardInfo card)
			{
				onCardGenerated?.Invoke(card);
			});
			return GenerateRandomCard(seed, requestPlayer, onCardGenerated);
		}

		public RandomStatInfo[] ApplyRandomStats(CardInfo cardInfo, Random random)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			BuiltRandomCard orAddComponent = ExtensionMethods.GetOrAddComponent<BuiltRandomCard>(((Component)cardInfo).gameObject, false);
			orAddComponent.CardName = RandomCardOption.CardName;
			orAddComponent.ModInitials = RandomCardOption.ModInitials;
			Gun component = ((Component)cardInfo).GetComponent<Gun>();
			CharacterStatModifiers component2 = ((Component)cardInfo).GetComponent<CharacterStatModifiers>();
			ApplyCardStats component3 = ((Component)cardInfo).GetComponent<ApplyCardStats>();
			Block component4 = ((Component)cardInfo).GetComponent<Block>();
			LoggerUtils.LogInfo("Generating random stats for " + cardInfo.cardName + "...");
			int num = Mathf.Max(0, RandomCardOption.Min);
			int max = Mathf.Clamp(RandomCardOption.Max, num, StatGenerators.Count);
			RandomStatInfo[] array = SelectRandomStats(random, num, max);
			cardInfo.cardStats = (CardInfoStat[])(object)new CardInfoStat[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				RandomStatInfo randomStatInfo = array[i];
				randomStatInfo.StatGenerator.Apply(randomStatInfo.Value, cardInfo, component, component3, component2, component4);
				cardInfo.cardStats[i] = new CardInfoStat
				{
					stat = randomStatInfo.StatGenerator.StatName,
					amount = randomStatInfo.StatGenerator.GetStatString(randomStatInfo.Value),
					positive = randomStatInfo.StatGenerator.IsPositive(randomStatInfo.Value)
				};
				LoggerUtils.LogInfo($"Applied stat {randomStatInfo.StatGenerator.StatName} with value {randomStatInfo.Value}.");
			}
			LoggerUtils.LogInfo($"Generated {array.Length} stats for {cardInfo.cardName}.");
			return array;
		}

		private RandomStatInfo[] SelectRandomStats(Random random, int min, int max)
		{
			LoggerUtils.LogInfo("Selecting random stats for '" + CardGenName + "'");
			int num = Mathf.Clamp(min, 0, StatGenerators.Count);
			int num2 = Mathf.Clamp(max, num, StatGenerators.Count);
			int num3 = random.Next(num, num2 + 1);
			List<RandomStatGenerator> list = new List<RandomStatGenerator>(num3);
			RandomStatInfo[] array = new RandomStatInfo[num3];
			while (list.Count < num3)
			{
				int index = random.Next(StatGenerators.Count);
				if (!list.Contains(StatGenerators[index]))
				{
					float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
					if (StatGenerators[index].ShouldApply(value))
					{
						list.Add(StatGenerators[index]);
						array[list.Count - 1] = new RandomStatInfo(StatGenerators[index], value);
						LoggerUtils.LogInfo($"Selected stat {array[list.Count - 1].StatGenerator.StatName} with value {array[list.Count - 1].Value}.");
					}
				}
			}
			LoggerUtils.LogInfo($"Selected {list.Count} stats for '{CardGenName}'");
			return array;
		}

		public override string ToString()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return $"RandomCardsGenerator: {CardGenName} | CardName: {RandomCardOption.CardName} | Rarity: {RandomCardOption.CardRarity} | Min: {RandomCardOption.Min} | Max: {RandomCardOption.Max}";
		}
	}
	internal static class RandomCardsResolver
	{
		internal static CardInfo[] ResolveRandomCards(CardInfo[] hand)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Player player = (((int)(PickerType)ExtensionMethods.GetFieldValue((object)CardChoice.instance, "pickerType") != 0) ? PlayerManager.instance.players[CardChoice.instance.pickrID] : PlayerManager.instance.GetPlayersInTeam(CardChoice.instance.pickrID)[0]);
			for (int i = 0; i < hand.Length; i++)
			{
				RandomCard component = ((Component)hand[i]).GetComponent<RandomCard>();
				if ((Object)(object)component != (Object)null)
				{
					if (RandomCardsGenerator.RandomStatCardGenerators.TryGetValue(component.StatGenName, out var value))
					{
						hand[i] = value.CreateRandomCardForOther(player).GetComponent<CardInfo>();
						PickManager.RegisterAlternetSpawnName(hand[i], "__" + value.RandomCardOption.ModInitials + "__" + hand[i].cardName);
					}
					else
					{
						LoggerUtils.LogError("Stat generator " + component.StatGenName + " does not exist.");
					}
				}
			}
			return hand;
		}
	}
	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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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 ? "%" : "");
		}
	}
}
namespace RandomCardsGenerators.Utils
{
	internal static class LoggerUtils
	{
		private const bool logging = false;

		public static void LogInfo(string message)
		{
		}

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

		public static void LogError(string message)
		{
			Main.ModLogger.LogError((object)message);
		}
	}
	public class FindRandomCardsGeneratorResult
	{
		public readonly int Seed;

		public readonly RandomCardsGenerator RandomCardsGenerator;

		public FindRandomCardsGeneratorResult(int seed, RandomCardsGenerator randomCardsGenerator)
		{
			Seed = seed;
			RandomCardsGenerator = randomCardsGenerator;
		}
	}
	public static class RandomCardsUtils
	{
		public static Regex randomCardRegex = new Regex("^___RANDOM___(.*?)_(?:\\((\\d+)\\))?$", RegexOptions.Compiled);

		public static FindRandomCardsGeneratorResult FindRandomCardsGeneratorByName(string cardName)
		{
			Match match = randomCardRegex.Match(cardName);
			if (match.Success)
			{
				string generatorName = match.Groups[1].Value;
				if (match.Groups.Count <= 2 || !int.TryParse(match.Groups[2].Value, out var result))
				{
					return null;
				}
				int seed = result;
				RandomCardsGenerator value = RandomCardsGenerator.RandomStatCardGenerators.FirstOrDefault((KeyValuePair<string, RandomCardsGenerator> r) => r.Key == generatorName).Value;
				if (value != null)
				{
					return new FindRandomCardsGeneratorResult(seed, value);
				}
			}
			return null;
		}
	}
	public static class RandomStatsUtils
	{
		public static float ScaleStatByIntensity(float intensity, float baseValue = 1f)
		{
			return baseValue / 2f / (1f - intensity);
		}
	}
}
namespace RandomCardsGenerators.StatsGroup
{
	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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.health += value;
		}

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

		public override string StatName => "Size";

		public SizeStatGenerator(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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.sizeMultiplier += value;
		}

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.movementSpeed += 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.regen += value;
		}

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

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

		public override string StatName => "Spread";

		public SpreadStatGenerator(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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.spread += value;
		}

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

		public override string StatName => "Drag";

		public DragStatGenerator(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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.drag += value;
		}

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

		public override string StatName => "Life Steal";

		public LifeSteelStatGenerator(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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.lifeSteal += value;
		}

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

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

		public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.reloadTimeAdd += value;
		}

		public override string GetStatString(float value)
		{
			return string.Format("{0}{1:F2}s", (value > 0f) ? "+" : "", value);
		}

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

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

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

		public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			block.cdAdd += value;
		}

		public override string GetStatString(float value)
		{
			return string.Format("{0}{1:F2}s", (value > 0f) ? "+" : "", value);
		}

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

		public override bool IsPositive(float value)
		{
			return value < 0f;
		}
	}
	public class NumberOfProjectilesStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Number of Projectiles";

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

		public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.numberOfProjectiles += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(Mathf.RoundToInt(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 BouncesStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Bounces";

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

		public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			gun.reflects += Mathf.RoundToInt(value);
		}

		public override string GetStatString(float value)
		{
			return GetStringValue(Mathf.RoundToInt(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 AmmoStatGenerator : RandomStatGenerator
	{
		public override string StatName => "Ammo";

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

		public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, 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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.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, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.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;
		}
	}
}
namespace RandomCardsGenerators.Patches
{
	[HarmonyPatch]
	public class RandomCardSpawningPatches
	{
		[HarmonyPatch(typeof(Cards), "AddCardToPlayer", new Type[]
		{
			typeof(Player),
			typeof(CardInfo),
			typeof(bool),
			typeof(string),
			typeof(float),
			typeof(float),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static bool AddRandomCardToPlayer(Player player, CardInfo card)
		{
			if ((Object)(object)((Component)card).GetComponent<ToggleCustomCard>() != (Object)null && (PhotonNetwork.OfflineMode || PhotonNetwork.IsMasterClient))
			{
				foreach (NormalDrawableRandomCard normalDrawableCard in NormalDrawableRandomCard.NormalDrawableCards)
				{
					if (normalDrawableCard.ToggleCard != null && (Object)(object)normalDrawableCard.ToggleCard.toggleCardInfo == (Object)(object)card)
					{
						normalDrawableCard.StatCardGenerator.CreateRandomCard(player);
						return false;
					}
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(Cards), "RPCA_AssignCard", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(bool),
			typeof(string),
			typeof(float),
			typeof(float),
			typeof(bool)
		})]
		[HarmonyPrefix]
		public static bool AssignRandomCardRPC(string cardObjectName, int playerID, bool reassign, string twoLetterCode, float forceDisplay, float forceDisplayDelay, bool addToCardBar)
		{
			Player player = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
			if (DrawableRandomCard.ObjectNameToDrawable.TryGetValue(cardObjectName, out var value))
			{
				if (PhotonNetwork.IsMasterClient || PhotonNetwork.OfflineMode)
				{
					value.StatCardGenerator.CreateRandomCard(player);
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(CardChoicePatchGetRanomCard), "OrignialGetRanomCard", new Type[] { typeof(CardInfo[]) })]
		[HarmonyPrefix]
		private static void NormalDrawableCardsSpawn(ref CardInfo[] cards)
		{
			List<CardInfo> list = new List<CardInfo>(cards);
			foreach (NormalDrawableRandomCard normalDrawableCard in NormalDrawableRandomCard.NormalDrawableCards)
			{
				if (list.Contains(normalDrawableCard.ToggleCard.toggleCardInfo))
				{
					list.Remove(normalDrawableCard.ToggleCard.toggleCardInfo);
					list.Add(normalDrawableCard.CardInfo);
				}
			}
			cards = list.ToArray();
		}

		[HarmonyPatch(typeof(CardManager), "GetCardInfoWithName")]
		[HarmonyPostfix]
		public static void GetRandomCardInfoWithName(string cardName, ref CardInfo __result)
		{
			FindRandomCardsGeneratorResult findRandomCardsGeneratorResult = RandomCardsUtils.FindRandomCardsGeneratorByName(cardName);
			if (findRandomCardsGeneratorResult != null)
			{
				__result = findRandomCardsGeneratorResult.RandomCardsGenerator.GenerateRandomCard(findRandomCardsGeneratorResult.Seed).GetComponent<CardInfo>();
			}
		}
	}
}
namespace RandomCardsGenerators.Extensions
{
	public static class RandomExtension
	{
		public static float NextFloat(this Random random, float minValue, float maxValue)
		{
			return (float)random.NextDouble() * (maxValue - minValue) + minValue;
		}
	}
}
namespace RandomCardsGenerators.Cards
{
	internal class BuiltRandomCard : CustomCard
	{
		public string ModInitials;

		public string CardName;

		public override void SetupCard(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 override bool GetEnabled()
		{
			return false;
		}

		protected override GameObject GetCardArt()
		{
			return base.cardInfo.cardArt;
		}

		protected override string GetDescription()
		{
			return base.cardInfo.cardDestription;
		}

		protected override Rarity GetRarity()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return base.cardInfo.rarity;
		}

		protected override CardInfoStat[] GetStats()
		{
			return base.cardInfo.cardStats;
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return base.cardInfo.colorTheme;
		}

		protected override string GetTitle()
		{
			return base.cardInfo.cardName;
		}

		public override string GetModName()
		{
			return ModInitials;
		}
	}
	public class DrawableRandomCard
	{
		internal static List<DrawableRandomCard> DrawableCards = new List<DrawableRandomCard>();

		internal static Dictionary<string, DrawableRandomCard> ObjectNameToDrawable = new Dictionary<string, DrawableRandomCard>();

		internal static readonly Random random = new Random();

		public readonly RandomCardsGenerator StatCardGenerator;

		public readonly GameObject CardGameObject;

		public readonly CardInfo CardInfo;

		public DrawableRandomCard(RandomCardsGenerator statCardGenerator)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			StatCardGenerator = statCardGenerator;
			GameObject val = Object.Instantiate<GameObject>(Main.blankCardPrefab);
			((Object)val).name = statCardGenerator.CardGenName + "_DrawableCard";
			Object.Destroy((Object)(object)((Component)val.transform.GetChild(0)).gameObject);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.AddComponent<RandomCard>().StatGenName = statCardGenerator.CardGenName;
			CardInfo = val.GetComponent<CardInfo>();
			CardGameObject = val;
			CardInfo.cardBase = Main.blankCardPrefab.GetComponent<CardInfo>().cardBase;
			CardInfo.rarity = statCardGenerator.RandomCardOption.CardRarity;
			CardInfo.cardName = statCardGenerator.RandomCardOption.CardName;
			CardInfo.cardDestription = statCardGenerator.RandomCardOption.CardDescription;
			CardInfo.colorTheme = statCardGenerator.RandomCardOption.ColorTheme;
			PhotonNetwork.PrefabPool.RegisterPrefab(((Object)val).name, val);
			DrawableCards.Add(this);
			ObjectNameToDrawable.Add(((Object)val).name, this);
			LoggerUtils.LogInfo("Created drawable card for '" + statCardGenerator.CardGenName + "'");
		}

		public GameObject InstantiateCard(Vector3 position, Quaternion rotation, int seed, Vector3 localScale, Player requestPlayer = null)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			LoggerUtils.LogInfo("Instantiating '" + StatCardGenerator.CardGenName + "'. " + (((Object)(object)requestPlayer != (Object)null) ? $"Requesting Player Id: {requestPlayer.playerID}" : ""));
			return PhotonNetwork.Instantiate(((Object)CardGameObject).name, position, rotation, (byte)0, new object[3]
			{
				seed,
				requestPlayer?.playerID ?? (-1),
				localScale
			});
		}

		public GameObject InstantiateCard(Vector3 position, Quaternion rotation, int seed, Player requestPlayer = null)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			LoggerUtils.LogInfo("Instantiating '" + StatCardGenerator.CardGenName + "'. " + (((Object)(object)requestPlayer != (Object)null) ? $"Requesting Player Id: {requestPlayer.playerID}" : ""));
			return PhotonNetwork.Instantiate(((Object)CardGameObject).name, position, rotation, (byte)0, new object[2]
			{
				seed,
				requestPlayer?.playerID ?? (-1)
			});
		}

		public GameObject ReplaceCard(CardInfo cardInfo, Player requestPlayer)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			LoggerUtils.LogInfo("Replacing card '" + ((Object)cardInfo).name + "' with '" + StatCardGenerator.CardGenName + "'. " + (((Object)(object)requestPlayer != (Object)null) ? $"Requesting Player Id: {requestPlayer.playerID}" : ""));
			ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Main.instance, 3, (Action)delegate
			{
				PhotonNetwork.Destroy(((Component)cardInfo).gameObject);
			});
			return InstantiateCard(((Component)cardInfo).transform.position, ((Component)cardInfo).transform.rotation, random.Next(int.MaxValue), ((Component)cardInfo).transform.localScale, requestPlayer);
		}

		public GameObject ReplaceCard(CardInfo cardInfo)
		{
			return ReplaceCard(cardInfo, null);
		}
	}
	public class RandomCard : MonoBehaviour, IPunInstantiateMagicCallback
	{
		public string StatGenName;

		public void OnPhotonInstantiate(PhotonMessageInfo info)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			object[] data = info.photonView.InstantiationData;
			if (data == null)
			{
				return;
			}
			LoggerUtils.LogInfo($"OnPhotonInstantiate called for '{StatGenName}' with data length: {data.Length}");
			Player val = null;
			int num = (int)data[0];
			if ((int)data[1] != -1)
			{
				val = ((IEnumerable<Player>)PlayerManager.instance.players).FirstOrDefault((Func<Player, bool>)((Player p) => p.playerID == (int)data[1]));
			}
			if (data.Length >= 3)
			{
				Vector3 localScale = (Vector3)data[2];
				((Component)this).gameObject.transform.localScale = localScale;
			}
			LoggerUtils.LogInfo($"Generating generatedRandom generatedCardInfo with seed {num} using stat generator {StatGenName}");
			LoggerUtils.LogInfo(string.Format("Receive Data: \nSeed: {0}\nPlayer Id: {1}", num, val.playerID.ToString() ?? "None"));
			if (RandomCardsGenerator.RandomStatCardGenerators.TryGetValue(StatGenName, out var value))
			{
				GenerateCard(value, num, val);
			}
			else
			{
				LoggerUtils.LogError("Stat generator " + StatGenName + " does not exist.");
			}
		}

		private void GenerateCard(RandomCardsGenerator generator, int seed, Player requestPlayer)
		{
			CardInfo cardInfo = ((Component)this).GetComponent<CardInfo>();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Creating card from " + generator.CardGenName + "' cards generator");
			stringBuilder.AppendLine(string.Format("Data: \nSeed: {0}\nPlayer Id: {1}", seed, requestPlayer.playerID.ToString() ?? "None"));
			LoggerUtils.LogInfo(stringBuilder.ToString());
			GeneratorEventsActions generatorEventsActions = new GeneratorEventsActions();
			generatorEventsActions.OnCardBuilt = (Action<GeneratedCardInfo>)Delegate.Combine(generatorEventsActions.OnCardBuilt, (Action<GeneratedCardInfo>)delegate(GeneratedCardInfo generatedCardInfo)
			{
				LoggerUtils.LogInfo($"CardGenerator: {generator}");
				LoggerUtils.LogInfo($"GeneratedCardInfo: {generatedCardInfo}");
				GeneratedCardInfo obj = new GeneratedCardInfo(generator, cardInfo, generatedCardInfo.RandomStatInfos, generatedCardInfo.Random, seed, requestPlayer);
				CardInfoStat[] cardStats = generatedCardInfo.CardInfo.cardStats;
				Random random = new Random(seed);
				generator.ApplyRandomStats(cardInfo, random);
				LoggerUtils.LogInfo($"Applied {cardStats.Length} stats to toggleCardInfo {cardInfo.cardName}.");
				cardInfo.sourceCard = generatedCardInfo.CardInfo;
				cardInfo.cardStats = cardStats;
				cardInfo.cardName = $"{generator.RandomCardOption.CardName} (Seed : {seed})";
				generatedCardInfo.RandomCardsGenerator.GeneratorActions.OnCardGenerated?.Invoke(obj);
				generatedCardInfo.RandomCardsGenerator.GeneratorActions.OnCardBuilt?.Invoke(obj);
				((Component)this).gameObject.GetComponentInChildren<CardInfoDisplayer>().DrawCard(cardStats, generator.RandomCardOption.CardName, generator.RandomCardOption.CardDescription, (Sprite)null, false);
				LoggerUtils.LogInfo($"Card {cardInfo.cardName} displayed with {cardStats.Length} stats.");
				if (Main.RarityTextType != null)
				{
					((Component)this).gameObject.AddComponent(Main.RarityTextType);
				}
			});
			generator.GenerateRandomCard(requestPlayer, seed, generatorEventsActions);
		}
	}
	public class NormalDrawableRandomCard : DrawableRandomCard
	{
		public static List<NormalDrawableRandomCard> NormalDrawableCards = new List<NormalDrawableRandomCard>();

		public ToggleCard ToggleCard;

		public NormalDrawableRandomCard(RandomCardsGenerator statCardGenerator)
			: base(statCardGenerator)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			RandomCardOption randomCardOption = statCardGenerator.RandomCardOption;
			ToggleCard = new ToggleCard(new List<CardInfo> { CardInfo }, randomCardOption.CardName, randomCardOption.CardDescription, randomCardOption.ModInitials, randomCardOption.ColorTheme);
			ToggleCard.toggleCardInfo.rarity = randomCardOption.CardRarity;
			NormalDrawableCards.Add(this);
		}
	}
	public class ToggleCard
	{
		internal static readonly List<ToggleCard> ToggleCards = new List<ToggleCard>();

		internal static bool AllowedToggleCard = false;

		public readonly CardInfo toggleCardInfo;

		public List<CardInfo> cardsInToggle = new List<CardInfo>();

		public bool IsEnabled
		{
			get
			{
				if ((Object)(object)toggleCardInfo != (Object)null)
				{
					return CardManager.IsCardActive(toggleCardInfo);
				}
				return false;
			}
		}

		public ToggleCard(List<CardInfo> cards, string cardName, string cardDescription, string modInitials, CardThemeColorType colorTheme = 3)
		{
			//IL_008e: 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)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(Main.blankCardPrefab);
			Object.Destroy((Object)(object)((Component)obj.transform.GetChild(0)).gameObject);
			Object.DontDestroyOnLoad((Object)(object)obj);
			CardInfo component = obj.GetComponent<CardInfo>();
			ToggleCustomCard toggleCustomCard = obj.AddComponent<ToggleCustomCard>();
			component.cardName = cardName;
			component.cardDestription = cardDescription;
			component.cardBase = Main.blankCardPrefab.GetComponent<CardInfo>().cardBase;
			component.rarity = (Rarity)0;
			component.colorTheme = colorTheme;
			toggleCustomCard.ModInitials = modInitials;
			((CustomCard)toggleCustomCard).RegisterUnityCard((Action<CardInfo>)delegate
			{
				LoggerUtils.LogInfo("Register toggle card " + cardName + " with description: " + cardDescription + " and mod initials: " + modInitials);
			});
			cardsInToggle = cards;
			ToggleCards.Add(this);
			toggleCardInfo = component;
		}

		public bool IsCardEnabledInstance(CardInfo cardInfo)
		{
			if ((Object)(object)cardInfo == (Object)null)
			{
				return false;
			}
			CardInfo val = cardInfo;
			if ((Object)(object)val.sourceCard != (Object)null)
			{
				val = val.sourceCard;
			}
			if (cardsInToggle.Contains(val))
			{
				return IsEnabled;
			}
			return true;
		}

		public static bool IsCardEnabled(CardInfo cardInfo)
		{
			CardInfo val = cardInfo;
			if ((Object)(object)val.sourceCard != (Object)null)
			{
				val = val.sourceCard;
			}
			foreach (ToggleCard toggleCard in ToggleCards)
			{
				if (!toggleCard.IsCardEnabledInstance(val))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal class ToggleCustomCard : CustomCard
	{
		public string ModInitials;

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
		}

		protected override GameObject GetCardArt()
		{
			return base.cardInfo.cardArt;
		}

		protected override string GetDescription()
		{
			return base.cardInfo.cardDestription;
		}

		protected override Rarity GetRarity()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return base.cardInfo.rarity;
		}

		protected override CardInfoStat[] GetStats()
		{
			return base.cardInfo.cardStats;
		}

		protected override CardThemeColorType GetTheme()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return base.cardInfo.colorTheme;
		}

		protected override string GetTitle()
		{
			return base.cardInfo.cardName;
		}

		public override string GetModName()
		{
			return ModInitials;
		}
	}
}