using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ModdingUtils.Utils;
using RarityLib.Utils;
using ReksikCards.Cards;
using ReksikCards.Culture;
using ReksikCards.Monos;
using ReksikCards.Vfx;
using TMPro;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Networking;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ReksikCards")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0fbecc4f03dc29fe44c83f8b0218e1023db9b306")]
[assembly: AssemblyProduct("ReksikCards")]
[assembly: AssemblyTitle("ReksikCards")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ReksikCards
{
	public enum ReksikBondId
	{
		Workshop,
		IronPact,
		Harmony,
		RedDetonation,
		LongGame,
		BossProtocol
	}
	public sealed class ReksikBondDefinition
	{
		public ReksikBondId Id { get; }

		public string Key { get; }

		public string DisplayName { get; }

		public string CompactName { get; }

		public string FirstCardName { get; }

		public string SecondCardName { get; }

		internal ReksikBondDefinition(ReksikBondId id, string key, string displayName, string compactName, string firstCardName, string secondCardName)
		{
			Id = id;
			Key = key;
			DisplayName = displayName;
			CompactName = compactName;
			FirstCardName = firstCardName;
			SecondCardName = secondCardName;
		}
	}
	public sealed class ReksikActiveBond
	{
		public ReksikBondDefinition Definition { get; }

		public int FirstCount { get; }

		public int SecondCount { get; }

		public int CombinedLevel { get; }

		public float BondPower { get; }

		internal ReksikActiveBond(ReksikBondDefinition definition, int firstCount, int secondCount, int combinedLevel, float bondPower)
		{
			Definition = definition;
			FirstCount = firstCount;
			SecondCount = secondCount;
			CombinedLevel = combinedLevel;
			BondPower = bondPower;
		}
	}
	public static class ReksikBonds
	{
		private static readonly ReksikBondDefinition[] DefinitionsInternal = new ReksikBondDefinition[6]
		{
			new ReksikBondDefinition(ReksikBondId.Workshop, "workshop", "Workshop", "WS", "Artem", "Sosnovka"),
			new ReksikBondDefinition(ReksikBondId.IronPact, "iron-pact", "Iron Pact", "IP", "Daniil", "Dmitriy"),
			new ReksikBondDefinition(ReksikBondId.Harmony, "harmony", "Harmony", "HY", "Tukson", "Nesen"),
			new ReksikBondDefinition(ReksikBondId.RedDetonation, "red-detonation", "Red Detonation", "RD", "Fedr", "Viktor"),
			new ReksikBondDefinition(ReksikBondId.LongGame, "long-game", "Long Game", "LG", "Egor", "Matvey"),
			new ReksikBondDefinition(ReksikBondId.BossProtocol, "boss-protocol", "Boss Protocol", "BP", "Rex", "Agent")
		};

		public static IReadOnlyList<ReksikBondDefinition> Definitions => DefinitionsInternal;

		public static int Count(Player player, string cardName)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(cardName))
			{
				return 0;
			}
			ReksikStackTrackerMono component = ((Component)player).gameObject.GetComponent<ReksikStackTrackerMono>();
			if (!((Object)(object)component != (Object)null))
			{
				return 0;
			}
			return component.Get(cardName);
		}

		public static bool Has(Player player, string cardName)
		{
			return Count(player, cardName) > 0;
		}

		public static bool Has(Player player, ReksikBondId bondId)
		{
			ReksikBondDefinition reksikBondDefinition = Find(bondId);
			if (reksikBondDefinition != null && Has(player, reksikBondDefinition.FirstCardName))
			{
				return Has(player, reksikBondDefinition.SecondCardName);
			}
			return false;
		}

		public static bool Has(Player player, string firstCardName, string secondCardName)
		{
			if (Has(player, firstCardName))
			{
				return Has(player, secondCardName);
			}
			return false;
		}

		public static int CombinedLevel(Player player, ReksikBondId bondId)
		{
			ReksikBondDefinition reksikBondDefinition = Find(bondId);
			if (reksikBondDefinition != null)
			{
				return CombinedLevel(player, reksikBondDefinition);
			}
			return 0;
		}

		public static int CombinedLevel(Player player, string bondKey)
		{
			ReksikBondDefinition reksikBondDefinition = Find(bondKey);
			if (reksikBondDefinition != null)
			{
				return CombinedLevel(player, reksikBondDefinition);
			}
			return 0;
		}

		public static int CombinedLevel(Player player, string firstCardName, string secondCardName)
		{
			int num = Count(player, firstCardName);
			int num2 = Count(player, secondCardName);
			if (num <= 0 || num2 <= 0)
			{
				return 0;
			}
			return num + num2 - 1;
		}

		public static int CombinedLevel(Player player, ReksikBondDefinition definition)
		{
			if (definition == null)
			{
				return 0;
			}
			return CombinedLevel(player, definition.FirstCardName, definition.SecondCardName);
		}

		public static float BondPower(Player player, ReksikBondId bondId)
		{
			return BondPower(CombinedLevel(player, bondId));
		}

		public static float BondPower(Player player, string bondKey)
		{
			return BondPower(CombinedLevel(player, bondKey));
		}

		public static float BondPower(Player player, ReksikBondDefinition definition)
		{
			return BondPower(CombinedLevel(player, definition));
		}

		public static float BondPower(int combinedLevel)
		{
			if (!ReksikHostSettings.BondsEnabled || combinedLevel <= 0)
			{
				return 0f;
			}
			return (float)combinedLevel * ReksikHostSettings.MechanicPower;
		}

		public static IEnumerable<ReksikActiveBond> ActiveBonds(Player player)
		{
			for (int i = 0; i < DefinitionsInternal.Length; i++)
			{
				ReksikBondDefinition reksikBondDefinition = DefinitionsInternal[i];
				int num = Count(player, reksikBondDefinition.FirstCardName);
				int num2 = Count(player, reksikBondDefinition.SecondCardName);
				if (num > 0 && num2 > 0)
				{
					int combinedLevel = num + num2 - 1;
					yield return new ReksikActiveBond(reksikBondDefinition, num, num2, combinedLevel, BondPower(combinedLevel));
				}
			}
		}

		public static IEnumerable<ReksikActiveBond> GetActiveBonds(Player player)
		{
			return ActiveBonds(player);
		}

		public static ReksikBondDefinition? Find(ReksikBondId bondId)
		{
			for (int i = 0; i < DefinitionsInternal.Length; i++)
			{
				if (DefinitionsInternal[i].Id == bondId)
				{
					return DefinitionsInternal[i];
				}
			}
			return null;
		}

		public static ReksikBondDefinition? Find(string bondKey)
		{
			if (string.IsNullOrEmpty(bondKey))
			{
				return null;
			}
			for (int i = 0; i < DefinitionsInternal.Length; i++)
			{
				ReksikBondDefinition reksikBondDefinition = DefinitionsInternal[i];
				if (string.Equals(reksikBondDefinition.Key, bondKey, StringComparison.OrdinalIgnoreCase) || string.Equals(reksikBondDefinition.DisplayName, bondKey, StringComparison.OrdinalIgnoreCase))
				{
					return reksikBondDefinition;
				}
			}
			return null;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency("root.rarity.lib", "1.3.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.reksikcards.rounds", "ReksikCards", "5.0.0")]
	[BepInProcess("Rounds.exe")]
	public class ReksikCardsPlugin : BaseUnityPlugin
	{
		public const string ModId = "com.reksikcards.rounds";

		public const string ModName = "ReksikCards";

		public const string Version = "5.0.0";

		public const string ModInitials = "Reksik";

		private float nextBondScanAt;

		public static ReksikCardsPlugin Instance { get; private set; }

		internal static void LogCultureRuntime(string message)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				((BaseUnityPlugin)Instance).Logger.LogInfo((object)message);
			}
		}

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("com.reksikcards.rounds").PatchAll();
		}

		private void Start()
		{
			Instance = this;
			ReksikHostSettings.Initialize(((BaseUnityPlugin)this).Config);
			ReksikSettingsMenu.Register();
			ReksikHostSettings.StartNetworking();
			CustomCard.BuildCard<RexCard>();
			CustomCard.BuildCard<ViktorCard>();
			CustomCard.BuildCard<DaniilCard>();
			CustomCard.BuildCard<DmitriyCard>();
			CustomCard.BuildCard<RetiredTankerCard>();
			CustomCard.BuildCard<AgentCard>();
			CustomCard.BuildCard<EgorCard>();
			CustomCard.BuildCard<NazarCard>();
			CustomCard.BuildCard<MatveyCard>();
			CustomCard.BuildCard<MatusovskyCard>();
			CustomCard.BuildCard<RomanCard>();
			CustomCard.BuildCard<TuksonCard>();
			CustomCard.BuildCard<NesenCard>();
			CustomCard.BuildCard<RostislavCard>();
			CustomCard.BuildCard<FedrCard>();
			CustomCard.BuildCard<MaksimCard>();
			CustomCard.BuildCard<SosnovkaCard>();
			CustomCard.BuildCard<ArtemCard>();
			CustomCard.BuildCard<Subject8Card>();
			CustomCard.BuildCard<KsyushaCard>();
			CustomCard.BuildCard<ArinaCard>();
			CustomCard.BuildCard<OneAndMinusOneCard>();
			CulturalCardRegistry.RegisterAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("ReksikCards 5.0.0 loaded: 22 manual + " + 198 + " Culture cards registered."));
		}

		private void Update()
		{
			ReksikHostSettings.UpdateHostSync();
			ReksikRarityWeights.Update();
			if (Time.unscaledTime < nextBondScanAt)
			{
				return;
			}
			nextBondScanAt = Time.unscaledTime + 0.75f;
			if ((Object)(object)PlayerManager.instance == (Object)null || PlayerManager.instance.players == null)
			{
				return;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player != (Object)null)
				{
					ReksikBondSystemMono.GetOrAdd(player);
				}
			}
		}
	}
	internal static class ReksikRuntimeStatMath
	{
		private const float MultiplierEpsilon = 0.0001f;

		public static float ApplyMultiplier(float currentValue, ref float appliedMultiplier, float newMultiplier, float minValue = float.NegativeInfinity, float maxValue = float.PositiveInfinity)
		{
			float num = RemoveMultiplierCore(currentValue, appliedMultiplier);
			float num2 = Mathf.Max(0.0001f, newMultiplier);
			float num3 = ClampFloat(num * num2, minValue, maxValue);
			appliedMultiplier = ((Mathf.Abs(num) < 0.0001f) ? 1f : (num3 / num));
			return num3;
		}

		public static float RemoveMultiplier(float currentValue, ref float appliedMultiplier, float minValue = float.NegativeInfinity, float maxValue = float.PositiveInfinity)
		{
			float value = RemoveMultiplierCore(currentValue, appliedMultiplier);
			appliedMultiplier = 1f;
			return ClampFloat(value, minValue, maxValue);
		}

		public static float ApplyAdditive(float currentValue, ref float appliedAmount, float newAmount, float minValue = float.NegativeInfinity, float maxValue = float.PositiveInfinity)
		{
			float num = currentValue - appliedAmount;
			float num2 = ClampFloat(num + newAmount, minValue, maxValue);
			appliedAmount = num2 - num;
			return num2;
		}

		public static float RemoveAdditive(float currentValue, ref float appliedAmount, float minValue = float.NegativeInfinity, float maxValue = float.PositiveInfinity)
		{
			float value = currentValue - appliedAmount;
			appliedAmount = 0f;
			return ClampFloat(value, minValue, maxValue);
		}

		public static float ApplyMinimumBoost(float currentValue, ref float appliedAmount, float minimumValue)
		{
			float num = currentValue - appliedAmount;
			appliedAmount = Mathf.Max(0f, minimumValue - num);
			return num + appliedAmount;
		}

		public static float RemoveMinimumBoost(float currentValue, ref float appliedAmount)
		{
			return RemoveAdditive(currentValue, ref appliedAmount);
		}

		public static int ApplyAdditive(int currentValue, ref int appliedAmount, int newAmount, int minValue = int.MinValue, int maxValue = int.MaxValue)
		{
			int num = currentValue - appliedAmount;
			int num2 = Mathf.Clamp(num + newAmount, minValue, maxValue);
			appliedAmount = num2 - num;
			return num2;
		}

		public static int RemoveAdditive(int currentValue, ref int appliedAmount, int minValue = int.MinValue, int maxValue = int.MaxValue)
		{
			int num = currentValue - appliedAmount;
			appliedAmount = 0;
			return Mathf.Clamp(num, minValue, maxValue);
		}

		private static float RemoveMultiplierCore(float currentValue, float appliedMultiplier)
		{
			float num = ((Mathf.Abs(appliedMultiplier) < 0.0001f) ? 1f : appliedMultiplier);
			return currentValue / num;
		}

		private static float ClampFloat(float value, float minValue, float maxValue)
		{
			if (!float.IsNegativeInfinity(minValue))
			{
				value = Mathf.Max(minValue, value);
			}
			if (!float.IsPositiveInfinity(maxValue))
			{
				value = Mathf.Min(maxValue, value);
			}
			return value;
		}
	}
	internal static class ReksikUtils
	{
		private static readonly FieldInfo PlayerVelocityField = typeof(PlayerVelocity).GetField("velocity", BindingFlags.Instance | BindingFlags.NonPublic);

		public static IEnumerable<Player> EnemyPlayers(Player self)
		{
			if ((Object)(object)PlayerManager.instance == (Object)null || PlayerManager.instance.players == null || (Object)(object)self == (Object)null)
			{
				yield break;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if (!((Object)(object)player == (Object)null) && player.teamID != self.teamID)
				{
					yield return player;
				}
			}
		}

		public static Player? GetClosestEnemy(Player self)
		{
			//IL_0011: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self == (Object)null)
			{
				return null;
			}
			Vector2 val = Vector2.op_Implicit(((Component)self).transform.position);
			Player result = null;
			float num = float.MaxValue;
			foreach (Player item in EnemyPlayers(self))
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.data == (Object)null) && !item.data.dead)
				{
					Vector2 val2 = Vector2.op_Implicit(((Component)item).transform.position) - val;
					float sqrMagnitude = ((Vector2)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = item;
					}
				}
			}
			return result;
		}

		public static Player? GetClosestEnemy(Player self, float maxRange)
		{
			//IL_001b: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self == (Object)null)
			{
				return null;
			}
			if (maxRange <= 0f)
			{
				return null;
			}
			Vector2 val = Vector2.op_Implicit(((Component)self).transform.position);
			float num = maxRange * maxRange;
			Player result = null;
			float num2 = num;
			foreach (Player item in EnemyPlayers(self))
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.data == (Object)null) && !item.data.dead)
				{
					Vector2 val2 = Vector2.op_Implicit(((Component)item).transform.position) - val;
					float sqrMagnitude = ((Vector2)(ref val2)).sqrMagnitude;
					if (sqrMagnitude <= num2)
					{
						num2 = sqrMagnitude;
						result = item;
					}
				}
			}
			return result;
		}

		public static float GetDamageFactor(Player p)
		{
			try
			{
				if ((Object)(object)p == (Object)null || (Object)(object)p.data == (Object)null || (Object)(object)p.data.weaponHandler == (Object)null || (Object)(object)p.data.weaponHandler.gun == (Object)null)
				{
					return 1f;
				}
				float damage = p.data.weaponHandler.gun.damage;
				if (float.IsNaN(damage) || float.IsInfinity(damage))
				{
					return 1f;
				}
				return Mathf.Clamp(damage, 0.05f, 50f);
			}
			catch
			{
				return 1f;
			}
		}

		public static float HealthFraction(Player p)
		{
			if ((Object)(object)p == (Object)null || (Object)(object)p.data == (Object)null)
			{
				return 1f;
			}
			if (p.data.maxHealth <= 0f)
			{
				return 1f;
			}
			return Mathf.Clamp01(p.data.health / p.data.maxHealth);
		}

		public static void Heal(Player p, float amount)
		{
			if (!((Object)(object)p == (Object)null) && !((Object)(object)p.data == (Object)null))
			{
				p.data.health = Mathf.Min(p.data.maxHealth, p.data.health + amount);
			}
		}

		public static void AddVelocity(Player p, Vector2 add)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null || (Object)(object)p.data == (Object)null)
			{
				return;
			}
			if (PlayerVelocityField != null && (Object)(object)p.data.playerVel != (Object)null)
			{
				try
				{
					Vector2 val = (Vector2)PlayerVelocityField.GetValue(p.data.playerVel);
					PlayerVelocityField.SetValue(p.data.playerVel, val + add);
					return;
				}
				catch (Exception)
				{
				}
			}
			MoveTransform componentInChildren = ((Component)p).GetComponentInChildren<MoveTransform>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.velocity += new Vector3(add.x, add.y, 0f);
			}
		}

		public static void AddHorizontalVelocityTowards(Player p, Vector2 target, float force)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null || (Object)(object)p.data == (Object)null || Mathf.Approximately(force, 0f))
			{
				return;
			}
			float num = target.x - ((Component)p).transform.position.x;
			if (Mathf.Abs(num) < 0.05f)
			{
				try
				{
					num = ((Component)p.data.weaponHandler.gun).transform.right.x;
				}
				catch
				{
					num = 1f;
				}
			}
			AddVelocity(p, new Vector2(Mathf.Sign(num) * force, 0f));
		}

		public static bool IsLocallyOwned(Player player)
		{
			try
			{
				object obj = (((Object)(object)player == (Object)null) ? null : player.data);
				if (obj == null)
				{
					return false;
				}
				Type type = obj.GetType();
				object obj2 = type.GetField("view", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj);
				if (obj2 == null)
				{
					obj2 = type.GetProperty("view", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj, null);
				}
				if (obj2 == null)
				{
					return false;
				}
				PropertyInfo property = obj2.GetType().GetProperty("IsMine", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				bool flag = default(bool);
				int num;
				if (property != null)
				{
					object value = property.GetValue(obj2, null);
					if (value is bool)
					{
						flag = (bool)value;
						num = 1;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch
			{
				return false;
			}
		}

		public static string GetNickname(Player p)
		{
			try
			{
				object obj = (((Object)(object)p == (Object)null) ? null : p.data);
				if (obj == null)
				{
					return string.Empty;
				}
				Type type = obj.GetType();
				object obj2 = null;
				FieldInfo field = type.GetField("view", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				obj2 = ((!(field != null)) ? type.GetProperty("view", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(obj, null) : field.GetValue(obj));
				if (obj2 == null)
				{
					return string.Empty;
				}
				object obj3 = obj2.GetType().GetProperty("Owner", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj2, null);
				if (obj3 == null)
				{
					return string.Empty;
				}
				return (obj3.GetType().GetProperty("NickName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj3, null) as string) ?? string.Empty;
			}
			catch
			{
				return string.Empty;
			}
		}
	}
}
namespace ReksikCards.Culture
{
	public static class CulturalCardCatalog
	{
		public const int ExpectedCount = 198;

		private const string TypePrefix = "CulturalCard";

		private const string ClassroomSource = "Classroom of the Elite";

		private static readonly string[] AllowedSources;

		private static readonly IReadOnlyList<CulturalCardDefinition> AllInternal;

		private static readonly Dictionary<string, CulturalCardDefinition> ByStableId;

		public static IReadOnlyList<CulturalCardDefinition> All => AllInternal;

		static CulturalCardCatalog()
		{
			AllowedSources = new string[8] { "Foundation", "Lord of War", "Kaguya-sama", "Code Geass", "Zirkonavty", "Classroom of the Elite", "Project Hail Mary", "Amazing Digital Circus" };
			AllInternal = Array.AsReadOnly(BuildSeed());
			ByStableId = BuildStableIdIndex(AllInternal);
			Validate(AllInternal);
		}

		public static CulturalCardDefinition GetByIndex(int index)
		{
			if (index < 0 || index >= AllInternal.Count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			return AllInternal[index];
		}

		public static CulturalCardDefinition GetByCardType(Type cardType)
		{
			if (cardType == null)
			{
				throw new ArgumentNullException("cardType");
			}
			string name = cardType.Name;
			if (name.StartsWith("CulturalCard", StringComparison.Ordinal) && name.Length == "CulturalCard".Length + 3 && int.TryParse(name.Substring("CulturalCard".Length), NumberStyles.None, CultureInfo.InvariantCulture, out var result) && result >= 0 && result < AllInternal.Count)
			{
				return GetByIndex(result);
			}
			throw new KeyNotFoundException("Type '" + cardType.FullName + "' is not a CulturalCard000..CulturalCard197 type.");
		}

		public static CulturalCardDefinition GetByStableId(string stableId)
		{
			if (stableId == null)
			{
				throw new ArgumentNullException("stableId");
			}
			if (ByStableId.TryGetValue(stableId, out CulturalCardDefinition value))
			{
				return value;
			}
			throw new KeyNotFoundException("Unknown cultural stable id '" + stableId + "'.");
		}

		private static CulturalCardDefinition[] BuildSeed()
		{
			List<CulturalCardDefinition> list = new List<CulturalCardDefinition>(198);
			Add(list, 0, "Hari Seldon", "Foundation", "foundation-psychohistory", legendary: true);
			Add(list, 1, "Gaal Dornick", "Foundation", "foundation-psychohistory");
			Add(list, 2, "Salvor Hardin", "Foundation", "foundation-psychohistory");
			Add(list, 3, "Hober Mallow", "Foundation", "foundation-psychohistory");
			Add(list, 4, "Bayta Darell", "Foundation", "foundation-psychohistory");
			Add(list, 5, "The Mule", "Foundation", "foundation-psychohistory", legendary: true);
			Add(list, 6, "Arkady Darell", "Foundation", "foundation-psychohistory");
			Add(list, 7, "Eto Demerzel", "Foundation", "foundation-plan");
			Add(list, 8, "Psychohistory", "Foundation", "foundation-plan");
			Add(list, 9, "Seldon Plan", "Foundation", "foundation-plan");
			Add(list, 10, "Terminus Vault", "Foundation", "foundation-plan");
			Add(list, 11, "Prime Radiant", "Foundation", "foundation-plan");
			Add(list, 12, "Second Foundation", "Foundation", "foundation-plan");
			Add(list, 13, "First Foundation", "Foundation", "foundation-crisis");
			Add(list, 14, "Encyclopedia Galactica", "Foundation", "foundation-crisis");
			Add(list, 15, "Imperial Trantor", "Foundation", "foundation-crisis");
			Add(list, 16, "Anacreon Crisis", "Foundation", "foundation-crisis");
			Add(list, 17, "Four Kingdoms", "Foundation", "foundation-crisis");
			Add(list, 18, "Trader Prince", "Foundation", "foundation-crisis");
			Add(list, 19, "Mentalic Shield", "Foundation", "foundation-mentalic");
			Add(list, 20, "Time Vault", "Foundation", "foundation-mentalic");
			Add(list, 21, "Galactic Empire", "Foundation", "foundation-mentalic");
			Add(list, 22, "Foundation's Edge", "Foundation", "foundation-mentalic");
			Add(list, 23, "Gaia Consensus", "Foundation", "foundation-mentalic");
			Add(list, 24, "Star's End", "Foundation", "foundation-mentalic");
			Add(list, 25, "Yuri Orlov", "Lord of War", "lord-of-war-trade", legendary: true);
			Add(list, 26, "Vitaly Orlov", "Lord of War", "lord-of-war-trade");
			Add(list, 27, "Ava Fontaine", "Lord of War", "lord-of-war-trade");
			Add(list, 28, "Jack Valentine", "Lord of War", "lord-of-war-trade");
			Add(list, 29, "Simeon Weisz", "Lord of War", "lord-of-war-trade");
			Add(list, 30, "Andre Baptiste Sr.", "Lord of War", "lord-of-war-trade");
			Add(list, 31, "Andre Baptiste Jr.", "Lord of War", "lord-of-war-logistics");
			Add(list, 32, "Anatoly Orlov", "Lord of War", "lord-of-war-logistics");
			Add(list, 33, "Irina Orlov", "Lord of War", "lord-of-war-logistics");
			Add(list, 34, "The Bullet's Journey", "Lord of War", "lord-of-war-logistics");
			Add(list, 35, "Odessa Arsenal", "Lord of War", "lord-of-war-logistics");
			Add(list, 36, "Liberia Contract", "Lord of War", "lord-of-war-logistics");
			Add(list, 37, "Container Manifest", "Lord of War", "lord-of-war-pressure");
			Add(list, 38, "Interpol Tail", "Lord of War", "lord-of-war-pressure");
			Add(list, 39, "Arms Bazaar", "Lord of War", "lord-of-war-pressure");
			Add(list, 40, "False End-User Certificate", "Lord of War", "lord-of-war-pressure");
			Add(list, 41, "Embargo Runner", "Lord of War", "lord-of-war-pressure");
			Add(list, 42, "Cargo of Kalashnikovs", "Lord of War", "lord-of-war-pressure");
			Add(list, 43, "Gunrunner's Ledger", "Lord of War", "lord-of-war-legacy");
			Add(list, 44, "Dictator's Favor", "Lord of War", "lord-of-war-legacy");
			Add(list, 45, "Border Inspection", "Lord of War", "lord-of-war-legacy");
			Add(list, 46, "Merchant of Death", "Lord of War", "lord-of-war-legacy");
			Add(list, 47, "Family Business", "Lord of War", "lord-of-war-legacy");
			Add(list, 48, "Last Shipment", "Lord of War", "lord-of-war-legacy");
			Add(list, 49, "Supply and Demand", "Lord of War", "lord-of-war-legacy", legendary: true);
			Add(list, 50, "Kaguya Shinomiya", "Kaguya-sama", "kaguya-mind-games", legendary: true);
			Add(list, 51, "Miyuki Shirogane", "Kaguya-sama", "kaguya-mind-games", legendary: true);
			Add(list, 52, "Chika Fujiwara", "Kaguya-sama", "kaguya-mind-games");
			Add(list, 53, "Yu Ishigami", "Kaguya-sama", "kaguya-mind-games");
			Add(list, 54, "Miko Iino", "Kaguya-sama", "kaguya-mind-games");
			Add(list, 55, "Ai Hayasaka", "Kaguya-sama", "kaguya-mind-games");
			Add(list, 56, "Kei Shirogane", "Kaguya-sama", "kaguya-student-council");
			Add(list, 57, "Maki Shijo", "Kaguya-sama", "kaguya-student-council");
			Add(list, 58, "Nagisa Kashiwagi", "Kaguya-sama", "kaguya-student-council");
			Add(list, 59, "Tsubasa Tanuma", "Kaguya-sama", "kaguya-student-council");
			Add(list, 60, "Papa Shirogane", "Kaguya-sama", "kaguya-student-council");
			Add(list, 61, "Kobachi Osaragi", "Kaguya-sama", "kaguya-student-council");
			Add(list, 62, "Mikado Shijo", "Kaguya-sama", "kaguya-festival");
			Add(list, 63, "Student Council Room", "Kaguya-sama", "kaguya-festival");
			Add(list, 64, "Love Is War", "Kaguya-sama", "kaguya-festival");
			Add(list, 65, "Psychological Feint", "Kaguya-sama", "kaguya-festival");
			Add(list, 66, "French Exchange Party", "Kaguya-sama", "kaguya-festival");
			Add(list, 67, "Fireworks Promise", "Kaguya-sama", "kaguya-festival");
			Add(list, 68, "Moon Viewing", "Kaguya-sama", "kaguya-confession");
			Add(list, 69, "Election Campaign", "Kaguya-sama", "kaguya-confession");
			Add(list, 70, "Culture Festival Heart", "Kaguya-sama", "kaguya-confession");
			Add(list, 71, "Dual Confession", "Kaguya-sama", "kaguya-confession");
			Add(list, 72, "Impossible Challenge", "Kaguya-sama", "kaguya-confession");
			Add(list, 73, "Secret Cosplay", "Kaguya-sama", "kaguya-confession");
			Add(list, 74, "Ramen Emperor", "Kaguya-sama", "kaguya-confession");
			Add(list, 75, "Lelouch vi Britannia", "Code Geass", "code-geass-geass", legendary: true);
			Add(list, 76, "C.C.", "Code Geass", "code-geass-geass", legendary: true);
			Add(list, 77, "Suzaku Kururugi", "Code Geass", "code-geass-knightmare");
			Add(list, 78, "Kallen Kozuki", "Code Geass", "code-geass-knightmare");
			Add(list, 79, "Nunnally vi Britannia", "Code Geass", "code-geass-requiem");
			Add(list, 80, "Schneizel el Britannia", "Code Geass", "code-geass-requiem");
			Add(list, 81, "Euphemia li Britannia", "Code Geass", "code-geass-requiem");
			Add(list, 82, "Jeremiah Gottwald", "Code Geass", "code-geass-factions");
			Add(list, 83, "Cornelia li Britannia", "Code Geass", "code-geass-factions");
			Add(list, 84, "Rolo Lamperouge", "Code Geass", "code-geass-geass");
			Add(list, 85, "Shirley Fenette", "Code Geass", "code-geass-requiem");
			Add(list, 86, "Charles zi Britannia", "Code Geass", "code-geass-geass");
			Add(list, 87, "V.V.", "Code Geass", "code-geass-geass");
			Add(list, 88, "Lloyd Asplund", "Code Geass", "code-geass-knightmare");
			Add(list, 89, "Rakshata Chawla", "Code Geass", "code-geass-knightmare");
			Add(list, 90, "Zero Requiem", "Code Geass", "code-geass-requiem", legendary: true);
			Add(list, 91, "Geass Command", "Code Geass", "code-geass-geass");
			Add(list, 92, "Black Knights", "Code Geass", "code-geass-factions");
			Add(list, 93, "Knightmare Gawain", "Code Geass", "code-geass-knightmare");
			Add(list, 94, "Lancelot Albion", "Code Geass", "code-geass-knightmare");
			Add(list, 95, "Guren Mk-II", "Code Geass", "code-geass-knightmare");
			Add(list, 96, "Damocles", "Code Geass", "code-geass-requiem");
			Add(list, 97, "F.L.E.I.J.A.", "Code Geass", "code-geass-requiem");
			Add(list, 98, "Sword of Akasha", "Code Geass", "code-geass-geass");
			Add(list, 99, "Rebellion Broadcast", "Code Geass", "code-geass-factions");
			Add(list, 100, "Star Captain", "Zirkonavty", "zirkonavty-navigation", legendary: true);
			Add(list, 101, "Orbital Navigator", "Zirkonavty", "zirkonavty-navigation");
			Add(list, 102, "Void Cartographer", "Zirkonavty", "zirkonavty-navigation");
			Add(list, 103, "Comet Signal", "Zirkonavty", "zirkonavty-navigation");
			Add(list, 104, "Solar Sail", "Zirkonavty", "zirkonavty-navigation");
			Add(list, 105, "Nebula Passage", "Zirkonavty", "zirkonavty-navigation");
			Add(list, 106, "Gravity Well", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 107, "Cryogenic Watch", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 108, "Lunar Relay", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 109, "Red Dwarf Route", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 110, "Deep-Space Beacon", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 111, "Meteor Shield", "Zirkonavty", "zirkonavty-engineering");
			Add(list, 112, "Stellar Map", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 113, "Silent Orbit", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 114, "Cosmic EVA", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 115, "Ion Wake", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 116, "Photon Reserve", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 117, "Black-Sky Protocol", "Zirkonavty", "zirkonavty-expedition");
			Add(list, 118, "Asteroid Harbor", "Zirkonavty", "zirkonavty-signals");
			Add(list, 119, "Wormhole Estimate", "Zirkonavty", "zirkonavty-signals");
			Add(list, 120, "Exoplanet Dawn", "Zirkonavty", "zirkonavty-signals");
			Add(list, 121, "Radio Horizon", "Zirkonavty", "zirkonavty-signals");
			Add(list, 122, "Return Burn", "Zirkonavty", "zirkonavty-signals");
			Add(list, 123, "Constellation Pact", "Zirkonavty", "zirkonavty-signals");
			Add(list, 124, "Homeworld Signal", "Zirkonavty", "zirkonavty-signals", legendary: true);
			Add(list, 125, "Kiyotaka Ayanokoji", "Classroom of the Elite", "classroom-hidden-genius", legendary: true);
			Add(list, 126, "Suzune Horikita", "Classroom of the Elite", "classroom-class-leaders", legendary: true);
			Add(list, 127, "Kikyo Kushida", "Classroom of the Elite", "classroom-social-web");
			Add(list, 128, "Class D Survival Test", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 129, "Island Special Exam", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 130, "Kei Karuizawa", "Classroom of the Elite", "classroom-social-web");
			Add(list, 131, "Kakeru Ryuen", "Classroom of the Elite", "classroom-class-leaders", legendary: true);
			Add(list, 132, "Yosuke Hirata", "Classroom of the Elite", "classroom-social-web");
			Add(list, 133, "Sports Festival", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 134, "Paper Shuffle", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 135, "Rooftop Confrontation", "Classroom of the Elite", "classroom-hidden-genius");
			Add(list, 136, "Arisu Sakayanagi", "Classroom of the Elite", "classroom-class-leaders");
			Add(list, 137, "Honami Ichinose", "Classroom of the Elite", "classroom-class-leaders");
			Add(list, 138, "Hiyori Shiina", "Classroom of the Elite", "classroom-social-web");
			Add(list, 139, "Mixed Training Camp", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 140, "Event Selection Exam", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 141, "Class Poll", "Classroom of the Elite", "classroom-special-exams");
			Add(list, 142, "Ichika Amasawa", "Classroom of the Elite", "classroom-white-room");
			Add(list, 143, "Takuya Yagami", "Classroom of the Elite", "classroom-white-room");
			Add(list, 144, "Tsubasa Nanase", "Classroom of the Elite", "classroom-first-years");
			Add(list, 145, "Kazuomi Hosen", "Classroom of the Elite", "classroom-first-years");
			Add(list, 146, "First-Year Special Exam", "Classroom of the Elite", "classroom-first-years");
			Add(list, 147, "Year Two Strategy", "Classroom of the Elite", "classroom-hidden-genius");
			Add(list, 148, "Ryland Grace", "Project Hail Mary", "hail-mary-science", legendary: true);
			Add(list, 149, "Rocky the Eridian", "Project Hail Mary", "hail-mary-science", legendary: true);
			Add(list, 150, "Eva Stratt", "Project Hail Mary", "hail-mary-science");
			Add(list, 151, "Yao Li-Jie", "Project Hail Mary", "hail-mary-science");
			Add(list, 152, "Olesya Ilyukhina", "Project Hail Mary", "hail-mary-science");
			Add(list, 153, "Martin DuBois", "Project Hail Mary", "hail-mary-science");
			Add(list, 154, "Annie Shapiro", "Project Hail Mary", "hail-mary-mission");
			Add(list, 155, "Dimitri Komorov", "Project Hail Mary", "hail-mary-mission");
			Add(list, 156, "Astrophage", "Project Hail Mary", "hail-mary-mission", legendary: true);
			Add(list, 157, "Petrova Line", "Project Hail Mary", "hail-mary-mission");
			Add(list, 158, "Hail Mary Vessel", "Project Hail Mary", "hail-mary-mission");
			Add(list, 159, "Blip-A", "Project Hail Mary", "hail-mary-mission");
			Add(list, 160, "Eridian Tunnel", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 161, "Tau Ceti Mission", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 162, "Ammonia Atmosphere", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 163, "Xenonite", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 164, "Spin Drive", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 165, "Chain Model", "Project Hail Mary", "hail-mary-engineering");
			Add(list, 166, "Taumoeba", "Project Hail Mary", "hail-mary-survival");
			Add(list, 167, "Nitrogen Resistance", "Project Hail Mary", "hail-mary-survival");
			Add(list, 168, "Centrifuge Lab", "Project Hail Mary", "hail-mary-survival");
			Add(list, 169, "Beatles Databank", "Project Hail Mary", "hail-mary-survival");
			Add(list, 170, "Three-Body Orbit", "Project Hail Mary", "hail-mary-survival");
			Add(list, 171, "Save Erid", "Project Hail Mary", "hail-mary-survival");
			Add(list, 172, "Save Earth", "Project Hail Mary", "hail-mary-survival");
			Add(list, 173, "Pomni", "Amazing Digital Circus", "digital-circus-cast", legendary: true);
			Add(list, 174, "Caine", "Amazing Digital Circus", "digital-circus-cast", legendary: true);
			Add(list, 175, "Jax", "Amazing Digital Circus", "digital-circus-cast");
			Add(list, 176, "Ragatha", "Amazing Digital Circus", "digital-circus-cast");
			Add(list, 177, "Gangle", "Amazing Digital Circus", "digital-circus-cast");
			Add(list, 178, "Zooble", "Amazing Digital Circus", "digital-circus-cast");
			Add(list, 179, "Kinger", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 180, "Bubble", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 181, "Kaufmo", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 182, "Gummigoo", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 183, "Princess Loolilalu", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 184, "The Fudge", "Amazing Digital Circus", "digital-circus-adventure");
			Add(list, 185, "The Moon", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 186, "The Sun", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 187, "Digital Circus Tent", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 188, "Exit Door", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 189, "Abstracted Cellar", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 190, "Candy Canyon Kingdom", "Amazing Digital Circus", "digital-circus-abstraction");
			Add(list, 191, "In-House Adventure", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 192, "NPC Paradox", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 193, "Comedy Mask", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 194, "Tragedy Mask", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 195, "Glitching Hallway", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 196, "Caine's Roulette", "Amazing Digital Circus", "digital-circus-chaos");
			Add(list, 197, "The Void Beyond", "Amazing Digital Circus", "digital-circus-chaos");
			return list.ToArray();
		}

		private static void Add(List<CulturalCardDefinition> cards, int index, string title, string sourceKey, string familyId, bool legendary = false)
		{
			string stableId = "CulturalCard" + index.ToString("D3", CultureInfo.InvariantCulture);
			CulturalRarityTier rarity = ResolveRarity(stableId, title, familyId, legendary);
			CulturalAuthoredCardProfile culturalAuthoredCardProfile = CulturalAuthoredProfileCatalog.Resolve(stableId, sourceKey);
			CulturalMechanicSpec[] mechanics = culturalAuthoredCardProfile.Mechanics;
			CulturalBaseStats baseStats = culturalAuthoredCardProfile.BaseStats;
			IReadOnlyList<CulturalCardStat> stats = CulturalCardPresentation.BuildBaseStats(baseStats);
			cards.Add(new CulturalCardDefinition(index, stableId, title, BuildDescription(stableId, culturalAuthoredCardProfile.ShowMechanic, mechanics), sourceKey, familyId, rarity, allowMultiple: true, baseStats, stats, Array.AsReadOnly(mechanics)));
		}

		private static CulturalRarityTier ResolveRarity(string stableId, string title, string familyId, bool legendary)
		{
			bool flag = IsLegendaryOverride(stableId);
			if (legendary != flag)
			{
				throw new InvalidOperationException("Legendary seed flag for '" + stableId + "' does not match its explicit profile.");
			}
			if (flag)
			{
				return CulturalRarityTier.Legendary;
			}
			if (stableId == "CulturalCard106" || stableId == "CulturalCard188" || IsRareTitle(title))
			{
				return CulturalRarityTier.Rare;
			}
			if (!IsUncommonFamily(familyId))
			{
				return CulturalRarityTier.Common;
			}
			return CulturalRarityTier.Uncommon;
		}

		private static bool IsRareTitle(string title)
		{
			switch (title)
			{
			case "Geass Command":
			case "Prime Radiant":
			case "Merchant of Death":
			case "Year Two Strategy":
			case "Abstracted Cellar":
			case "Knightmare Gawain":
			case "Terminus Vault":
			case "Culture Festival Heart":
			case "F.L.E.I.J.A.":
			case "Black-Sky Protocol":
			case "Rooftop Confrontation":
			case "Xenonite":
			case "Save Earth":
			case "The Void Beyond":
				return true;
			default:
				return false;
			}
		}

		private static bool IsUncommonFamily(string familyId)
		{
			switch (familyId)
			{
			case "foundation-crisis":
			case "hail-mary-mission":
			case "digital-circus-chaos":
			case "lord-of-war-pressure":
			case "classroom-first-years":
			case "hail-mary-engineering":
			case "zirkonavty-expedition":
			case "kaguya-festival":
			case "code-geass-factions":
			case "classroom-special-exams":
			case "digital-circus-adventure":
				return true;
			default:
				return false;
			}
		}

		private static bool IsLegendaryOverride(string stableId)
		{
			switch (stableId)
			{
			case "CulturalCard000":
			case "CulturalCard005":
			case "CulturalCard100":
			case "CulturalCard025":
			case "CulturalCard124":
			case "CulturalCard125":
			case "CulturalCard126":
			case "CulturalCard049":
			case "CulturalCard148":
			case "CulturalCard149":
			case "CulturalCard050":
			case "CulturalCard051":
			case "CulturalCard156":
			case "CulturalCard075":
			case "CulturalCard076":
			case "CulturalCard173":
			case "CulturalCard174":
			case "CulturalCard090":
			case "CulturalCard131":
				return true;
			default:
				return false;
			}
		}

		private static string BuildDescription(string stableId, bool showPrimaryMechanic, IReadOnlyList<CulturalMechanicSpec> mechanics)
		{
			if (CulturalSignatureState.HasSignature(stableId))
			{
				return string.Empty;
			}
			return CulturalCardPresentation.BuildDescription(showPrimaryMechanic, mechanics);
		}

		private static Dictionary<string, CulturalCardDefinition> BuildStableIdIndex(IReadOnlyList<CulturalCardDefinition> cards)
		{
			Dictionary<string, CulturalCardDefinition> dictionary = new Dictionary<string, CulturalCardDefinition>(StringComparer.Ordinal);
			for (int i = 0; i < cards.Count; i++)
			{
				dictionary.Add(cards[i].StableId, cards[i]);
			}
			return dictionary;
		}

		private static void Validate(IReadOnlyList<CulturalCardDefinition> cards)
		{
			if (cards.Count != 198)
			{
				throw new InvalidOperationException($"Cultural seed must contain exactly {198} cards, found {cards.Count}.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			int num = 0;
			int num2 = 0;
			float num3 = 0f;
			float num4 = 0f;
			CulturalCardDefinition culturalCardDefinition = null;
			for (int i = 0; i < AllowedSources.Length; i++)
			{
				dictionary.Add(AllowedSources[i], 0);
			}
			for (int j = 0; j < cards.Count; j++)
			{
				CulturalCardDefinition culturalCardDefinition2 = cards[j];
				string text = "CulturalCard" + j.ToString("D3", CultureInfo.InvariantCulture);
				if (culturalCardDefinition2.Index != j || !string.Equals(culturalCardDefinition2.StableId, text, StringComparison.Ordinal))
				{
					throw new InvalidOperationException($"Cultural seed index {j} must be '{text}', found index={culturalCardDefinition2.Index}, id='{culturalCardDefinition2.StableId}'.");
				}
				if (!hashSet.Add(culturalCardDefinition2.StableId))
				{
					throw new InvalidOperationException("Duplicate cultural stable id '" + culturalCardDefinition2.StableId + "'.");
				}
				if (!hashSet2.Add(culturalCardDefinition2.Title))
				{
					throw new InvalidOperationException("Duplicate cultural title '" + culturalCardDefinition2.Title + "'.");
				}
				if (!dictionary.ContainsKey(culturalCardDefinition2.SourceKey))
				{
					throw new InvalidOperationException("Cultural card '" + culturalCardDefinition2.StableId + "' uses non-whitelisted source '" + culturalCardDefinition2.SourceKey + "'.");
				}
				if (string.IsNullOrWhiteSpace(culturalCardDefinition2.FamilyId) || culturalCardDefinition2.Description.Length > 140 || culturalCardDefinition2.Stats.Count < 3 || culturalCardDefinition2.Stats.Count > 4 || culturalCardDefinition2.Mechanics.Count < 1 || culturalCardDefinition2.Mechanics.Count > 2)
				{
					throw new InvalidOperationException("Cultural card '" + culturalCardDefinition2.StableId + "' has incomplete or malformed data.");
				}
				bool flag = false;
				bool flag2 = false;
				for (int k = 0; k < culturalCardDefinition2.Stats.Count; k++)
				{
					flag |= culturalCardDefinition2.Stats[k].IsPositive;
					flag2 |= !culturalCardDefinition2.Stats[k].IsPositive;
				}
				if (!flag || (culturalCardDefinition2.Rarity != CulturalRarityTier.Legendary && !flag2))
				{
					throw new InvalidOperationException("Cultural card '" + culturalCardDefinition2.StableId + "' must expose a strong boon" + ((culturalCardDefinition2.Rarity == CulturalRarityTier.Legendary) ? "." : " and a visible tradeoff."));
				}
				if (!culturalCardDefinition2.AllowMultiple)
				{
					throw new InvalidOperationException("Cultural card '" + culturalCardDefinition2.StableId + "' must allow duplicate stacks.");
				}
				dictionary[culturalCardDefinition2.SourceKey]++;
				if (culturalCardDefinition2.Rarity == CulturalRarityTier.Legendary)
				{
					num++;
					if (!IsLegendaryOverride(culturalCardDefinition2.StableId) || culturalCardDefinition2.Mechanics.Count != 1)
					{
						throw new InvalidOperationException("Legendary card '" + culturalCardDefinition2.StableId + "' must have one explicit signature mechanic.");
					}
					float num5 = Math.Abs(culturalCardDefinition2.Mechanics[0].Magnitude * (float)culturalCardDefinition2.Mechanics[0].BurstCount);
					if (culturalCardDefinition2.StableId == "CulturalCard125")
					{
						num3 = num5;
					}
					else
					{
						num4 = Math.Max(num4, num5);
					}
				}
				if (string.Equals(culturalCardDefinition2.Title, "Kiyotaka Ayanokoji", StringComparison.Ordinal))
				{
					culturalCardDefinition = culturalCardDefinition2;
				}
				if (IsLegendaryOverride(culturalCardDefinition2.StableId))
				{
					num2++;
				}
				if (string.Equals(culturalCardDefinition2.SourceKey, "Classroom of the Elite", StringComparison.Ordinal))
				{
					if (culturalCardDefinition2.FamilyId.IndexOf("-season-", StringComparison.Ordinal) >= 0)
					{
						throw new InvalidOperationException("Classroom card '" + culturalCardDefinition2.StableId + "' still uses a season as its mechanic family.");
					}
					if (!culturalCardDefinition2.FamilyId.StartsWith("classroom-", StringComparison.Ordinal))
					{
						throw new InvalidOperationException("Classroom card '" + culturalCardDefinition2.StableId + "' uses an unrelated family '" + culturalCardDefinition2.FamilyId + "'.");
					}
					hashSet3.Add(culturalCardDefinition2.FamilyId);
				}
			}
			if (num != 19)
			{
				throw new InvalidOperationException($"Cultural seed must contain exactly 19 Legendary cards, found {num}.");
			}
			if (culturalCardDefinition == null || culturalCardDefinition.Rarity != CulturalRarityTier.Legendary)
			{
				throw new InvalidOperationException("Kiyotaka Ayanokoji must exist and be Legendary.");
			}
			if (culturalCardDefinition.BaseStats.Health < 2f || culturalCardDefinition.BaseStats.Damage < 2f || culturalCardDefinition.BaseStats.AttackSpeed > 0.5f || culturalCardDefinition.BaseStats.BlockCooldown > 0.5f)
			{
				throw new InvalidOperationException("Kiyotaka Ayanokoji must keep the strongest four-axis base profile.");
			}
			if (num2 != 19)
			{
				throw new InvalidOperationException($"Legendary profiles are incomplete: {num2}/19.");
			}
			if (num3 <= num4)
			{
				throw new InvalidOperationException("Ayanokoji must keep the strongest legendary signature coefficient.");
			}
			for (int l = 0; l < AllowedSources.Length; l++)
			{
				if (dictionary[AllowedSources[l]] <= 0)
				{
					throw new InvalidOperationException("Whitelisted source '" + AllowedSources[l] + "' has no cards.");
				}
			}
			string[] array = new string[6] { "classroom-hidden-genius", "classroom-class-leaders", "classroom-social-web", "classroom-special-exams", "classroom-white-room", "classroom-first-years" };
			for (int m = 0; m < array.Length; m++)
			{
				if (!hashSet3.Contains(array[m]))
				{
					throw new InvalidOperationException("Classroom of the Elite requires semantic family '" + array[m] + "'.");
				}
			}
		}
	}
	public enum CulturalRarityTier
	{
		Common,
		Uncommon,
		Rare,
		Legendary
	}
	public sealed class CulturalCardStat
	{
		public string Label { get; }

		public string Amount { get; }

		public bool IsPositive { get; }

		public CulturalCardStat(string label, string amount, bool isPositive)
		{
			Label = label ?? throw new ArgumentNullException("label");
			Amount = amount ?? throw new ArgumentNullException("amount");
			IsPositive = isPositive;
		}
	}
	public sealed class CulturalBaseStats
	{
		public float Health { get; set; } = 1f;

		public float MovementSpeed { get; set; } = 1f;

		public float Jump { get; set; } = 1f;

		public float PlayerGravity { get; set; } = 1f;

		public float SizeMultiplier { get; set; } = 1f;

		public int ExtraJumps { get; set; }

		public int Respawns { get; set; }

		public float LifeSteal { get; set; }

		public float Regeneration { get; set; }

		public float DamageOverTime { get; set; }

		public float Damage { get; set; } = 1f;

		public float AttackSpeed { get; set; } = 1f;

		public float Knockback { get; set; } = 1f;

		public float ProjectileSpeed { get; set; } = 1f;

		public float ProjectileSimulationSpeed { get; set; } = 1f;

		public float ProjectileGravity { get; set; } = 1f;

		public float SpreadMultiplier { get; set; } = 1f;

		public float ProjectileSizeAdd { get; set; }

		public float ReloadTime { get; set; } = 1f;

		public float ReloadTimeAdd { get; set; }

		public int Ammo { get; set; }

		public float AmmoRegeneration { get; set; }

		public int Projectiles { get; set; }

		public int Bursts { get; set; }

		public int Reflects { get; set; }

		public int Bounces { get; set; }

		public float BounceSpeed { get; set; } = 1f;

		public float BounceDamage { get; set; } = 1f;

		public float Slow { get; set; }

		public float DamageAfterDistance { get; set; } = 1f;

		public float BulletLifetime { get; set; }

		public float BlockCooldown { get; set; } = 1f;

		public float BlockCooldownAdd { get; set; }

		public float BlockHealing { get; set; }

		public int AdditionalBlocks { get; set; }
	}
	public sealed class CulturalCardDefinition
	{
		public int Index { get; }

		public string StableId { get; }

		public string Title { get; }

		public string Description { get; }

		public string SourceKey { get; }

		public string FamilyId { get; }

		public CulturalRarityTier Rarity { get; }

		public bool AllowMultiple { get; }

		public CulturalBaseStats BaseStats { get; }

		public IReadOnlyList<CulturalCardStat> Stats { get; }

		public IReadOnlyList<CulturalMechanicSpec> Mechanics { get; }

		public CulturalCardDefinition(int index, string stableId, string title, string description, string sourceKey, string familyId, CulturalRarityTier rarity, bool allowMultiple, CulturalBaseStats baseStats, IReadOnlyList<CulturalCardStat> stats, IReadOnlyList<CulturalMechanicSpec> mechanics)
		{
			Index = index;
			StableId = stableId ?? throw new ArgumentNullException("stableId");
			Title = title ?? throw new ArgumentNullException("title");
			Description = description ?? throw new ArgumentNullException("description");
			SourceKey = sourceKey ?? throw new ArgumentNullException("sourceKey");
			FamilyId = familyId ?? throw new ArgumentNullException("familyId");
			Rarity = rarity;
			AllowMultiple = allowMultiple;
			BaseStats = baseStats ?? throw new ArgumentNullException("baseStats");
			Stats = stats ?? throw new ArgumentNullException("stats");
			Mechanics = mechanics ?? throw new ArgumentNullException("mechanics");
		}
	}
	public sealed class CulturalCard000 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard001 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard002 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard003 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard004 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard005 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard006 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard007 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard008 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard009 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard010 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard011 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard012 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard013 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard014 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard015 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard016 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard017 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard018 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard019 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard020 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard021 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard022 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard023 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard024 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard025 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard026 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard027 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard028 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard029 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard030 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard031 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard032 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard033 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard034 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard035 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard036 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard037 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard038 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard039 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard040 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard041 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard042 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard043 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard044 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard045 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard046 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard047 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard048 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard049 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard050 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard051 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard052 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard053 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard054 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard055 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard056 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard057 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard058 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard059 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard060 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard061 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard062 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard063 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard064 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard065 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard066 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard067 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard068 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard069 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard070 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard071 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard072 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard073 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard074 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard075 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard076 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard077 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard078 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard079 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard080 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard081 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard082 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard083 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard084 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard085 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard086 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard087 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard088 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard089 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard090 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard091 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard092 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard093 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard094 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard095 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard096 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard097 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard098 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard099 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard100 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard101 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard102 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard103 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard104 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard105 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard106 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard107 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard108 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard109 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard110 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard111 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard112 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard113 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard114 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard115 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard116 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard117 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard118 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard119 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard120 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard121 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard122 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard123 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard124 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard125 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard126 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard127 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard128 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard129 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard130 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard131 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard132 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard133 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard134 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard135 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard136 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard137 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard138 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard139 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard140 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard141 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard142 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard143 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard144 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard145 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard146 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard147 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard148 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard149 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard150 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard151 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard152 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard153 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard154 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard155 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard156 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard157 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard158 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard159 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard160 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard161 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard162 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard163 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard164 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard165 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard166 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard167 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard168 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard169 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard170 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard171 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard172 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard173 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard174 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard175 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard176 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard177 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard178 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard179 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard180 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard181 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard182 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard183 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard184 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard185 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard186 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard187 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard188 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard189 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard190 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard191 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard192 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard193 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard194 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard195 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard196 : CulturalDefinitionCard
	{
	}
	public sealed class CulturalCard197 : CulturalDefinitionCard
	{
	}
	internal static class CulturalCardPresentation
	{
		public static IReadOnlyList<CulturalCardStat> BuildBaseStats(CulturalBaseStats stats)
		{
			List<CulturalCardStat> list = new List<CulturalCardStat>(4);
			AddMultiplier(list, "Health", stats.Health, lowerIsBeneficial: false);
			AddMultiplier(list, "Damage", stats.Damage, lowerIsBeneficial: false);
			AddInverseRate(list, "Attack speed", stats.AttackSpeed);
			AddMultiplier(list, "Move speed", stats.MovementSpeed, lowerIsBeneficial: false);
			AddPlayerSize(list, stats.SizeMultiplier);
			AddMultiplier(list, "Jump", stats.Jump, lowerIsBeneficial: false);
			AddMultiplier(list, "Player gravity", stats.PlayerGravity, lowerIsBeneficial: true);
			AddPercentAdditive(list, "Lifesteal", stats.LifeSteal, positiveWhenAboveZero: true);
			AddFloat(list, "Regeneration", stats.Regeneration, positiveWhenAboveZero: true, " HP/s");
			AddSeconds(list, "Damage delay", stats.DamageOverTime);
			AddMultiplier(list, "Knockback", stats.Knockback, lowerIsBeneficial: false);
			AddMultiplier(list, "Bullet speed", stats.ProjectileSpeed, lowerIsBeneficial: false);
			AddMultiplier(list, "Simulation speed", stats.ProjectileSimulationSpeed, lowerIsBeneficial: false);
			AddMultiplier(list, "Bullet gravity", stats.ProjectileGravity, lowerIsBeneficial: true);
			AddMultiplier(list, "Spread", stats.SpreadMultiplier, lowerIsBeneficial: true);
			AddFloat(list, "Bullet size", stats.ProjectileSizeAdd, positiveWhenAboveZero: true);
			AddMultiplier(list, "Reload time", stats.ReloadTime, lowerIsBeneficial: true);
			AddSignedSeconds(list, "Reload time", stats.ReloadTimeAdd, lowerIsBeneficial: true);
			AddInt(list, "Ammo", stats.Ammo, positiveWhenAboveZero: true);
			AddFloat(list, "Ammo regen", stats.AmmoRegeneration, positiveWhenAboveZero: true, "/s");
			AddInt(list, "Projectiles", stats.Projectiles, positiveWhenAboveZero: true);
			AddInt(list, "Bursts", stats.Bursts, positiveWhenAboveZero: true);
			AddInt(list, "Reflects", stats.Reflects, positiveWhenAboveZero: true);
			AddInt(list, "Bounces", stats.Bounces, positiveWhenAboveZero: true);
			AddMultiplier(list, "Bounce speed", stats.BounceSpeed, lowerIsBeneficial: false);
			AddMultiplier(list, "Bounce damage", stats.BounceDamage, lowerIsBeneficial: false);
			AddPercentAdditive(list, "Slow", stats.Slow, positiveWhenAboveZero: true);
			AddMultiplier(list, "Distance damage", stats.DamageAfterDistance, lowerIsBeneficial: false);
			AddFloat(list, "Bullet lifetime", stats.BulletLifetime, positiveWhenAboveZero: false, " sec");
			AddMultiplier(list, "Block cooldown", stats.BlockCooldown, lowerIsBeneficial: true);
			AddSignedSeconds(list, "Block cooldown", stats.BlockCooldownAdd, lowerIsBeneficial: true);
			AddFloat(list, "Block healing", stats.BlockHealing, positiveWhenAboveZero: true);
			AddInt(list, "Block charges", stats.AdditionalBlocks, positiveWhenAboveZero: true);
			AddInt(list, "Extra jumps", stats.ExtraJumps, positiveWhenAboveZero: true);
			AddInt(list, "Revives", stats.Respawns, positiveWhenAboveZero: true);
			return list.AsReadOnly();
		}

		public static string BuildDescription(bool showPrimaryMechanic, IReadOnlyList<CulturalMechanicSpec> mechanics)
		{
			if (!showPrimaryMechanic || mechanics.Count == 0)
			{
				return string.Empty;
			}
			string text = EffectSentence(mechanics[0].EffectId);
			if (mechanics.Count != 1)
			{
				return text + " " + EffectSentence(mechanics[1].EffectId);
			}
			return text;
		}

		private static void AddPlayerSize(ICollection<CulturalCardStat> result, float value)
		{
			if (!(Math.Abs(value - 1f) <= 0.0001f))
			{
				float num = (value - 1f) * 100f;
				result.Add(new CulturalCardStat("Player size", Percent(num), num < 0f));
			}
		}

		private static void AddInverseRate(ICollection<CulturalCardStat> result, string label, float intervalMultiplier)
		{
			if (!(Math.Abs(intervalMultiplier - 1f) <= 0.0001f))
			{
				float num = (0f - (intervalMultiplier - 1f)) * 100f;
				result.Add(new CulturalCardStat(label, Percent(num), num > 0f));
			}
		}

		private static void AddMultiplier(ICollection<CulturalCardStat> result, string label, float value, bool lowerIsBeneficial)
		{
			if (!(Math.Abs(value - 1f) <= 0.0001f))
			{
				float num = (value - 1f) * 100f;
				bool isPositive = (lowerIsBeneficial ? (num < 0f) : (num > 0f));
				result.Add(new CulturalCardStat(label, Percent(num), isPositive));
			}
		}

		private static void AddPercentAdditive(ICollection<CulturalCardStat> result, string label, float value, bool positiveWhenAboveZero)
		{
			if (!(Math.Abs(value) <= 0.0001f))
			{
				bool isPositive = (positiveWhenAboveZero ? (value > 0f) : (value < 0f));
				result.Add(new CulturalCardStat(label, Percent(value * 100f), isPositive));
			}
		}

		private static void AddSeconds(ICollection<CulturalCardStat> result, string label, float value)
		{
			if (!(Math.Abs(value) <= 0.0001f))
			{
				result.Add(new CulturalCardStat(label, SignedNumber(value) + " sec", value > 0f));
			}
		}

		private static void AddSignedSeconds(ICollection<CulturalCardStat> result, string label, float value, bool lowerIsBeneficial)
		{
			if (!(Math.Abs(value) <= 0.0001f))
			{
				bool isPositive = (lowerIsBeneficial ? (value < 0f) : (value > 0f));
				result.Add(new CulturalCardStat(label, SignedNumber(value) + " sec", isPositive));
			}
		}

		private static void AddFloat(ICollection<CulturalCardStat> result, string label, float value, bool positiveWhenAboveZero, string suffix = "")
		{
			if (!(Math.Abs(value) <= 0.0001f))
			{
				bool isPositive = (positiveWhenAboveZero ? (value > 0f) : (value < 0f));
				result.Add(new CulturalCardStat(label, SignedNumber(value) + suffix, isPositive));
			}
		}

		private static void AddInt(ICollection<CulturalCardStat> result, string label, int value, bool positiveWhenAboveZero)
		{
			if (value != 0)
			{
				bool isPositive = (positiveWhenAboveZero ? (value > 0) : (value < 0));
				result.Add(new CulturalCardStat(label, Signed(value), isPositive));
			}
		}

		private static string EffectSentence(CulturalEffectId effectId)
		{
			return effectId switch
			{
				CulturalEffectId.ProjectileDamage => "Shots gain extra damage.", 
				CulturalEffectId.ProjectileSpeed => "Shots gain extra speed.", 
				CulturalEffectId.ProjectileSize => "Shots grow in flight.", 
				CulturalEffectId.ShootHeal => "The first shot heals you.", 
				CulturalEffectId.ShootLunge => "The first shot lunges forward.", 
				CulturalEffectId.ShootShockwave => "The first shot releases a shockwave.", 
				CulturalEffectId.BlockHeal => "Blocking restores health.", 
				CulturalEffectId.BlockRepel => "Blocking repels nearby enemies.", 
				CulturalEffectId.BlockDamage => "Blocking damages nearby enemies.", 
				CulturalEffectId.BlockAmmo => "Blocking reloads and empowers the next volley.", 
				CulturalEffectId.DamageRecovery => "Taking damage restores part of your health.", 
				CulturalEffectId.DamageRetaliation => "Taking damage retaliates against the attacker.", 
				CulturalEffectId.DamageCharge => "Taking damage empowers the next volley.", 
				CulturalEffectId.Regeneration => "Regenerates health over time.", 
				CulturalEffectId.ProximityDamage => "The nearest enemy takes periodic damage.", 
				CulturalEffectId.LowHealthPulse => "Low health triggers periodic recovery.", 
				_ => string.Empty, 
			};
		}

		private static string Percent(float value)
		{
			return ((value > 0f) ? "+" : string.Empty) + value.ToString("0.#", CultureInfo.InvariantCulture) + "%";
		}

		private static string SignedNumber(float value)
		{
			return ((value > 0f) ? "+" : string.Empty) + value.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static string Signed(int value)
		{
			if (value <= 0)
			{
				return value.ToString(CultureInfo.InvariantCulture);
			}
			return "+" + value.ToString(CultureInfo.InvariantCulture);
		}
	}
	public static class CulturalCardRegistry
	{
		public const int CardCount = 198;

		private static readonly Dictionary<Type, int> IndexByType = new Dictionary<Type, int>(198);

		private static bool registered;

		public static void RegisterAll()
		{
			if (!registered)
			{
				registered = true;
				Register<CulturalCard000>(0);
				Register<CulturalCard001>(1);
				Register<CulturalCard002>(2);
				Register<CulturalCard003>(3);
				Register<CulturalCard004>(4);
				Register<CulturalCard005>(5);
				Register<CulturalCard006>(6);
				Register<CulturalCard007>(7);
				Register<CulturalCard008>(8);
				Register<CulturalCard009>(9);
				Register<CulturalCard010>(10);
				Register<CulturalCard011>(11);
				Register<CulturalCard012>(12);
				Register<CulturalCard013>(13);
				Register<CulturalCard014>(14);
				Register<CulturalCard015>(15);
				Register<CulturalCard016>(16);
				Register<CulturalCard017>(17);
				Register<CulturalCard018>(18);
				Register<CulturalCard019>(19);
				Register<CulturalCard020>(20);
				Register<CulturalCard021>(21);
				Register<CulturalCard022>(22);
				Register<CulturalCard023>(23);
				Register<CulturalCard024>(24);
				Register<CulturalCard025>(25);
				Register<CulturalCard026>(26);
				Register<CulturalCard027>(27);
				Register<CulturalCard028>(28);
				Register<CulturalCard029>(29);
				Register<CulturalCard030>(30);
				Register<CulturalCard031>(31);
				Register<CulturalCard032>(32);
				Register<CulturalCard033>(33);
				Register<CulturalCard034>(34);
				Register<CulturalCard035>(35);
				Register<CulturalCard036>(36);
				Register<CulturalCard037>(37);
				Register<CulturalCard038>(38);
				Register<CulturalCard039>(39);
				Register<CulturalCard040>(40);
				Register<CulturalCard041>(41);
				Register<CulturalCard042>(42);
				Register<CulturalCard043>(43);
				Register<CulturalCard044>(44);
				Register<CulturalCard045>(45);
				Register<CulturalCard046>(46);
				Register<CulturalCard047>(47);
				Register<CulturalCard048>(48);
				Register<CulturalCard049>(49);
				Register<CulturalCard050>(50);
				Register<CulturalCard051>(51);
				Register<CulturalCard052>(52);
				Register<CulturalCard053>(53);
				Register<CulturalCard054>(54);
				Register<CulturalCard055>(55);
				Register<CulturalCard056>(56);
				Register<CulturalCard057>(57);
				Register<CulturalCard058>(58);
				Register<CulturalCard059>(59);
				Register<CulturalCard060>(60);
				Register<CulturalCard061>(61);
				Register<CulturalCard062>(62);
				Register<CulturalCard063>(63);
				Register<CulturalCard064>(64);
				Register<CulturalCard065>(65);
				Register<CulturalCard066>(66);
				Register<CulturalCard067>(67);
				Register<CulturalCard068>(68);
				Register<CulturalCard069>(69);
				Register<CulturalCard070>(70);
				Register<CulturalCard071>(71);
				Register<CulturalCard072>(72);
				Register<CulturalCard073>(73);
				Register<CulturalCard074>(74);
				Register<CulturalCard075>(75);
				Register<CulturalCard076>(76);
				Register<CulturalCard077>(77);
				Register<CulturalCard078>(78);
				Register<CulturalCard079>(79);
				Register<CulturalCard080>(80);
				Register<CulturalCard081>(81);
				Register<CulturalCard082>(82);
				Register<CulturalCard083>(83);
				Register<CulturalCard084>(84);
				Register<CulturalCard085>(85);
				Register<CulturalCard086>(86);
				Register<CulturalCard087>(87);
				Register<CulturalCard088>(88);
				Register<CulturalCard089>(89);
				Register<CulturalCard090>(90);
				Register<CulturalCard091>(91);
				Register<CulturalCard092>(92);
				Register<CulturalCard093>(93);
				Register<CulturalCard094>(94);
				Register<CulturalCard095>(95);
				Register<CulturalCard096>(96);
				Register<CulturalCard097>(97);
				Register<CulturalCard098>(98);
				Register<CulturalCard099>(99);
				Register<CulturalCard100>(100);
				Register<CulturalCard101>(101);
				Register<CulturalCard102>(102);
				Register<CulturalCard103>(103);
				Register<CulturalCard104>(104);
				Register<CulturalCard105>(105);
				Register<CulturalCard106>(106);
				Register<CulturalCard107>(107);
				Register<CulturalCard108>(108);
				Register<CulturalCard109>(109);
				Register<CulturalCard110>(110);
				Register<CulturalCard111>(111);
				Register<CulturalCard112>(112);
				Register<CulturalCard113>(113);
				Register<CulturalCard114>(114);
				Register<CulturalCard115>(115);
				Register<CulturalCard116>(116);
				Register<CulturalCard117>(117);
				Register<CulturalCard118>(118);
				Register<CulturalCard119>(119);
				Register<CulturalCard120>(120);
				Register<CulturalCard121>(121);
				Register<CulturalCard122>(122);
				Register<CulturalCard123>(123);
				Register<CulturalCard124>(124);
				Register<CulturalCard125>(125);
				Register<CulturalCard126>(126);
				Register<CulturalCard127>(127);
				Register<CulturalCard128>(128);
				Register<CulturalCard129>(129);
				Register<CulturalCard130>(130);
				Register<CulturalCard131>(131);
				Register<CulturalCard132>(132);
				Register<CulturalCard133>(133);
				Register<CulturalCard134>(134);
				Register<CulturalCard135>(135);
				Register<CulturalCard136>(136);
				Register<CulturalCard137>(137);
				Register<CulturalCard138>(138);
				Register<CulturalCard139>(139);
				Register<CulturalCard140>(140);
				Register<CulturalCard141>(141);
				Register<CulturalCard142>(142);
				Register<CulturalCard143>(143);
				Register<CulturalCard144>(144);
				Register<CulturalCard145>(145);
				Register<CulturalCard146>(146);
				Register<CulturalCard147>(147);
				Register<CulturalCard148>(148);
				Register<CulturalCard149>(149);
				Register<CulturalCard150>(150);
				Register<CulturalCard151>(151);
				Register<CulturalCard152>(152);
				Register<CulturalCard153>(153);
				Register<CulturalCard154>(154);
				Register<CulturalCard155>(155);
				Register<CulturalCard156>(156);
				Register<CulturalCard157>(157);
				Register<CulturalCard158>(158);
				Register<CulturalCard159>(159);
				Register<CulturalCard160>(160);
				Register<CulturalCard161>(161);
				Register<CulturalCard162>(162);
				Register<CulturalCard163>(163);
				Register<CulturalCard164>(164);
				Register<CulturalCard165>(165);
				Register<CulturalCard166>(166);
				Register<CulturalCard167>(167);
				Register<CulturalCard168>(168);
				Register<CulturalCard169>(169);
				Register<CulturalCard170>(170);
				Register<CulturalCard171>(171);
				Register<CulturalCard172>(172);
				Register<CulturalCard173>(173);
				Register<CulturalCard174>(174);
				Register<CulturalCard175>(175);
				Register<CulturalCard176>(176);
				Register<CulturalCard177>(177);
				Register<CulturalCard178>(178);
				Register<CulturalCard179>(179);
				Register<CulturalCard180>(180);
				Register<CulturalCard181>(181);
				Register<CulturalCard182>(182);
				Register<CulturalCard183>(183);
				Register<CulturalCard184>(184);
				Register<CulturalCard185>(185);
				Register<CulturalCard186>(186);
				Register<CulturalCard187>(187);
				Register<CulturalCard188>(188);
				Register<CulturalCard189>(189);
				Register<CulturalCard190>(190);
				Register<CulturalCard191>(191);
				Register<CulturalCard192>(192);
				Register<CulturalCard193>(193);
				Register<CulturalCard194>(194);
				Register<CulturalCard195>(195);
				Register<CulturalCard196>(196);
				Register<CulturalCard197>(197);
			}
		}

		internal static CulturalCardDefinition DefinitionFor(Type cardType)
		{
			if (!IndexByType.TryGetValue(cardType, out var value))
			{
				throw new InvalidOperationException("Unregistered cultural marker type: " + cardType.FullName);
			}
			return CulturalCardCatalog.GetByIndex(value);
		}

		private static void Register<T>(int index) where T : CulturalDefinitionCard
		{
			IndexByType.Add(typeof(T), index);
			CustomCard.BuildCard<T>((Action<CardInfo>)delegate(CardInfo card)
			{
				CulturalCardDefinition byIndex = CulturalCardCatalog.GetByIndex(index);
				card.cardName = byIndex.Title;
				card.cardDestription = CulturalSignaturePresentation.Append(byIndex.StableId, byIndex.Description);
			});
		}
	}
	public abstract class CulturalDefinitionCard : ReksikCardsBase
	{
		private CulturalCardDefinition? definition;

		internal CulturalCardDefinition Definition => definition ?? (definition = CulturalCardCatalog.GetByCardType(((object)this).GetType()));

		public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
		{
			CulturalCardDefinition culturalCardDefinition = Definition;
			cardInfo.allowMultiple = culturalCardDefinition.AllowMultiple;
			ApplyBaseStats(culturalCardDefinition.BaseStats, gun, statModifiers, block);
			cardInfo.categories = Array.Empty<CardCategory>();
			cardInfo.blacklistedCategories = Array.Empty<CardCategory>();
		}

		private static void ApplyBaseStats(CulturalBaseStats baseStats, Gun gun, CharacterStatModifiers statModifiers, Block block)
		{
			statModifiers.health = baseStats.Health;
			statModifiers.movementSpeed = baseStats.MovementSpeed;
			statModifiers.jump = baseStats.Jump;
			statModifiers.gravity = baseStats.PlayerGravity;
			statModifiers.sizeMultiplier = baseStats.SizeMultiplier;
			statModifiers.numberOfJumps = baseStats.ExtraJumps;
			statModifiers.respawns = baseStats.Respawns;
			statModifiers.lifeSteal = baseStats.LifeSteal;
			statModifiers.regen = baseStats.Regeneration;
			statModifiers.secondsToTakeDamageOver = baseStats.DamageOverTime;
			gun.damage = baseStats.Damage;
			gun.attackSpeed = baseStats.AttackSpeed;
			gun.knockback = baseStats.Knockback;
			gun.projectileSpeed = baseStats.ProjectileSpeed;
			gun.projectielSimulatonSpeed = baseStats.ProjectileSimulationSpeed;
			gun.gravity = baseStats.ProjectileGravity;
			gun.multiplySpread = baseStats.SpreadMultiplier;
			gun.size = baseStats.ProjectileSizeAdd;
			gun.reloadTime = baseStats.ReloadTime;
			gun.reloadTimeAdd = baseStats.ReloadTimeAdd;
			gun.ammo = baseStats.Ammo;
			gun.ammoReg = baseStats.AmmoRegeneration;
			gun.numberOfProjectiles = baseStats.Projectiles;
			gun.bursts = baseStats.Bursts;
			gun.reflects = baseStats.Reflects + baseStats.Bounces;
			gun.speedMOnBounce = baseStats.BounceSpeed;
			gun.dmgMOnBounce = baseStats.BounceDamage;
			gun.slow = baseStats.Slow;
			gun.damageAfterDistanceMultiplier = baseStats.DamageAfterDistance;
			gun.destroyBulletAfter = baseStats.BulletLifetime;
			block.cdMultiplier = baseStats.BlockCooldown;
			block.cdAdd = baseStats.BlockCooldownAdd;
			block.healing = baseStats.BlockHealing;
			block.additionalBlocks = baseStats.AdditionalBlocks;
		}

		public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!((Object)(object)player == (Object)null))
			{
				CulturalCardDefinition culturalCardDefinition = Definition;
				CulturalRuntimeMono.GetOrAdd(player).AddCard(culturalCardDefinition.StableId, culturalCardDefinition.FamilyId, culturalCardDefinition.SourceKey, culturalCardDefinition.Rarity, culturalCardDefinition.Mechanics);
			}
		}

		public override void OnRemoveCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if (!((Object)(object)player == (Object)null))
			{
				CulturalRuntimeMono component = ((Component)player).GetComponent<CulturalRuntimeMono>();
				if ((Object)(object)component != (Object)null)
				{
					component.RemoveCard(Definition.StableId);
				}
			}
		}

		public override void OnReassignCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)data == (Object)null || data.currentCards == null)
			{
				return;
			}
			CulturalCardDefinition culturalCardDefinition = Definition;
			int num = 0;
			for (int i = 0; i < data.currentCards.Count; i++)
			{
				CardInfo val = data.currentCards[i];
				CulturalDefinitionCard culturalDefinitionCard = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<CulturalDefinitionCard>() : null);
				if ((Object)(object)culturalDefinitionCard != (Object)null && string.Equals(culturalDefinitionCard.Definition.StableId, culturalCardDefinition.StableId, StringComparison.Ordinal))
				{
					num++;
				}
			}
			CulturalRuntimeMono.GetOrAdd(player).SetCard(culturalCardDefinition.StableId, culturalCardDefinition.FamilyId, culturalCardDefinition.SourceKey, culturalCardDefinition.Rarity, num, culturalCardDefinition.Mechanics);
		}

		protected override string GetTitle()
		{
			return Definition.StableId;
		}

		protected override string GetDescription()
		{
			CulturalCardDefinition culturalCardDefinition = Definition;
			return CulturalSignaturePresentation.Append(culturalCardDefinition.StableId, culturalCardDefinition.Description);
		}

		protected override CardInfoStat[] GetStats()
		{
			//IL_002b: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			CulturalCardDefinition culturalCardDefinition = Definition;
			CardInfoStat[] array = (CardInfoStat[])(object)new CardInfoStat[culturalCardDefinition.Stats.Count];
			for (int i = 0; i < array.Length; i++)
			{
				CulturalCardStat culturalCardStat = culturalCardDefinition.Stats[i];
				array[i] = new CardInfoStat
				{
					positive = culturalCardStat.IsPositive,
					stat = culturalCardStat.Label,
					amount = culturalCardStat.Amount,
					simepleAmount = (SimpleAmount)0
				};
			}
			return array;
		}

		protected override Rarity GetRarity()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return (Rarity)(Definition.Rarity switch
			{
				CulturalRarityTier.Common => 0, 
				CulturalRarityTier.Uncommon => 1, 
				CulturalRarityTier.Rare => 2, 
				CulturalRarityTier.Legendary => ReksikRarities.Legendary, 
				_ => throw new ArgumentOutOfRangeException(), 
			});
		}

		protected override GameObject GetCardArt()
		{
			return CulturalSharedArtCache.GetOrCreate(Definition);
		}

		protected override CardThemeColorType GetTheme()
		{
			return (CardThemeColorType)(Definition.SourceKey switch
			{
				"Foundation" => 7, 
				"Lord of War" => 1, 
				"Kaguya-sama" => 4, 
				"Code Geass" => 0, 
				"Zirkonavty" => 3, 
				"Classroom of the Elite" => 2, 
				"Project Hail Mary" => 6, 
				"Amazing Digital Circus" => 4, 
				_ => 3, 
			});
		}
	}
	internal static class CulturalSharedArtCache
	{
		private static readonly Dictionary<string, GameObject> BySource = new Dictionary<string, GameObject>();

		private static readonly Dictionary<string, GameObject> ByStableId = new Dictionary<string, GameObject>();

		private static Font? font;

		public static GameObject GetOrCreate(CulturalCardDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (definition.Rarity == CulturalRarityTier.Legendary)
			{
				if (ByStableId.TryGetValue(definition.StableId, out GameObject value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				if (TryLoadPortrait(definition, out value))
				{
					DisableRenderers(value);
					((Object)value).hideFlags = (HideFlags)61;
					Object.DontDestroyOnLoad((Object)(object)value);
					ByStableId[definition.StableId] = value;
					return value;
				}
			}
			return GetOrCreate(definition.SourceKey);
		}

		public static GameObject GetOrCreate(string sourceKey)
		{
			string text = (string.IsNullOrWhiteSpace(sourceKey) ? "culture" : sourceKey.Trim());
			if (BySource.TryGetValue(text, out GameObject value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			value = BuildFallback(text);
			DisableRenderers(value);
			((Object)value).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)value);
			BySource[text] = value;
			return value;
		}

		private static bool TryLoadPortrait(CulturalCardDefinition definition, out GameObject portrait)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: 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_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			portrait = null;
			string name = "ReksikCards.Assets.CulturePortraits." + definition.StableId + ".png";
			using Stream stream = typeof(CulturalSharedArtCache).Assembly.GetManifestResourceStream(name);
			if (stream == null || stream.Length <= 0 || stream.Length > int.MaxValue)
			{
				return false;
			}
			byte[] array = new byte[(int)stream.Length];
			int num;
			for (int i = 0; i < array.Length; i += num)
			{
				num = stream.Read(array, i, array.Length - i);
				if (num <= 0)
				{
					return false;
				}
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, array, true))
			{
				Object.Destroy((Object)(object)val);
				return false;
			}
			((Object)val).name = definition.StableId + "_PortraitTexture";
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Object)val).hideFlags = (HideFlags)61;
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), (float)((Texture)val).width);
			((Object)val2).name = definition.StableId + "_PortraitSprite";
			((Object)val2).hideFlags = (HideFlags)61;
			Color val3 = SourceColor(definition.SourceKey);
			portrait = new GameObject("CulturePortrait_" + definition.StableId);
			portrait.AddComponent<CulturalArtSpawnFixMono>();
			GameObject val4 = new GameObject("Background");
			val4.transform.SetParent(portrait.transform, false);
			SpriteRenderer obj = val4.AddComponent<SpriteRenderer>();
			obj.sprite = ReksikSpriteCache.Square;
			obj.color = new Color(val3.r * 0.2f, val3.g * 0.2f, val3.b * 0.2f, 0.98f);
			((Renderer)obj).sortingOrder = 0;
			val4.transform.localScale = new Vector3(1.14f, 1.14f, 1f);
			GameObject val5 = new GameObject("Portrait");
			val5.transform.SetParent(portrait.transform, false);
			SpriteRenderer obj2 = val5.AddComponent<SpriteRenderer>();
			obj2.sprite = val2;
			obj2.color = Color.white;
			((Renderer)obj2).sortingOrder = 1;
			val5.transform.localScale = new Vector3(1.08f, 1.08f, 1f);
			GameObject val6 = new GameObject("LegendaryHalo");
			val6.transform.SetParent(portrait.transform, false);
			SpriteRenderer obj3 = val6.AddComponent<SpriteRenderer>();
			obj3.sprite = ReksikSpriteCache.Ring;
			obj3.color = new Color(1f, 0.76f, 0.18f, 0.72f);
			((Renderer)obj3).sortingOrder = 2;
			val6.transform.localScale = new Vector3(1.12f, 1.12f, 1f);
			AddText(portrait, "Source", SourceLabel(definition.SourceKey), new Vector3(0f, -0.43f, 0f), 0.048f, 42, new Color(1f, 0.88f, 0.48f, 0.82f), 3);
			portrait.transform.localScale = Vector3.one * 0.78f;
			return true;
		}

		private static GameObject BuildFallback(string sourceKey)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			Color val = SourceColor(sourceKey);
			GameObject val2 = new GameObject("CultureArt_" + SafeObjectName(sourceKey));
			val2.AddComponent<CulturalArtSpawnFixMono>();
			GameObject val3 = new GameObject("Background");
			val3.transform.SetParent(val2.transform, false);
			SpriteRenderer obj = val3.AddComponent<SpriteRenderer>();
			obj.sprite = ReksikSpriteCache.Square;
			obj.color = new Color(val.r * 0.34f, val.g * 0.34f, val.b * 0.34f, 0.96f);
			((Renderer)obj).sortingOrder = 0;
			val3.transform.localScale = new Vector3(1.16f, 1.16f, 1f);
			GameObject val4 = new GameObject("Halo");
			val4.transform.SetParent(val2.transform, false);
			SpriteRenderer obj2 = val4.AddComponent<SpriteRenderer>();
			obj2.sprite = ReksikSpriteCache.Ring;
			obj2.color = new Color(val.r, val.g, val.b, 0.78f);
			((Renderer)obj2).sortingOrder = 1;
			val4.transform.localScale = new Vector3(0.88f, 0.88f, 1f);
			AddText(val2, "Source", SourceLabel(sourceKey), new Vector3(0f, 0.31f, 0f), 0.075f, 58, new Color(1f, 1f, 1f, 0.72f), 2);
			val2.transform.localScale = Vector3.one * 0.78f;
			return val2;
		}

		private static void AddText(GameObject root, string objectName, string value, Vector3 position, float characterSize, int fontSize, Color color, int sortingOrder)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(objectName);
			val.transform.SetParent(root.transform, false);
			val.transform.localPosition = position;
			TextMesh val2 = val.AddComponent<TextMesh>();
			val2.text = value;
			val