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.Patches;
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 PickPhaseImprovements;
using RarityLib.Utils;
using Sonigon;
using TMPro;
using TabInfo.Utils;
using ToggleCardsCategories;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.Extensions;
using UnboundLib.GameModes;
using UnboundLib.Utils;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;
using UnityEngine.UI.ProceduralImage;
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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("AALUND13.Cards.Core", "AALUND13 Cards Core", "1.2.2")]
[BepInProcess("Rounds.exe")]
public class AAC_Core : BaseUnityPlugin
{
public const string ModInitials = "AAC";
internal const string ModId = "AALUND13.Cards.Core";
internal const string ModName = "AALUND13 Cards Core";
internal const string Version = "1.2.2";
internal const string FullVersion = "2.3.1";
internal const bool IsBeta = false;
public static List<BaseUnityPlugin> Plugins;
internal static ManualLogSource ModLogger;
internal static Harmony Harmony;
public static CardCategory[] NoLotteryCategories;
public static CardCategory[] NoSteelCategories;
public static AAC_Core Instance { get; private set; }
private void Awake()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
Instance = this;
ModLogger = ((BaseUnityPlugin)this).Logger;
Harmony = new Harmony("AALUND13.Cards.Core");
Harmony.PatchAll();
ToggleCardsCategoriesManager.instance.RegisterCategories("AAC");
AACMenu.RegesterMenu(((BaseUnityPlugin)this).Config);
}
private void Start()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: 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();
}
CardBarHandlerExtensionsPatch.Patch(Harmony);
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") };
}
private IEnumerator OnGameStart(IGameModeHandler gm)
{
ConstantDamageHandler.Instance.Reset();
yield break;
}
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 Func<GameObject, CardInfo> <>9__5_1;
public static UnityAction <>9__7_0;
public static UnityAction<bool> <>9__7_1;
public static UnityAction <>9__7_2;
internal void <RegesterMenu>b__3_0()
{
}
internal void <CreateModuleMenu>b__4_0()
{
}
internal CardInfo <CreateModuleMenuWithReadmeGenerator>b__5_1(GameObject obj)
{
return obj.GetComponent<CardInfo>();
}
internal void <NewGui>b__7_0()
{
}
internal void <NewGui>b__7_1(bool val)
{
DebugMode.Value = val;
}
internal void <NewGui>b__7_2()
{
string systemCopyBuffer = ReadmeGenerator.CreateReadme("AALUND13 Cards", "2.3.1", CardResgester.AllModCards);
GUIUtility.systemCopyBuffer = systemCopyBuffer;
}
}
public static Action OnMenuRegister;
internal static ConfigEntry<bool> DebugMode;
private static GameObject ModulesMenu;
internal 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__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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: 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)
{
GameObject menu = CreateModuleMenu(moduleName);
ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)AAC_Core.Instance, 2, (Action)delegate
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
List<CardInfo> cardInfos = cardResgester.Cards.Select((GameObject obj) => obj.GetComponent<CardInfo>()).ToList();
MenuHandler.CreateButton("Generate Readme: " + moduleName, menu, (UnityAction)delegate
{
string systemCopyBuffer = ReadmeGenerator.CreateReadme(moduleName, version, cardInfos);
GUIUtility.systemCopyBuffer = systemCopyBuffer;
}, 60, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
});
return menu;
}
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_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
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Expected O, but got Unknown
object obj = <>c.<>9__7_0;
if (obj == null)
{
UnityAction val = delegate
{
};
<>c.<>9__7_0 = val;
obj = (object)val;
}
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 value)
{
DebugMode.Value = value;
}, 30, true, (Color?)null, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
GameObject val2 = CreateModuleMenu("AALUND13 Cards Core");
object obj2 = <>c.<>9__7_2;
if (obj2 == null)
{
UnityAction val3 = delegate
{
string systemCopyBuffer = ReadmeGenerator.CreateReadme("AALUND13 Cards", "2.3.1", CardResgester.AllModCards);
GUIUtility.systemCopyBuffer = systemCopyBuffer;
};
<>c.<>9__7_2 = val3;
obj2 = (object)val3;
}
MenuHandler.CreateButton("Generate Full Readme", val2, (UnityAction)obj2, 60, 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
{
private const bool DEBUG = true;
private static void Loginternal(LogLevel level, string message, bool bypassCheck = false)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Invalid comparison between I4 and Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
if (((uint)((32 > (int)level) ? 1 : 1) | (bypassCheck ? 1u : 0u)) != 0)
{
StackFrame stackFrame = new StackFrame(2);
MethodBase method = stackFrame.GetMethod();
string name = method.DeclaringType.Name;
AAC_Core.ModLogger.Log(level, (object)("[" + name + "] " + message));
}
}
public static void Log(LogLevel level, string message, bool bypassCheck = false)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
Loginternal(level, message, bypassCheck);
}
public static void LogInfo(string message, bool bypassCheck = false)
{
Loginternal((LogLevel)16, message, bypassCheck);
}
public static void LogWarn(string message)
{
Loginternal((LogLevel)4, message, bypassCheck: true);
}
public static void LogError(string message)
{
Loginternal((LogLevel)2, message, bypassCheck: true);
}
}
}
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 = false;
public GameObject ArtParent;
private void Start()
{
if (AddRandomArtAtStart)
{
GenerateRandomArt();
}
}
private void OnEnable()
{
if (AddRandomArtAtEnable)
{
GenerateRandomArt();
}
}
private void OnDisable()
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
foreach (Transform item in ArtParent.transform)
{
Transform val = item;
Object.Destroy((Object)(object)((Component)val).gameObject);
}
}
public void GenerateRandomArt()
{
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: 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)
{
CardInfo val = array[Random.Range(0, array.Length)];
GameObject val2 = Object.Instantiate<GameObject>(val.cardArt, ArtParent.transform);
val2.transform.localScale = Vector3.one;
val2.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_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_0022: 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)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: 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_002a: 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_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: 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_005b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: 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 magnitude = ((Vector3)(ref val3)).magnitude;
float num2 = 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 val = AssetBundle.LoadFromStream(stream);
if ((Object)(object)val == (Object)null)
{
LoggerUtils.LogError("AssetBundle.LoadFromStream returned null for resource '" + text2 + "'");
}
else
{
LoggerUtils.LogInfo("Successfully loaded AssetBundle from resource '" + text2 + "'", bypassCheck: true);
}
return val;
}
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 CardInfo LastPickedCard => (cardPickedInPickPhase.Count > 0) ? cardPickedInPickPhase[cardPickedInPickPhase.Count - 1] : null;
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_0029: Unknown result type (might be due to invalid IL or missing references)
if (!Application.isEditor)
{
Rarity randomRarity = GetRandomRarity();
Image[] array = edges;
foreach (Image val in array)
{
((Graphic)val).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" };
List<string> list = 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 num3 = 0; num3 < item.Value.Count; num3++)
{
string cardName = item.Value[num3].cardName;
stringBuilder.Append("- " + cardName.PadRight(totalWidth));
if ((num3 + 1) % num2 == 0 || num3 == 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_004d: 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(ExtraPlayerSkins))]
internal class AALUND13Team
{
private static PlayerSkin SkinWhite;
internal static readonly PlayerSkin White = new PlayerSkin
{
color = new Color(0.8f, 0.8f, 0.8f, 1f),
backgroundColor = new Color(0.8f, 0.8f, 0.8f, 1f),
winText = new Color(0.8f, 0.8f, 0.8f, 1f),
particleEffect = new Color(0.8f, 0.8f, 0.8f, 1f)
};
public const int TeamID = 131;
[HarmonyPatch("GetTeamColorName")]
[HarmonyPostfix]
public static void PatchName(int teamID, ref string __result)
{
if (teamID == 131)
{
__result = "<u><b>AALUND13</b></u>";
}
}
[HarmonyPatch("GetPlayerSkinColors")]
[HarmonyPrefix]
public static bool PatchGetSkin(int colorID, ref PlayerSkin __result)
{
if (colorID != 131)
{
return true;
}
if ((Object)(object)SkinWhite == (Object)null)
{
SkinWhite = CreateSkins(colorID, White);
}
__result = SkinWhite;
return false;
}
private static PlayerSkin CreateSkins(int colorID, PlayerSkin skinPrefab)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: 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_010e: Unknown result type (might be due to invalid IL or missing references)
PropertyInfo property = typeof(PlayerSkinBank).GetProperty("Instance", BindingFlags.Static | BindingFlags.NonPublic);
PlayerSkinBank val = (PlayerSkinBank)((property != null) ? property.GetValue(null, null) : null);
PlayerSkin val2 = (((Object)(object)val != (Object)null) ? val.skins[colorID % 4].currentPlayerSkin : null);
PlayerSkin component = ((Component)Object.Instantiate<PlayerSkin>(val2)).gameObject.GetComponent<PlayerSkin>();
Object.DontDestroyOnLoad((Object)(object)component);
component.color = skinPrefab.color;
component.backgroundColor = skinPrefab.backgroundColor;
component.winText = skinPrefab.winText;
component.particleEffect = skinPrefab.particleEffect;
PlayerSkinParticle componentInChildren = ((Component)component).GetComponentInChildren<PlayerSkinParticle>();
ParticleSystem component2 = ((Component)componentInChildren).GetComponent<ParticleSystem>();
MainModule main = component2.main;
MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
((MinMaxGradient)(ref startColor)).colorMin = skinPrefab.backgroundColor;
((MinMaxGradient)(ref startColor)).colorMax = skinPrefab.color;
((MainModule)(ref main)).startColor = startColor;
ExtensionMethods.SetFieldValue((object)componentInChildren, "startColor1", (object)skinPrefab.backgroundColor);
ExtensionMethods.SetFieldValue((object)componentInChildren, "startColor2", (object)skinPrefab.color);
return component;
}
}
[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>();
CustomStatModifers[] array = components;
foreach (CustomStatModifers customStatModifers in array)
{
customStatModifers.Apply(___playerToUpgrade);
}
}
}
[HarmonyPatch(typeof(Block))]
internal class BlockPatch
{
[HarmonyPatch("blocked")]
[HarmonyPrefix]
public static void BlockedPrefix(Block __instance, GameObject projectile, Vector3 forward, Vector3 hitPos)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: 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);
}
}
}
public class CardBarHandlerExtensionsPatch
{
public static void Patch(Harmony harmony)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(typeof(CardBarHandlerExtensionsPatch), "CardBarColor", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(CardBarHandlerExtensions), "Rebuild", (Type[])null, (Type[])null);
harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
LoggerUtils.LogInfo("Patch 'UnboundLib' CardBarHandlerExtensions.Rebuild method");
if (AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "io.olavim.rounds.rwf"))
{
Type type = Type.GetType("RWF.CardBarHandlerExtensions, RoundsWithFriends");
MethodInfo method = type.GetMethod("Rebuild");
harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
LoggerUtils.LogInfo("Patch 'RWF' CardBarHandlerExtensions.Rebuild method");
}
else
{
LoggerUtils.LogInfo("No 'RWF' CardBarHandlerExtensions.Rebuild method to patch");
}
}
public static void CardBarColor()
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
int[] array = (from p in PlayerManager.instance.players
where PlayerExtensions.GetAdditionalData(p).colorID == 131
select p.playerID).ToArray();
CardBar[] array2 = (CardBar[])ExtensionMethods.GetFieldValue((object)CardBarHandler.instance, "cardBars");
int[] array3 = array;
foreach (int num2 in array3)
{
CardBar val = array2[num2];
GameObject gameObject = ((Component)((Component)val).transform.GetChild(((Component)val).transform.childCount - 1)).gameObject;
ProceduralImage[] componentsInChildren = gameObject.GetComponentsInChildren<ProceduralImage>();
foreach (ProceduralImage val2 in componentsInChildren)
{
((Graphic)val2).color = Color.black;
}
TextMeshProUGUI componentInChildren = gameObject.GetComponentInChildren<TextMeshProUGUI>();
((Graphic)componentInChildren).color = Color.white;
}
}
}
[HarmonyPatch(typeof(CardChoice))]
internal class CardChoicePatch
{
[HarmonyPatch("IDoEndPick")]
[HarmonyPriority(800)]
private static void Postfix(GameObject pickedCard, int pickId)
{
Player playerWithID = ExtensionMethods.GetPlayerWithID(PlayerManager.instance, pickId);
if (!((Object)(object)playerWithID == (Object)null))
{
PickCardTracker.instance.AddCardPickedInPickPhase(pickedCard.GetComponent<CardInfo>());
}
}
}
[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();
}
}
}
[HarmonyPatch(typeof(DamageOverTime))]
internal class DamageOverTimePatch
{
[HarmonyPatch("TakeDamageOverTime")]
[HarmonyPrefix]
public static void TakeDamageOverTimePrefix(DamageOverTime __instance, ref Vector2 damage, Vector2 position, float time, float interval, Color color, SoundEvent soundDamageOverTime, GameObject damagingWeapon, ref Player damagingPlayer, ref bool lethal)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: 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)
{
DamageInfo damageInfo = DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamageOvertime, val.player, damagingPlayer, damage, lethal);
damage = damageInfo.Damage;
lethal = damageInfo.IsLethal;
damagingPlayer = damageInfo.DamagingPlayer;
}
}
}
[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, ref Player damagingPlayer, ref Vector2 damage, ref bool lethal)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
TakeDamageRunning = true;
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
DamageInfo damageInfo = DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnTakeDamage, val.player, damagingPlayer, damage, lethal);
damage = damageInfo.Damage;
lethal = damageInfo.IsLethal;
damagingPlayer = damageInfo.DamagingPlayer;
}
[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, ref Player damagingPlayer, bool healthRemoval, ref 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_002e: 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)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
CharacterData val = (CharacterData)Traverse.Create((object)__instance).Field("data").GetValue();
AALUND13CardCharacterDataAdditionalData additionalData = val.GetAdditionalData();
DamageInfo damageInfo = DamageEventHandler.TriggerDamageEvent(DamageEventHandler.DamageEventType.OnDoDamage, val.player, damagingPlayer, damage, lethal);
damage = damageInfo.Damage;
lethal = damageInfo.IsLethal;
damagingPlayer = damageInfo.DamagingPlayer;
}
[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();
}
}
}
[HarmonyPatch(typeof(CardBarUtils), "ResetPlayersLineColor", new Type[] { typeof(int) })]
public class ModdingUtilsCardBarPatch
{
private static void Postfix(int playerID)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
Player val = PlayerManager.instance.players.Find((Player p) => p.playerID == playerID);
if (PlayerExtensions.GetAdditionalData(val).colorID == 131)
{
CardBar val2 = CardBarUtils.instance.PlayersCardBar(playerID);
TextMeshProUGUI[] componentsInChildren = ((Component)val2).gameObject.GetComponentsInChildren<TextMeshProUGUI>();
foreach (TextMeshProUGUI val3 in componentsInChildren)
{
((Graphic)val3).color = Color.white;
}
}
}
}
}
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 = false;
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_002a: 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_002a: 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_002a: 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_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
GameObject[] objectToSpawn = base.objectToSpawn;
foreach (GameObject val in objectToSpawn)
{
DamageSpawnedAttack component = val.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_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
DamagingPlayer = damagingPlayer;
Color = color;
Damage = damage;
}
public ConstantDamageInfo AddDamage(float damage)
{
//IL_0008: 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_00a1: 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_00a1: 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_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: 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_006d: 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)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: 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_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: 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 IOnDoDamageEventOverridable
{
DamageInfo OnDamage(DamageInfo info);
}
public interface IOnTakeDamageEvent
{
void OnTakeDamage(DamageInfo damage);
}
public interface IOnTakeDamageEventOverridable
{
DamageInfo OnTakeDamage(DamageInfo info);
}
public interface IOnTakeDamageOvertimeEvent
{
void OnTakeDamageOvertime(DamageInfo damage);
}
public interface IOnTakeDamageOvertimeEventOverridable
{
DamageInfo OnTakeDamageOvertime(DamageInfo info);
}
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>>();
internal Dictionary<Player, List<IOnDoDamageEventOverridable>> OnDoDamageOverridableEvents = new Dictionary<Player, List<IOnDoDamageEventOverridable>>();
internal Dictionary<Player, List<IOnTakeDamageEventOverridable>> OnTakeDamageOverridableEvents = new Dictionary<Player, List<IOnTakeDamageEventOverridable>>();
internal Dictionary<Player, List<IOnTakeDamageOvertimeEventOverridable>> OnTakeDamageOvertimeOverridableEvents = new Dictionary<Player, List<IOnTakeDamageOvertimeEventOverridable>>();
internal Dictionary<Player, List<IOnDoDamageEventOverridable>> OnDoDamageEventsOverridableOtherPlayer = new Dictionary<Player, List<IOnDoDamageEventOverridable>>();
internal Dictionary<Player, List<IOnTakeDamageEventOverridable>> OnTakeDamageEventsOverridableOtherPlayer = new Dictionary<Player, List<IOnTakeDamageEventOverridable>>();
internal Dictionary<Player, List<IOnTakeDamageOvertimeEventOverridable>> OnTakeDamageOvertimeEventsOverridableOtherPlayer = new Dictionary<Player, List<IOnTakeDamageOvertimeEventOverridable>>();
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);
}
if (obj is IOnDoDamageEventOverridable item4)
{
if (!OnDoDamageOverridableEvents.ContainsKey(player))
{
OnDoDamageOverridableEvents[player] = new List<IOnDoDamageEventOverridable>();
}
OnDoDamageOverridableEvents[player].Add(item4);
}
if (obj is IOnTakeDamageEventOverridable item5)
{
if (!OnTakeDamageOverridableEvents.ContainsKey(player))
{
OnTakeDamageOverridableEvents[player] = new List<IOnTakeDamageEventOverridable>();
}
OnTakeDamageOverridableEvents[player].Add(item5);
}
if (obj is IOnTakeDamageOvertimeEventOverridable item6)
{
if (!OnTakeDamageOvertimeOverridableEvents.ContainsKey(player))
{
OnTakeDamageOvertimeOverridableEvents[player] = new List<IOnTakeDamageOvertimeEventOverridable>();
}
OnTakeDamageOvertimeOverridableEvents[player].Add(item6);
}
}
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);
}
if (obj is IOnDoDamageEventOverridable item4)
{
if (!OnDoDamageEventsOverridableOtherPlayer.ContainsKey(player))
{
OnDoDamageEventsOverridableOtherPlayer[player] = new List<IOnDoDamageEventOverridable>();
}
OnDoDamageEventsOverridableOtherPlayer[player].Add(item4);
}
if (obj is IOnTakeDamageEventOverridable item5)
{
if (!OnTakeDamageEventsOverridableOtherPlayer.ContainsKey(player))
{
OnTakeDamageEventsOverridableOtherPlayer[player] = new List<IOnTakeDamageEventOverridable>();
}
OnTakeDamageEventsOverridableOtherPlayer[player].Add(item5);
}
if (obj is IOnTakeDamageOvertimeEventOverridable item6)
{
if (!OnTakeDamageOvertimeEventsOverridableOtherPlayer.ContainsKey(player))
{
OnTakeDamageOvertimeEventsOverridableOtherPlayer[player] = new List<IOnTakeDamageOvertimeEventOverridable>();
}
OnTakeDamageOvertimeEventsOverridableOtherPlayer[player].Add(item6);
}
}
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);
}
if (obj is IOnDoDamageEventOverridable item7 && OnDoDamageOverridableEvents.ContainsKey(player))
{
OnDoDamageOverridableEvents[player].Remove(item7);
}
if (obj is IOnTakeDamageEventOverridable item8 && OnTakeDamageOverridableEvents.ContainsKey(player))
{
OnTakeDamageOverridableEvents[player].Remove(item8);
}
if (obj is IOnTakeDamageOvertimeEventOverridable item9 && OnTakeDamageOvertimeOverridableEvents.ContainsKey(player))
{
OnTakeDamageOvertimeOverridableEvents[player].Remove(item9);
}
if (obj is IOnDoDamageEventOverridable item10 && OnDoDamageEventsOverridableOtherPlayer.ContainsKey(player))
{
OnDoDamageEventsOverridableOtherPlayer[player].Remove(item10);
}
if (obj is IOnTakeDamageEventOverridable item11 && OnTakeDamageEventsOverridableOtherPlayer.ContainsKey(player))
{
OnTakeDamageEventsOverridableOtherPlayer[player].Remove(item11);
}
if (obj is IOnTakeDamageOvertimeEventOverridable item12 && OnTakeDamageOvertimeEventsOverridableOtherPlayer.ContainsKey(player))
{
OnTakeDamageOvertimeEventsOverridableOtherPlayer[player].Remove(item12);
}
}
internal static DamageInfo TriggerDamageEvent(DamageEventType eventType, Player hurtPlayer, Player damagingPlayer, Vector2 damage, bool isLethal)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
DamageInfo damageInfo = new DamageInfo(damage, isLethal, damagingPlayer, hurtPlayer);
switch (eventType)
{
case DamageEventType.OnDoDamage:
if (Instance.OnDoDamageEvents.ContainsKey(hurtPlayer))
{
foreach (IOnDoDamageEvent item in Instance.OnDoDamageEvents[hurtPlayer])
{
item.OnDamage(damageInfo);
}
}
if (!Instance.OnDoDamageOverridableEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnDoDamageEventOverridable item2 in Instance.OnDoDamageOverridableEvents[hurtPlayer])
{
damageInfo = item2.OnDamage(damageInfo);
}
break;
case DamageEventType.OnTakeDamage:
if (Instance.OnTakeDamageEvents.ContainsKey(hurtPlayer))
{
foreach (IOnTakeDamageEvent item3 in Instance.OnTakeDamageEvents[hurtPlayer])
{
item3.OnTakeDamage(damageInfo);
}
}
if (!Instance.OnTakeDamageOverridableEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnTakeDamageEventOverridable item4 in Instance.OnTakeDamageOverridableEvents[hurtPlayer])
{
damageInfo = item4.OnTakeDamage(damageInfo);
}
break;
case DamageEventType.OnTakeDamageOvertime:
if (Instance.OnTakeDamageOvertimeEvents.ContainsKey(hurtPlayer))
{
foreach (IOnTakeDamageOvertimeEvent item5 in Instance.OnTakeDamageOvertimeEvents[hurtPlayer])
{
item5.OnTakeDamageOvertime(damageInfo);
}
}
if (!Instance.OnTakeDamageOvertimeOverridableEvents.ContainsKey(hurtPlayer))
{
break;
}
foreach (IOnTakeDamageOvertimeEventOverridable item6 in Instance.OnTakeDamageOvertimeOverridableEvents[hurtPlayer])
{
damageInfo = item6.OnTakeDamageOvertime(damageInfo);
}
break;
}
foreach (KeyValuePair<Player, List<IOnDoDamageEvent>> item7 in Instance.OnDoDamageEventsOtherPlayer)
{
if (!((Object)(object)item7.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnDoDamageEvent item8 in item7.Value)
{
if (eventType == DamageEventType.OnDoDamage)
{
item8.OnDamage(damageInfo);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageEvent>> item9 in Instance.OnTakeDamageEventsOtherPlayer)
{
if (!((Object)(object)item9.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageEvent item10 in item9.Value)
{
if (eventType == DamageEventType.OnTakeDamage)
{
item10.OnTakeDamage(damageInfo);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageOvertimeEvent>> item11 in Instance.OnTakeDamageOvertimeEventsOtherPlayer)
{
if (!((Object)(object)item11.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageOvertimeEvent item12 in item11.Value)
{
if (eventType == DamageEventType.OnTakeDamageOvertime)
{
item12.OnTakeDamageOvertime(damageInfo);
}
}
}
foreach (KeyValuePair<Player, List<IOnDoDamageEventOverridable>> item13 in Instance.OnDoDamageEventsOverridableOtherPlayer)
{
if (!((Object)(object)item13.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnDoDamageEventOverridable item14 in item13.Value)
{
if (eventType == DamageEventType.OnDoDamage)
{
damageInfo = item14.OnDamage(damageInfo);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageEventOverridable>> item15 in Instance.OnTakeDamageEventsOverridableOtherPlayer)
{
if (!((Object)(object)item15.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageEventOverridable item16 in item15.Value)
{
if (eventType == DamageEventType.OnTakeDamage)
{
damageInfo = item16.OnTakeDamage(damageInfo);
}
}
}
foreach (KeyValuePair<Player, List<IOnTakeDamageOvertimeEventOverridable>> item17 in Instance.OnTakeDamageOvertimeEventsOverridableOtherPlayer)
{
if (!((Object)(object)item17.Key != (Object)(object)hurtPlayer))
{
continue;
}
foreach (IOnTakeDamageOvertimeEventOverridable item18 in item17.Value)
{
if (eventType == DamageEventType.OnTakeDamageOvertime)
{
damageInfo = item18.OnTakeDamageOvertime(damageInfo);
}
}
}
return damageInfo;
}
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_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: 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_000a: 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_0011: 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_002e: 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_0044: 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 virtual int HandSize { get; set; } = 0;
[Obsolete("Property Picks is deprecated. Use the number of times you call AddExtraPick instead to determine the number of picks.")]
public int Picks { get; internal set; } = 0;
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
{
internal static Dictionary<Player, Dictionary<Type, List<ShuffleData>>> extraPicks = new Dictionary<Player, Dictionary<Type, List<ShuffleData>>>();
public static ExtraPickHandler activePickHandler;
public static Player currentPlayer;
[Obsolete("Method AddExtraPick with ExtraPickPhaseTrigger parameter is deprecated. Use AddExtraPick without the parameter instead.")]
public static void AddExtraPick(ExtraPickHandler extraPickHandler, Player player, int picks, ExtraPickPhaseTrigger pickPhaseTrigger = ExtraPickPhaseTrigger.TriggerInPlayerPickEnd)
{
AddExtraPick(extraPickHandler, player, picks);
}
[Obsolete("Method AddExtraPick<T> with ExtraPickPhaseTrigger parameter is deprecated. Use AddExtraPick<T> without the parameter instead.")]
public static void AddExtraPick<T>(Player player, int picks, ExtraPickPhaseTrigger pickPhaseTrigger = ExtraPickPhaseTrigger.TriggerInPlayerPickEnd) where T : ExtraPickHandler
{
AddExtraPick((ExtraPickHandler)Activator.CreateInstance(typeof(T)), player, picks);
}
public static void AddExtraPick<T>(Player player, int picks) where T : ExtraPickHandler
{
AddExtraPick((ExtraPickHandler)Activator.CreateInstance(typeof(T)), player, picks);
}
public static ShuffleData RemoveExtraPick<T>(Player player) where T : ExtraPickHandler
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
if (!extraPicks.TryGetValue(player, out var value))
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks.");
}
if (!value.TryGetValue(typeof(T), out var value2))
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks of type '{typeof(T)}'.");
}
if (value2.Count <= 0)
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks of type '{typeof(T)}'.");
}
ShuffleData result = value2[0];
value2.RemoveAt(0);
return result;
}
public static ShuffleData RemoveExtraPick(ExtraPickHandler handler, Player player)
{
//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_0010: Unknown result type (might be due to invalid IL or missing references)
return RemoveExtraPick(handler.GetType(), player);
}
public static ShuffleData RemoveExtraPick(Type handlerType, Player player)
{
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
if (!extraPicks.TryGetValue(player, out var value))
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks.");
}
if (!value.TryGetValue(handlerType, out var value2))
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks of type '{handlerType}'.");
}
if (value2.Count <= 0)
{
throw new Exception($"Player '{player.playerID}' does not have any extra picks of type '{handlerType}'.");
}
ShuffleData result = value2[0];
value2.RemoveAt(0);
return result;
}
public static bool HasExtraPick<T>(Player player) where T : ExtraPickHandler
{
Dictionary<Type, List<ShuffleData>> value;
List<ShuffleData> value2;
return extraPicks.TryGetValue(player, out value) && value.TryGetValue(typeof(T), out value2) && value2.Count > 0;
}
public static bool HasExtraPick(ExtraPickHandler handler, Player player)
{
Dictionary<Type, List<ShuffleData>> value;
List<ShuffleData> value2;
return extraPicks.TryGetValue(player, out value) && value.TryGetValue(handler.GetType(), out value2) && value2.Count > 0;
}
public static bool HasExtraPick(Player player, Type handlerType)
{
Dictionary<Type, List<ShuffleData>> value;
List<ShuffleData> value2;
return extraPicks.TryGetValue(player, out value) && value.TryGetValue(handlerType, out value2) && value2.Count > 0;
}
public static void AddExtraPick(ExtraPickHandler handler, Player player, int picks)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < picks; i++)
{
ShuffleData val = new ShuffleData
{
HandSize = handler.HandSize,
Relative = false,
Condition = (CardInfo info) => handler.PickConditions(player, info),
pickStartCallback = delegate
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
handler.OnPickStart(player);
if (HasExtraPick(handler, player))
{
RemoveExtraPick(handler, player);
}
},
pickEndCallback = delegate
{
handler.OnPickEnd(player, PickManager.lastPickedCard);
}
};
PickManager.QueueShuffleForPicker(player, val);
if (!extraPicks.TryGetValue(player, out var value))
{
value = new Dictionary<Type, List<ShuffleData>>();
extraPicks[player] = value;
}
if (!value.TryGetValue(handler.GetType(), out var value2))
{
value2 = new List<ShuffleData>();
value[handler.GetType()] = value2;
}
value2.Add(val);
}
}
}
}
namespace AALUND13Cards.Core.Extensions
{
public class AALUND13CardCharacterDataAdditionalData
{
public float BlockPircePercent = 0f;
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 = false;
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>();
CustomStatModifers[] array = components;
foreach (CustomStatModifers customStatModifers in array)
{
customStatModifers.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>();
OnAddedEffect[] array = components;
foreach (OnAddedEffect onAddedEffect in array)
{
onAddedEffect.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 = 0f;
public override void Apply(Player player)
{
CharacterData data = player.data;
AALUND13CardCharacterDataAdditionalData additionalData = 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)
{
CardInfo[] source = PlayerManager.instance.players.SelectMany((Player p) => p.data.currentCards).ToArray();
int num = source.Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo);
if (num >= 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)
{
int num = PickCardTracker.instance.CardPickedInPickPhase.Count((CardInfo c) => (Object)(object)c == (Object)(object)base.CardInfo);
if (num >= AllowedPickCount)
{
return false;
}
return true;
}
}
public class PlayerHaveRegenCondition : CardCondition
{
public float MinRegen;
public override bool IsPlayerAllowedCard(Player player)
{
return player.data.healthHandler.regeneration >= MinRegen;
}
}
}
