using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AALUND13Cards.Core.Cards;
using AALUND13Cards.Core.Cards.Conditions;
using AALUND13Cards.Core.Cards.Effects;
using AALUND13Cards.Core.Extensions;
using AALUND13Cards.Core.Handlers;
using AALUND13Cards.Core.Utils;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using HarmonyLib;
using JARL.Bases;
using JARL.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.GameModes;
using ModdingUtils.Utils;
using ModsPlus;
using Photon.Pun;
using RarityLib.Utils;
using Sonigon;
using TMPro;
using TabInfo.Utils;
using ToggleCardsCategories;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using WillsWackyManagers.Utils;
[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 AALUND13Cards.Core
{
[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("AALUND13.Cards.Core", "AALUND13 Cards Core", "1.0.0")]
[BepInProcess("Rounds.exe")]
public class AAC_Core : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <OnGameStart>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <OnGameStart>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
if (<>1__state != 0)
{
return false;
}
<>1__state = -1;
ConstantDamageHandler.Instance.Reset();
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public const string ModInitials = "AAC";
internal const string ModId = "AALUND13.Cards.Core";
internal const string ModName = "AALUND13 Cards Core";
internal const string Version = "1.0.0";
internal const string FullVersion = "2.0.0";
internal const bool IsBeta = true;
public static List<BaseUnityPlugin> Plugins;
internal static ManualLogSource ModLogger;
public static CardResgester CardMainResgester;
public static CardCategory[] NoLotteryCategories;
public static CardCategory[] NoSteelCategories;
public static AAC_Core Instance { get; private set; }
public void Awake()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
ModLogger = ((BaseUnityPlugin)this).Logger;
new Harmony("AALUND13.Cards.Core").PatchAll();
ToggleCardsCategoriesManager.instance.RegisterCategories("AAC");
AACMenu.RegesterMenu(((BaseUnityPlugin)this).Config);
}
public void Start()
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
Plugins = (List<BaseUnityPlugin>)typeof(Chainloader).GetField("_plugins", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
DeathHandler.OnPlayerDeath += new DeathHandlerDelegate(OnPlayerDeath);
if (Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
{
TabinfoInterface.Setup();
}
GameModeManager.AddHook("PlayerPickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ExtraCardPickHandler.HandleExtraPicks(ExtraPickPhaseTrigger.TriggerInPlayerPickEnd)));
GameModeManager.AddHook("PickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => ExtraCardPickHandler.HandleExtraPicks(ExtraPickPhaseTrigger.TriggerInPickEnd)));
GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)OnGameStart);
((Component)this).gameObject.AddComponent<DelayDamageHandler>();
((Component)this).gameObject.AddComponent<PickCardTracker>();
((Component)this).gameObject.AddComponent<DamageEventHandler>();
((Component)this).gameObject.AddComponent<DeathActionHandler>();
((Component)this).gameObject.AddComponent<ConstantDamageHandler>();
NoLotteryCategories = (CardCategory[])(object)new CardCategory[2]
{
CustomCardCategories.instance.CardCategory("CardManipulation"),
CustomCardCategories.instance.CardCategory("NoRandom")
};
NoSteelCategories = (CardCategory[])(object)new CardCategory[1] { CustomCardCategories.instance.CardCategory("NoRemove") };
}
[IteratorStateMachine(typeof(<OnGameStart>d__17))]
private IEnumerator OnGameStart(IGameModeHandler gm)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <OnGameStart>d__17(0);
}
private void OnPlayerDeath(Player player, Dictionary<Player, DamageInfo> playerDamageInfos)
{
if ((Object)(object)((Component)player).GetComponent<DelayDamageHandler>() != (Object)null)
{
((MonoBehaviour)((Component)player).GetComponent<DelayDamageHandler>()).StopAllCoroutines();
}
}
}
public static class AACMenu
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__3_0;
public static UnityAction <>9__4_0;
public static UnityAction <>9__7_0;
public static UnityAction<bool> <>9__7_1;
internal void <RegesterMenu>b__3_0()
{
}
internal void <CreateModuleMenu>b__4_0()
{
}
internal void <NewGui>b__7_0()
{
}
internal void <NewGui>b__7_1(bool val)
{
DebugMode.Value = val;
}
}
public static Action OnMenuRegister;
internal static ConfigEntry<bool> DebugMode;
private static GameObject ModulesMenu;
internal static void RegesterMenu(ConfigFile config)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
object obj = <>c.<>9__3_0;
if (obj == null)
{
UnityAction val = delegate
{
};
<>c.<>9__3_0 = val;
obj = (object)val;
}
Unbound.RegisterMenu("AALUND13 Cards", (UnityAction)obj, (Action<GameObject>)NewGui, (GameObject)null, false);
DebugMode = config.Bind<bool>("AALUND13 Cards Core", "DebugMode", false, "Enabled or disabled Debug Mode");
}
public static GameObject CreateModuleMenu(string moduleName)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
LoggerUtils.LogInfo($"Is ModulesMenu null?: {(Object)(object)ModulesMenu == (Object)null}");
string obj = moduleName ?? "";
object obj2 = <>c.<>9__4_0;
if (obj2 == null)
{
UnityAction val = delegate
{
};
<>c.<>9__4_0 = val;
obj2 = (object)val;
}
GameObject val2 = MenuHandler.CreateMenu(obj, (UnityAction)obj2, ModulesMenu, 50, true, true, ((Component)ModulesMenu.transform.parent).gameObject, true, -1);
TextMeshProUGUI val3 = default(TextMeshProUGUI);
MenuHandler.CreateText("<b>" + moduleName + "</b>", val2, ref val3, 70, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
return val2;
}
public static GameObject CreateModuleMenuWithReadmeGenerator(string moduleName, string version, CardResgester cardResgester)
{
return CreateModuleMenu(moduleName);
}
public static void AddBlank(GameObject menu, int space = 30)
{
TextMeshProUGUI val = default(TextMeshProUGUI);
MenuHandler.CreateText(" ", menu, ref val, space, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
}
private static void NewGui(GameObject menu)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
object obj = <>c.<>9__7_0;
if (obj == null)
{
UnityAction val2 = delegate
{
};
<>c.<>9__7_0 = val2;
obj = (object)val2;
}
ModulesMenu = MenuHandler.CreateMenu("Modules", (UnityAction)obj, menu, 50, true, true, ((Component)menu.transform.parent).gameObject, true, -1);
MenuHandler.CreateToggle(DebugMode.Value, "<#c41010> Debug Mode", menu, (UnityAction<bool>)delegate(bool val)
{
DebugMode.Value = val;
}, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
OnMenuRegister?.Invoke();
}
}
public class TabinfoInterface
{
public static StatCategory GetOrCreateCategory(string name, int priority)
{
if (!TabInfoManager.Categories.ContainsKey(name.ToLower()))
{
return TabInfoManager.RegisterCategory(name, 6);
}
return TabInfoManager.Categories[name.ToLower()];
}
internal static void Setup()
{
StatCategory orCreateCategory = GetOrCreateCategory("AA Stats", 6);
TabInfoManager.RegisterStat(orCreateCategory, "Block Pierce Percent", (Func<Player, bool>)((Player p) => p.data.GetAdditionalData().BlockPircePercent != 0f), (Func<Player, string>)((Player p) => $"{p.data.GetAdditionalData().BlockPircePercent * 100f:0}%"));
TabInfoManager.RegisterStat(orCreateCategory, "Damage Per Seconds", (Func<Player, bool>)((Player _) => true), (Func<Player, string>)((Player p) => $"{p.GetDPS()}"));
TabInfoManager.RegisterStat(orCreateCategory, "Bullets Per Seconds", (Func<Player, bool>)((Player _) => true), (Func<Player, string>)((Player p) => $"{p.GetSPS()}"));
}
}
public static class LoggerUtils
{
public static bool logging = AACMenu.DebugMode.Value;
public static void LogInfo(string message, bool bypassCheck = false)
{
if (logging || bypassCheck)
{
AAC_Core.ModLogger.LogInfo((object)message);
}
}
public static void LogWarn(string message)
{
AAC_Core.ModLogger.LogWarning((object)message);
}
public static void LogError(string message)
{
AAC_Core.ModLogger.LogError((object)message);
}
}
}
namespace AALUND13Cards.Core.VisualEffect
{
public class AddAComponentToRandomObjects : MonoBehaviour
{
public int NumberOfObjectsToAdd = 1;
public MonoBehaviour ComponentToAdd;
public List<GameObject> TargetObjects;
private void Start()
{
if (TargetObjects == null || TargetObjects.Count == 0)
{
Debug.LogWarning("No TargetObjects specified to add the component to.");
return;
}
for (int i = 0; i < NumberOfObjectsToAdd; i++)
{
AddComponentToRandomObject();
}
}
private void AddComponentToRandomObject()
{
if (TargetObjects == null || TargetObjects.Count == 0)
{
Debug.LogWarning("No TargetObjects specified to add the component to.");
return;
}
int index = Random.Range(0, TargetObjects.Count);
GameObject val = TargetObjects[index];
if ((Object)(object)val.GetComponent(((object)ComponentToAdd).GetType()) != (Object)null)
{
Debug.LogWarning("Component " + ((object)ComponentToAdd).GetType().Name + " already exists on " + ((Object)val).name);
return;
}
val.AddComponent(((object)ComponentToAdd).GetType());
TargetObjects.RemoveAt(index);
}
}
public class AddRandomCardArt : MonoBehaviour
{
public bool AddRandomArtAtStart = true;
public bool AddRandomArtAtEnable;
public GameObject ArtParent;
private void Start()
{
if (AddRandomArtAtStart)
{
GenerateRandomArt();
}
}
private void OnEnable()
{
if (AddRandomArtAtEnable)
{
GenerateRandomArt();
}
}
private void OnDisable()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
foreach (Transform item in ArtParent.transform)
{
Object.Destroy((Object)(object)((Component)item).gameObject);
}
}
public void GenerateRandomArt()
{
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
if (Application.isEditor)
{
Debug.LogWarning((object)"Random Card Art cannot be generated in editor mode.");
return;
}
CardInfo[] array = (from c in CardManager.cards
where (Object)(object)c.Value.cardInfo.cardArt != (Object)null
select c.Value.cardInfo).ToArray();
if (array.Length != 0)
{
GameObject obj = Object.Instantiate<GameObject>(array[Random.Range(0, array.Length)].cardArt, ArtParent.transform);
obj.transform.localScale = Vector3.one;
obj.transform.localPosition = Vector3.zero;
}
}
}
public class StartWithRandomRotationOffset : MonoBehaviour
{
[Tooltip("The maximum rotation offset in degrees that will be applied to the object at start.")]
public float rotationOffset = 25f;
private void Start()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
float num = Random.Range(0f - rotationOffset, rotationOffset);
Quaternion rotation = ((Component)this).transform.rotation;
Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
eulerAngles.z += num;
((Component)this).transform.rotation = Quaternion.Euler(eulerAngles);
}
}
[DisallowMultipleComponent]
public class StartWithRandomSize : MonoBehaviour
{
public Vector2 sizeRange = new Vector2(0.75f, 1.25f);
private void Start()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
float num = Random.Range(sizeRange.x, sizeRange.y);
((Component)this).transform.localScale = new Vector3(num, num, 1f);
}
}
[ExecuteAlways]
[RequireComponent(typeof(RectTransform))]
public class StretchImageBetween : MonoBehaviour
{
public RectTransform pointA;
public RectTransform pointB;
private RectTransform rectTransform;
private void Awake()
{
rectTransform = ((Component)this).GetComponent<RectTransform>();
}
private void Update()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: 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_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: 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_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: 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_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)pointA == (Object)null) && !((Object)(object)pointB == (Object)null))
{
Vector3 val = ((Transform)rectTransform).parent.InverseTransformPoint(((Transform)pointA).position);
Vector3 val2 = ((Transform)rectTransform).parent.InverseTransformPoint(((Transform)pointB).position);
Vector3 localPosition = (val + val2) / 2f;
((Transform)rectTransform).localPosition = localPosition;
Vector3 val3 = val2 - val;
float num = Mathf.Atan2(val3.y, val3.x) * 57.29578f;
((Transform)rectTransform).localRotation = Quaternion.Euler(0f, 0f, num);
float num2 = ((Vector3)(ref val3)).magnitude / ((Transform)rectTransform).localScale.x;
rectTransform.sizeDelta = new Vector2(num2, rectTransform.sizeDelta.y);
}
}
}
}
namespace AALUND13Cards.Core.Utils
{
public class AssetsUtils
{
public static AssetBundle LoadAssetBundle(string bundleName, Assembly assembly)
{
string fullName = assembly.FullName;
LoggerUtils.LogInfo("Loading embedded asset bundle. Using assembly: " + fullName, bypassCheck: true);
LoggerUtils.LogInfo("bundleName requested: '" + bundleName + "'", bypassCheck: true);
string[] manifestResourceNames = assembly.GetManifestResourceNames();
LoggerUtils.LogInfo($"Found {manifestResourceNames.Length} embedded resource(s) in assembly:", bypassCheck: true);
string[] array = manifestResourceNames;
foreach (string text in array)
{
LoggerUtils.LogInfo(" '" + text + "'", bypassCheck: true);
}
string text2 = null;
try
{
text2 = manifestResourceNames.Single((string str) => str.EndsWith(bundleName));
LoggerUtils.LogInfo("Matched resource name: '" + text2 + "'", bypassCheck: true);
}
catch (Exception ex)
{
LoggerUtils.LogError("Exception while matching resource name: " + ex.GetType().Name + " — " + ex.Message);
}
if (text2 == null)
{
LoggerUtils.LogError("No resource name ending with '" + bundleName + "' was found.");
return null;
}
try
{
using Stream stream = assembly.GetManifestResourceStream(text2);
if (stream == null)
{
LoggerUtils.LogError("GetManifestResourceStream returned null for resource '" + text2 + "'");
return null;
}
AssetBundle obj = AssetBundle.LoadFromStream(stream);
if ((Object)(object)obj == (Object)null)
{
LoggerUtils.LogError("AssetBundle.LoadFromStream returned null for resource '" + text2 + "'");
}
else
{
LoggerUtils.LogInfo("Successfully loaded AssetBundle from resource '" + text2 + "'", bypassCheck: true);
}
return obj;
}
catch (Exception ex2)
{
LoggerUtils.LogError("Exception loading from stream: " + ex2.GetType().Name + " — " + ex2.Message);
return null;
}
}
}
public interface ICustomStats
{
void ResetStats();
}
public class CustomStatsRegistry : IEnumerable<ICustomStats>, IEnumerable
{
private readonly Dictionary<Type, ICustomStats> statsMap = new Dictionary<Type, ICustomStats>();
public bool Exist<T>() where T : ICustomStats
{
return statsMap.ContainsKey(typeof(T));
}
public T Get<T>() where T : ICustomStats
{
return (T)statsMap[typeof(T)];
}
public T Add<T>(T customStatsHandler) where T : ICustomStats
{
if (Exist<T>())
{
throw new ArgumentException("Item '" + typeof(T).FullName + "' already exists.", "customStatsHandler");
}
if (customStatsHandler == null)
{
throw new ArgumentNullException("customStatsHandler");
}
statsMap.Add(typeof(T), customStatsHandler);
return customStatsHandler;
}
public T GetOrCreate<T>() where T : ICustomStats, new()
{
if (statsMap.TryGetValue(typeof(T), out var value))
{
return (T)value;
}
return Add(new T());
}
public void ResetAll()
{
foreach (ICustomStats value in statsMap.Values)
{
value.ResetStats();
}
}
public IEnumerator<ICustomStats> GetEnumerator()
{
return statsMap.Values.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
public class PhotonPrefabPool : MonoBehaviour
{
public List<GameObject> Prefabs = new List<GameObject>();
public void RegisterPrefabs()
{
foreach (GameObject prefab in Prefabs)
{
if ((Object)(object)prefab != (Object)null)
{
PhotonNetwork.PrefabPool.RegisterPrefab(((Object)prefab).name, prefab);
LoggerUtils.LogInfo("Registered prefab: " + ((Object)prefab).name);
}
}
}
}
public class PickCardTracker : MonoBehaviour, IPickStartHookHandler
{
public static PickCardTracker instance;
private readonly List<CardInfo> cardPickedInPickPhase = new List<CardInfo>();
public IReadOnlyList<CardInfo> CardPickedInPickPhase => cardPickedInPickPhase.AsReadOnly();
public bool AlreadyPickedInPickPhase(CardInfo card)
{
if ((Object)(object)card == (Object)null)
{
return false;
}
return cardPickedInPickPhase.Contains(card);
}
public void OnPickStart()
{
cardPickedInPickPhase.Clear();
}
internal void AddCardPickedInPickPhase(CardInfo card)
{
if (!((Object)(object)card == (Object)null))
{
if ((Object)(object)card.sourceCard != (Object)null)
{
card = card.sourceCard;
}
if (!cardPickedInPickPhase.Contains(card))
{
cardPickedInPickPhase.Add(card);
}
}
}
private void Awake()
{
if ((Object)(object)instance != (Object)null)
{
Debug.LogWarning((object)"PickCardTracker instance already exists! Destroying the new one.");
Object.Destroy((Object)(object)((Component)this).gameObject);
}
else
{
instance = this;
InterfaceGameModeHooksManager.instance.RegisterHooks((object)this);
}
}
}
public class RandomCardRarity : MonoBehaviour
{
public Image[] edges;
public void OnEnable()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
if (!Application.isEditor)
{
Rarity randomRarity = GetRandomRarity();
Image[] array = edges;
for (int i = 0; i < array.Length; i++)
{
((Graphic)array[i]).color = randomRarity.color;
}
}
else
{
Debug.Log((object)"RandomCardRarity is running in the editor");
}
}
public static Rarity GetRandomRarity()
{
float num = RarityUtils.Rarities.Sum((KeyValuePair<int, Rarity> r) => r.Value.calculatedRarity);
float num2 = Random.Range(0f, num);
Rarity result = null;
foreach (KeyValuePair<int, Rarity> rarity in RarityUtils.Rarities)
{
num2 -= rarity.Value.calculatedRarity;
if (num2 <= 0f)
{
result = rarity.Value;
break;
}
}
return result;
}
}
internal static class ReadmeGenerator
{
public static string CreateReadme(string modName, string version, List<CardInfo> cardInfos)
{
string[] source = new string[2] { "Classes", "Extra Cards" };
new List<string>();
StringBuilder stringBuilder = new StringBuilder();
bool flag = true;
stringBuilder.AppendLine("# " + modName + " [v" + version + "]");
stringBuilder.AppendLine($"{modName} introduces <b>{cardInfos.Count}</b> cards developed by <b>AALUND13</b>. ");
stringBuilder.AppendLine("If you encounter any bugs, please report them in the [issues](https://github.com/AALUND13/AALUND13-Cards/issues) tab.");
stringBuilder.AppendLine("<h3>Cards:</h3>");
Dictionary<string, List<CardInfo>> cardWithCategories = GetCardWithCategories(cardInfos);
int num = cardInfos.Max((CardInfo c) => c.cardName.Length);
foreach (KeyValuePair<string, List<CardInfo>> item in cardWithCategories)
{
Stack<string> stack = new Stack<string>(item.Key.Split(new char[1] { '/' }));
string text = stack.Pop();
while (stack.Count > 0)
{
string text2 = stack.Pop();
if (source.Contains(text2))
{
text = text2 + " - " + text;
}
}
if (!flag)
{
stringBuilder.AppendLine("<br>");
}
stringBuilder.AppendLine("<b>" + text + ":</b>");
stringBuilder.AppendLine("<pre>");
int num2 = 4;
int totalWidth = num + 2;
for (int i = 0; i < item.Value.Count; i++)
{
string cardName = item.Value[i].cardName;
stringBuilder.Append("- " + cardName.PadRight(totalWidth));
if ((i + 1) % num2 == 0 || i == item.Value.Count - 1)
{
stringBuilder.AppendLine();
}
}
stringBuilder.AppendLine("</pre>");
flag = false;
}
return stringBuilder.ToString();
}
private static Dictionary<string, List<CardInfo>> GetCardWithCategories(List<CardInfo> cardInfos)
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, string> dictionary = new Dictionary<string, string> { { "Devil/Outcomes", "Devil" } };
Dictionary<string, List<CardInfo>> dictionary2 = new Dictionary<string, List<CardInfo>>(StringComparer.OrdinalIgnoreCase);
foreach (CardInfo cardInfo in cardInfos)
{
IToggleCardCategory component = ((Component)cardInfo).GetComponent<IToggleCardCategory>();
string key = ((component != null) ? component.GetCardCategoryInfo().Name : "Other");
if (dictionary.TryGetValue(key, out var value))
{
key = value;
}
if (!dictionary2.TryGetValue(key, out var value2))
{
value2 = (dictionary2[key] = new List<CardInfo>());
}
value2.Add(((Component)cardInfo).GetComponent<CardInfo>());
}
return dictionary2.OrderBy<KeyValuePair<string, List<CardInfo>>, string>((KeyValuePair<string, List<CardInfo>> kvp) => kvp.Key, StringComparer.OrdinalIgnoreCase).ToDictionary((KeyValuePair<string, List<CardInfo>> kvp) => kvp.Key, (KeyValuePair<string, List<CardInfo>> kvp) => kvp.Value);
}
}
}
namespace AALUND13Cards.Core.Patches
{
[HarmonyPatch(typeof(Cards), "PlayerIsAllowedCard")]
internal class AllowedCardPatch
{
private static void Postfix(Player player, CardInfo card, ref bool __result)
{
if ((Object)(object)player == (Object)null || (Object)(object)card == (Object)null)
{
return;
}
CardCondition[] components = ((Component)card).GetComponents<CardCondition>();
if (components != null && components.Length != 0)
{
CardCondition[] array = components;
foreach (CardCondition cardCondition in array)
{
if (!((Object)(object)cardCondition == (Object)null) && !cardCondition.IsPlayerAllowedCard(player))
{
__result = false;
break;
}
}
}
if ((Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(player) && ExtraCardPickHandler.extraPicks[player].Count > 0)
{
bool flag = ExtraCardPickHandler.activePickHandler.PickConditions(player, card);
__result &= flag;
}
}
}
[HarmonyPatch(typeof(ApplyCardStats), "ApplyStats")]
internal class ApplyCardStatsPatch
{
public static void Postfix(ApplyCardStats __instance, Player ___playerToUpgrade)
{
CustomStatModifers[] components = ((Component)__instance).gameObject.GetComponents<CustomStatModifers>();
for (int i = 0; i < components.Length; i++)
{
components[i].Apply(___playerToUpgrade);
}
}
}
[HarmonyPatch(typeof(Block))]
internal class BlockPatch
{
[HarmonyPatch("blocked")]
[HarmonyPrefix]
public static void BlockedPrefix(Block __instance, GameObject projectile, Vector3 forward, Vector3 hitPos)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
ProjectileHit component = projectile.GetComponent<ProjectileHit>();
HealthHandler val = (HealthHandler)ExtensionMethods.GetFieldValue((object)__instance, "health");
float blockPircePercent = component.ownPlayer.data.GetAdditionalData().BlockPircePercent;
if (blockPircePercent > 0f)
{
Vector2 val2 = Vector2.op_Implicit((component.bulletCanDealDeamage ? component.damage : 1f) * blockPircePercent * ((Vector3)(ref forward)).normalized);
((Damagable)val).TakeDamage(val2, Vector2.op_Implicit(hitPos), component.projectileColor, component.ownWeapon, component.ownPlayer, true, true);
Object.Destroy((Object)(object)projectile);
}
}
}
[HarmonyPatch(typeof(CardChoice))]
internal class CardChoicePatch
{
[HarmonyPatch("IDoEndPick")]
private static void Postfix(GameObject pickedCard, int pickId)
{
Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickId);
if (!((Object)(object)playerWithID == (Object)null))
{
if ((Object)(object)ExtraCardPickHandler.currentPlayer != (Object)null && ExtraCardPickHandler.extraPicks.ContainsKey(playerWithID) && ExtraCardPickHandler.activePickHandler.Picks > 0)
{
ExtraCardPickHandler.activePickHandler.OnPickEnd(playerWithID, pickedCard.GetComponent<CardInfo>());
}
PickCardTracker.instance.AddCardPickedInPickPhase(pickedCard.GetComponent<CardInfo>());
}
}
}
[HarmonyPatch(typeof(CharacterStatModifiers))]
public class CharacterStatModifiersPatch
{
[HarmonyPatch("ResetStats")]
[HarmonyPrefix]
public static void ResetStats(CharacterStatModifiers __instance)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: 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();
}
}
}
[HarmonyPatch(typeof(DamageOverTime))]
internal class DamageOverTimePatch
{
[HarmonyPatch("TakeDamageOverTime")]
[HarmonyPrefix]
public static void TakeDamageOverTimePrefix(DamageOverTime __instance, Vector2 damage, Vector2 position, float time, float interval, Color color, SoundEvent soundDamageOverTime, GameObject damagingWeapon, Player damagingPlayer, bool lethal)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
if (!HealthHandlerPatch.TakeDamageRunning)
{
DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamageOvertime, val.player, damagingPlayer, damage, lethal);
}
}
}
[HarmonyPatch(typeof(HealthHandler))]
internal class HealthHandlerPatch
{
public static bool TakeDamageRunning;
[HarmonyPatch("Revive")]
[HarmonyPostfix]
public static void RevivePrefix(HealthHandler __instance, CharacterData ___data)
{
ConstantDamageHandler.Instance.RemovePlayerFromAll(___data.player);
((MonoBehaviour)DelayDamageHandler.Instance).StopAllCoroutines();
}
[HarmonyPatch("TakeDamage", new Type[]
{
typeof(Vector2),
typeof(Vector2),
typeof(Color),
typeof(GameObject),
typeof(Player),
typeof(bool),
typeof(bool)
})]
[HarmonyPrefix]
public static void TakeDamagePrefix(HealthHandler __instance, Player damagingPlayer, Vector2 damage, bool lethal)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
TakeDamageRunning = true;
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamage, val.player, damagingPlayer, damage, lethal);
}
[HarmonyPatch("TakeDamage", new Type[]
{
typeof(Vector2),
typeof(Vector2),
typeof(Color),
typeof(GameObject),
typeof(Player),
typeof(bool),
typeof(bool)
})]
[HarmonyPostfix]
public static void TakeDamagePostfix(HealthHandler __instance, Vector2 damage)
{
TakeDamageRunning = false;
}
[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_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_0023: 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)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
val.GetAdditionalData();
Vector2 damage2 = damage;
DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnDoDamage, val.player, damagingPlayer, damage2, lethal);
}
[HarmonyPatch("RPCA_Die_Phoenix")]
[HarmonyPrefix]
public static void PhoenixRevive(Player ___player, bool ___isRespawning, Vector2 deathDirection)
{
if (!___isRespawning && !___player.data.dead && DeathActionHandler.Instance.registeredReviveActions.TryGetValue(___player, out var value))
{
value?.Invoke();
}
}
[HarmonyPatch("RPCA_Die")]
[HarmonyPrefix]
public static void TrueDeath(Player ___player, bool ___isRespawning, Vector2 deathDirection)
{
if (!___isRespawning && !___player.data.dead && DeathActionHandler.Instance.registeredTrueDeathActions.TryGetValue(___player, out var value))
{
value?.Invoke();
}
}
}
}
namespace AALUND13Cards.Core.MonoBehaviours
{
public class DamageSpawnedAttack : SpawnedAttack
{
public Vector2 Damage;
}
public class DamageSpawnObjects : SpawnObjects, IOnDoDamageEvent, IOnTakeDamageEvent, IOnTakeDamageOvertimeEvent
{
public float DamageThreshold = 0.5f;
public bool TriggerOnDamage;
public bool TriggerOnTakeDamage = true;
public bool TriggerOnOvertimeDamage = true;
private Player player;
public void Start()
{
player = ((Component)this).GetComponentInParent<Player>();
DamageEventHandler.Instance.RegisterDamageEvent(this, player);
}
public void OnDestroy()
{
DamageEventHandler.Instance.UnregisterDamageEvent(this, player);
}
public void OnDamage(DamageInfo damage)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if (TriggerOnDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
{
SpawnDamage(damage.Damage);
}
}
public void OnTakeDamage(DamageInfo damage)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if (TriggerOnTakeDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
{
SpawnDamage(damage.Damage);
}
}
public void OnTakeDamageOvertime(DamageInfo damage)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if (TriggerOnOvertimeDamage && ((Vector2)(ref damage.Damage)).magnitude >= DamageThreshold)
{
SpawnDamage(damage.Damage);
}
}
public void SpawnDamage(Vector2 damage)
{
//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)
GameObject[] objectToSpawn = base.objectToSpawn;
for (int i = 0; i < objectToSpawn.Length; i++)
{
DamageSpawnedAttack component = objectToSpawn[i].GetComponent<DamageSpawnedAttack>();
if ((Object)(object)component != (Object)null)
{
component.Damage = damage;
}
}
((SpawnObjects)this).Spawn();
}
}
}
namespace AALUND13Cards.Core.MonoBehaviours.CardsEffects
{
[RequireComponent(typeof(DamageSpawnedAttack), typeof(Explosion))]
public class SetExplosionDamageOfTakenDamage : MonoBehaviour
{
public float ExplosionDamageMultiplier = 1f;
private DamageSpawnedAttack damageSpawnedAttack;
private Explosion explosion;
private void Awake()
{
damageSpawnedAttack = ((Component)this).GetComponent<DamageSpawnedAttack>();
explosion = ((Component)this).GetComponent<Explosion>();
}
private void Start()
{
explosion.damage = ((Vector2)(ref damageSpawnedAttack.Damage)).magnitude * ExplosionDamageMultiplier;
}
}
}
namespace AALUND13Cards.Core.Handlers
{
public struct ConstantDamageInfo
{
public Player DamagingPlayer;
public Color Color;
public float Damage;
public ConstantDamageInfo(Player damagingPlayer, Color color, float damage)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
DamagingPlayer = damagingPlayer;
Color = color;
Damage = damage;
}
public ConstantDamageInfo AddDamage(float damage)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
return new ConstantDamageInfo(DamagingPlayer, Color, Damage + damage);
}
}
public class ConstantDamageHandler : MonoBehaviour
{
public Dictionary<Player, List<ConstantDamageInfo>> playerConstantDamages = new Dictionary<Player, List<ConstantDamageInfo>>();
public Dictionary<Player, List<ConstantDamageInfo>> PlayerConstantPrecentageDamages = new Dictionary<Player, List<ConstantDamageInfo>>();
public static ConstantDamageHandler Instance;
public void AddConstantDamage(Player player, Player damagingPlayer, Color color, float damage)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
if (!playerConstantDamages.ContainsKey(player))
{
playerConstantDamages[player] = new List<ConstantDamageInfo>();
}
int num = playerConstantDamages[player].FindIndex((ConstantDamageInfo info) => info.Color == color);
if (num != -1)
{
playerConstantDamages[player][num] = playerConstantDamages[player][num].AddDamage(damage);
}
else
{
playerConstantDamages[player].Add(new ConstantDamageInfo(damagingPlayer, color, damage));
}
}
public void AddConstantPrecentageDamage(Player player, Player damagingPlayer, Color color, float precentage)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
if (!PlayerConstantPrecentageDamages.ContainsKey(player))
{
PlayerConstantPrecentageDamages[player] = new List<ConstantDamageInfo>();
}
int num = PlayerConstantPrecentageDamages[player].FindIndex((ConstantDamageInfo info) => info.Color == color);
if (num != -1)
{
PlayerConstantPrecentageDamages[player][num] = PlayerConstantPrecentageDamages[player][num].AddDamage(precentage);
}
else
{
PlayerConstantPrecentageDamages[player].Add(new ConstantDamageInfo(damagingPlayer, color, precentage));
}
}
internal void RemovePlayerFromAll(Player player)
{
if (playerConstantDamages.ContainsKey(player))
{
playerConstantDamages.Remove(player);
}
if (PlayerConstantPrecentageDamages.ContainsKey(player))
{
PlayerConstantPrecentageDamages.Remove(player);
}
}
internal void Reset()
{
playerConstantDamages.Clear();
PlayerConstantPrecentageDamages.Clear();
}
private void Start()
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
else
{
Object.Destroy((Object)(object)this);
}
DeathHandler.OnPlayerDeath += (DeathHandlerDelegate)delegate(Player player, Dictionary<Player, DamageInfo> playerDamageInfo)
{
if (playerConstantDamages.ContainsKey(player))
{
playerConstantDamages.Remove(player);
}
if (PlayerConstantPrecentageDamages.ContainsKey(player))
{
PlayerConstantPrecentageDamages.Remove(player);
}
};
}
private void Update()
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: 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_0140: Unknown result type (might be due to invalid IL or missing references)
foreach (KeyValuePair<Player, List<ConstantDamageInfo>> item in playerConstantDamages.ToList())
{
foreach (ConstantDamageInfo item2 in item.Value)
{
Player key = item.Key;
float num = item2.Damage * Time.deltaTime;
if (num > 0f)
{
key.data.healthHandler.DoDamage(Vector2.down * num, Vector2.zero, item2.Color, (GameObject)null, item2.DamagingPlayer, false, true, true);
}
}
}
foreach (KeyValuePair<Player, List<ConstantDamageInfo>> item3 in PlayerConstantPrecentageDamages.ToList())
{
foreach (ConstantDamageInfo item4 in item3.Value)
{
Player key2 = item3.Key;
float num2 = item4.Damage * Time.deltaTime;
if (num2 > 0f)
{
key2.data.healthHandler.DoDamage(Vector2.down * (key2.data.maxHealth * num2), Vector2.zero, item4.Color, (GameObject)null, item4.DamagingPlayer, false, true, true);
}
}
}
}
}
public struct DamageInfo
{
public Vector2 Damage;
public bool IsLethal;
public Player DamagingPlayer;
public Player HurtPlayer;
public DamageInfo(Vector2 damage, bool isLethal, Player damagingPlayer, Player hurtPlayer)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
Damage = damage;
IsLethal = isLethal;
DamagingPlayer = damagingPlayer;
HurtPlayer = hurtPlayer;
}
}
public interface IOnDoDamageEvent
{
void OnDamage(DamageInfo damage);
}
public interface IOnTakeDamageEvent
{
void OnTakeDamage(DamageInfo damage);
}
public interface IOnTakeDamageOvertimeEvent
{
void OnTakeDamageOvertime(DamageInfo damage);
}
public class DamageEventHandler : MonoBehaviour
{
public enum DamageEventType
{
OnDoDamage,
OnTakeDamage,
OnTakeDamageOvertime
}
internal Dictionary<Player, List<IOnDoDamageEvent>> OnDoDamageEvents = new Dictionary<Player, List<IOnDoDamageEvent>>();
internal Dictionary<Player, List<IOnTakeDamageEvent>> OnTakeDamageEvents = new Dictionary<Player, List<IOnTakeDamageEvent>>();
internal Dictionary<Player, List<IOnTakeDamageOvertimeEvent>> OnTakeDamageOvertimeEvents = new Dictionary<Player, List<IOnTakeDamageOvertimeEvent>>();
internal Dictionary<Player, List<IOnDoDamageEvent>> OnDoDamageEventsOtherPlayer = new Dictionary<Player, List<IOnDoDamageEvent>>();
internal Dictionary<Player, List<IOnTakeDamageEvent>> OnTakeDamageEventsOtherPlayer = new Dictionary<Player, List<IOnTakeDamageEvent>>();
internal Dictionary<Player, List<IOnTakeDamageOvertimeEvent>> OnTakeDamageOvertimeEventsOtherPlayer = new Dictionary<Player, List<IOnTakeDamageOvertimeEvent>>();
public static DamageEventHandler Instance;
public void RegisterDamageEvent(object obj, Player player)
{
if (obj is IOnDoDamageEvent item)
{
if (!OnDoDamageEvents.ContainsKey(player))
{
OnDoDamageEvents[player] = new List<IOnDoDamageEvent>();
}
OnDoDamageEvents[player].Add(item);
}
if (obj is IOnTakeDamageEvent item2)
{
if (!OnTakeDamageEvents.ContainsKey(player))
{
OnTakeDamageEvents[player] = new List<IOnTakeDamageEvent>();
}
OnTakeDamageEvents[player].Add(item2);
}
if (obj is IOnTakeDamageOvertimeEvent item3)
{
if (!OnTakeDamageOvertimeEvents.ContainsKey(player))
{
OnTakeDamageOvertimeEvents[player] = new List<IOnTakeDamageOvertimeEvent>();
}
OnTakeDamageOvertimeEvents[player].Add(item3);
}
}
public void RegisterDamageEventForOtherPlayers(object obj, Player player)
{
if (obj is IOnDoDamageEvent item)
{
if (!OnDoDamageEventsOtherPlayer.ContainsKey(player))
{
OnDoDamageEventsOtherPlayer[player] = new List<IOnDoDamageEvent>();
}
OnDoDamageEventsOtherPlayer[player].Add(item);
}
if (obj is IOnTakeDamageEvent item2)
{
if (!OnTakeDamageEventsOtherPlayer.ContainsKey(player))
{
OnTakeDamageEventsOtherPlayer[player] = new List<IOnTakeDamageEvent>();
}
OnTakeDamageEventsOtherPlayer[player].Add(item2);
}
if (obj is IOnTakeDamageOvertimeEvent item3)
{
if (!OnTakeDamageOvertimeEventsOtherPlayer.ContainsKey(player))
{
OnTakeDamageOvertimeEventsOtherPlayer[player] = new List<IOnTakeDamageOvertimeEvent>();
}
OnTakeDamageOvertimeEventsOtherPlayer[player].Add(item3);
}
}
public void UnregisterDamageEvent(object obj, Player player)
{
if (obj is IOnDoDamageEvent item && OnDoDamageEvents.ContainsKey(player))
{
OnDoDamageEvents[player].Remove(item);
}
if (obj is IOnTakeDamageEvent item2 && OnTakeDamageEvents.ContainsKey(player))
{
OnTakeDamageEvents[player].Remove(item2);
}
if (obj is IOnTakeDamageOvertimeEvent item3 && OnTakeDamageOvertimeEvents.ContainsKey(player))
{
OnTakeDamageOvertimeEvents[player].Remove(item3);
}
if (obj is IOnDoDamageEvent item4 && OnDoDamageEventsOtherPlayer.ContainsKey(player))
{
OnDoDamageEventsOtherPlayer[player].Remove(item4);
}
if (obj is IOnTakeDamageEvent item5 && OnTakeDamageEventsOtherPlayer.ContainsKey(player))
{
OnTakeDamageEventsOtherPlayer[player].Remove(item5);
}
if (obj is IOnTakeDamageOvertimeEvent item6 && OnTakeDamageOvertimeEventsOtherPlayer.ContainsKey(player))
{
OnTakeDamageOvertimeEventsOtherPlayer[player].Remove(item6);
}
}
internal static void TriggerDamageEvent(DamageEventType eventType, Player hurtPlayer, Player damagingPlayer, Vector2 damage, bool isLethal)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
DamageInfo damage2 = new DamageInfo(damage, isLethal, damagingPlayer, hurtPlayer);
switch (eventType)
{
case DamageEventType.OnDoDamage:
if (!Instance.OnDoDamageEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnDoDamageEvent item in Instance.OnDoDamageEvents[hurtPlayer])
{
item.OnDamage(damage2);
}
break;
case DamageEventType.OnTakeDamage:
if (!Instance.OnTakeDamageEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnTakeDamageEvent item2 in Instance.OnTakeDamageEvents[hurtPlayer])
{
item2.OnTakeDamage(damage2);
}
break;
case DamageEventType.OnTakeDamageOvertime:
if (!Instance.OnTakeDamageOvertimeEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnTakeDamageOvertimeEvent item3 in Instance.OnTakeDamageOvertimeEvents[hurtPlayer])
{
item3.OnTakeDamageOvertime(damage2);
}
break;
}
foreach (KeyValuePair<Player, List<IOnDoDamageEvent>> item4 in Instance.OnDoDamageEventsOtherPlayer)
{
if (!((Object)(object)item4.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnDoDamageEvent item5 in item4.Value)
{
if (eventType == DamageEventType.OnDoDamage)
{
item5.OnDamage(damage2);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageEvent>> item6 in Instance.OnTakeDamageEventsOtherPlayer)
{
if (!((Object)(object)item6.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageEvent item7 in item6.Value)
{
if (eventType == DamageEventType.OnTakeDamage)
{
item7.OnTakeDamage(damage2);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageOvertimeEvent>> item8 in Instance.OnTakeDamageOvertimeEventsOtherPlayer)
{
if (!((Object)(object)item8.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageOvertimeEvent item9 in item8.Value)
{
if (eventType == DamageEventType.OnTakeDamageOvertime)
{
item9.OnTakeDamageOvertime(damage2);
}
}
}
}
private void Awake()
{
if ((Object)(object)Instance != (Object)null)
{
Object.Destroy((Object)(object)this);
}
else
{
Instance = this;
}
}
}
public class DeathActionHandler : MonoBehaviour
{
public static DeathActionHandler Instance;
internal Dictionary<Player, Action> registeredReviveActions = new Dictionary<Player, Action>();
internal Dictionary<Player, Action> registeredTrueDeathActions = new Dictionary<Player, Action>();
public DeathActionHandler()
{
Instance = this;
}
public void RegisterReviveAction(Player player, Action onRevive)
{
if (registeredReviveActions.TryGetValue(player, out var value))
{
value = (Action)Delegate.Combine(value, onRevive);
}
else
{
registeredReviveActions.Add(player, onRevive);
}
}
public void DeregisterReviveAction(Player player, Action onRevive)
{
if (registeredReviveActions.TryGetValue(player, out var value))
{
value = (Action)Delegate.Remove(value, onRevive);
}
}
public void RegisterTrueDeathAction(Player player, Action onTrueDeath)
{
if (registeredTrueDeathActions.TryGetValue(player, out var value))
{
value = (Action)Delegate.Combine(value, onTrueDeath);
}
else
{
registeredTrueDeathActions.Add(player, onTrueDeath);
}
}
public void DeregisterTrueDeathAction(Player player, Action onTrueDeath)
{
if (registeredTrueDeathActions.TryGetValue(player, out var value))
{
value = (Action)Delegate.Remove(value, onTrueDeath);
}
}
}
public struct DelayDamageInfo
{
public Vector2 Damage;
public Vector2 Position;
public Color BlinkColor;
public GameObject DamagingWeapon;
public Player DamagingPlayer;
public bool HealthRemoval;
public bool Lethal;
public bool IngnoreBlock;
public DelayDamageInfo(Vector2 damage, Vector2 position, Color blinkColor, GameObject damagingWeapon = null, Player damagingPlayer = null, bool healthRemoval = false, bool lethal = true, bool ignoreBlock = false)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: 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_0010: Unknown result type (might be due to invalid IL or missing references)
Damage = damage;
Position = position;
BlinkColor = blinkColor;
DamagingWeapon = damagingWeapon;
DamagingPlayer = damagingPlayer;
HealthRemoval = healthRemoval;
Lethal = lethal;
IngnoreBlock = ignoreBlock;
}
}
public class DelayDamageHandler : MonoBehaviour
{
public Player player;
public static DelayDamageHandler Instance { get; private set; }
public void Awake()
{
player = ((Component)this).GetComponent<Player>();
Instance = this;
}
public void DelayDamage(DelayDamageInfo delayDamageInfo, float delay, Action beforeDamageCall = null, Action afterDamageCall = null)
{
ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)this, delay, (Action)delegate
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
beforeDamageCall?.Invoke();
player.data.healthHandler.DoDamage(delayDamageInfo.Damage, delayDamageInfo.Position, delayDamageInfo.BlinkColor, delayDamageInfo.DamagingWeapon, delayDamageInfo.DamagingPlayer, delayDamageInfo.HealthRemoval, delayDamageInfo.Lethal, delayDamageInfo.IngnoreBlock);
afterDamageCall?.Invoke();
});
}
}
public enum ExtraPickPhaseTrigger
{
TriggerInPlayerPickEnd,
TriggerInPickEnd
}
public class ExtraPickHandler
{
public int Picks { get; internal set; }
public virtual bool PickConditions(Player player, CardInfo card)
{
return true;
}
public virtual void OnPickStart(Player player)
{
}
public virtual void OnPickEnd(Player player, CardInfo card)
{
}
}
public static class ExtraCardPickHandler
{
[CompilerGenerated]
private sealed class <HandleExtraPickForPlayer>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Player player;
public ExtraPickHandler handler;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HandleExtraPickForPlayer>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
currentPlayer = player;
activePickHandler = handler;
handler.OnPickStart(player);
<>2__current = GameModeManager.TriggerHook("PlayerPickStart");
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
CardChoiceVisuals.instance.Show(player.playerID, true);
<>2__current = CardChoice.instance.DoPick(1, player.playerID, (PickerType)1);
<>1__state = 2;
return true;
case 2:
<>1__state = -1;
<>2__current = (object)new WaitForSecondsRealtime(0.1f);
<>1__state = 3;
return true;
case 3:
<>1__state = -1;
handler.Picks = Mathf.Max(0, handler.Picks - 1);
<>2__current = GameModeManager.TriggerHook("PlayerPickEnd");
<>1__state = 4;
return true;
case 4:
<>1__state = -1;
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <HandleExtraPicks>d__9 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public ExtraPickPhaseTrigger pickPhaseTrigger;
private Player[] <>7__wrap1;
private int <>7__wrap2;
private Player <player>5__4;
private List<KeyValuePair<Type, ExtraPickHandler>>.Enumerator <>7__wrap4;
private ExtraPickHandler <handler>5__6;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HandleExtraPicks>d__9(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<player>5__4 = null;
<handler>5__6 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = PlayerManager.instance.players.ToArray();
<>7__wrap2 = 0;
goto IL_017b;
case 1:
<>1__state = -3;
goto IL_00fb;
case 2:
{
<>1__state = -3;
goto IL_0149;
}
IL_017b:
if (<>7__wrap2 < <>7__wrap1.Length)
{
<player>5__4 = <>7__wrap1[<>7__wrap2];
if (extraPicks.TryGetValue(<player>5__4, out var value) && value.TryGetValue(pickPhaseTrigger, out var value2))
{
<>7__wrap4 = value2.ToList().GetEnumerator();
<>1__state = -3;
goto IL_0150;
}
goto IL_016d;
}
<>7__wrap1 = null;
currentPlayer = null;
activePickHandler = null;
return false;
IL_0149:
<handler>5__6 = null;
goto IL_0150;
IL_016d:
<>7__wrap2++;
goto IL_017b;
IL_00fb:
if (<handler>5__6.Picks > 0)
{
<>2__current = HandleExtraPickForPlayer(<player>5__4, pickPhaseTrigger, <handler>5__6);
<>1__state = 1;
return true;
}
goto IL_0149;
IL_0150:
if (<>7__wrap4.MoveNext())
{
<handler>5__6 = <>7__wrap4.Current.Value;
if (pickPhaseTrigger == ExtraPickPhaseTrigger.TriggerInPickEnd)
{
goto IL_00fb;
}
if (<handler>5__6.Picks > 0)
{
<>2__current = HandleExtraPickForPlayer(<player>5__4, pickPhaseTrigger, <handler>5__6);
<>1__state = 2;
return true;
}
goto IL_0149;
}
<>m__Finally1();
<player>5__4 = null;
goto IL_016d;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap4).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static Dictionary<Player, Dictionary<ExtraPickPhaseTrigger, Dictionary<Type, ExtraPickHandler>>> extraPicks = new Dictionary<Player, Dictionary<ExtraPickPhaseTrigger, Dictionary<Type, ExtraPickHandler>>>();
public static ExtraPickHandler activePickHandler;
public static Player currentPlayer;
public static void AddExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks, ExtraPickPhaseTrigger pickPhaseTrigger = ExtraPickPhaseTrigger.TriggerInPlayerPickEnd)
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[4]
{
player.playerID,
extraPickHandler.GetType().AssemblyQualifiedName,
picks,
pickPhaseTrigger
});
}
public static void AddExtraPick<T>(Player player, int picks, ExtraPickPhaseTrigger pickPhaseTrigger = ExtraPickPhaseTrigger.TriggerInPlayerPickEnd) where T : ExtraPickHandler
{
NetworkingManager.RPC(typeof(ExtraCardPickHandler), "RPCA_AddExtraPick", new object[4]
{
player.playerID,
typeof(T).AssemblyQualifiedName,
picks,
pickPhaseTrigger
});
}
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, ExtraPickPhaseTrigger pickPhaseTrigger)
{
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))
{
if (!extraPicks.ContainsKey(val))
{
extraPicks[val] = new Dictionary<ExtraPickPhaseTrigger, Dictionary<Type, ExtraPickHandler>>();
}
if (!extraPicks[val].ContainsKey(pickPhaseTrigger))
{
extraPicks[val][pickPhaseTrigger] = new Dictionary<Type, ExtraPickHandler>();
}
if (!extraPicks[val][pickPhaseTrigger].TryGetValue(type, out var value))
{
value = (ExtraPickHandler)Activator.CreateInstance(type);
extraPicks[val][pickPhaseTrigger][type] = value;
}
value.Picks += picks;
}
}
[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 || !extraPicks.TryGetValue(val, out var value))
{
return;
}
foreach (KeyValuePair<ExtraPickPhaseTrigger, Dictionary<Type, ExtraPickHandler>> item in value.ToList())
{
if (item.Value.TryGetValue(type, out var value2))
{
int num = Math.Min(value2.Picks, picks);
value2.Picks -= num;
picks -= num;
if (value2.Picks <= 0)
{
item.Value.Remove(type);
}
}
if (item.Value.Count == 0)
{
value.Remove(item.Key);
}
if (picks <= 0)
{
break;
}
}
}
[IteratorStateMachine(typeof(<HandleExtraPicks>d__9))]
internal static IEnumerator HandleExtraPicks(ExtraPickPhaseTrigger pickPhaseTrigger)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HandleExtraPicks>d__9(0)
{
pickPhaseTrigger = pickPhaseTrigger
};
}
[IteratorStateMachine(typeof(<HandleExtraPickForPlayer>d__10))]
private static IEnumerator HandleExtraPickForPlayer(Player player, ExtraPickPhaseTrigger pickPhaseTrigger, ExtraPickHandler handler)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HandleExtraPickForPlayer>d__10(0)
{
player = player,
handler = handler
};
}
}
}
namespace AALUND13Cards.Core.Extensions
{
public class AALUND13CardCharacterDataAdditionalData
{
public float BlockPircePercent;
public CustomStatsRegistry CustomStatsRegistry = new CustomStatsRegistry();
public void Reset()
{
BlockPircePercent = 0f;
CustomStatsRegistry.ResetAll();
}
}
public static class CharacterDataExtensions
{
public static readonly ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData> data = new ConditionalWeakTable<CharacterData, AALUND13CardCharacterDataAdditionalData>();
public static AALUND13CardCharacterDataAdditionalData GetAdditionalData(this CharacterData characterData)
{
return data.GetOrCreateValue(characterData);
}
public static CustomStatsRegistry GetCustomStatsRegistry(this CharacterData characterData)
{
return data.GetOrCreateValue(characterData).CustomStatsRegistry;
}
public static void AddData(this CharacterData characterData, AALUND13CardCharacterDataAdditionalData value)
{
try
{
data.Add(characterData, value);
}
catch (Exception)
{
}
}
}
public static class PlayerExtensions
{
public static float GetDPS(this Player player)
{
float num = player.data.weaponHandler.gun.damage * player.data.weaponHandler.gun.bulletDamageMultiplier * player.data.weaponHandler.gun.projectiles[0].objectToSpawn.GetComponent<ProjectileHit>().damage * player.data.weaponHandler.gun.chargeDamageMultiplier;
GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
int maxAmmo = componentInChildren.maxAmmo;
int num2 = (int)((float)player.data.weaponHandler.gun.numberOfProjectiles + player.data.weaponHandler.gun.chargeNumberOfProjectilesTo);
int num3 = Mathf.Max(player.data.weaponHandler.gun.bursts, 1);
float timeBetweenBullets = player.data.weaponHandler.gun.timeBetweenBullets;
float num4 = (float)ExtensionMethods.InvokeMethod((object)componentInChildren, "ReloadTime", Array.Empty<object>());
float num5 = Mathf.Max(player.data.weaponHandler.gun.attackSpeed, 0.01f);
int num6 = num3 * num2;
int num7 = Mathf.Max(maxAmmo / num6, 1);
float num8 = (float)(num3 - 1) * timeBetweenBullets;
float num9 = (num5 + num8) * (float)(num7 - 1) + Mathf.Max(num4, num5 + num8);
float num10 = 1f / num9;
return num * (float)num7 * (float)num6 * num10 / 1.33333f;
}
public static float GetSPS(this Player player)
{
GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
int maxAmmo = componentInChildren.maxAmmo;
int num = (int)((float)player.data.weaponHandler.gun.numberOfProjectiles + player.data.weaponHandler.gun.chargeNumberOfProjectilesTo);
int num2 = Mathf.Max(player.data.weaponHandler.gun.bursts, 1);
float timeBetweenBullets = player.data.weaponHandler.gun.timeBetweenBullets;
float num3 = (float)ExtensionMethods.InvokeMethod((object)componentInChildren, "ReloadTime", Array.Empty<object>());
float num4 = Mathf.Max(player.data.weaponHandler.gun.attackSpeed, 0.01f);
int num5 = num2 * num;
int num6 = Mathf.Max(maxAmmo / num5, 1);
float num7 = (float)(num2 - 1) * timeBetweenBullets;
float num8 = (num4 + num7) * (float)(num6 - 1) + Mathf.Max(num3, num4 + num7);
return (float)(num6 * num) / num8;
}
}
}
namespace AALUND13Cards.Core.Cards
{
public class AACustomCard : CustomUnityCard
{
public string RequireMod = "";
public bool IsCursed;
public override void OnRegister(CardInfo cardInfo)
{
if (IsCursed)
{
CurseManager.instance.RegisterCurse(cardInfo);
List<CardCategory> list = new List<CardCategory>(cardInfo.categories) { CustomCardCategories.instance.CardCategory("Curse") };
cardInfo.categories = list.ToArray();
}
}
public override void OnReassignCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
CustomStatModifers[] components = ((Component)this).GetComponents<CustomStatModifers>();
for (int i = 0; i < components.Length; i++)
{
components[i].OnReassign(player);
}
}
public override void OnAddCard(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
{
OnAddedEffect[] components = ((Component)this).GetComponents<OnAddedEffect>();
for (int i = 0; i < components.Length; i++)
{
components[i].OnAdded(player, gun, gunAmmo, data, health, gravity, block, characterStats);
}
}
public override string GetModName()
{
return "AAC";
}
}
public class CardResgester : MonoBehaviour
{
public static List<CardInfo> AllModCards = new List<CardInfo>();
public List<GameObject> Cards;
private Dictionary<string, CardInfo> ModCards = new Dictionary<string, CardInfo>();
private void SetupCard(CustomCard customCard)
{
if (!((Object)(object)customCard == (Object)null))
{
customCard.cardInfo = ((Component)customCard).GetComponent<CardInfo>();
customCard.gun = ((Component)customCard).GetComponent<Gun>();
customCard.cardStats = ((Component)customCard).GetComponent<ApplyCardStats>();
customCard.statModifiers = ((Component)customCard).GetComponent<CharacterStatModifiers>();
customCard.block = ExtensionMethods.GetOrAddComponent<Block>(((Component)customCard).gameObject, false);
customCard.SetupCard(customCard.cardInfo, customCard.gun, customCard.cardStats, customCard.statModifiers, customCard.block);
}
}
public void RegisterCards()
{
foreach (GameObject card in Cards)
{
CardInfo component = card.GetComponent<CardInfo>();
AACustomCard customCard = card.GetComponent<AACustomCard>();
if ((Object)(object)component == (Object)null)
{
Debug.LogError((object)("[AALUND13 Cards Core][Card] " + ((Object)card).name + " does not have a 'CardInfo' component"));
continue;
}
if ((Object)(object)customCard == (Object)null)
{
Debug.LogError((object)("[AALUND13 Cards Core][Card] " + component.cardName + " does not have a 'AACustomCard' component"));
continue;
}
if (!Utility.IsNullOrWhiteSpace(customCard.RequireMod) && !AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == customCard.RequireMod))
{
Debug.LogWarning((object)("[AALUND13 Cards Core][Card] " + component.cardName + " does not have the require mod of '" + customCard.RequireMod + "'"));
continue;
}
try
{
SetupCard((CustomCard)(object)customCard);
}
catch (Exception arg)
{
Debug.LogError((object)string.Format("[{0}][Card] {1} failed to setup the card: {2}", "AALUND13 Cards Core", component.cardName, arg));
continue;
}
((CustomCard)customCard).RegisterUnityCard((Action<CardInfo>)delegate(CardInfo registerCardInfo)
{
try
{
((CustomUnityCard)customCard).Register(registerCardInfo);
}
catch (Exception arg2)
{
Debug.LogError((object)string.Format("[{0}][Card] {1} failed to execute the 'Register' method: {2}", "AALUND13 Cards Core", registerCardInfo.cardName, arg2));
}
});
Debug.Log((object)("[AALUND13 Cards Core][Card] Registered Card: " + component.cardName));
ModCards.Add(component.cardName, component);
AllModCards.Add(component);
}
}
}
public abstract class CustomStatModifers : MonoBehaviour
{
public abstract void Apply(Player player);
public virtual void OnReassign(Player player)
{
}
}
}
namespace AALUND13Cards.Core.Cards.StatModifers
{
public class AAStatModifers : CustomStatModifers
{
[Header("Blocks Stats")]
public float BlockPircePercent;
public override void Apply(Player player)
{
AALUND13CardCharacterDataAdditionalData additionalData = player.data.GetAdditionalData();
additionalData.BlockPircePercent = Mathf.Clamp(additionalData.BlockPircePercent + BlockPircePercent, 0f, 1f);
}
}
}
namespace AALUND13Cards.Core.Cards.Effects
{
public abstract class OnAddedEffect : MonoBehaviour
{
public abstract void OnAdded(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats);
}
}
namespace AALUND13Cards.Core.Cards.Conditions
{
public abstract class CardCondition : MonoBehaviour
{
public CardInfo CardInfo => ((Component)this).GetComponent<CardInfo>();
public abstract bool IsPlayerAllowedCard(Player player);
}
public class CardLimitCondition : CardCondition
{
public int AllowedAmount = 1;
public override bool IsPlayerAllowedCard(Player player)
{
if (PlayerManager.instance.players.SelectMany((Player p) => p.data.currentCards).ToArray().Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo) >= AllowedAmount)
{
return false;
}
return true;
}
}
internal class MinEnemyPlayersCondition : CardCondition
{
public int MinEnemyPlayers = 2;
public override bool IsPlayerAllowedCard(Player player)
{
return PlayerStatus.GetEnemyPlayers(player).Count >= MinEnemyPlayers;
}
}
public class MinPlayersCondition : CardCondition
{
public int MinPlayers = 3;
public override bool IsPlayerAllowedCard(Player player)
{
return PlayerManager.instance.players.Count >= MinPlayers;
}
}
public class PickPhaseLimitCondition : CardCondition
{
public int AllowedPickCount = 1;
public override bool IsPlayerAllowedCard(Player player)
{
if (PickCardTracker.instance.CardPickedInPickPhase.Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo) >= AllowedPickCount)
{
return false;
}
return true;
}
}
public class PlayerHaveRegenCondition : CardCondition
{
public float MinRegen;
public override bool IsPlayerAllowedCard(Player player)
{
return player.data.healthHandler.regeneration >= MinRegen;
}
}
}
