using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Patches;
using ModdingUtils.Utils;
using Photon.Pun;
using RandomCardsGenerators.Cards;
using RandomCardsGenerators.Extensions;
using RandomCardsGenerators.Utils;
using TMPro;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Utils;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace RandomCardsGenerators
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.aalund13.rounds.random_cards_generator", "Random Cards Generator", "1.0.0")]
[BepInProcess("Rounds.exe")]
public class Main : BaseUnityPlugin
{
private const string modId = "com.aalund13.rounds.random_cards_generator";
private const string modName = "Random Cards Generator";
internal const string modInitials = "RCG";
internal static Main instance;
internal static ManualLogSource ModLogger;
internal static AssetBundle assets;
internal static GameObject blankCardPrefab;
internal static Type RarityTextType;
internal static Dictionary<string, float> ModRarities;
private static Harmony harmony;
private void Awake()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
instance = this;
ModLogger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("com.aalund13.rounds.random_cards_generator");
harmony.PatchAll();
assets = AssetUtils.LoadAssetBundleFromResources("randomcardsgenerator_assets", typeof(Main).Assembly);
blankCardPrefab = assets.LoadAsset<GameObject>("__RCG__BlankCard");
Debug.Log("Random Cards Generator loaded!");
}
private void Start()
{
Cards.instance.AddCardValidationFunction((Func<Player, CardInfo, bool>)delegate(Player player, CardInfo card)
{
if (ToggleCard.ToggleCards.Any((ToggleCard c) => (Object)(object)c.toggleCardInfo == (Object)(object)card))
{
return false;
}
ToggleCard.IsCardEnabled(card);
return true;
});
if (Chainloader.PluginInfos.TryGetValue("pykess.rounds.plugins.deckcustomization", out var value))
{
Assembly assembly = ((object)value.Instance).GetType().Assembly;
RarityTextType = assembly.GetType("DeckCustomization.RarityText");
ModRarities = (Dictionary<string, float>)assembly.GetType("DeckCustomization.DeckCustomization").GetField("ModRarities", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
DeckCustomizationPatch.Patch(harmony, assembly);
}
Debug.Log("Random Cards Generator started!");
}
}
internal static class GeneratedCardHolder
{
public static readonly Dictionary<string, List<GeneratedCardInfo>> GeneratedCardsMap = new Dictionary<string, List<GeneratedCardInfo>>();
public static readonly List<GeneratedCardInfo> GeneratedCards = new List<GeneratedCardInfo>();
public static List<GeneratedCardInfo> GetGeneratedCards(string statGenName)
{
if (GeneratedCardsMap.ContainsKey(statGenName))
{
return GeneratedCardsMap[statGenName];
}
return new List<GeneratedCardInfo>();
}
public static GeneratedCardInfo IsCardGenerated(CardInfo cardInfo)
{
return GeneratedCards.FirstOrDefault((GeneratedCardInfo c) => (Object)(object)c.CardInfo == (Object)(object)cardInfo);
}
public static void AddCardToGenerated(string statGenName, GeneratedCardInfo cardInfo)
{
if (GeneratedCardsMap.ContainsKey(statGenName))
{
GeneratedCardsMap[statGenName].Add(cardInfo);
}
else
{
GeneratedCardsMap.Add(statGenName, new List<GeneratedCardInfo> { cardInfo });
}
GeneratedCards.Add(cardInfo);
}
}
public class ModRandomCardsGenerators
{
protected readonly Dictionary<string, RandomCardsGenerator> CardsGenerators = new Dictionary<string, RandomCardsGenerator>();
public ModRandomCardsGenerators(List<RandomCardsGenerator> cardsGenerators)
{
foreach (RandomCardsGenerator cardsGenerator in cardsGenerators)
{
if (cardsGenerators == null || cardsGenerators.Count == 0)
{
throw new Exception("No handlers provided.");
}
if (CardsGenerators.ContainsKey(cardsGenerator.CardGenName))
{
throw new Exception("Handler for " + cardsGenerator.CardGenName + " already exists.");
}
CardsGenerators.Add(cardsGenerator.CardGenName, cardsGenerator);
}
}
public void CreateRandomCard(string cardGenName, int seed, Player player = null)
{
GetHandler(cardGenName).CreateRandomCard(seed, player);
}
public void CreateRandomCard(string cardGenName, Player player = null)
{
GetHandler(cardGenName).CreateRandomCard(player);
}
public RandomCardsGenerator GetHandler(string statGenName)
{
return CardsGenerators[statGenName];
}
public IEnumerable<RandomCardsGenerator> GetAllHandlers()
{
return CardsGenerators.Values;
}
public void AddGenerator(string cardGenName, RandomCardsGenerator handler)
{
if (!CardsGenerators.ContainsKey(cardGenName))
{
CardsGenerators.Add(cardGenName, handler);
return;
}
throw new Exception("Handler for " + cardGenName + " already exists.");
}
public void RemoveGenerator(string cardGenName)
{
if (CardsGenerators.ContainsKey(cardGenName))
{
CardsGenerators.Remove(cardGenName);
}
}
}
public class ModRandomCardsGenerators<T> : ModRandomCardsGenerators where T : Enum
{
protected readonly Dictionary<T, RandomCardsGenerator> TypedCardsGenerators = new Dictionary<T, RandomCardsGenerator>();
public ModRandomCardsGenerators(Dictionary<T, RandomCardsGenerator> cardsGenerators)
: base(new List<RandomCardsGenerator>(cardsGenerators.Values))
{
foreach (KeyValuePair<T, RandomCardsGenerator> cardsGenerator in cardsGenerators)
{
if (TypedCardsGenerators.ContainsKey(cardsGenerator.Key))
{
throw new Exception($"Handler for {cardsGenerator.Key} already exists.");
}
TypedCardsGenerators.Add(cardsGenerator.Key, cardsGenerator.Value);
}
}
public void CreateRandomCard(T stats, int seed, Player player = null)
{
RandomCardsGenerator handler = GetHandler(stats);
NetworkingManager.RaiseEvent($"{handler.CardGenName}_SyncEvent", new object[2]
{
seed,
player?.playerID ?? (-1)
});
}
public void CreateRandomCard(T stats, Player player = null)
{
RandomCardsGenerator handler = GetHandler(stats);
int num = Random.Range(0, int.MaxValue);
NetworkingManager.RaiseEvent($"{handler.CardGenName}_SyncEvent", new object[2]
{
num,
player?.playerID ?? (-1)
});
}
public RandomCardsGenerator GetHandler(T stat)
{
return TypedCardsGenerators[stat];
}
public void AddGenerator(T stat, RandomCardsGenerator handler)
{
if (!TypedCardsGenerators.ContainsKey(stat) && !CardsGenerators.ContainsKey(handler.CardGenName))
{
TypedCardsGenerators.Add(stat, handler);
CardsGenerators.Add(handler.CardGenName, handler);
return;
}
throw new Exception($"Handler for {stat} already exists or the handler is already registered with another stat generator.");
}
public void RemoveGenerator(T stat)
{
if (TypedCardsGenerators.ContainsKey(stat))
{
TypedCardsGenerators.Remove(stat);
CardsGenerators.Remove(stat.ToString());
}
}
}
internal class DeckCustomizationPatch
{
public static void Patch(Harmony harmony, Assembly assembly)
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
harmony.Patch((MethodBase)assembly.GetType("DeckCustomization.RarityUtils").GetMethod("GetRelativeRarity", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), new HarmonyMethod(typeof(DeckCustomizationPatch), "GetRelativeRarityPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
public static bool GetRelativeRarityPrefix(string modName, ref float __result)
{
if (!Main.ModRarities.ContainsKey(modName))
{
__result = 0.5f;
return false;
}
return true;
}
}
public struct RandomStatInfo
{
public RandomStatGenerator StatGenerator;
public float Value;
public RandomStatInfo(RandomStatGenerator statGenerator, float value)
{
StatGenerator = statGenerator;
Value = value;
}
public override string ToString()
{
return $"RandomStatInfo: {StatGenerator.StatName} | Value: {Value}";
}
}
public struct RandomCardOption
{
public string CardName;
public string ModInitials;
public string CardDescription;
public string TwoLetterCode;
public Rarity CardRarity;
public CardThemeColorType ColorTheme;
public int Min;
public int Max;
public RandomCardOption(string cardName, string modInitials, string cardDescription, string twoLetterCode, int min, int max, Rarity cardRarity, CardThemeColorType colorTheme = 3)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
CardName = cardName;
ModInitials = modInitials;
CardDescription = cardDescription;
TwoLetterCode = twoLetterCode;
CardRarity = cardRarity;
ColorTheme = colorTheme;
Min = min;
Max = max;
}
public override string ToString()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
return $"RandomCardOption: {CardName} | Rarity: {CardRarity} | ModInitials: {ModInitials} | Description: {CardDescription} | TwoLetterCode: {TwoLetterCode} | Min: {Min} | Max: {Max}";
}
}
public struct GeneratedCardInfo
{
public RandomCardsGenerator RandomCardsGenerator;
public CardInfo CardInfo;
public RandomStatInfo[] RandomStatInfos;
public Random Random;
public int Seed;
public bool HasValue
{
get
{
if (RandomCardsGenerator != null && (Object)(object)CardInfo != (Object)null && RandomStatInfos != null)
{
return RandomStatInfos.Length != 0;
}
return false;
}
}
public GeneratedCardInfo(RandomCardsGenerator randomCardsGenerator, CardInfo cardInfo, RandomStatInfo[] randomStatInfos, Random random, int seed)
{
RandomCardsGenerator = randomCardsGenerator;
CardInfo = cardInfo;
RandomStatInfos = randomStatInfos;
Random = random;
Seed = seed;
}
public override string ToString()
{
return string.Format("GeneratedCardInfo: {0} | CardName: {1} | Seed: {2} | RandomStatInfos: {3}", RandomCardsGenerator.CardGenName, CardInfo.cardName, Seed, string.Join(", ", RandomStatInfos.Select((RandomStatInfo x) => x.StatGenerator.StatName)));
}
}
public class RandomCardsGenerator
{
internal const string SYNC_EVENT_FORMAT = "{0}_SyncEvent";
internal const string CARD_NAME_FORMAT = "{0} Card ({1})";
internal static readonly Dictionary<string, RandomCardsGenerator> RandomStatCardGenerators = new Dictionary<string, RandomCardsGenerator>();
public readonly Dictionary<int, GeneratedCardInfo> GeneratedCards = new Dictionary<int, GeneratedCardInfo>();
public readonly List<RandomStatGenerator> StatGenerators;
public readonly RandomCardOption RandomCardOption;
public readonly string CardGenName;
public Action<GeneratedCardInfo> OnCardGenerated;
public RandomCardsGenerator(string cardGenName, RandomCardOption randomCardOption, List<RandomStatGenerator> statGenerators)
{
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Expected O, but got Unknown
RandomCardsGenerator randomCardsGenerator = this;
if (RandomStatCardGenerators.ContainsKey(cardGenName))
{
throw new Exception("A RandomCardsGenerators with the name " + cardGenName + " already exists!");
}
if (string.IsNullOrEmpty(cardGenName) || string.IsNullOrWhiteSpace(cardGenName))
{
throw new Exception("Card generator name cannot be null or empty!");
}
string text = randomCardOption.ModInitials + "_" + ExtensionMethods.Sanitize(cardGenName, (string[])null);
RandomStatCardGenerators.Add(text, this);
RandomCardOption = randomCardOption;
CardGenName = text;
StatGenerators = statGenerators;
NetworkingManager.RegisterEvent($"{cardGenName}_SyncEvent", (PhotonEvent)delegate(object[] data)
{
try
{
int seed = (int)data[0];
int playerID = (int)data[1];
Player player = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
randomCardsGenerator.GenerateRandomCard(seed, player);
}
catch (Exception arg)
{
LoggerUtils.LogError($"Error generating random stats for {cardGenName}: {arg}");
}
});
}
public void CreateRandomCard(int seed, Player player = null)
{
NetworkingManager.RaiseEvent($"{CardGenName}_SyncEvent", new object[2] { seed, player.playerID });
}
public void CreateRandomCard(Player player = null)
{
int num = Random.Range(0, int.MaxValue);
NetworkingManager.RaiseEvent($"{CardGenName}_SyncEvent", new object[2] { num, player.playerID });
}
public GameObject GenerateRandomCard(int seed, Player player = null, Action<GeneratedCardInfo> onCardGenerated = null)
{
//IL_0128: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
if (GeneratedCards.ContainsKey(seed))
{
LoggerUtils.LogInfo($"Card with seed {seed} already generated for {CardGenName}. Returning existing card.");
onCardGenerated?.Invoke(GeneratedCards[seed]);
if ((Object)(object)player != (Object)null)
{
Cards.instance.AddCardToPlayer(player, GeneratedCards[seed].CardInfo, false, RandomCardOption.TwoLetterCode, 2f, 2f, true);
}
return ((Component)GeneratedCards[seed].CardInfo).gameObject;
}
GameObject obj = Object.Instantiate<GameObject>(Main.blankCardPrefab);
Object.Destroy((Object)(object)((Component)obj.transform.GetChild(0)).gameObject);
Object.DontDestroyOnLoad((Object)(object)obj);
CardInfo component = obj.GetComponent<CardInfo>();
BuiltRandomCard builtRandomCard = obj.AddComponent<BuiltRandomCard>();
component.cardName = $"{CardGenName} Card ({GeneratedCardHolder.GetGeneratedCards(CardGenName).Count})";
component.cardDestription = RandomCardOption.CardDescription;
component.rarity = RandomCardOption.CardRarity;
component.colorTheme = RandomCardOption.ColorTheme;
Cards.instance.AddHiddenCard(component);
Random random = new Random(seed);
RandomStatInfo[] randomStatInfos = ApplyRandomStats(component, random);
GeneratedCardInfo generatedCardInfo = new GeneratedCardInfo(this, component, randomStatInfos, random, seed);
GeneratedCardHolder.AddCardToGenerated(CardGenName, generatedCardInfo);
GeneratedCards[seed] = generatedCardInfo;
((CustomCard)builtRandomCard).BuildUnityCard((Action<CardInfo>)delegate(CardInfo cardInfo)
{
if ((Object)(object)player != (Object)null)
{
ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)Main.instance, 0.2f, (Action)delegate
{
Cards.instance.AddCardToPlayer(player, cardInfo, false, RandomCardOption.TwoLetterCode, 2f, 2f, true);
});
}
LoggerUtils.LogInfo("Card built!");
});
((Object)obj).name = ExtensionMethods.Sanitize($"___RANDOM___{CardGenName}_({seed})", (string[])null);
onCardGenerated?.Invoke(generatedCardInfo);
Action<GeneratedCardInfo> onCardGenerated2 = OnCardGenerated;
if (onCardGenerated2 != null)
{
onCardGenerated2(generatedCardInfo);
return obj;
}
return obj;
}
public RandomStatInfo[] ApplyRandomStats(CardInfo cardInfo, Random random)
{
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Expected O, but got Unknown
BuiltRandomCard orAddComponent = ExtensionMethods.GetOrAddComponent<BuiltRandomCard>(((Component)cardInfo).gameObject, false);
orAddComponent.CardName = RandomCardOption.CardName;
orAddComponent.ModInitials = RandomCardOption.ModInitials;
Gun component = ((Component)cardInfo).GetComponent<Gun>();
CharacterStatModifiers component2 = ((Component)cardInfo).GetComponent<CharacterStatModifiers>();
ApplyCardStats component3 = ((Component)cardInfo).GetComponent<ApplyCardStats>();
Block component4 = ((Component)cardInfo).GetComponent<Block>();
LoggerUtils.LogInfo("Generating random stats for " + cardInfo.cardName + "...");
int num = Mathf.Max(0, RandomCardOption.Min);
int max = Mathf.Clamp(RandomCardOption.Max, num, StatGenerators.Count);
RandomStatInfo[] array = SelectRandomStats(random, num, max);
cardInfo.cardStats = (CardInfoStat[])(object)new CardInfoStat[array.Length];
for (int i = 0; i < array.Length; i++)
{
RandomStatInfo randomStatInfo = array[i];
randomStatInfo.StatGenerator.Apply(randomStatInfo.Value, cardInfo, component, component3, component2, component4);
cardInfo.cardStats[i] = new CardInfoStat
{
stat = randomStatInfo.StatGenerator.StatName,
amount = randomStatInfo.StatGenerator.GetStatString(randomStatInfo.Value),
positive = randomStatInfo.StatGenerator.IsPositive(randomStatInfo.Value)
};
LoggerUtils.LogInfo($"Applied stat {randomStatInfo.StatGenerator.StatName} with value {randomStatInfo.Value}.");
}
LoggerUtils.LogInfo($"Generated {array.Length} stats for {cardInfo.cardName}.");
return array;
}
private RandomStatInfo[] SelectRandomStats(Random random, int min, int max)
{
LoggerUtils.LogInfo("Selecting random stats for " + CardGenName + "...");
int num = Mathf.Clamp(min, 0, StatGenerators.Count);
int num2 = Mathf.Clamp(max, num, StatGenerators.Count);
int num3 = random.Next(num, num2 + 1);
List<RandomStatGenerator> list = new List<RandomStatGenerator>(num3);
RandomStatInfo[] array = new RandomStatInfo[num3];
while (list.Count < num3)
{
int index = random.Next(StatGenerators.Count);
if (!list.Contains(StatGenerators[index]))
{
float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
if (StatGenerators[index].ShouldApply(value))
{
list.Add(StatGenerators[index]);
array[list.Count - 1] = new RandomStatInfo(StatGenerators[index], value);
LoggerUtils.LogInfo($"Selected stat {array[list.Count - 1].StatGenerator.StatName} with value {array[list.Count - 1].Value}.");
}
}
}
LoggerUtils.LogInfo($"Selected {list.Count} stats for {CardGenName}.");
return array;
}
public override string ToString()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
return $"RandomCardsGenerator: {CardGenName} | CardName: {RandomCardOption.CardName} | Rarity: {RandomCardOption.CardRarity} | Min: {RandomCardOption.Min} | Max: {RandomCardOption.Max}";
}
}
public abstract class RandomStatGenerator
{
public abstract string StatName { get; }
public float MinValue { get; private set; }
public float MaxValue { get; private set; }
public RandomStatGenerator(float minValue, float maxValue)
{
MinValue = minValue;
MaxValue = maxValue;
}
public abstract void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block);
public virtual string GetStatString(float value)
{
return GetStringValue(value * 100f);
}
public abstract bool IsPositive(float value);
public virtual bool ShouldApply(float value)
{
return value != 0f;
}
protected string GetStringValue(float value, bool isPercentage = true)
{
return string.Format("{0}{1}{2}", (value > 0f) ? "+" : "", Mathf.Round(value), isPercentage ? "%" : "");
}
}
}
namespace RandomCardsGenerators.Utils
{
internal static class LoggerUtils
{
private const bool logging = false;
public static void LogInfo(string message)
{
}
public static void LogWarn(string message)
{
Main.ModLogger.LogWarning((object)message);
}
public static void LogError(string message)
{
Main.ModLogger.LogError((object)message);
}
}
public class FindRandomCardsGeneratorResult
{
public readonly int Seed;
public readonly RandomCardsGenerator RandomCardsGenerator;
public FindRandomCardsGeneratorResult(int seed, RandomCardsGenerator randomCardsGenerator)
{
Seed = seed;
RandomCardsGenerator = randomCardsGenerator;
}
}
public static class RandomCardsUtils
{
public static Regex randomCardRegex = new Regex("^___RANDOM___(.*?)_(?:\\((\\d+)\\))?$", RegexOptions.Compiled);
public static FindRandomCardsGeneratorResult FindRandomCardsGeneratorByName(string cardName)
{
Match match = randomCardRegex.Match(cardName);
if (match.Success)
{
string generatorName = match.Groups[1].Value;
if (match.Groups.Count <= 2 || !int.TryParse(match.Groups[2].Value, out var result))
{
return null;
}
int seed = result;
RandomCardsGenerator value = RandomCardsGenerator.RandomStatCardGenerators.FirstOrDefault((KeyValuePair<string, RandomCardsGenerator> r) => r.Key == generatorName).Value;
if (value != null)
{
return new FindRandomCardsGeneratorResult(seed, value);
}
}
return null;
}
}
public static class RandomStatsUtils
{
public static float ScaleStatByIntensity(float intensity, float baseValue = 1f)
{
return baseValue / 2f / (1f - intensity);
}
}
}
namespace RandomCardsGenerators.StatsGroup
{
public class HealthStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Health";
public HealthStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.health += value;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class SizeStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Size";
public SizeStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.sizeMultiplier += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class DamageStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Damage";
public DamageStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.damage += value;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class ReloadTimeStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Reload Time";
public ReloadTimeStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.reloadTime += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class AttackSpeedStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Attack Speed";
public AttackSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.attackSpeed += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class MovementSpeedStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Movement Speed";
public MovementSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.movementSpeed += value;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class BlockCooldownStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Block Cooldown";
public BlockCooldownStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.025f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
block.cdMultiplier += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class BulletSpeedStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Bullet Speed";
public BulletSpeedStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.projectileSpeed += value;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class RegenStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Regen";
public RegenStatGenerator(float minValue, float maxValue, float thresholdToZero = 1f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.regen += value;
}
public override string GetStatString(float value)
{
return GetStringValue(value, isPercentage: false);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class SpreadStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Spread";
public SpreadStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.spread += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class DragStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Drag";
public DragStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.drag += value;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class LifeSteelStatGenerator : RandomStatGenerator
{
public float ThresholdToZero;
public override string StatName => "Life Steal";
public LifeSteelStatGenerator(float minValue, float maxValue, float thresholdToZero = 0.05f)
: base(minValue, maxValue)
{
ThresholdToZero = thresholdToZero;
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= ThresholdToZero;
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.lifeSteal += value;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class ReloadTimeSecondStatGenerator : RandomStatGenerator
{
public override string StatName => "Reload Time";
public ReloadTimeSecondStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.reloadTimeAdd += value;
}
public override string GetStatString(float value)
{
return string.Format("{0}{1:F2}s", (value > 0f) ? "+" : "", value);
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= 0.05f;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class BlockCooldownSecondStatGenerator : RandomStatGenerator
{
public override string StatName => "Block Cooldown";
public BlockCooldownSecondStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
block.cdAdd += value;
}
public override string GetStatString(float value)
{
return string.Format("{0}{1:F2}s", (value > 0f) ? "+" : "", value);
}
public override bool ShouldApply(float value)
{
return Mathf.Abs(value) >= 0.05f;
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class NumberOfProjectilesStatGenerator : RandomStatGenerator
{
public override string StatName => "Number of Projectiles";
public NumberOfProjectilesStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.numberOfProjectiles += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(Mathf.RoundToInt(value), isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class BouncesStatGenerator : RandomStatGenerator
{
public override string StatName => "Bounces";
public BouncesStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.reflects += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(Mathf.RoundToInt(value), isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class AmmoStatGenerator : RandomStatGenerator
{
public override string StatName => "Ammo";
public AmmoStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
gun.ammo += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class AdditionalBlocksStatGenerator : RandomStatGenerator
{
public override string StatName => "Additiona Block";
public AdditionalBlocksStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
block.additionalBlocks += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class ExtraLiveStatGenerator : RandomStatGenerator
{
public override string StatName => "Extra Live";
public ExtraLiveStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.respawns += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class JumpStatGenerator : RandomStatGenerator
{
public override string StatName => "Jump";
public JumpStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override void Apply(float value, CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
statModifiers.numberOfJumps += Mathf.RoundToInt(value);
}
public override string GetStatString(float value)
{
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldApply(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
}
namespace RandomCardsGenerators.Patches
{
[HarmonyPatch]
public class RandomCardSpawningPatches
{
[HarmonyPatch(typeof(CardChoice), "SpawnUniqueCard")]
private class SpawnUniqueCardPatch
{
public static bool PickPhaseCardSpawning;
[HarmonyPriority(800)]
private static void Prefix()
{
PickPhaseCardSpawning = true;
}
[HarmonyPriority(800)]
private static void Postfix()
{
PickPhaseCardSpawning = false;
}
}
[HarmonyPatch(typeof(CardChoice), "Spawn")]
[HarmonyPriority(0)]
[HarmonyPrefix]
private static bool Spawn(GameObject objToSpawn, Vector3 pos, Quaternion rot, ref GameObject __result)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)objToSpawn != (Object)null && (Object)(object)objToSpawn.GetComponent<RandomCard>() != (Object)null)
{
__result = PhotonNetwork.Instantiate(((Object)objToSpawn).name, pos, rot, (byte)0, new object[1] { DrawableRandomCard.random.Next(int.MaxValue) });
return false;
}
return true;
}
[HarmonyPatch(typeof(Cards), "AddCardToPlayer", new Type[]
{
typeof(Player),
typeof(CardInfo),
typeof(bool),
typeof(string),
typeof(float),
typeof(float),
typeof(bool)
})]
[HarmonyPrefix]
private static bool AddRandomCardToPlayer(Player player, CardInfo card)
{
if ((Object)(object)((Component)card).GetComponent<ToggleCustomCard>() != (Object)null && (PhotonNetwork.OfflineMode || PhotonNetwork.IsMasterClient))
{
foreach (NormalDrawableRandomCard normalDrawableCard in NormalDrawableRandomCard.NormalDrawableCards)
{
if (normalDrawableCard.ToggleCard != null && (Object)(object)normalDrawableCard.ToggleCard.toggleCardInfo == (Object)(object)card)
{
normalDrawableCard.StatCardGenerator.CreateRandomCard(player);
return false;
}
}
}
return true;
}
[HarmonyPatch(typeof(Cards), "RPCA_AssignCard", new Type[]
{
typeof(string),
typeof(int),
typeof(bool),
typeof(string),
typeof(float),
typeof(float),
typeof(bool)
})]
[HarmonyPrefix]
public static void AssignRandomCardRPC(string cardObjectName, int playerID, bool reassign, string twoLetterCode, float forceDisplay, float forceDisplayDelay, bool addToCardBar)
{
FindRandomCardsGeneratorResult findRandomCardsGeneratorResult = RandomCardsUtils.FindRandomCardsGeneratorByName(cardObjectName);
if (findRandomCardsGeneratorResult != null)
{
PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
findRandomCardsGeneratorResult.RandomCardsGenerator.GenerateRandomCard(findRandomCardsGeneratorResult.Seed);
}
}
[HarmonyPatch(typeof(CardChoicePatchGetRanomCard), "OrignialGetRanomCard", new Type[] { typeof(CardInfo[]) })]
[HarmonyPrefix]
private static void NormalDrawableCardsSpawn(ref CardInfo[] cards)
{
if (!SpawnUniqueCardPatch.PickPhaseCardSpawning)
{
return;
}
List<CardInfo> list = new List<CardInfo>(cards);
foreach (NormalDrawableRandomCard normalDrawableCard in NormalDrawableRandomCard.NormalDrawableCards)
{
list.Add(normalDrawableCard.CardInfo);
}
cards = list.ToArray();
}
[HarmonyPatch(typeof(CardManager), "GetCardInfoWithName")]
[HarmonyPostfix]
public static void GetRandomCardInfoWithName(string cardName, ref CardInfo __result)
{
FindRandomCardsGeneratorResult findRandomCardsGeneratorResult = RandomCardsUtils.FindRandomCardsGeneratorByName(cardName);
if (findRandomCardsGeneratorResult != null)
{
__result = findRandomCardsGeneratorResult.RandomCardsGenerator.GenerateRandomCard(findRandomCardsGeneratorResult.Seed).GetComponent<CardInfo>();
}
}
}
}
namespace RandomCardsGenerators.Extensions
{
public static class RandomExtension
{
public static float NextFloat(this Random random, float minValue, float maxValue)
{
return (float)random.NextDouble() * (maxValue - minValue) + minValue;
}
}
}
namespace RandomCardsGenerators.Cards
{
internal class BuiltRandomCard : CustomCard
{
public string ModInitials;
public string CardName;
public override void SetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
{
TextMeshProUGUI[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
if (componentsInChildren.Length != 0)
{
((TMP_Text)((Component)componentsInChildren.Where((TextMeshProUGUI obj) => ((Object)((Component)obj).gameObject).name == "Text_Name").FirstOrDefault()).GetComponent<TextMeshProUGUI>()).text = CardName;
}
});
}
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
}
public override bool GetEnabled()
{
return false;
}
protected override GameObject GetCardArt()
{
return base.cardInfo.cardArt;
}
protected override string GetDescription()
{
return base.cardInfo.cardDestription;
}
protected override Rarity GetRarity()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return base.cardInfo.rarity;
}
protected override CardInfoStat[] GetStats()
{
return base.cardInfo.cardStats;
}
protected override CardThemeColorType GetTheme()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return base.cardInfo.colorTheme;
}
protected override string GetTitle()
{
return base.cardInfo.cardName;
}
public override string GetModName()
{
return ModInitials;
}
}
public class DrawableRandomCard
{
internal static List<DrawableRandomCard> DrawableCards = new List<DrawableRandomCard>();
internal static readonly Random random = new Random();
public readonly RandomCardsGenerator StatCardGenerator;
public readonly GameObject CardGameObject;
public readonly CardInfo CardInfo;
public DrawableRandomCard(RandomCardsGenerator statCardGenerator)
{
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
GameObject val = Object.Instantiate<GameObject>(Main.blankCardPrefab);
((Object)val).name = "__" + statCardGenerator.RandomCardOption.ModInitials + "__" + statCardGenerator.CardGenName + "_DrawableCard";
Object.Destroy((Object)(object)((Component)val.transform.GetChild(0)).gameObject);
Object.DontDestroyOnLoad((Object)(object)val);
RandomCard randomCard = val.AddComponent<RandomCard>();
CardInfo = val.GetComponent<CardInfo>();
CardInfo.cardBase = Main.blankCardPrefab.GetComponent<CardInfo>().cardBase;
CardInfo.rarity = statCardGenerator.RandomCardOption.CardRarity;
CardInfo.cardName = statCardGenerator.RandomCardOption.CardName;
CardInfo.cardDestription = statCardGenerator.RandomCardOption.CardDescription;
CardInfo.colorTheme = statCardGenerator.RandomCardOption.ColorTheme;
randomCard.StatGenName = statCardGenerator.CardGenName;
PhotonNetwork.PrefabPool.RegisterPrefab(((Object)val).name, val);
CardGameObject = val;
StatCardGenerator = statCardGenerator;
DrawableCards.Add(this);
}
public GameObject InstantiateCard(Vector3 position, Quaternion rotation, int seed, Vector3 localScale)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
return PhotonNetwork.Instantiate(((Object)CardGameObject).name, position, rotation, (byte)0, new object[2] { seed, localScale });
}
public GameObject ReplaceCard(CardInfo cardInfo)
{
//IL_0030: 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_005f: Unknown result type (might be due to invalid IL or missing references)
ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Main.instance, 3, (Action)delegate
{
PhotonNetwork.Destroy(((Component)cardInfo).gameObject);
});
return InstantiateCard(((Component)cardInfo).transform.position, ((Component)cardInfo).transform.rotation, random.Next(int.MaxValue), ((Component)cardInfo).transform.localScale);
}
}
public class RandomCard : MonoBehaviour, IPunInstantiateMagicCallback
{
public string StatGenName;
public bool IsInstantiate;
public void OnPhotonInstantiate(PhotonMessageInfo info)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
object[] instantiationData = info.photonView.InstantiationData;
if (instantiationData != null)
{
int num = (int)instantiationData[0];
if (instantiationData.Length > 1 && instantiationData[1] is Vector3)
{
Vector3 localScale = (Vector3)instantiationData[1];
((Component)this).gameObject.transform.localScale = localScale;
}
LoggerUtils.LogInfo($"Generating generatedRandom generatedCardInfo with seed {num} using stat generator {StatGenName}");
if (RandomCardsGenerator.RandomStatCardGenerators.TryGetValue(StatGenName, out var value))
{
GenerateCard(value, num);
}
else
{
LoggerUtils.LogError("Stat generator " + StatGenName + " does not exist.");
}
IsInstantiate = true;
}
}
private void GenerateCard(RandomCardsGenerator generator, int seed)
{
CardInfo cardInfo = ((Component)this).GetComponent<CardInfo>();
generator.GenerateRandomCard(seed, null, delegate(GeneratedCardInfo generatedCardInfo)
{
LoggerUtils.LogInfo($"CardGenerator: {generator}");
LoggerUtils.LogInfo($"GeneratedCardInfo: {generatedCardInfo}");
GeneratedCardInfo obj = new GeneratedCardInfo(generator, cardInfo, generatedCardInfo.RandomStatInfos, generatedCardInfo.Random, seed);
CardInfoStat[] cardStats = generatedCardInfo.CardInfo.cardStats;
Random random = new Random(seed);
generator.ApplyRandomStats(cardInfo, random);
LoggerUtils.LogInfo($"Applied {cardStats.Length} stats to toggleCardInfo {cardInfo.cardName}.");
cardInfo.sourceCard = generatedCardInfo.CardInfo;
cardInfo.cardStats = cardStats;
generatedCardInfo.RandomCardsGenerator.OnCardGenerated?.Invoke(obj);
((Component)this).gameObject.GetComponentInChildren<CardInfoDisplayer>().DrawCard(cardStats, generator.RandomCardOption.CardName, generator.RandomCardOption.CardDescription, (Sprite)null, false);
LoggerUtils.LogInfo($"Card {cardInfo.cardName} displayed with {cardStats.Length} stats.");
if (Main.RarityTextType != null)
{
((Component)this).gameObject.AddComponent(Main.RarityTextType);
}
});
}
}
public class NormalDrawableRandomCard : DrawableRandomCard
{
public static List<NormalDrawableRandomCard> NormalDrawableCards = new List<NormalDrawableRandomCard>();
public ToggleCard ToggleCard;
public NormalDrawableRandomCard(RandomCardsGenerator statCardGenerator, bool createToggleCard = true)
: base(statCardGenerator)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: 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)
if (createToggleCard)
{
RandomCardOption randomCardOption = statCardGenerator.RandomCardOption;
ToggleCard = new ToggleCard(new List<CardInfo> { CardInfo }, randomCardOption.CardName, randomCardOption.CardDescription, randomCardOption.ModInitials, randomCardOption.ColorTheme);
ToggleCard.toggleCardInfo.rarity = randomCardOption.CardRarity;
}
NormalDrawableCards.Add(this);
}
}
public class ToggleCard
{
internal static readonly List<ToggleCard> ToggleCards = new List<ToggleCard>();
public readonly CardInfo toggleCardInfo;
public List<CardInfo> cardsInToggle = new List<CardInfo>();
public bool IsEnabled
{
get
{
if ((Object)(object)toggleCardInfo != (Object)null)
{
return CardManager.IsCardActive(toggleCardInfo);
}
return false;
}
}
public ToggleCard(List<CardInfo> cards, string cardName, string cardDescription, string modInitials, CardThemeColorType colorTheme = 3)
{
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
GameObject obj = Object.Instantiate<GameObject>(Main.blankCardPrefab);
Object.Destroy((Object)(object)((Component)obj.transform.GetChild(0)).gameObject);
Object.DontDestroyOnLoad((Object)(object)obj);
CardInfo component = obj.GetComponent<CardInfo>();
ToggleCustomCard toggleCustomCard = obj.AddComponent<ToggleCustomCard>();
component.cardName = cardName;
component.cardDestription = cardDescription;
component.cardBase = Main.blankCardPrefab.GetComponent<CardInfo>().cardBase;
component.rarity = (Rarity)0;
component.colorTheme = colorTheme;
toggleCustomCard.ModInitials = modInitials;
((CustomCard)toggleCustomCard).RegisterUnityCard((Action<CardInfo>)delegate
{
LoggerUtils.LogInfo("Register toggle card " + cardName + " with description: " + cardDescription + " and mod initials: " + modInitials);
});
cardsInToggle = cards;
ToggleCards.Add(this);
toggleCardInfo = component;
}
public bool IsCardEnabledInstance(CardInfo cardInfo)
{
if ((Object)(object)cardInfo == (Object)null)
{
return false;
}
CardInfo val = cardInfo;
if ((Object)(object)val.sourceCard != (Object)null)
{
val = val.sourceCard;
}
if (cardsInToggle.Contains(val))
{
return IsEnabled;
}
return true;
}
public static bool IsCardEnabled(CardInfo cardInfo)
{
CardInfo val = cardInfo;
if ((Object)(object)val.sourceCard != (Object)null)
{
val = val.sourceCard;
}
foreach (ToggleCard toggleCard in ToggleCards)
{
if (!toggleCard.IsCardEnabledInstance(val))
{
return false;
}
}
return true;
}
}
internal class ToggleCustomCard : CustomCard
{
public string ModInitials;
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
}
protected override GameObject GetCardArt()
{
return base.cardInfo.cardArt;
}
protected override string GetDescription()
{
return base.cardInfo.cardDestription;
}
protected override Rarity GetRarity()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return base.cardInfo.rarity;
}
protected override CardInfoStat[] GetStats()
{
return base.cardInfo.cardStats;
}
protected override CardThemeColorType GetTheme()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return base.cardInfo.colorTheme;
}
protected override string GetTitle()
{
return base.cardInfo.cardName;
}
public override string GetModName()
{
return ModInitials;
}
}
}
