using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using AALUND13Card.Armors;
using AALUND13Card.Cards;
using AALUND13Card.Extensions;
using AALUND13Card.Handlers;
using AALUND13Card.Handlers.ExtraPickHandlers;
using AALUND13Card.MonoBehaviours;
using AALUND13Card.MonoBehaviours.Soulstreak;
using AALUND13Card.RandomStatGenerators;
using AALUND13Card.RandomStatGenerators.Generators;
using AALUND13Card.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JARL;
using JARL.Armor;
using JARL.Armor.Bases;
using JARL.Armor.Utlis;
using JARL.Bases;
using JARL.Utils;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.GameModes;
using ModdingUtils.MonoBehaviours;
using ModdingUtils.Patches;
using ModdingUtils.Utils;
using ModsPlus;
using Photon.Pun;
using RarityLib.Utils;
using SoundImplementation;
using TMPro;
using TabInfo.Utils;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using WillsWackyManagers.Utils;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace AALUND13_Card.MonoBehaviours
{
public class CardFactoryMono : MonoBehaviour, IPickEndHookHandler
{
public Player Player;
public Gun Gun;
public GunAmmo GunAmmo;
public CharacterData Data;
public HealthHandler Health;
public Gravity Gravity;
public Block Block;
public CharacterStatModifiers CharacterStats;
public void Start()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Expected O, but got Unknown
Player = ((Component)this).GetComponentInParent<Player>();
Gun = Player.data.weaponHandler.gun;
GunAmmo = (GunAmmo)ExtensionMethods.GetFieldValue((object)Gun, "gunAmmo");
Data = Player.data;
Health = Player.data.healthHandler;
Gravity = ((Component)Player).GetComponent<Gravity>();
Block = Player.data.block;
CharacterStats = Player.data.stats;
InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
}
public void OnDestroy()
{
InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
}
public void OnPickEnd()
{
if (!PhotonNetwork.IsMasterClient)
{
return;
}
for (int i = 0; i < Player.data.GetAdditionalData().RandomCardsAtStart; i++)
{
float num = Random.Range(0f, 1f);
if (num < 0.7f)
{
CardInfo val = Cards.instance.NORARITY_GetRandomCardWithCondition(Player, Gun, GunAmmo, Data, Health, Gravity, Block, CharacterStats, (Func<CardInfo, Player, Gun, GunAmmo, CharacterData, HealthHandler, Gravity, Block, CharacterStatModifiers, bool>)condition, 1000);
Cards.instance.AddCardToPlayer(Player, val, false, "", 0f, 0f, true);
}
else
{
RandomStatManager.CreateRandomStatsCard("NegativeStatGenerator", "Defective Card", "A defective card", 1, 4, Player, "DC");
}
}
}
private bool condition(CardInfo card, Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
return true;
}
}
}
namespace AALUND13Card
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.aalund13.rounds.aalund13_cards", "AALUND13 Cards", "1.6.3")]
[BepInProcess("Rounds.exe")]
public class AALUND13_Cards : BaseUnityPlugin
{
internal const string ModInitials = "AAC";
internal const string CurseInitials = "AAC (Curse)";
internal const string ModId = "com.aalund13.rounds.aalund13_cards";
internal const string ModName = "AALUND13 Cards";
internal const string Version = "1.6.3";
internal static List<BaseUnityPlugin> Plugins;
internal static ManualLogSource ModLogger;
internal static AssetBundle Assets;
public static GameObject BlankCardPrefab;
public static CardCategory SoulstreakClassCards;
public static Material PixelateEffectMaterial;
public static Material ScanEffectMaterial;
public static AALUND13_Cards Instance { get; private set; }
public void Awake()
{
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
Instance = this;
ModLogger = ((BaseUnityPlugin)this).Logger;
ConfigHandler.RegesterMenu(((BaseUnityPlugin)this).Config);
Assets = AssetUtils.LoadAssetBundleFromResources("aacardassets", typeof(AALUND13_Cards).Assembly);
if ((Object)(object)Assets == (Object)null)
{
throw new Exception("Failed to load asset bundle");
}
BlankCardPrefab = Assets.LoadAsset<GameObject>("__AAC__Blank");
PixelateEffectMaterial = Assets.LoadAsset<Material>("PixelateEffectMaterial");
ScanEffectMaterial = Assets.LoadAsset<Material>("ScanEffectMaterial");
NegativeStatGenerator.RegisterNegativeStatGenerators();
CorruptedStatGenerator.RegisterCorruptedStatGenerators();
Harmony val = new Harmony("com.aalund13.rounds.aalund13_cards");
val.PatchAll();
}
public void Start()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
Plugins = (List<BaseUnityPlugin>)typeof(Chainloader).GetField("_plugins", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
Assets.LoadAsset<GameObject>("ModCards").GetComponent<CardResgester>().RegisterCards<AALUND13_Cards>("AAC");
DeathHandler.OnPlayerDeath += new DeathHandlerDelegate(OnPlayerDeath);
ArmorFramework.RegisterArmorType<SoulArmor>();
ArmorFramework.RegisterArmorType<BattleforgedArmor>();
GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ExtraCardPickHandler.HandleExtraPicks()));
GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
GameModeManager.AddHook("PickStart", (Func<IGameModeHandler, IEnumerator>)OnPickStart);
if (Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
{
TabinfoInterface.Setup();
}
CorruptedStatGenerator.BuildGlitchedCard();
((Component)this).gameObject.AddComponent<DelayDamageHandler>();
}
private IEnumerator OnGameStart(IGameModeHandler gameModeHandler)
{
foreach (Player player in PlayerManager.instance.players)
{
if (PhotonNetwork.IsMasterClient || PhotonNetwork.OfflineMode)
{
player.data.GetAdditionalData().Souls = 0u;
player.data.GetAdditionalData().CorruptedCardSpawnChance = 0f;
}
}
yield break;
}
private IEnumerator OnPickStart(IGameModeHandler gameModeHandler)
{
foreach (Player player in PlayerManager.instance.players)
{
if (PhotonNetwork.IsMasterClient || PhotonNetwork.OfflineMode)
{
bool isWinner = gameModeHandler.GetRoundWinners().Contains(player.teamID);
if (player.data.GetAdditionalData().ExtraCardPicks > 0 && !isWinner)
{
ExtraCardPickHandler.AddExtraPick<ExtraPickHandler>(player, player.data.GetAdditionalData().ExtraCardPicks);
}
}
}
yield break;
}
private void OnPlayerDeath(Player player, Dictionary<Player, DamageInfo> playerDamageInfos)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)((Component)player).GetComponent<DelayDamageHandler>() != (Object)null)
{
((MonoBehaviour)((Component)player).GetComponent<DelayDamageHandler>()).StopAllCoroutines();
}
foreach (KeyValuePair<Player, DamageInfo> playerDamageInfo in playerDamageInfos)
{
if (playerDamageInfo.Value.TimeSinceLastDamage <= 5f && (Object)(object)((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>() != (Object)null && !playerDamageInfo.Key.data.dead)
{
((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>().AddSouls();
if ((Object)(object)((Component)player).GetComponentInChildren<SoulstreakMono>() != (Object)null)
{
((Component)playerDamageInfo.Key).GetComponentInChildren<SoulstreakMono>().AddSouls((uint)((float)player.data.GetAdditionalData().Souls * 0.5f));
}
}
}
((Component)player).GetComponentInChildren<SoulstreakMono>()?.ResetSouls();
if ((Object)(object)((Component)player).GetComponentInChildren<SoulstreakMono>() == (Object)null)
{
player.data.GetAdditionalData().Souls = 0u;
}
}
}
public class TabinfoInterface
{
public static void Setup()
{
StatCategory val = TabInfoManager.RegisterCategory("AA Stats", 6);
TabInfoManager.RegisterStat(val, "Random Cards At Start", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().RandomCardsAtStart != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().RandomCardsAtStart}"));
TabInfoManager.RegisterStat(val, "Extra Card Picks", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().ExtraCardPicks != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().ExtraCardPicks}"));
TabInfoManager.RegisterStat(val, "Corrupted Card Spawn Chance", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().CorruptedCardSpawnChance != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().CorruptedCardSpawnChance * 100f:0}%"));
TabInfoManager.RegisterStat(val, "Corrupted Card Spawn Chance Per Pick", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().CorruptedCardSpawnChancePerPick != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().CorruptedCardSpawnChancePerPick * 100f:0}%"));
TabInfoManager.RegisterStat(val, "Delay Damage", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().secondToDealDamage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().secondToDealDamage} seconds"));
StatCategory val2 = TabInfoManager.RegisterCategory("Soulstreak Stats", 7);
TabInfoManager.RegisterStat(val2, "Max Health Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.MaxHealth != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.MaxHealth * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Player Size Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.PlayerSize != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.PlayerSize * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Movement Speed Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.MovementSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.MovementSpeed * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Attack Speed Pre Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.AttackSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.AttackSpeed * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Damage Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.Damage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.Damage * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Bullet Speed Per Kill", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.BulletSpeed != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.BulletSpeed * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Soul Armor Percentage", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentage != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentage * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Soul Armor Percentage Regen Rate", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentageRegenRate != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulArmorPercentageRegenRate * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Soul Drain Multiply", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().SoulStreakStats.SoulDrainMultiply != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().SoulStreakStats.SoulDrainMultiply * 100f:0}%"));
TabInfoManager.RegisterStat(val2, "Souls", (Func<Player, bool>)((Player p) => (Object)(object)((Component)p).GetComponentInChildren<SoulstreakMono>() != (Object)null && p.data.GetAdditionalData().Souls != 0), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().Souls}"));
}
}
public static class LoggerUtils
{
public static bool logging = ConfigHandler.DebugMode.Value;
public static void LogInfo(string message)
{
if (logging)
{
AALUND13_Cards.ModLogger.LogInfo((object)message);
}
}
public static void LogWarn(string message)
{
if (logging)
{
AALUND13_Cards.ModLogger.LogWarning((object)message);
}
}
public static void LogError(string message)
{
if (logging)
{
AALUND13_Cards.ModLogger.LogError((object)message);
}
}
}
}
namespace AALUND13Card.Utils
{
public static class RandomSyncSeed
{
private static readonly Random Random = new Random();
public static Dictionary<string, Action<SyncedRandomContext>> SyncedSeeds = new Dictionary<string, Action<SyncedRandomContext>>();
public static void InvokeWithSeed(string target, int seed, params object[] additionalParams)
{
NetworkingManager.RPC(typeof(RandomSyncSeed), "RPCA_SyncSeed", new object[3] { seed, target, additionalParams });
}
public static void Invoke(string target, params object[] additionalParams)
{
NetworkingManager.RPC(typeof(RandomSyncSeed), "RPCA_SyncSeed", new object[3]
{
Random.Next(),
target,
additionalParams
});
}
[UnboundRPC]
private static void RPCA_SyncSeed(int seed, string target, object[] additionalParams)
{
if (SyncedSeeds.ContainsKey(target))
{
SyncedSeeds[target](new SyncedRandomContext(seed, additionalParams));
}
}
public static void RegisterSyncedRandom(string target, Action<SyncedRandomContext> action)
{
SyncedSeeds.Add(target, action);
}
}
public class SyncedRandomContext
{
public Random Random { get; private set; }
public object[] Parameters { get; private set; }
public SyncedRandomContext(int seed, object[] parameters)
{
Random = new Random(seed);
Parameters = parameters;
}
}
}
namespace AALUND13Card.RandomStatGenerators
{
public class BuildRandomStatCard : AACustomCard
{
public string CardName;
public override void OnSetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
{
TextMeshProUGUI[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
if (componentsInChildren.Length != 0)
{
((TMP_Text)((Component)componentsInChildren.Where((TextMeshProUGUI obj) => ((Object)((Component)obj).gameObject).name == "Text_Name").FirstOrDefault()).GetComponent<TextMeshProUGUI>()).text = CardName;
}
});
}
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
}
}
public class GlitchedCardSpawnedChanceStatGenerator : RandomStatGenerator
{
public override string StatName => "Glitched Card Spawned Chance";
public GlitchedCardSpawnedChanceStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
AAStatModifers orAddComponent = ExtensionMethods.GetOrAddComponent<AAStatModifers>(cardObj, false);
orAddComponent.CorruptedCardSpawnChance += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public abstract class RandomStatGenerator
{
public abstract string StatName { get; }
public float MinValue { get; private set; }
public float MaxValue { get; private set; }
public RandomStatGenerator(float minValue, float maxValue)
{
MinValue = minValue;
MaxValue = maxValue;
}
public abstract string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block);
public abstract bool IsPositive(float value);
public virtual bool ShouldAddStat(float value)
{
return value != 0f;
}
protected string GetStringValue(float value, bool isPercentage = true)
{
return string.Format("{0}{1}{2}", (value > 0f) ? "+" : "", Mathf.Round(value), isPercentage ? "%" : "");
}
}
public class DamageStatGenerator : RandomStatGenerator
{
public override string StatName => "Damage";
public DamageStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
gun.damage += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class ReloadTimeStatGenerator : RandomStatGenerator
{
public override string StatName => "Reload Time";
public ReloadTimeStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
gun.reloadTime += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class AttackSpeedStatGenerator : RandomStatGenerator
{
public override string StatName => "Attack Speed";
public AttackSpeedStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
gun.attackSpeed += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class MovementSpeedStatGenerator : RandomStatGenerator
{
public override string StatName => "Movement Speed";
public MovementSpeedStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
characterStats.movementSpeed += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class HealthStatGenerator : RandomStatGenerator
{
public override string StatName => "Health";
public HealthStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
characterStats.health += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class BlockCooldownStatGenerator : RandomStatGenerator
{
public override string StatName => "Block Cooldown";
public BlockCooldownStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
block.cdMultiplier += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value < 0f;
}
}
public class BulletSpeedStatGenerator : RandomStatGenerator
{
public override string StatName => "Bullet Speed";
public BulletSpeedStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
gun.projectileSpeed += value;
return GetStringValue(value * 100f);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class RegenStatGenerator : RandomStatGenerator
{
public override string StatName => "Regen";
public RegenStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
characterStats.regen += value;
return GetStringValue(value, isPercentage: false);
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class AmmoStatGenerator : RandomStatGenerator
{
public override string StatName => "Ammo";
public AmmoStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
gun.ammo += Mathf.RoundToInt(value);
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldAddStat(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class AdditionalBlocksStatGenerator : RandomStatGenerator
{
public override string StatName => "Additiona Block";
public AdditionalBlocksStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
block.additionalBlocks += Mathf.RoundToInt(value);
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldAddStat(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public class ExtraLiveStatGenerator : RandomStatGenerator
{
public override string StatName => "Extra Live";
public ExtraLiveStatGenerator(float minValue, float maxValue)
: base(minValue, maxValue)
{
}
public override string Apply(float value, GameObject cardObj, Gun gun, CharacterStatModifiers characterStats, Block block)
{
characterStats.respawns += Mathf.RoundToInt(value);
return GetStringValue(value, isPercentage: false);
}
public override bool ShouldAddStat(float value)
{
return Mathf.RoundToInt(value) != 0;
}
public override bool IsPositive(float value)
{
return value > 0f;
}
}
public static class RandomStatManager
{
public static readonly Dictionary<string, RandomStatHandler> RandomStatHandlers = new Dictionary<string, RandomStatHandler>();
public static readonly Dictionary<string, List<CardInfo>> GeneratedCards = new Dictionary<string, List<CardInfo>>();
public static void AddRandomStatHandler(string statGenName, List<RandomStatGenerator> statGenerators)
{
RandomStatHandlers.Add(statGenName, new RandomStatHandler(statGenName, statGenerators));
}
internal static void AddCardToGenerated(string statGenName, CardInfo cardInfo)
{
if (GeneratedCards.ContainsKey(statGenName))
{
GeneratedCards[statGenName].Add(cardInfo);
return;
}
GeneratedCards.Add(statGenName, new List<CardInfo> { cardInfo });
}
internal static List<CardInfo> GetGeneratedCards(string statGenName)
{
if (GeneratedCards.ContainsKey(statGenName))
{
return GeneratedCards[statGenName];
}
return new List<CardInfo>();
}
public static void CreateRandomStatsCard(string statGenName, int seed, string cardName, string cardDescription, int minRandomStat, int maxRandomStat, Player player = null, string twoLetterCode = null)
{
RandomSyncSeed.InvokeWithSeed(statGenName, seed, cardName, cardDescription, minRandomStat, maxRandomStat, player?.playerID ?? (-1), twoLetterCode);
}
public static void CreateRandomStatsCard(string statGenName, string cardName, string cardDescription, int minRandomStat, int maxRandomStat, Player player = null, string twoLetterCode = null)
{
RandomSyncSeed.Invoke(statGenName, cardName, cardDescription, minRandomStat, maxRandomStat, player?.playerID ?? (-1), twoLetterCode);
}
}
public class RandomStatHandler
{
public readonly string StatGenName;
public List<RandomStatGenerator> StatGenerators { get; private set; }
public event Action<CardInfo, SyncedRandomContext> OnCardGenerated;
public RandomStatHandler(string statGenName, List<RandomStatGenerator> statGenerators)
{
StatGenName = statGenName;
StatGenerators = statGenerators;
RandomStatManager.RandomStatHandlers.Add(statGenName, this);
RandomSyncSeed.RegisterSyncedRandom(statGenName, SyncRandomSyncStats);
}
public void GetCardStatsFromSeed(int seed, int minRandomStat, int maxRandomStat, GameObject newCard, Gun gun, CharacterStatModifiers statModifiers, Block block)
{
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Expected O, but got Unknown
Random random = new Random(seed);
int num = random.Next(minRandomStat, maxRandomStat);
Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
while (dictionary.Count < num)
{
int index = random.Next(StatGenerators.Count);
if (!dictionary.ContainsKey(StatGenerators[index]))
{
float value = random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
if (StatGenerators[index].ShouldAddStat(value))
{
dictionary.Add(StatGenerators[index], value);
}
}
}
List<CardInfoStat> list = new List<CardInfoStat>();
foreach (KeyValuePair<RandomStatGenerator, float> item in dictionary)
{
list.Add(new CardInfoStat
{
stat = item.Key.StatName,
amount = item.Key.Apply(item.Value, newCard, gun, statModifiers, block),
positive = item.Key.IsPositive(item.Value)
});
}
CardInfo component = newCard.GetComponent<CardInfo>();
component.cardStats = list.ToArray();
}
private void SyncRandomSyncStats(SyncedRandomContext context)
{
//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
//IL_02df: Unknown result type (might be due to invalid IL or missing references)
//IL_0300: Unknown result type (might be due to invalid IL or missing references)
//IL_031e: Expected O, but got Unknown
string text = (string)context.Parameters[0];
string cardDestription = (string)context.Parameters[1];
int num = Mathf.Max(0, (int)context.Parameters[2]);
int maxValue = Mathf.Clamp((int)context.Parameters[3], num, StatGenerators.Count);
Player player = null;
if (context.Parameters.Length > 4 && (int)context.Parameters[4] != -1)
{
player = PlayerManager.instance.players.Find((Player p) => p.playerID == (int)context.Parameters[4]);
}
string twoLetterCode = ((context.Parameters.Length > 5) ? ((string)context.Parameters[5]) : null);
GameObject val = Object.Instantiate<GameObject>(AALUND13_Cards.BlankCardPrefab);
Object.Destroy((Object)(object)((Component)val.transform.GetChild(0)).gameObject);
Object.DontDestroyOnLoad((Object)(object)val);
CardInfo component = val.GetComponent<CardInfo>();
BuildRandomStatCard buildRandomStatCard = val.AddComponent<BuildRandomStatCard>();
RandomStatManager.AddCardToGenerated(StatGenName, component);
component.cardName = $"{StatGenName} Card ({RandomStatManager.GetGeneratedCards(StatGenName).Count})";
component.cardDestription = cardDestription;
buildRandomStatCard.CardName = text;
((CustomUnityCard)buildRandomStatCard).IsHidden = true;
Gun component2 = val.GetComponent<Gun>();
CharacterStatModifiers component3 = val.GetComponent<CharacterStatModifiers>();
Block component4 = val.GetComponent<Block>();
LoggerUtils.LogInfo("Generating random stats for " + text + "...");
int num2 = context.Random.Next(num, maxValue);
Dictionary<RandomStatGenerator, float> dictionary = new Dictionary<RandomStatGenerator, float>();
while (dictionary.Count < num2)
{
int index = context.Random.Next(StatGenerators.Count);
if (!dictionary.ContainsKey(StatGenerators[index]))
{
float value = context.Random.NextFloat(StatGenerators[index].MinValue, StatGenerators[index].MaxValue);
if (StatGenerators[index].ShouldAddStat(value))
{
dictionary.Add(StatGenerators[index], value);
}
}
}
List<CardInfoStat> list = new List<CardInfoStat>();
foreach (KeyValuePair<RandomStatGenerator, float> item in dictionary)
{
list.Add(new CardInfoStat
{
stat = item.Key.StatName,
amount = item.Key.Apply(item.Value, val, component2, component3, component4),
positive = item.Key.IsPositive(item.Value)
});
}
component.cardStats = list.ToArray();
LoggerUtils.LogInfo($"Generated {list.Count} stats for {text}.");
LoggerUtils.LogInfo("Building card...");
((CustomCard)buildRandomStatCard).BuildUnityCard((Action<CardInfo>)delegate(CardInfo cardInfo)
{
((CustomUnityCard)buildRandomStatCard).Register(cardInfo);
this.OnCardGenerated?.Invoke(cardInfo, context);
if ((Object)(object)player != (Object)null)
{
ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)AALUND13_Cards.Instance, 0.2f, (Action)delegate
{
Cards.instance.AddCardToPlayer(player, cardInfo, false, twoLetterCode, 2f, 2f, true);
});
}
LoggerUtils.LogInfo("Card built!");
});
}
}
}
namespace AALUND13Card.RandomStatGenerators.Generators
{
internal class CorruptedStatGenerator
{
public static List<CardInfo> CorruptedCards = new List<CardInfo>();
public static void RegisterCorruptedStatGenerators()
{
new RandomStatHandler("CorruptedStatGeneratorCommon", new List<RandomStatGenerator>
{
new DamageStatGenerator(-0.3f, 0.3f),
new ReloadTimeStatGenerator(-0.3f, 0.3f),
new AttackSpeedStatGenerator(-0.3f, 0.3f),
new MovementSpeedStatGenerator(-0.1f, 0.1f),
new HealthStatGenerator(-0.3f, 0.3f),
new BlockCooldownStatGenerator(-0.1f, 0.1f),
new BulletSpeedStatGenerator(-0.3f, 0.3f),
new AmmoStatGenerator(-2f, 2f),
new GlitchedCardSpawnedChanceStatGenerator(-0.05f, 0.05f)
}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
{
CorruptedCards.Add(card);
((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
};
new RandomStatHandler("CorruptedStatGeneratorUncommon", new List<RandomStatGenerator>
{
new DamageStatGenerator(-0.3f, 0.5f),
new ReloadTimeStatGenerator(-0.45f, 0.3f),
new AttackSpeedStatGenerator(-0.45f, 0.3f),
new MovementSpeedStatGenerator(-0.15f, 0.25f),
new HealthStatGenerator(-0.3f, 0.5f),
new BlockCooldownStatGenerator(-0.25f, 0.15f),
new BulletSpeedStatGenerator(-0.3f, 0.4f),
new AmmoStatGenerator(-2f, 4f),
new RegenStatGenerator(0f, 15f),
new AdditionalBlocksStatGenerator(0f, 0.6f),
new GlitchedCardSpawnedChanceStatGenerator(-0.1f, 0.1f)
}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
CorruptedCards.Add(card);
((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
card.rarity = (Rarity)1;
};
new RandomStatHandler("CorruptedStatGeneratorRare", new List<RandomStatGenerator>
{
new DamageStatGenerator(-0.3f, 0.8f),
new ReloadTimeStatGenerator(-0.6f, 0.3f),
new AttackSpeedStatGenerator(-0.6f, 0.3f),
new MovementSpeedStatGenerator(-0.2f, 0.35f),
new HealthStatGenerator(-0.3f, 0.75f),
new BlockCooldownStatGenerator(-0.3f, 0.1f),
new BulletSpeedStatGenerator(-0.3f, 0.6f),
new AmmoStatGenerator(-3f, 6f),
new RegenStatGenerator(0f, 35f),
new AdditionalBlocksStatGenerator(0f, 0.625f),
new GlitchedCardSpawnedChanceStatGenerator(-0.2f, 0.2f)
}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
CorruptedCards.Add(card);
((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
card.rarity = (Rarity)2;
};
new RandomStatHandler("CorruptedStatGeneratorLegendary", new List<RandomStatGenerator>
{
new DamageStatGenerator(-0.3f, 1f),
new ReloadTimeStatGenerator(-0.75f, 0.3f),
new AttackSpeedStatGenerator(-0.75f, 0.3f),
new MovementSpeedStatGenerator(-0.25f, 0.45f),
new HealthStatGenerator(-0.3f, 1f),
new BlockCooldownStatGenerator(-0.4f, 0.25f),
new BulletSpeedStatGenerator(-0.3f, 0.75f),
new AmmoStatGenerator(-4f, 8f),
new RegenStatGenerator(0f, 50f),
new AdditionalBlocksStatGenerator(0f, 5f / 6f),
new ExtraLiveStatGenerator(0f, 0.7692308f),
new GlitchedCardSpawnedChanceStatGenerator(-0.35f, 0.35f)
}).OnCardGenerated += delegate(CardInfo card, SyncedRandomContext context)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
CorruptedCards.Add(card);
((Component)card).gameObject.AddComponent<GlitchingCardEffect>();
card.rarity = RarityUtils.GetRarity("Legendary");
};
}
public static void BuildGlitchedCard()
{
Random random = new Random("1.6.3".GetHashCode());
for (int i = 0; i < 100; i++)
{
RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorCommon", random.Next(), "Corrupted Card", "A random description", 1, 3);
}
for (int j = 0; j < 75; j++)
{
RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorUncommon", random.Next(), "Corrupted Card", "A random description", 1, 4);
}
for (int k = 0; k < 50; k++)
{
RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorRare", random.Next(), "Corrupted Card", "A random description", 1, 5);
}
for (int l = 0; l < 25; l++)
{
RandomStatManager.CreateRandomStatsCard("CorruptedStatGeneratorLegendary", random.Next(), "Corrupted Card", "A random description", 2, 6);
}
}
}
internal class NegativeStatGenerator
{
public static void RegisterNegativeStatGenerators()
{
new RandomStatHandler("NegativeStatGenerator", new List<RandomStatGenerator>
{
new DamageStatGenerator(-0.5f, 0f),
new ReloadTimeStatGenerator(0f, 0.5f),
new AttackSpeedStatGenerator(0f, 0.5f),
new MovementSpeedStatGenerator(-0.5f, 0f),
new HealthStatGenerator(-0.5f, 0f),
new BlockCooldownStatGenerator(0f, 0.5f),
new BulletSpeedStatGenerator(-0.5f, 0f)
});
}
}
}
namespace AALUND13Card.Patches
{
[HarmonyPatch(typeof(Cards), "PlayerIsAllowedCard")]
public class AllowedCardPatch
{
private static void Postfix(Player player, CardInfo card, ref bool __result, Cards __instance)
{
if (!((Object)(object)player == (Object)null) && !((Object)(object)card == (Object)null) && (Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(player) && ExtraCardPickHandler.extraPicks[player].Count > 0)
{
ExtraPickHandler extraPickHandler = ExtraCardPickHandler.extraPicks[player][0];
bool flag = extraPickHandler.OnExtraPickStart(player, card);
__result &= flag;
}
}
}
[HarmonyPatch(typeof(ApplyCardStats), "ApplyStats")]
public class ApplyCardStatsPatch
{
public static void Postfix(ApplyCardStats __instance, Player ___playerToUpgrade)
{
AAStatModifers component = ((Component)__instance).gameObject.GetComponent<AAStatModifers>();
if ((Object)(object)component != (Object)null)
{
component.Apply(___playerToUpgrade);
}
}
}
[HarmonyPatch(typeof(CardChoice))]
public class CardChoicePatch
{
[HarmonyPatch("IDoEndPick")]
private static void Postfix(GameObject pickedCard, int theInt, int pickId)
{
Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickId);
if (!((Object)(object)playerWithID == (Object)null) && (Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(playerWithID) && ExtraCardPickHandler.extraPicks[playerWithID].Count > 0)
{
ExtraPickHandler extraPickHandler = ExtraCardPickHandler.extraPicks[playerWithID][0];
extraPickHandler.OnExtraPick(playerWithID, pickedCard.GetComponent<CardInfo>());
}
}
[HarmonyPatch("StartPick")]
private static void Prefix(int pickerIDToSet)
{
Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickerIDToSet);
playerWithID.data.GetAdditionalData().CorruptedCardSpawnChance += playerWithID.data.GetAdditionalData().CorruptedCardSpawnChancePerPick;
}
}
[HarmonyPatch(typeof(CharacterStatModifiers))]
public class CharacterStatModifiersPatch
{
[HarmonyPatch("ResetStats")]
[HarmonyPrefix]
public static void ResetStats(CharacterStatModifiers __instance)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
val.GetAdditionalData().Reset();
if (ExtraCardPickHandler.extraPicks.ContainsKey(val.player))
{
ExtraCardPickHandler.extraPicks[val.player].Clear();
}
Camera main = Camera.main;
if ((Object)(object)main != (Object)null)
{
Effect[] components = ((Component)main).GetComponents<Effect>();
foreach (Effect effect in components)
{
Object.Destroy((Object)(object)effect);
}
}
}
}
[HarmonyPatch(typeof(CardChoicePatchGetRanomCard), "OrignialGetRanomCard", new Type[] { typeof(CardInfo[]) })]
internal class GetRanomCardPatch
{
public static Random random = new Random();
private static void Prefix(ref CardInfo[] cards)
{
Player val = PickingPlayer(CardChoice.instance);
if ((Object)(object)val != (Object)null && random.NextFloat(0f, 1f) < val.data.GetAdditionalData().CorruptedCardSpawnChance)
{
cards = CorruptedStatGenerator.CorruptedCards.ToArray();
}
}
internal static Player PickingPlayer(CardChoice cardChoice)
{
object? obj = typeof(CardChoicePatchGetRanomCard).GetMethod("PickingPlayer", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[1] { cardChoice });
return (Player)((obj is Player) ? obj : null);
}
}
[HarmonyPatch(typeof(HealthHandler))]
public class HealthHandlerPatch
{
[HarmonyPatch("DoDamage")]
[HarmonyPrefix]
public static void DoDamage(HealthHandler __instance, ref Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon, Player damagingPlayer, bool healthRemoval, bool lethal, bool ignoreBlock)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
CharacterData block = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
AALUND13CardCharacterDataAdditionalData additionalData = block.GetAdditionalData();
if (additionalData.secondToDealDamage > 0f && !additionalData.dealDamage)
{
Vector2 damage2 = default(Vector2);
((Vector2)(ref damage2))..ctor(damage.x, damage.y);
ExtensionMethods.GetOrAddComponent<DelayDamageHandler>(((Component)__instance).gameObject, false).DelayDamage(damage2, position, blinkColor, damagingWeapon, damagingPlayer, healthRemoval, lethal, ignoreBlock);
damage = Vector2.zero;
}
else if (additionalData.dealDamage)
{
additionalData.dealDamage = false;
}
}
}
}
namespace AALUND13Card.MonoBehaviours
{
[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class Effect : MonoBehaviour
{
public Material Material;
private void OnRenderImage(RenderTexture src, RenderTexture dest)
{
if ((Object)(object)Material == (Object)null)
{
Graphics.Blit((Texture)(object)src, dest);
return;
}
RenderTexture temporary = RenderTexture.GetTemporary(((Texture)src).width, ((Texture)src).height);
Graphics.Blit((Texture)(object)src, temporary, Material, 0);
Graphics.Blit((Texture)(object)temporary, dest);
RenderTexture.ReleaseTemporary(temporary);
}
}
public class GlitchingCardEffect : MonoBehaviour
{
private void Start()
{
if (((Component)this).gameObject.transform.childCount == 0)
{
return;
}
ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)this, 1, (Action)delegate
{
GlitchingTextMono orAddComponent = ExtensionMethods.GetOrAddComponent<GlitchingTextMono>(((Component)this).gameObject, false);
orAddComponent.EffectAllText = false;
TextMeshProUGUI[] componentsInChildren = ((Component)((Component)this).gameObject.transform.GetChild(0).Find("Canvas/Front/Grid")).GetComponentsInChildren<TextMeshProUGUI>();
TextMeshProUGUI[] array = componentsInChildren;
foreach (TextMeshProUGUI textMesh in array)
{
orAddComponent.AddTextMesh(textMesh);
}
TextMeshProUGUI component = ((Component)((Component)this).gameObject.transform.GetChild(0).Find("Canvas/Front/Text_Name")).GetComponent<TextMeshProUGUI>();
orAddComponent.AddTextMesh(component);
});
}
}
public class GlitchingTextMono : MonoBehaviour
{
public static Regex regex = new Regex("<glitch>(.*?)(<\\/glitch>|$)", RegexOptions.Compiled);
public bool UseGlitchTag = false;
public bool EffectAllText = true;
private const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()_+-=<>?:\"{}|,./;'[]\\'~";
private List<(TextMeshProUGUI, string)> textMeshes = new List<(TextMeshProUGUI, string)>();
private List<char> characters = new List<char>();
private void Start()
{
characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz!@#$%^&*()_+-=<>?:\"{}|,./;'[]\\'~".ToList();
if (EffectAllText)
{
TextMeshProUGUI[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
textMeshes.AddRange(componentsInChildren.Select((TextMeshProUGUI obj) => (obj, ((TMP_Text)obj).text)));
}
}
public void AddTextMesh(TextMeshProUGUI textMesh)
{
textMeshes.Add((textMesh, ((TMP_Text)textMesh).text));
}
private void Update()
{
if (textMeshes.Count == 0)
{
return;
}
foreach (var (val, originalText) in textMeshes)
{
if (UseGlitchTag)
{
string text = ProcessTextWithGlitchTag(originalText);
((TMP_Text)val).text = text;
}
else
{
GlitchCharacters(val, originalText);
}
}
}
private void GlitchCharacters(TextMeshProUGUI textMesh, string originalText)
{
((TMP_Text)textMesh).text = "<mspace=0.5em>";
for (int i = 0; i < originalText.Length; i++)
{
((TMP_Text)textMesh).text = ((TMP_Text)textMesh).text + characters[Random.Range(0, characters.Count)];
}
}
private string ProcessTextWithGlitchTag(string originalText)
{
return regex.Replace(originalText, delegate(Match match)
{
string value = match.Groups[1].Value;
string text = GenerateGlitchedText(value.Length);
return "<mspace=0.5em>" + text + "</mspace>";
});
}
private string GenerateGlitchedText(int length)
{
char[] array = new char[length];
for (int i = 0; i < length; i++)
{
array[i] = characters[Random.Range(0, characters.Count)];
}
return new string(array);
}
}
public class SoulstreakDrain : MonoBehaviour
{
private SoulStreakStats soulstreakStats;
private DealDamageToPlayer dealDamageToPlayer;
private Player player;
public void Start()
{
player = ((Component)this).GetComponentInParent<Player>();
soulstreakStats = player.data.GetAdditionalData().SoulStreakStats;
dealDamageToPlayer = ((Component)this).GetComponent<DealDamageToPlayer>();
dealDamageToPlayer.soundDamage.variables.audioMixerGroup = SoundVolumeManager.Instance.audioMixer.FindMatchingGroups("SFX")[0];
}
public void Update()
{
if (soulstreakStats != null)
{
dealDamageToPlayer.damage = player.data.weaponHandler.gun.damage * 55f * soulstreakStats.SoulDrainMultiply;
}
}
public void Heal()
{
player.data.healthHandler.Heal(player.data.weaponHandler.gun.damage * 55f * soulstreakStats.SoulDrainMultiply * 0.25f);
}
}
[Flags]
public enum AbilityType
{
Armor = 1
}
[Serializable]
public class SoulStreakStats
{
public float MaxHealth = 1f;
public float PlayerSize = 1f;
public float MovementSpeed = 1f;
public float AttackSpeed = 1f;
public float Damage = 1f;
public float BulletSpeed = 1f;
public float SoulArmorPercentage = 0f;
public float SoulArmorPercentageRegenRate = 0f;
public float SoulDrainMultiply = 0f;
public AbilityType AbilityType;
}
public class SoulstreakMono : MonoBehaviour, IBattleStartHookHandler, IPointEndHookHandler
{
private Player player;
private ArmorHandler armorHandler;
public bool CanResetKills = true;
public bool AbilityActive;
public float AbilityCooldown;
public GameObject SoulsCounter;
public GameObject SoulsCounterGUI;
private SoulStreakStats SoulstreakStats => player.data.GetAdditionalData().SoulStreakStats;
private string SoulsString => string.Format("{0}: {1}", (Souls > 1) ? "Souls" : "Soul", Souls);
private uint Souls
{
get
{
return player.data.GetAdditionalData().Souls;
}
set
{
player.data.GetAdditionalData().Souls = value;
}
}
private void Start()
{
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
player = ((Component)((Component)this).gameObject.transform.parent).GetComponent<Player>();
armorHandler = ((Component)player).GetComponent<ArmorHandler>();
SoulsCounter = Object.Instantiate<GameObject>(SoulsCounter);
if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
{
SoulsCounterGUI = Object.Instantiate<GameObject>(SoulsCounterGUI);
SoulsCounterGUI.transform.SetParent(((Component)player).transform.parent);
}
player.data.SetWobbleObjectChild(SoulsCounter.transform);
SoulsCounter.transform.localPosition = Vector2.op_Implicit(new Vector2(0f, 0.3f));
InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
}
private void OnDestroy()
{
if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
{
Object.Destroy((Object)(object)SoulsCounterGUI);
}
Object.Destroy((Object)(object)SoulsCounter);
if ((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>() != (Object)null)
{
Object.Destroy((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>());
}
InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
}
private void Update()
{
if (player.data.isPlaying)
{
AbilityCooldown = Mathf.Max(AbilityCooldown - Time.deltaTime, 0f);
if (armorHandler.GetArmorByType<SoulArmor>().CurrentArmorValue <= 0f && armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue > 0f)
{
armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue = 0f;
AbilityCooldown = 10f;
AbilityActive = false;
}
}
((TMP_Text)SoulsCounter.GetComponent<TextMeshPro>()).text = SoulsString;
if (player.data.view.IsMine && !((Behaviour)((Component)player).GetComponent<PlayerAPI>()).enabled)
{
((TMP_Text)SoulsCounterGUI.GetComponentInChildren<TextMeshProUGUI>()).text = SoulsString;
}
}
public void BlockAbility()
{
if (SoulstreakStats.AbilityType == AbilityType.Armor && !AbilityActive && AbilityCooldown == 0f)
{
ArmorBase armorByType = armorHandler.GetArmorByType<SoulArmor>();
armorByType.MaxArmorValue = player.data.maxHealth * SoulstreakStats.SoulArmorPercentage * (float)(Souls + 1);
armorByType.ArmorRegenerationRate = armorByType.MaxArmorValue * SoulstreakStats.SoulArmorPercentageRegenRate;
armorByType.CurrentArmorValue = armorByType.MaxArmorValue;
AbilityActive = true;
}
}
public void ResetSouls()
{
if (CanResetKills)
{
LoggerUtils.LogInfo($"Resetting kill streak of player with ID {player.playerID}");
if ((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>() != (Object)null)
{
Object.Destroy((Object)(object)((Component)player).gameObject.GetComponent<SoulstreakEffect>());
}
Souls = 0u;
if (player.data.view.IsMine)
{
((TMP_Text)SoulsCounterGUI.GetComponentInChildren<TextMeshProUGUI>()).text = SoulsString;
}
}
}
public void AddSouls(uint kills = 1u)
{
if (CanResetKills)
{
LoggerUtils.LogInfo($"Adding {kills} kills for player with ID {player.playerID}");
Souls += kills;
ExtensionMethods.GetOrAddComponent<SoulstreakEffect>(((Component)player).gameObject, false).ApplyStats();
}
}
public void OnBattleStart()
{
CanResetKills = true;
ExtensionMethods.GetOrAddComponent<SoulstreakEffect>(((Component)player).gameObject, false).ApplyStats();
}
public void OnPointEnd()
{
CanResetKills = false;
armorHandler.GetArmorByType<SoulArmor>().MaxArmorValue = 0f;
}
}
}
namespace AALUND13Card.MonoBehaviours.Soulstreak
{
public class SoulstreakEffect : ReversibleEffect, IPickStartHookHandler, IGameStartHookHandler
{
public override void OnStart()
{
InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
((ReversibleEffect)this).SetLivesToEffect(int.MaxValue);
base.applyImmediately = false;
ApplyStats();
}
public void ApplyStats()
{
SoulStreakStats soulStreakStats = base.data.GetAdditionalData().SoulStreakStats;
uint souls = base.data.GetAdditionalData().Souls;
((ReversibleEffect)this).ClearModifiers(true);
base.characterDataModifier.maxHealth_mult = 1f + (soulStreakStats.MaxHealth - 1f) * (float)souls;
base.characterStatModifiersModifier.sizeMultiplier_mult = 1f + (soulStreakStats.PlayerSize - 1f) * (float)souls;
base.characterStatModifiersModifier.movementSpeed_mult = 1f + (soulStreakStats.MovementSpeed - 1f) * (float)souls;
base.gunStatModifier.attackSpeed_mult = 1f + (soulStreakStats.AttackSpeed - 1f) * (float)souls;
base.gunStatModifier.damage_mult = 1f + (soulStreakStats.Damage - 1f) * (float)souls;
base.gunStatModifier.projectileSpeed_mult = 1f + (soulStreakStats.BulletSpeed - 1f) * (float)souls;
((ReversibleEffect)this).ApplyModifiers();
}
public void OnGameStart()
{
Object.Destroy((Object)(object)this);
}
public void OnPickStart()
{
Object.Destroy((Object)(object)this);
}
public override void OnOnDestroy()
{
InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
}
}
}
namespace AALUND13Card.Handlers
{
internal class ConfigHandler
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__2_0;
internal void <RegesterMenu>b__2_0()
{
}
}
public static ConfigEntry<bool> DetailsMode;
public static ConfigEntry<bool> DebugMode;
public static void RegesterMenu(ConfigFile config)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Expected O, but got Unknown
object obj = <>c.<>9__2_0;
if (obj == null)
{
UnityAction val = delegate
{
};
<>c.<>9__2_0 = val;
obj = (object)val;
}
Unbound.RegisterMenu("AALUND13 Cards", (UnityAction)obj, (Action<GameObject>)NewGui, (GameObject)null, false);
DebugMode = config.Bind<bool>("AALUND13 Cards", "DebugMode", false, "Enabled or disabled Debug Mode");
}
public static void addBlank(GameObject menu)
{
TextMeshProUGUI val = default(TextMeshProUGUI);
MenuHandler.CreateText(" ", menu, ref val, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
}
public static void NewGui(GameObject menu)
{
MenuHandler.CreateToggle(DebugMode.Value, "<#c41010> Debug Mode", menu, (UnityAction<bool>)DebugModeChanged, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
static void DebugModeChanged(bool val)
{
DebugMode.Value = val;
}
}
}
public class DelayDamageHandler : MonoBehaviour, IBattleStartHookHandler
{
public Player player;
public void Awake()
{
player = ((Component)this).GetComponent<Player>();
InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
}
public void DelayDamage(Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon, Player damagingPlayer, bool healthRemoval, bool lethal, bool ignoreBlock)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)this, player.data.GetAdditionalData().secondToDealDamage, (Action)delegate
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
player.data.GetAdditionalData().dealDamage = true;
player.data.healthHandler.DoDamage(damage, position, blinkColor, damagingWeapon, damagingPlayer, healthRemoval, lethal, ignoreBlock);
});
}
public void OnDestroy()
{
InterfaceGameModeHooksManager.instance.RemoveHooks((object)this);
}
public void OnBattleStart()
{
((MonoBehaviour)this).StopAllCoroutines();
}
}
public class ExtraPickHandler
{
public virtual bool OnExtraPickStart(Player player, CardInfo card)
{
return true;
}
public virtual void OnExtraPick(Player player, CardInfo card)
{
}
}
public static class ExtraCardPickHandler
{
internal static Dictionary<Player, List<ExtraPickHandler>> extraPicks = new Dictionary<Player, List<ExtraPickHandler>>();
public static Player currentPlayer;
public static void AddExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks)
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[3]
{
player.playerID,
extraPickHandler.GetType().AssemblyQualifiedName,
picks
});
}
public static void AddExtraPick<T>(Player player, int picks) where T : ExtraPickHandler
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[3]
{
player.playerID,
typeof(T).AssemblyQualifiedName,
picks
});
}
public static void RemoveExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks)
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_RemoveExtraPick", new object[3]
{
player.playerID,
extraPickHandler.GetType().AssemblyQualifiedName,
picks
});
}
public static void RemoveExtraPick<T>(Player player, int picks) where T : ExtraPickHandler
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_RemoveExtraPick", new object[3]
{
player.playerID,
typeof(T).AssemblyQualifiedName,
picks
});
}
[UnboundRPC]
private static void RPCA_AddExtraPick(int playerId, string handlerType, int picks)
{
Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerId);
if ((Object)(object)val == (Object)null)
{
return;
}
Type type = Type.GetType(handlerType);
if (!(type == null))
{
ExtraPickHandler item = (ExtraPickHandler)Activator.CreateInstance(type);
if (!extraPicks.ContainsKey(val))
{
extraPicks.Add(val, new List<ExtraPickHandler>());
}
for (int i = 0; i < picks; i++)
{
extraPicks[val].Add(item);
}
}
}
[UnboundRPC]
public static void RPCA_RemoveExtraPick(int playerId, string handlerType, int picks)
{
Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerId);
if ((Object)(object)val == (Object)null)
{
return;
}
Type type = Type.GetType(handlerType);
if (type == null)
{
return;
}
ExtraPickHandler item = (ExtraPickHandler)Activator.CreateInstance(type);
if (extraPicks.ContainsKey(val))
{
for (int i = 0; i < picks; i++)
{
extraPicks[val].Remove(item);
}
}
}
internal static IEnumerator HandleExtraPicks()
{
Player[] array = PlayerManager.instance.players.ToArray();
foreach (Player player in array)
{
if (extraPicks.ContainsKey(player) && extraPicks[player].Count > 0)
{
yield return HandleExtraPickForPlayer(player);
}
}
currentPlayer = null;
}
private static IEnumerator HandleExtraPickForPlayer(Player player)
{
currentPlayer = player;
yield return GameModeManager.TriggerHook("PlayerPickStart");
CardChoiceVisuals.instance.Show((from i in Enumerable.Range(0, PlayerManager.instance.players.Count)
where PlayerManager.instance.players[i].playerID == player.playerID
select i).First(), true);
yield return CardChoice.instance.DoPick(1, player.playerID, (PickerType)1);
yield return (object)new WaitForSecondsRealtime(0.1f);
if (extraPicks.ContainsKey(player) && extraPicks[player].Count > 0)
{
extraPicks[player].RemoveAt(0);
}
yield return GameModeManager.TriggerHook("PlayerPickEnd");
}
}
}
namespace AALUND13Card.Handlers.ExtraPickHandlers
{
public class SteelPickHandler : ExtraPickHandler
{
public override bool OnExtraPickStart(Player player, CardInfo card)
{
List<CardInfo> list = new List<CardInfo>();
foreach (Player enemyPlayer in PlayerStatus.GetEnemyPlayers(player))
{
if ((Object)(object)enemyPlayer != (Object)(object)player)
{
list.AddRange(enemyPlayer.data.currentCards);
}
}
return list.Contains(card);
}
public override void OnExtraPick(Player player, CardInfo card)
{
if (!PhotonNetwork.OfflineMode && !PhotonNetwork.IsMasterClient)
{
return;
}
List<Player> list = new List<Player>();
foreach (Player enemyPlayer in PlayerStatus.GetEnemyPlayers(player))
{
if (enemyPlayer.data.currentCards.Contains(CardChoice.instance.GetSourceCard(card)))
{
list.Add(enemyPlayer);
}
}
if (list.Count != 0)
{
Player random = ExtensionMethods.GetRandom<Player>((IList)list);
Cards.instance.RemoveCardFromPlayer(random, CardChoice.instance.GetSourceCard(card), (SelectionType)2);
}
}
}
}
namespace AALUND13Card.Extensions
{
public class AALUND13CardCharacterDataAdditionalData
{
public float secondToDealDamage = 0f;
public bool dealDamage = true;
public SoulStreakStats SoulStreakStats = new SoulStreakStats();
public uint Souls = 0u;
public int RandomCardsAtStart = 0;
public int ExtraCardPicks = 0;
public float CorruptedCardSpawnChance = 0f;
public float CorruptedCardSpawnChancePerPick = 0f;
public void Reset()
{
secondToDealDamage = 0f;
dealDamage = true;
SoulStreakStats = new SoulStreakStats();
RandomCardsAtStart = 0;
ExtraCardPicks = 0;
CorruptedCardSpawnChancePerPick = 0f;
}
}
public static class CharacterDataExtensions
{
public static readonly ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData> data = new ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData>();
public static AALUND13CardCharacterDataAdditionalData GetAdditionalData(this CharacterData block)
{
return data.GetOrCreateValue(block);
}
public static void AddData(this CharacterData block, AALUND13CardCharacterDataAdditionalData value)
{
try
{
data.Add(block, value);
}
catch (Exception)
{
}
}
}
public static class RandomExtension
{
public static float NextFloat(this Random random, float minValue, float maxValue)
{
return (float)random.NextDouble() * (maxValue - minValue) + minValue;
}
}
}
namespace AALUND13Card.Cards
{
public class AACustomCard : CustomUnityCard
{
public override void OnSetupCard(CardInfo cardInfo, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers statModifiers, Block block)
{
LoggerUtils.LogInfo("[" + ((CustomCard)this).GetModName() + "][Card] " + ((CustomCard)this).GetTitle() + " has been setup.");
}
public override void OnReassignCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
AAStatModifers component = ((Component)this).GetComponent<AAStatModifers>();
if ((Object)(object)component != (Object)null)
{
component.OnReassign(player);
}
}
public override string GetModName()
{
return "AAC";
}
}
public enum ExtraPicksType
{
None,
Normal,
Steel
}
public class AAStatModifers : MonoBehaviour
{
[Header("Soulstreak Stats")]
public float MaxHealth = 0f;
public float PlayerSize = 0f;
public float MovementSpeed = 0f;
public float AttackSpeed = 0f;
public float Damage = 0f;
public float BulletSpeed = 0f;
public float SoulArmorPercentage = 0f;
public float SoulArmorPercentageRegenRate = 0f;
public float SoulDrainMultiply = 0f;
public AbilityType AbilityType;
[Header("Uncategorized Stats")]
public float SecondToDealDamage = 0f;
[Header("Armors Stats")]
public float BattleforgedArmor = 0f;
[Header("Extra Picks")]
public int ExtraPicks = 0;
public ExtraPicksType ExtraPicksType;
[Header("Extra Cards")]
public int RandomCardsAtStart = 0;
public int ExtraCardPicks = 0;
[Header("Corrupted Cards")]
public float CorruptedCardSpawnChance = 0f;
public float CorruptedCardSpawnChancePerPick = 0f;
public void Apply(Player player)
{
CharacterData data = player.data;
AALUND13CardCharacterDataAdditionalData additionalData = data.GetAdditionalData();
additionalData.SoulStreakStats.MaxHealth += MaxHealth;
additionalData.SoulStreakStats.PlayerSize += PlayerSize;
additionalData.SoulStreakStats.MovementSpeed += MovementSpeed;
additionalData.SoulStreakStats.AttackSpeed += AttackSpeed;
additionalData.SoulStreakStats.Damage += Damage;
additionalData.SoulStreakStats.BulletSpeed += BulletSpeed;
additionalData.SoulStreakStats.SoulArmorPercentage += SoulArmorPercentage;
additionalData.SoulStreakStats.SoulArmorPercentageRegenRate += SoulArmorPercentageRegenRate;
additionalData.SoulStreakStats.SoulDrainMultiply += SoulDrainMultiply;
additionalData.SoulStreakStats.AbilityType |= AbilityType;
additionalData.secondToDealDamage += SecondToDealDamage;
additionalData.RandomCardsAtStart += RandomCardsAtStart;
additionalData.ExtraCardPicks += ExtraCardPicks;
additionalData.CorruptedCardSpawnChance = Mathf.Max(additionalData.CorruptedCardSpawnChance + CorruptedCardSpawnChance, 0f);
additionalData.CorruptedCardSpawnChancePerPick += CorruptedCardSpawnChancePerPick;
if (BattleforgedArmor > 0f)
{
ArmorFramework.ArmorHandlers[player].AddArmor<BattleforgedArmor>(BattleforgedArmor, 0f, 0f, (ArmorReactivateType)0, 0.5f);
}
ExtraPickHandler extraPickHandler = GetExtraPickHandler(ExtraPicksType);
if (extraPickHandler != null && ExtraPicks > 0 && player.data.view.IsMine)
{
ExtraCardPickHandler.AddExtraPick(extraPickHandler, player, ExtraPicks);
}
}
public void OnReassign(Player player)
{
CharacterData data = player.data;
AALUND13CardCharacterDataAdditionalData additionalData = data.GetAdditionalData();
additionalData.CorruptedCardSpawnChancePerPick += CorruptedCardSpawnChancePerPick;
additionalData.ExtraCardPicks += ExtraCardPicks;
}
public ExtraPickHandler GetExtraPickHandler(ExtraPicksType type)
{
return type switch
{
ExtraPicksType.Normal => new ExtraPickHandler(),
ExtraPicksType.Steel => new SteelPickHandler(),
_ => null,
};
}
}
public class CursesEffectCard : AACustomCard
{
public List<Material> PostProcessingEffects = new List<Material>();
public override void OnRegister(CardInfo cardInfo)
{
CurseManager.instance.RegisterCurse(cardInfo);
}
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
if (!player.data.view.IsMine)
{
return;
}
Camera main = Camera.main;
if (!((Object)(object)main != (Object)null))
{
return;
}
foreach (Material postProcessingEffect in PostProcessingEffects)
{
((Component)main).gameObject.AddComponent<Effect>().Material = postProcessingEffect;
}
}
public override string GetModName()
{
return "AAC (Curse)";
}
}
public class RandomPickerCard : AACustomCard
{
public List<GameObject> randomCardsToChoseFrom = new List<GameObject>();
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
if (PhotonNetwork.OfflineMode || PhotonNetwork.IsMasterClient)
{
CardInfo component = ExtensionMethods.GetRandom<GameObject>((IList)randomCardsToChoseFrom).GetComponent<CardInfo>();
Cards.instance.AddCardToPlayer(player, component, true, "", 2f, 2f, true);
CardBarUtils.instance.ShowAtEndOfPhase(player, component);
}
}
}
}
namespace AALUND13Card.Armors
{
public class BattleforgedArmor : ArmorBase
{
public override BarColor GetBarColor()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
return new BarColor(Color.yellow * 0.6f, Color.yellow * 0.45f);
}
public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
DamageArmorInfo val = ArmorUtils.ApplyDamage(base.CurrentArmorValue, damage);
float num = base.CurrentArmorValue - val.Armor;
base.MaxArmorValue += num * 0.1f;
return val;
}
public override void OnRegister()
{
base.ArmorTags.Add("CanArmorPierce");
base.ArmorRegenCooldownSeconds = 5f;
}
}
public class SoulArmor : ArmorBase
{
public override BarColor GetBarColor()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
return new BarColor(Color.magenta * 0.6f, Color.magenta * 0.45f);
}
public override void OnRespawn()
{
SoulstreakMono componentInChildren = ((Component)((ArmorBase)this).ArmorHandler).GetComponentInChildren<SoulstreakMono>();
if ((Object)(object)componentInChildren != (Object)null)
{
base.MaxArmorValue = 0f;
base.CurrentArmorValue = 0f;
componentInChildren.AbilityCooldown = 0f;
componentInChildren.AbilityActive = false;
}
}
public override void OnRegister()
{
base.ArmorRegenCooldownSeconds = 5f;
}
}
}