Decompiled source of CardRenderer v1.0.0
CardRenderer.dll
Decompiled a month ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using BepInEx; using BepInEx.Logging; using CardRenderer.Core; using CardRenderer.SliceVariants; using CardRenderer.Utils; using CardsShared; using HarmonyLib; using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.SceneManagement; using UnityEngine.UI; [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.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: AssemblyCompany("CardRenderer")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0+746a5efe9166a66401b133f5116270c598c45555")] [assembly: AssemblyProduct("CardRenderer")] [assembly: AssemblyTitle("CardRenderer")] [assembly: AssemblyVersion("1.0.0.0")] namespace CardRenderer { public static class CardRendererAPI { public static GameObject NewMenu(string parentPath, string newRootName, string prefabAspectName = null) { return MenuManager.NewMenu(parentPath, newRootName, prefabAspectName); } public static GameObject NewPanel(string parentPath, string panelName, Vector2? startPosition = null, bool rightToLeft = false, string spriteName = "LargeUI9SliceBlue") { //IL_001f: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0027: Unknown result type (might be due to invalid IL or missing references) Vector2 startPosition2 = (Vector2)(((??)startPosition) ?? new Vector2(0f, 0f)); return MenuManager.NewPanel(parentPath, panelName, startPosition2, rightToLeft, spriteName); } public static GameObject ResizeToFitChildren(GameObject container, bool rightToLeft = false) { return MenuManager.ResizeToFitChildren(container, rightToLeft); } public static GameObject ResizeToFitChildrenVertical(GameObject container, bool rightToLeft = false) { return MenuManager.ResizeToFitChildrenVertical(container, rightToLeft); } public static GameObject CreateCardDisplay(CardDisplayData cardDisplayData, string parentPath = null, string sliceVariant = null, string prefabAspectName = null, Color? colorVariant = null, Color? textColorVariant = null) { return CardManager.CreateCardDisplay(cardDisplayData, parentPath, sliceVariant, prefabAspectName, colorVariant, textColorVariant); } public static void ConfigureCardPosition(GameObject cardGO, Vector3? localPosition = null, Vector2? anchoredPosition = null) { CardManager.ConfigureCardPosition(cardGO, localPosition, anchoredPosition); } public static void SwapCardSlice(string cardPath, string sliceVariant = null, Color? colorVariant = null, Color? textColorVariant = null) { CardManager.SwapCardSlice(cardPath, sliceVariant, colorVariant, textColorVariant); } public static void DisplayCardTree(List<CardTree> roots, string parentPath, string sliceVariant = null, string prefabAspectName = null, Color? colorVariant = null, Color? textColorVariant = null, bool rightToLeft = false, float? xSpacing = null, float? ySpacing = null, float? depth0YSpacing = null, float? depth1YSpacing = null) { //IL_0073: Unknown result type (might be due to invalid IL or missing references) float valueOrDefault = xSpacing.GetValueOrDefault(225f); float valueOrDefault2 = ySpacing.GetValueOrDefault(-90f); float valueOrDefault3 = depth0YSpacing.GetValueOrDefault(-7f); float valueOrDefault4 = depth1YSpacing.GetValueOrDefault(); float directionMultiplier = (rightToLeft ? (-1f) : 1f); Vector2 position = default(Vector2); ((Vector2)(ref position))..ctor(20f, -20f); foreach (CardTree root in roots) { CardTreeManager.DisplayNodeRecursive(root, parentPath, sliceVariant, prefabAspectName, colorVariant, textColorVariant, directionMultiplier, position, 0, valueOrDefault, valueOrDefault2, valueOrDefault3, valueOrDefault4); position.y += valueOrDefault2 * (float)CardTreeManager.CountLeaves(root); } } public static void DisplayCardTreeVertical(List<CardTree> roots, string parentPath, string sliceVariant = null, string prefabAspectName = null, Color? colorVariant = null, Color? textColorVariant = null, bool bottomToTop = false, float? xSpacing = null, float? ySpacing = null, float? depth0XSpacing = null, float? depth1XSpacing = null) { //IL_0073: Unknown result type (might be due to invalid IL or missing references) float valueOrDefault = xSpacing.GetValueOrDefault(225f); float valueOrDefault2 = ySpacing.GetValueOrDefault(-90f); float valueOrDefault3 = depth0XSpacing.GetValueOrDefault(7f); float valueOrDefault4 = depth1XSpacing.GetValueOrDefault(); float directionMultiplier = (bottomToTop ? (-1f) : 1f); Vector2 position = default(Vector2); ((Vector2)(ref position))..ctor(20f, -20f); foreach (CardTree root in roots) { CardTreeManager.DisplayNodeRecursiveVertical(root, parentPath, sliceVariant, prefabAspectName, colorVariant, textColorVariant, directionMultiplier, position, 0, valueOrDefault, valueOrDefault2, valueOrDefault3, valueOrDefault4); position.x += valueOrDefault * (float)CardTreeManager.CountLeaves(root); } } public static IEnumerator WaitForCardAspect(string cardAspect) { string path = "CardRenderer/CardsAspects/" + cardAspect; while ((Object)(object)GameObject.Find(path) == (Object)null) { yield return null; } } public static IEnumerator WaitForMenuAspect(string menuAspect) { string path = "CardRenderer/MenusAspects/" + menuAspect; while ((Object)(object)GameObject.Find(path) == (Object)null) { yield return null; } } } [BepInPlugin("AgusBut.CardRenderer", "CardRenderer", "1.0.0")] public class Plugin : BaseUnityPlugin { public static Plugin Instance { get; private set; } public static ManualLogSource Log { get; private set; } private void Awake() { //IL_0019: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Expected O, but got Unknown Instance = this; Log = ((BaseUnityPlugin)this).Logger; Harmony val = new Harmony("AgusBut.CardRenderer"); val.PatchAll(); SliceTexturesManager.LoadAndAttachAllUISprites(); ((BaseUnityPlugin)this).Logger.LogInfo((object)"CardRenderer loaded successfully."); } private void Start() { ((MonoBehaviour)this).StartCoroutine(CapturePrefabsWhenMainMenuLoads()); } private IEnumerator CapturePrefabsWhenMainMenuLoads() { while (true) { Scene activeScene = SceneManager.GetActiveScene(); if (!(((Scene)(ref activeScene)).name != "MainMenu")) { break; } yield return null; } if ((Object)(object)GameObject.Find("CardRenderer/CardsAspects/DefaultHorizontalCard") == (Object)null) { AspectsCapturer.CaptureBaseCardPrefab(); } if ((Object)(object)GameObject.Find("CardRenderer/MenusAspects/DefaultMenu") == (Object)null) { AspectsCapturer.CaptureBaseMenuPrefab(); } } } } namespace CardRenderer.Utils { internal class ColorsHelper { public static Color Black = new Color(0.196f, 0.196f, 0.196f, 1f); public static Color Grey = new Color(0.514f, 0.502f, 0.514f, 1f); public static Color White = new Color(1f, 1f, 1f, 1f); public static Color Green = new Color(0.635f, 0.741f, 0.451f, 1f); public static Color DeepGreen = new Color(0.259f, 0.403f, 0.155f, 1f); public static Color Blue = new Color(0.471f, 0.529f, 0.667f, 1f); public static Color DeepBlue = new Color(0f, 0f, 0.286f, 1f); public static Color Red = new Color(0.667f, 0.333f, 0.251f, 1f); public static Color DeepRed = new Color(0.323f, 0.054f, 0.05f, 1f); public static Color Purple = new Color(0.46f, 0.093f, 0.903f, 1f); public static Color DeepPurple = new Color(0.369f, 0.157f, 0.569f, 1f); public static Color Orange = new Color(0.544f, 0.411f, 0.265f, 1f); public static Color DeepOrange = new Color(0.612f, 0.478f, 0.208f, 1f); public static Color GetContrastByName(string colorName) { //IL_01df: Unknown result type (might be due to invalid IL or missing references) //IL_01e4: Unknown result type (might be due to invalid IL or missing references) //IL_021f: Unknown result type (might be due to invalid IL or missing references) //IL_0224: Unknown result type (might be due to invalid IL or missing references) //IL_01ff: Unknown result type (might be due to invalid IL or missing references) //IL_0204: Unknown result type (might be due to invalid IL or missing references) //IL_023f: Unknown result type (might be due to invalid IL or missing references) //IL_0244: Unknown result type (might be due to invalid IL or missing references) //IL_01e7: Unknown result type (might be due to invalid IL or missing references) //IL_01ec: Unknown result type (might be due to invalid IL or missing references) //IL_024f: Unknown result type (might be due to invalid IL or missing references) //IL_0247: Unknown result type (might be due to invalid IL or missing references) //IL_024c: Unknown result type (might be due to invalid IL or missing references) //IL_020f: Unknown result type (might be due to invalid IL or missing references) //IL_0214: Unknown result type (might be due to invalid IL or missing references) //IL_022f: Unknown result type (might be due to invalid IL or missing references) //IL_0234: Unknown result type (might be due to invalid IL or missing references) //IL_0217: Unknown result type (might be due to invalid IL or missing references) //IL_021c: Unknown result type (might be due to invalid IL or missing references) //IL_01f7: Unknown result type (might be due to invalid IL or missing references) //IL_01fc: Unknown result type (might be due to invalid IL or missing references) //IL_0237: Unknown result type (might be due to invalid IL or missing references) //IL_023c: Unknown result type (might be due to invalid IL or missing references) //IL_0207: Unknown result type (might be due to invalid IL or missing references) //IL_020c: Unknown result type (might be due to invalid IL or missing references) //IL_0227: Unknown result type (might be due to invalid IL or missing references) //IL_022c: Unknown result type (might be due to invalid IL or missing references) //IL_01ef: Unknown result type (might be due to invalid IL or missing references) //IL_01f4: Unknown result type (might be due to invalid IL or missing references) return (Color)(colorName.ToLower() switch { "blue" => DeepBlue, "deepblue" => Blue, "red" => DeepRed, "deepred" => Red, "green" => DeepGreen, "deepgreen" => Green, "purple" => DeepPurple, "deeppurple" => Purple, "orange" => DeepOrange, "deeporange" => Orange, "black" => Grey, "grey" => Black, "white" => Grey, _ => Grey, }); } } internal class GameObjectHelper { internal static GameObject GetOrCreatePersistentGO(string name) { //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown GameObject val = GameObject.Find(name); if ((Object)(object)val == (Object)null) { val = new GameObject(name); Object.DontDestroyOnLoad((Object)(object)val); } return val; } internal static GameObject GetOrCreateChild(Transform parent, string childName) { //IL_001e: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Expected O, but got Unknown Transform val = parent.Find(childName); if ((Object)(object)val != (Object)null) { return ((Component)val).gameObject; } GameObject val2 = new GameObject(childName); val2.transform.SetParent(parent, false); return val2; } internal static Transform FindDeepChild(Transform parent, string name) { //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0017: Expected O, but got Unknown foreach (Transform item in parent) { Transform val = item; if (((Object)val).name == name) { return val; } Transform val2 = FindDeepChild(val, name); if ((Object)(object)val2 != (Object)null) { return val2; } } return null; } } internal class SpriteHelper { private static readonly Dictionary<string, Sprite> _spriteCache = new Dictionary<string, Sprite>(); internal static Sprite FindSpriteByName(string spriteName) { if (_spriteCache.TryGetValue(spriteName, out var value)) { return value; } Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>(); foreach (Sprite val in array) { if (((Object)val).name == spriteName) { _spriteCache[spriteName] = val; return val; } } return null; } } } namespace CardRenderer.SliceVariants { internal static class SliceTextures2D { internal static readonly Dictionary<string, string> UISprites = new Dictionary<string, string> { { "UI9SliceBlue", "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" }, { "UI9SliceBlueFilled", "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" }, { "UI9SliceOrange", "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" }, { "UI9SliceOrangeFilled", "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" }, { "UI9SliceDeepRed", "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" }, { "UI9SliceDeepRedFilled", "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" }, { "UI9SliceBlack", "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" }, { "UI9SliceBlackFilled", "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" }, { "UI9SliceDeepBlue", "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" }, { "UI9SliceDeepBlueFilled", "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" }, { "UI9SliceDeepOrange", "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" }, { "UI9SliceDeepOrangeFilled", "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAYAAAB5fY51AAAAAXNSR0IB2cksfwAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAEcALAAVTxpkSQAAAAlwSFlzAAALEwAACxMBAJqcGAAADwNJREFUeAHt2z2y41gZx+HprslJICGekEWQsQ5WxjrIZhGExCSQsIKhTlPntttXll99/yU9DvD9OJZePcf3V3JT8+Wnmz7++udffrvppbvsCwj87dd/frnAZUy+hFtctDhNfl94wQkF7hCxSwZLoE7412bk1QWuGLDLBEukVn+/O+BFBK4UrlMHS6Qu8hflMnYTOHu8Thksodrt/e1EFxY4Y7xOFSyhuvBfj0s7TOBM4TpFsITqsPeyE99I4Azhig6WUN3or8WlxggkhysyWEIV8941yI0FEsMVFyyxuvFfiEuPE0iLVkywhCruvWogAh8CKeE6PFhC9fGe8AWBeIGjw3VosMQq/v1pQAKfBI6M1iHBEqpP7wE/IHAqgaOitXuwxOpU70vDEhgV2DtcuwZLrEb33i8JnFJgz2jtFiyxOuV70dAESgJ7RWuXYIlVac8tInBqgT2itXmwxOrU70HDE5gksHW0Ng2WWE3aa4sJXEJgy2htEiyhusT7zkUQmC2wVbRWD5ZYzd5jLyRwKYEtovX1UkIuhgCBGIEtbl5WvcPaYsAYfYMQIDBLYM07rdWCJVaz9tKLCNxCYK1orRIssbrFe85FElgksEa0FgdLrBbtoRcTuJXA0mgtCpZY3eq95mIJrCKwJFr+X8JVtsBBCBDYQ2D2HZa7qz22xzkIXFNg7l3WrGCJ1TXfRK6KwJ4Cc6I1+SOhWO25pc5FgMCjwORgPb7Y1wQIEJgrMOfmZ9JHwjknmHsxXkeAwD0Epnw0LN9hidU93jyukkCyQDlYyRdhNgIEzisw5WaoFKwpBzwvm8kJEEgXKAUr/SLMR4DAuQWqN0Vv/9G9eqBzc5meAIEEgXf/AO8OK2GXzECAQElg9A7L3VXJ0CICBFYUGLvLcoe1IrRDESCwrcDLOyx3V9vCOzoBAq8FXt1lucN6beY3BAiECQwGy91V2C4ZhwCBbwKDwWJDgACBIwVe3TR9CtarhUcO79wECBBoAp+ChYUAAQIJAkM3T4KVsDNmIECgJPBDsIaKVjqKRQQIENhB4Idg7XA+pyBAgEBZ4PkmSrDKdBYSIHC0wEewnkt29GDOT4AAgWeBj2A9/8L3BAgQSBB4vJkSrIQdMQMBAiUBwSoxWUSAQILAt2A93nIlDGUGAgQIDAm4wxpS8TMCBKIE+k2VYEVti2EIEBgTEKwxHb8jQCBKQLCitsMwBAiMCXztnw3HFvkdAQIEEgS+CFbCNpiBAIGKgI+EFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECEQICFbENhiCAIGKgGBVlKwhQCBCQLAitsEQBAhUBASromQNAQIRAoIVsQ2GIECgIiBYFSVrCBCIEBCsiG0wBAECFQHBqihZQ4BAhIBgRWyDIQgQqAgIVkXJGgIEIgQEK2IbDEGAQEVAsCpK1hAgECEgWBHbYAgCBCoCglVRsoYAgQgBwYrYBkMQIFAREKyKkjUECBwu8K///PcnwTp8GwxAgEBV4GurlgcBAgTOIOAO6wy7ZEYCBL4JCJY3AgECpxEQrNNslUEJEBAs7wECBOIF+r+1fwtW/yZ+agMSIHBrAXdYt95+F0/gXAKCda79Mi2B2wk8fgIUrNttvwsmcF6Bj2A9Vuy8l2NyAgSuLPARrCtfpGsjQOAaAj8Ey13WNTbVVRC4isBzk34I1lUu0nUQIHBNAcG65r66KgKXFPgUrOdbsEtetYsiQCBeYKhFn4IVfxUGJEDgtgKCddutd+EEcgWG7q7+/o9/fxkM1tDi3EszGQECdxH42qp1l4t1nQQI5AuM3TAN3mG1Sxp7Uf4lm5AAgSsKvAzWFS/WNREgkC3w7kZpNFjvXpx96aYjQOBqAqPButrFuh4CBHIFxm6Q+r+1fwtW/2boUsYOMrTezwgQILCVgDusrWQdlwCBskD1xqgUrOrBytNZSIAAgaLA4yfAUrDacUWrqGsZAQKTBKa05SNYjxWbdDaLCRAgMFNgSqzaKT6CVTnf1INXjmkNAQIEqgKf/rOcv/zpD7+9e/Eff/+7d0v8ngABAqMClRug509+k+6wRs/ulwQIECgKVGI1dKhZwZp7sqEB/IwAAQJVgU8fCdsLKx8L2zofDZuCBwECUwSqNzzPHwfbOWbdYfXhqifu6z0TIHBvgaXNWBSse9O7egIEpghMidXQ3VU712CwXi0eGm7KEEOv9zMCBAhUBQaDVX1xXydaXcIzAQJDAlMaMXbD9DJYYy9aOtDQ6/2MAIFrCkyJ1TuBl8F698Kh36852NDx/YwAgXMJTG3Cuxul0WC9e/EQ3dQBh47hZwQInF9gixaMBmsu2RaDzp3F6wgQ2F9gTgMqN0hvg1U5yBDHnIGHjuNnBAicS2DLv/23wVpCteXgS+byWgIEthGY+zdfvTEqBat6sCGCuRcwdCw/I0AgV2CPv/XB/5bwFUn1vzEcer3/7nBIxc8IXENgSaym3BCV7rDWIF1yQWuc3zEIEFhfoP1dL/nbnhKrNv2kYE09+DPP0ot7Pp7vCRA4TmBJqOZOPekjYT/Jko+G/Rg+InYJzwTOJ7BGrObcAE26w1qTdY0LXnMexyJA4L3AWp+S5sSqTTcrWHNP9syx1sU/H9f3BAisL5BwkzHrI2GnWOOjYT+Wj4hdwjOBLIG1Q7XkhmdRsBrrmtFqxxOupuBBIEMgKVZN5OcMlu9TdCDh+m7iKwJ7C/S/wzXPu+TOqs8x69+w+ovb8xpDPB6vf93AtkDrx/dMgMBngfS/u8UfCfslr/3RsB+3PbvbetTwNYH1Bba+OVjrxma1YDXCLaPVt0i8uoRnAssFtg5Vm3CtWLVjrRqsdsA9otXOI1xNwYPAPIE9QtUmWzNW7XirB6sddK9otXO1h3j938H/EhgT2CtSfYa1Y9WOu0mw2oH3jlY7p3A1BQ8CPwrsHap29i1i1Y67WbDawY+IVjtvfwhYl/B8J4EjAvXou1Ws2jk2DVY7wdHRajP0h4B1Cc9XEjg6UI+WW8aqnWfzYLWTJEWrzfP4ELFHDV+nCyTF6dlq61i18+0SrHai5Gi1+TwIEJgvsEes2nS7BaudTLSaggeB6wjsFaoutmuw2klFq9N7JnBugb1j1bR2D1bfIuHqEp4JnE/giFg1pcOC1U4uWk3Bg8B5BI4KVRc6NFh9COHqEp4J5AocHasmExGsNohoNQUPAnkCCaHqKjHB6gMJV5fwTOB4gaRYNY24YPUtEq4u4ZnA/gJpoeoCscHqAwpXl/BMYHuB1FD1K48PVhtUtPp2eSawjUB6qPpVnyJYfdj2LF6PGr4msEzgLKHqV3m6YPXBhatLeCYwXeBsoepXeNpg9Qtoz+L1qOFrAsMCZ43U49VcIlj9goSrS3gm8F3gCqHqV3OpYPWL6s8C1iU830ngSoF63rdLB+v5YgXsWcT3VxC4cqCe9+dWwXq++Pa9iA2p+FmqwJ3iNLQH/wPdEz0lBkbeCgAAAABJRU5ErkJggg==" }, { "UI9SliceDeepGreen", "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" }, { "UI9SliceDeepGreenFilled", "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" }, { "UI9SliceDeepPurple", "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsCAYAAAB5fY51AAAAAXNSR0IB2cksfwAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAZiS0dEAC0AKgB11acWTwAAAAlw
CardsShared.dll
Decompiled a month agousing System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using UnityEngine; [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.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: AssemblyCompany("CardsShared")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0+746a5efe9166a66401b133f5116270c598c45555")] [assembly: AssemblyProduct("CardsShared")] [assembly: AssemblyTitle("CardsShared")] [assembly: AssemblyVersion("1.0.0.0")] namespace CardsShared; public enum Category { Tower, DOT, Building, Buff, Monster } public enum Subcategory { Ballista, Mortar, TeslaCoil, FrostKeep, FlameThrower, PoisonSprayer, Shredder, Encampment, Lookout, VampireLair, Cannon, Monument, Radar, Obelisk, ParticleCannon, DOTBleed, DOTBurn, DOTPoison, ManaSiphon, Mine, ManaBank, HauntedHouse, University, DrawBuff, GoldBuff, ManaBuff, CritsBuff, TowerBuff, TreeBuff, MonsterHealthBuff, MonsterArmorBuff, MonsterShieldBuff, MonsterDamageBuff, MonsterMoveSpeedBuff, MonsterSlowDebuff, MonsterHasteBuff, MonsterTowerDamageBuff, MonsterGoldDebuff } [Flags] public enum AcquisitionType { None = 0, AlwaysInRun = 1, StoreUnlocksInRun = 2, StoreAppliesPermanent = 4 } public class CardDisplayData { public string Title; public string Description; public string SpriteName; public Sprite Sprite; public string UnlockName; public bool UnlockedByDefault; public bool Unlocked; public List<string> Unlocks; public Category Category; public Subcategory Subcategory; public AcquisitionType AcquisitionType; } public class CardTree { public CardDisplayData Card; public List<CardTree> Children = new List<CardTree>(); } public static class CardTreeBuilder { public static List<CardTree> BuildCardTrees(List<CardDisplayData> cards) { List<CardDisplayData> list = cards.Where((CardDisplayData c) => !string.IsNullOrEmpty(c.UnlockName)).ToList(); HashSet<string> reverseLookup = new HashSet<string>(from unlock in list.Where((CardDisplayData c) => c.Unlocks != null).SelectMany((CardDisplayData c) => c.Unlocks) where !string.IsNullOrEmpty(unlock) select unlock); List<CardDisplayData> source = list.Where((CardDisplayData c) => !reverseLookup.Contains(c.UnlockName)).ToList(); Dictionary<string, CardTree> nodeMap = new Dictionary<string, CardTree>(); foreach (CardDisplayData item in list) { if (nodeMap.ContainsKey(item.UnlockName)) { Debug.LogWarning((object)("[CardTreeBuilder] Duplicate UnlockName detected and skipped: " + item.UnlockName)); continue; } nodeMap[item.UnlockName] = new CardTree { Card = item }; } foreach (CardTree value2 in nodeMap.Values) { List<string> unlocks = value2.Card.Unlocks; if (unlocks == null) { continue; } foreach (string item2 in unlocks) { if (!string.IsNullOrEmpty(item2) && nodeMap.TryGetValue(item2, out var value)) { value2.Children.Add(value); } } } return (from r in source where nodeMap.ContainsKey(r.UnlockName) select nodeMap[r.UnlockName]).ToList(); } } public static class CardTreeUtils { public static List<CardDisplayData> GetAllDescendants(CardTree root) { List<CardDisplayData> list = new List<CardDisplayData>(); CollectDescendants(root, list); return list; } private static void CollectDescendants(CardTree node, List<CardDisplayData> collected) { foreach (CardTree child in node.Children) { collected.Add(child.Card); CollectDescendants(child, collected); } } }
