Add wip caching

MiraAPI/Modifiers/ModifierDisplay/ModifierDisplayComponent.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using HarmonyLib;
 using Il2CppInterop.Runtime.Attributes;
 using MiraAPI.LocalSettings;
+using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
 using Reactor.Utilities.Attributes;
 using Reactor.Utilities.Extensions;
@@ -137,7 +138,7 @@ public class ModifierDisplayComponent(nint cppPtr) : MonoBehaviour(cppPtr)
     internal void DestroyComponent(ModifierUiComponent component)
     {
         _modifiers.Remove(component.Modifier!);
-        component.gameObject.DestroyImmediate();
+        component.gameObject.DeepDestroy();
         RefreshModifiers();
     }
 
@@ -207,7 +208,7 @@ public class ModifierDisplayComponent(nint cppPtr) : MonoBehaviour(cppPtr)
                 continue;
             }
 
-            mod.Value.gameObject.Destroy();
+            mod.Value.gameObject.DeepDestroy();
             _modifiers.Remove(mod.Key);
         }
 

MiraAPI/Patches/Freeplay/TaskAdderPatches.cs

@@ -276,8 +276,9 @@ public static class TaskAdderPatches
             __instance.transform.FindChild("TitleText_TMP")?.gameObject.DestroyImmediate();
         }
 
-        __instance.ActiveItems.ToArray().Do(x => x.gameObject.Destroy());
+        __instance.ActiveItems.ToArray().Do(x => x.gameObject.DeepDestroy(false));
         __instance.ActiveItems.Clear();
+        Utilities.Extensions.ClearGarbageCollector();
 
         float num = 0f;
         float num2 = 0f;

MiraAPI/Patches/HudManagerPatches.cs

@@ -143,8 +143,9 @@ public static class HudManagerPatches
 
         foreach (var t in BottomLeft.GetComponentsInChildren<ActionButton>(true))
         {
-            t.gameObject.Destroy();
+            t.gameObject.DeepDestroy(false);
         }
+        Utilities.Extensions.ClearGarbageCollector();
 
         var gridArrange = BottomLeft.GetComponent<GridArrange>();
         var aspectPosition = BottomLeft.GetComponent<AspectPosition>();

MiraAPI/Patches/Menu/HatsTabPatches.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using AmongUs.Data;
+using HarmonyLib;
+using MiraAPI.Utilities;
+using MiraAPI.Utilities.Assets;
+using Reactor.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.Patches.Menu;
+
+[HarmonyPatch(typeof(HatsTab))]
+public static class HatsTabPatches
+{
+    private static SortedList<string, List<HatData>> sortedHats = [];
+    private static int currentPage;
+
+    private static void PreviousPage(HatsTab hatsTab)
+    {
+        currentPage--;
+        currentPage = currentPage < 0 ? sortedHats.Count - 1 : currentPage;
+        GenerateHats(hatsTab, currentPage);
+    }
+
+    private static void NextPage(HatsTab hatsTab)
+    {
+        currentPage++;
+        currentPage = currentPage > sortedHats.Count - 1 ? 0 : currentPage;
+        GenerateHats(hatsTab, currentPage);
+    }
+
+    [HarmonyPatch(nameof(HatsTab.OnEnable))]
+    [HarmonyPrefix]
+    public static bool OnEnablePrefix(HatsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableHatsExist)
+        {
+            return true;
+        }
+        __instance.currentHat = HatManager.Instance.GetHatById(DataManager.Player.Customization.Hat);
+        var allHats = HatManager.Instance.GetUnlockedHats().ToImmutableList();
+
+        if (sortedHats.Count == 0)
+        {
+            var comparer = new ControllableComparer<string>(["vanilla"], [], StringComparer.InvariantCulture);
+            sortedHats = new SortedList<string, List<HatData>>(comparer);
+            foreach (var hat in allHats)
+            {
+                if (!sortedHats.ContainsKey(hat.StoreName)) sortedHats[hat.StoreName] = [];
+                sortedHats[hat.StoreName].Add(hat);
+            }
+        }
+
+        InventoryUtility.CreateNextBackButtons(__instance, PreviousPage, NextPage);
+
+        GenerateHats(__instance, currentPage);
+
+        return false;
+    }
+
+    [HarmonyPatch(typeof(HatsTab), nameof(HatsTab.Update))]
+    [HarmonyPrefix]
+    public static void UpdatePrefix(HatsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableHatsExist)
+        {
+            return;
+        }
+        if (sortedHats.Count == 0) return;
+
+        if (Input.GetKeyDown(KeyCode.LeftControl) || Input.GetKeyDown(KeyCode.RightControl) || Input.GetKeyDown(KeyCode.LeftArrow))
+        {
+            PreviousPage(__instance);
+        }
+        else if (Input.GetKeyDown(KeyCode.Tab) || Input.GetKeyDown(KeyCode.RightArrow))
+        {
+            NextPage(__instance);
+        }
+    }
+
+    private static IEnumerator? loadRoutine;
+    private static int hatIndex;
+
+    private static void GenerateHats(HatsTab __instance, int page)
+    {
+        if (loadRoutine != null) Coroutines.Stop(loadRoutine);
+
+        hatIndex = 0;
+        foreach (var instanceColorChip in __instance.ColorChips) instanceColorChip.gameObject.DeepDestroy(false);
+        __instance.ColorChips.Clear();
+        __instance.scroller.Inner.GetComponentsInChildren<TextMeshPro>().Do(x => x.gameObject.DeepDestroy(false));
+        Utilities.Extensions.ClearGarbageCollector();
+
+        var groupNameText = __instance.GetComponentInChildren<TextMeshPro>(false);
+
+        var (groupName, hats) = sortedHats.ToArray()[page];
+        var text = Object.Instantiate(groupNameText, __instance.scroller.Inner);
+        text.enabled = true;
+        text.gameObject.transform.localScale = Vector3.one;
+        text.GetComponent<TextTranslatorTMP>().Destroy();
+        text.EnableStencilMasking();
+        text.text = $"{groupName} ({currentPage + 1}/{sortedHats.Count})";
+        text.alignment = TextAlignmentOptions.Center;
+        text.fontSize = 5f;
+        text.fontSizeMax = 5f;
+        text.fontSizeMin = 0f;
+        var xLerp = __instance.XRange.Lerp(0.5f);
+        var yLerp = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+        text.transform.localPosition = new Vector3(xLerp, yLerp, -1f);
+
+        hatIndex += 5;
+        loadRoutine = Coroutines.Start(CoGenerateChips(__instance, hats));
+    }
+
+    private static IEnumerator CoGenerateChips(HatsTab __instance, List<HatData> hats)
+    {
+        __instance.scroller.ScrollToTop();
+        var batchSize = 5;
+        for (var i = 0; i < hats.Count; i += batchSize)
+        {
+            var batch = hats.Skip(i).Take(batchSize).ToList();
+
+            foreach (var hat in batch.OrderBy(HatManager.Instance.allHats.IndexOf))
+            {
+                var hatXposition = __instance.XRange.Lerp(hatIndex % __instance.NumPerRow / (__instance.NumPerRow - 1f));
+                var hatYposition = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+                GenerateColorChip(__instance, new Vector2(hatXposition, hatYposition), hat);
+                hatIndex += 1;
+                yield return null;
+            }
+
+            __instance.SetScrollerBounds();
+            yield return new WaitForSeconds(0.01f);
+        }
+        __instance.currentHatIsEquipped = true;
+        loadRoutine = null;
+    }
+
+    private static void GenerateColorChip(HatsTab __instance, Vector2 position, HatData hat)
+    {
+        var colorChip = Object.Instantiate(__instance.ColorTabPrefab, __instance.scroller.Inner);
+        colorChip.gameObject.name = hat.ProductId;
+        if (ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard)
+        {
+            colorChip.Button.OnClick.AddListener((Action)__instance.ClickEquip);
+            colorChip.Button.OnMouseOver.AddListener((Action)(() => __instance.SelectHat(hat)));
+            colorChip.Button.OnMouseOut.AddListener((Action)(() => __instance.SelectHat(HatManager.Instance.GetHatById(DataManager.Player.Customization.Hat))));
+        }
+        else
+        {
+            colorChip.Button.OnClick.AddListener((Action)(() => __instance.SelectHat(hat)));
+        }
+
+        colorChip.Inner.SetHat(hat, __instance.HasLocalPlayer() ? PlayerControl.LocalPlayer.Data.DefaultOutfit.ColorId : DataManager.Player.Customization.Color);
+        colorChip.Button.ClickMask = __instance.scroller.Hitbox;
+        colorChip.SelectionHighlight.gameObject.SetActive(false);
+        __instance.UpdateMaterials(colorChip.Inner.FrontLayer, hat);
+        colorChip.Inner.SetMaskType(PlayerMaterial.MaskType.SimpleUI);
+        colorChip.transform.localPosition = new Vector3(position.x, position.y, -1f);
+        colorChip.Inner.transform.localPosition = hat.ChipOffset + new Vector2(0f, -0.3f);
+        colorChip.Tag = hat;
+        __instance.ColorChips.Add(colorChip);
+    }
+}

MiraAPI/Patches/Menu/InventoryUtility.cs

@@ -0,0 +1,54 @@
+using System;
+using MiraAPI.Utilities.Assets;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UI;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.Patches.Menu;
+
+public static class InventoryUtility
+{
+    public static void CreateNextBackButtons<T>(T tab, Action<T> previousPage, Action<T> nextPage) where T : InventoryTab
+    {
+        var title = tab.transform.FindChild("Text");
+        title.localPosition = new Vector3(.9123f, -.23f, -55);
+        title.GetComponent<TextMeshPro>().alignment = TextAlignmentOptions.Center;
+
+        tab.scroller.Hitbox.transform.localScale -= new Vector3(0, 0.1f, 0);
+        tab.scroller.Hitbox.transform.localPosition -= new Vector3(0, 0.1f, 0);
+
+        var leftButtonElement = Object.Instantiate(PlayerCustomizationMenu.Instance.BackButton.gameObject, tab.transform);
+        var leftSpriteRenderer = leftButtonElement.GetComponent<SpriteRenderer>();
+        var leftButton = leftButtonElement.GetComponent<PassiveButton>();
+
+        leftButtonElement.transform.localPosition = new Vector3(-1.1f, -0.2f, -55);
+        leftSpriteRenderer.sprite = MiraAssets.NextButton.LoadAsset();
+        leftSpriteRenderer.flipX = true;
+
+        leftButton.OnMouseOver = new UnityEvent();
+        leftButton.OnMouseOver.AddListener((Action)(() => leftSpriteRenderer.sprite = MiraAssets.NextButtonActive.LoadAsset()));
+        leftButton.OnMouseOut = new UnityEvent();
+        leftButton.OnMouseOut.AddListener((Action)(() => leftSpriteRenderer.sprite = MiraAssets.NextButton.LoadAsset()));
+
+        leftButton.OnClick = new Button.ButtonClickedEvent();
+        leftButton.OnClick.AddListener((Action)(() => previousPage(tab)));
+
+        var rightButtonElement = Object.Instantiate(leftButtonElement, tab.transform);
+        var rightSpriteRenderer = rightButtonElement.GetComponent<SpriteRenderer>();
+        var rightButton = rightButtonElement.GetComponent<PassiveButton>();
+
+        rightButtonElement.transform.localPosition = new Vector3(2.8f, -0.2f, -55);
+        rightSpriteRenderer.sprite = MiraAssets.NextButton.LoadAsset();
+        rightSpriteRenderer.flipX = false;
+
+        rightButton.OnMouseOver = new UnityEvent();
+        rightButton.OnMouseOver.AddListener((Action)(() => rightSpriteRenderer.sprite = MiraAssets.NextButtonActive.LoadAsset()));
+        rightButton.OnMouseOut = new UnityEvent();
+        rightButton.OnMouseOut.AddListener((Action)(() => rightSpriteRenderer.sprite = MiraAssets.NextButton.LoadAsset()));
+
+        rightButton.OnClick = new Button.ButtonClickedEvent();
+        rightButton.OnClick.AddListener((Action)(() => nextPage(tab)));
+    }
+}

MiraAPI/Patches/Menu/MainMenuManagerPatches.cs

@@ -20,6 +20,7 @@ public static class MainMenuManagerPatches
     [HarmonyPostfix]
     public static void AwakePostfix()
     {
+        AddressablesLoader.LoadAll();
         Coroutines.Start(SetFps());
     }
 

MiraAPI/Patches/Menu/NameplatesTabPatches.cs

@@ -0,0 +1,152 @@
+using AmongUs.Data;
+using HarmonyLib;
+using Innersloth.Assets;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MiraAPI.Utilities.Assets;
+using TMPro;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.Patches.Menu;
+
+[HarmonyPatch(typeof(NameplatesTab))]
+public static class NameplatesTabPatches
+{
+    private static readonly SortedList<string, List<NamePlateData>> SortedNameplates = new(new ControllableComparer<string>(["vanilla"], [], StringComparer.InvariantCulture));
+    private static int currentPage;
+    internal static void AddRange(IEnumerable<(string Key, NamePlateData Visor)> data)
+    {
+        foreach (var item in data)
+        {
+            if (!SortedNameplates.ContainsKey(item.Key)) SortedNameplates.Add(item.Key, []);
+            SortedNameplates[item.Key].Add(item.Visor);
+        }
+    }
+
+    private static void PreviousPage(NameplatesTab tab)
+    {
+        currentPage--;
+        currentPage = currentPage < 0 ? SortedNameplates.Count - 1 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+    private static void NextPage(NameplatesTab tab)
+    {
+        currentPage++;
+        currentPage = currentPage > SortedNameplates.Count - 1 ? 0 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+    [HarmonyPatch(nameof(NameplatesTab.OnEnable))]
+    [HarmonyPrefix]
+    public static bool OnEnablePrefix(NameplatesTab __instance)
+    {
+        if (!AddressablesLoader.AddressableNameplatesExist)
+        {
+            return true;
+        }
+        __instance.plateId = HatManager.Instance.GetNamePlateById(DataManager.Player.Customization.namePlate).ProdId;
+
+        if (!SortedNameplates.ContainsKey("Vanilla")) AddRange(DestroyableSingleton<HatManager>.Instance.GetUnlockedNamePlates().Select(x => ("Vanilla", x)));
+
+        InventoryUtility.CreateNextBackButtons(__instance, PreviousPage, NextPage);
+
+        GenerateHats(__instance, currentPage);
+
+        return false;
+    }
+
+    [HarmonyPatch(typeof(NameplatesTab), nameof(NameplatesTab.Update))]
+    [HarmonyPrefix]
+
+    public static void UpdatePrefix(NameplatesTab __instance)
+    {
+        if (!AddressablesLoader.AddressableNameplatesExist)
+        {
+            return;
+        }
+        if (Input.GetKeyDown(KeyCode.LeftControl) || Input.GetKeyDown(KeyCode.RightControl) || Input.GetKeyDown(KeyCode.LeftArrow))
+        {
+            PreviousPage(__instance);
+        }
+        else if (Input.GetKeyDown(KeyCode.Tab) || Input.GetKeyDown(KeyCode.RightArrow))
+        {
+            NextPage(__instance);
+        }
+    }
+
+    private static void GenerateHats(NameplatesTab __instance, int page)
+    {
+        foreach (var instanceColorChip in __instance.ColorChips) instanceColorChip.gameObject.DeepDestroy(false);
+        __instance.ColorChips.Clear();
+        __instance.scroller.Inner.GetComponentsInChildren<TextMeshPro>().Do(x => x.gameObject.DeepDestroy(false));
+        Utilities.Extensions.ClearGarbageCollector();
+
+        var groupNameText = __instance.GetComponentInChildren<TextMeshPro>(false);
+
+        int hatIndex = 0;
+
+        var (groupName, nameplates) = SortedNameplates.ToArray()[page];
+        var text = Object.Instantiate(groupNameText, __instance.scroller.Inner);
+        text.enabled = true;
+        text.gameObject.transform.localScale = Vector3.one;
+        text.GetComponent<TextTranslatorTMP>().Destroy();
+        text.EnableStencilMasking();
+        text.text = $"{groupName} ({currentPage + 1}/{SortedNameplates.Count})";
+        text.alignment = TextAlignmentOptions.Center;
+        text.fontSize = 5f;
+        text.fontSizeMax = 5f;
+        text.fontSizeMin = 0f;
+        float xLerp = __instance.XRange.Lerp(0.5f);
+        float yLerp = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+        text.transform.localPosition = new Vector3(xLerp, yLerp, -1f);
+
+        hatIndex += 2;
+        foreach (var visor in nameplates.OrderBy(HatManager.Instance.allNamePlates.IndexOf))
+        {
+            float hatXposition = __instance.XRange.Lerp(hatIndex % __instance.NumPerRow / (__instance.NumPerRow - 1f));
+            float hatYposition = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+            GenerateColorChip(__instance, new Vector2(hatXposition, hatYposition), visor);
+            hatIndex += 1;
+        }
+
+        __instance.SetScrollerBounds();
+        __instance.currentNameplateIsEquipped = true;
+    }
+
+    private static void GenerateColorChip(NameplatesTab __instance, Vector2 position, NamePlateData namePlate)
+    {
+        var colorChip = Object.Instantiate(__instance.ColorTabPrefab, __instance.scroller.Inner);
+        colorChip.gameObject.name = namePlate.ProductId;
+
+        if (ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard)
+        {
+            colorChip.Button.OnClick.AddListener((Action)__instance.ClickEquip);
+            colorChip.Button.OnMouseOver.AddListener((Action)(() => __instance.SelectNameplate(namePlate)));
+            colorChip.Button.OnMouseOut.AddListener(
+                (Action)(() => __instance.SelectNameplate(
+                    HatManager.Instance.GetNamePlateById(DataManager.Player.Customization.NamePlate))));
+        }
+        else
+        {
+            colorChip.Button.OnClick.AddListener((Action)(() => __instance.SelectNameplate(namePlate)));
+        }
+
+        colorChip.Button.ClickMask = __instance.scroller.Hitbox;
+        colorChip.ProductId = namePlate.ProdId;
+
+        var x = (NamePlateViewData viewdata) =>
+        {
+            colorChip.transform.GetChild(1).GetComponent<SpriteRenderer>().sprite = viewdata?.Image;
+            // (colorChip as NameplateChip).image.sprite = viewdata?.Image;
+        };
+        __instance.StartCoroutine(AddressableAssetExtensions.CoLoadAssetAsync<NamePlateViewData>(__instance, namePlate.GetAssetReference(), x));
+        colorChip.transform.localPosition = new Vector3(position.x, position.y, -1f);
+        colorChip.Tag = namePlate;
+        __instance.ColorChips.Add(colorChip);
+    }
+}

MiraAPI/Patches/Menu/SkinsTabPatches.cs

@@ -0,0 +1,149 @@
+using AmongUs.Data;
+using HarmonyLib;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using MiraAPI.Utilities.Assets;
+using TMPro;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.Patches.Menu;
+
+[HarmonyPatch(typeof(SkinsTab))]
+public static class SkinsTabPatches
+{
+    private static SortedList<string, List<SkinData>> sortedSkins = [];
+    private static int currentPage;
+
+    private static void PreviousPage(SkinsTab tab)
+    {
+        currentPage--;
+        currentPage = currentPage < 0 ? sortedSkins.Count - 1 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+    private static void NextPage(SkinsTab tab)
+    {
+        currentPage++;
+        currentPage = currentPage > sortedSkins.Count - 1 ? 0 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+    [HarmonyPatch(nameof(SkinsTab.OnEnable))]
+    [HarmonyPrefix]
+    public static bool OnEnablePrefix(SkinsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableSkinsExist)
+        {
+            return true;
+        }
+        __instance.skinId = HatManager.Instance.GetSkinById(DataManager.Player.Customization.Skin).ProdId;
+        var allSkins = HatManager.Instance.GetUnlockedSkins().ToImmutableList();
+
+        if (sortedSkins.Count == 0)
+        {
+            var comparer = new ControllableComparer<string>(["vanilla"], [], StringComparer.InvariantCulture);
+            sortedSkins = new SortedList<string, List<SkinData>>(comparer);
+            foreach (var skin in allSkins)
+            {
+                if (!sortedSkins.ContainsKey(skin.StoreName)) sortedSkins[skin.StoreName] = [];
+                sortedSkins[skin.StoreName].Add(skin);
+            }
+        }
+
+        InventoryUtility.CreateNextBackButtons(__instance, PreviousPage, NextPage);
+
+        GenerateHats(__instance, currentPage);
+
+        return false;
+    }
+
+    [HarmonyPatch(typeof(SkinsTab), nameof(SkinsTab.Update))]
+    [HarmonyPrefix]
+
+    public static void UpdatePrefix(SkinsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableSkinsExist)
+        {
+            return;
+        }
+        if (Input.GetKeyDown(KeyCode.LeftControl) || Input.GetKeyDown(KeyCode.RightControl) || Input.GetKeyDown(KeyCode.LeftArrow))
+        {
+            PreviousPage(__instance);
+        }
+        else if (Input.GetKeyDown(KeyCode.Tab) || Input.GetKeyDown(KeyCode.RightArrow))
+        {
+            NextPage(__instance);
+        }
+    }
+
+    private static void GenerateHats(SkinsTab __instance, int page)
+    {
+        foreach (var instanceColorChip in __instance.ColorChips) instanceColorChip.gameObject.DeepDestroy(false);
+        __instance.ColorChips.Clear();
+        __instance.scroller.Inner.GetComponentsInChildren<TextMeshPro>().Do(x => x.gameObject.DeepDestroy(false));
+        Utilities.Extensions.ClearGarbageCollector();
+
+        var groupNameText = __instance.GetComponentInChildren<TextMeshPro>(false);
+
+        int hatIndex = 0;
+
+        var (groupName, skins) = sortedSkins.ToArray()[page];
+        var text = Object.Instantiate(groupNameText, __instance.scroller.Inner);
+        text.enabled = true;
+        text.gameObject.transform.localScale = Vector3.one;
+        text.GetComponent<TextTranslatorTMP>().Destroy();
+        text.EnableStencilMasking();
+        text.text = $"{groupName} ({currentPage + 1}/{sortedSkins.Count})";
+        text.alignment = TextAlignmentOptions.Center;
+        text.fontSize = 5f;
+        text.fontSizeMax = 5f;
+        text.fontSizeMin = 0f;
+        float xLerp = __instance.XRange.Lerp(0.5f);
+        float yLerp = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+        text.transform.localPosition = new Vector3(xLerp, yLerp, -1f);
+
+        hatIndex += 5;
+        foreach (var skin in skins.OrderBy(HatManager.Instance.allSkins.IndexOf))
+        {
+            float hatXposition = __instance.XRange.Lerp(hatIndex % __instance.NumPerRow / (__instance.NumPerRow - 1f));
+            float hatYposition = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+            GenerateColorChip(__instance, new Vector2(hatXposition, hatYposition), skin);
+            hatIndex += 1;
+        }
+
+        __instance.SetScrollerBounds();
+        __instance.currentSkinIsEquipped = true;
+    }
+
+    private static void GenerateColorChip(SkinsTab __instance, Vector2 position, SkinData skin)
+    {
+        var colorChip = Object.Instantiate(__instance.ColorTabPrefab, __instance.scroller.Inner);
+        colorChip.gameObject.name = skin.ProductId;
+        if (ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard)
+        {
+            colorChip.Button.OnClick.AddListener((Action)__instance.ClickEquip);
+            colorChip.Button.OnMouseOver.AddListener((Action)(() => __instance.SelectSkin(skin)));
+            colorChip.Button.OnMouseOut.AddListener(
+                (Action)(() =>
+                    __instance.SelectSkin(HatManager.Instance.GetSkinById(DataManager.Player.Customization.Skin))));
+        }
+        else
+        {
+            colorChip.Button.OnClick.AddListener((Action)(() => __instance.SelectSkin(skin)));
+        }
+        colorChip.Button.ClickMask = __instance.scroller.Hitbox;
+        colorChip.ProductId = skin.ProductId;
+        colorChip.SelectionHighlight.gameObject.SetActive(false);
+        __instance.UpdateMaterials(colorChip.Inner.FrontLayer, skin);
+        skin.SetPreview(colorChip.Inner.FrontLayer, __instance.HasLocalPlayer() ? PlayerControl.LocalPlayer.Data.DefaultOutfit.ColorId : DataManager.Player.Customization.Color);
+        colorChip.transform.localPosition = new Vector3(position.x, position.y, -1f);
+        colorChip.Inner.transform.localPosition = skin.ChipOffset + new Vector2(0f, -0.3f);
+        colorChip.Tag = skin;
+        __instance.ColorChips.Add(colorChip);
+    }
+}

MiraAPI/Patches/Menu/VisorsTabPatches.cs

@@ -0,0 +1,149 @@
+using AmongUs.Data;
+using HarmonyLib;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MiraAPI.Utilities.Assets;
+using TMPro;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.Patches.Menu;
+
+[HarmonyPatch(typeof(VisorsTab))]
+public static class VisorsTabPatches
+{
+    private static readonly SortedList<string, List<VisorData>> SortedVisors = new(new ControllableComparer<string>(["vanilla"], [], StringComparer.InvariantCulture));
+    private static int currentPage;
+    internal static void AddRange(IEnumerable<(string Key, VisorData Visor)> data)
+    {
+        foreach (var item in data)
+        {
+            if (!SortedVisors.ContainsKey(item.Key)) SortedVisors.Add(item.Key, []);
+            SortedVisors[item.Key].Add(item.Visor);
+        }
+    }
+
+    private static void PreviousPage(VisorsTab tab)
+    {
+        currentPage--;
+        currentPage = currentPage < 0 ? SortedVisors.Count - 1 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+    private static void NextPage(VisorsTab tab)
+    {
+        currentPage++;
+        currentPage = currentPage > SortedVisors.Count - 1 ? 0 : currentPage;
+        GenerateHats(tab, currentPage);
+    }
+
+
+    [HarmonyPatch(nameof(VisorsTab.OnEnable))]
+    [HarmonyPrefix]
+    public static bool OnEnablePrefix(VisorsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableVisorsExist)
+        {
+            return true;
+        }
+        __instance.visorId = HatManager.Instance.GetVisorById(DataManager.Player.Customization.Visor).ProdId;
+
+        if (!SortedVisors.ContainsKey("Vanilla")) AddRange(DestroyableSingleton<HatManager>.Instance.GetUnlockedVisors().Select(x => ("Vanilla", x)));
+
+        InventoryUtility.CreateNextBackButtons(__instance, PreviousPage, NextPage);
+
+        GenerateHats(__instance, currentPage);
+
+        return false;
+    }
+
+    [HarmonyPatch(typeof(VisorsTab), nameof(VisorsTab.Update))]
+    [HarmonyPrefix]
+
+    public static void UpdatePrefix(VisorsTab __instance)
+    {
+        if (!AddressablesLoader.AddressableVisorsExist)
+        {
+            return;
+        }
+        if (Input.GetKeyDown(KeyCode.LeftControl) || Input.GetKeyDown(KeyCode.RightControl) || Input.GetKeyDown(KeyCode.LeftArrow))
+        {
+            PreviousPage(__instance);
+        }
+        else if (Input.GetKeyDown(KeyCode.Tab) || Input.GetKeyDown(KeyCode.RightArrow))
+        {
+            NextPage(__instance);
+        }
+    }
+
+    private static void GenerateHats(VisorsTab __instance, int page)
+    {
+        foreach (var instanceColorChip in __instance.ColorChips) instanceColorChip.gameObject.DeepDestroy(false);
+        __instance.ColorChips.Clear();
+        __instance.scroller.Inner.GetComponentsInChildren<TextMeshPro>().Do(x => x.gameObject.DeepDestroy(false));
+        Utilities.Extensions.ClearGarbageCollector();
+
+        var groupNameText = __instance.GetComponentInChildren<TextMeshPro>(false);
+
+        int hatIndex = 0;
+
+        var (groupName, visors) = SortedVisors.ToArray()[page];
+        var text = Object.Instantiate(groupNameText, __instance.scroller.Inner);
+        text.enabled = true;
+        text.gameObject.transform.localScale = Vector3.one;
+        text.GetComponent<TextTranslatorTMP>().Destroy();
+        text.EnableStencilMasking();
+        text.text = $"{groupName} ({currentPage + 1}/{SortedVisors.Count})";
+        text.alignment = TextAlignmentOptions.Center;
+        text.fontSize = 5f;
+        text.fontSizeMax = 5f;
+        text.fontSizeMin = 0f;
+        float xLerp = __instance.XRange.Lerp(0.5f);
+        float yLerp = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+        text.transform.localPosition = new Vector3(xLerp, yLerp, -1f);
+
+        hatIndex += 5;
+        foreach (var visor in visors.OrderBy(HatManager.Instance.allVisors.IndexOf))
+        {
+            float hatXposition = __instance.XRange.Lerp(hatIndex % __instance.NumPerRow / (__instance.NumPerRow - 1f));
+            float hatYposition = __instance.YStart - hatIndex / __instance.NumPerRow * __instance.YOffset;
+            GenerateColorChip(__instance, new Vector2(hatXposition, hatYposition), visor);
+            hatIndex += 1;
+        }
+
+        __instance.SetScrollerBounds();
+        __instance.currentVisorIsEquipped = true;
+    }
+
+    private static void GenerateColorChip(VisorsTab __instance, Vector2 position, VisorData visor)
+    {
+        var colorChip = Object.Instantiate(__instance.ColorTabPrefab, __instance.scroller.Inner);
+        colorChip.gameObject.name = visor.ProductId;
+
+        if (ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard)
+        {
+            colorChip.Button.OnClick.AddListener((Action)__instance.ClickEquip);
+            colorChip.Button.OnMouseOver.AddListener((Action)(() => __instance.SelectVisor(visor)));
+            colorChip.Button.OnMouseOut.AddListener(
+                (Action)(() =>
+                    __instance.SelectVisor(HatManager.Instance.GetVisorById(DataManager.Player.Customization.Visor))));
+        }
+        else
+        {
+            colorChip.Button.OnClick.AddListener((Action)(() => __instance.SelectVisor(visor)));
+        }
+
+        colorChip.Button.ClickMask = __instance.scroller.Hitbox;
+        colorChip.ProductId = visor.ProductId;
+        colorChip.SelectionHighlight.gameObject.SetActive(false);
+        __instance.UpdateMaterials(colorChip.Inner.FrontLayer, visor);
+        visor.SetPreview(colorChip.Inner.FrontLayer, __instance.HasLocalPlayer() ? PlayerControl.LocalPlayer.Data.DefaultOutfit.ColorId : DataManager.Player.Customization.Color);
+        colorChip.transform.localPosition = new Vector3(position.x, position.y, -1f);
+        colorChip.Inner.transform.localPosition = visor.ChipOffset + new Vector2(0f, -0.3f);
+        colorChip.Tag = visor;
+        __instance.ColorChips.Add(colorChip);
+    }
+}

MiraAPI/Patches/Options/GameOptionsMenuPatch.cs

@@ -139,11 +139,25 @@ internal static class GameOptionsMenuPatch
 
     private static void CustomMenuOneCreate(GameOptionsMenu menu)
     {
-        var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
-            .Where(x => x.ParentMenu == MenuCategory.CustomOne) ?? [];
-        foreach (var group in groups)
+        var existing = GameSettingMenuPatches.CachedGameSettings.FirstOrDefault(x => x.ModId == GameSettingMenuPatches.SelectedModIdx && x.Category == MenuCategory.CustomOne);
+        if (existing != null)
         {
-            CreateGroup(menu, group);
+            GameSettingMenuPatches.ShowGameOptions(existing, menu);
+        }
+        else
+        {
+            var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
+                .Where(x => x.ParentMenu == MenuCategory.CustomOne) ?? [];
+            foreach (var group in groups)
+            {
+                CreateGroup(menu, group);
+            }
+            GameSettingMenuPatches.AddGameSettings(
+                MenuCategory.CustomOne,
+                menu.Children,
+                menu.settingsContainer
+                    .GetComponentsInChildren<CategoryHeaderMasked>()
+                    .ToList());
         }
     }
 
@@ -160,11 +174,25 @@ internal static class GameOptionsMenuPatch
 
     private static void CustomMenuTwoCreate(GameOptionsMenu menu)
     {
-        var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
-            .Where(x => x.ParentMenu == MenuCategory.CustomTwo) ?? [];
-        foreach (var group in groups)
+        var existing = GameSettingMenuPatches.CachedGameSettings.FirstOrDefault(x => x.ModId == GameSettingMenuPatches.SelectedModIdx && x.Category == MenuCategory.CustomTwo);
+        if (existing != null)
         {
-            CreateGroup(menu, group);
+            GameSettingMenuPatches.ShowGameOptions(existing, menu);
+        }
+        else
+        {
+            var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
+                .Where(x => x.ParentMenu == MenuCategory.CustomTwo) ?? [];
+            foreach (var group in groups)
+            {
+                CreateGroup(menu, group);
+            }
+            GameSettingMenuPatches.AddGameSettings(
+                MenuCategory.CustomTwo,
+                menu.Children,
+                menu.settingsContainer
+                    .GetComponentsInChildren<CategoryHeaderMasked>()
+                    .ToList());
         }
     }
 
@@ -181,11 +209,25 @@ internal static class GameOptionsMenuPatch
 
     private static void ModifiersCreate(GameOptionsMenu menu)
     {
-        var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
-            .Where(x => x.ShowInModifiersMenu || x.OptionableType?.IsAssignableTo(typeof(BaseModifier)) == true) ?? [];
-        foreach (var group in groups)
+        var existing = GameSettingMenuPatches.CachedGameSettings.FirstOrDefault(x => x.ModId == GameSettingMenuPatches.SelectedModIdx && x.Category == MenuCategory.Modifiers);
+        if (existing != null)
         {
-            CreateGroup(menu, group);
+            GameSettingMenuPatches.ShowGameOptions(existing, menu);
+        }
+        else
+        {
+            var groups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
+                .Where(x => x.ShowInModifiersMenu || x.OptionableType?.IsAssignableTo(typeof(BaseModifier)) == true) ?? [];
+            foreach (var group in groups)
+            {
+                CreateGroup(menu, group);
+            }
+            GameSettingMenuPatches.AddGameSettings(
+                MenuCategory.Modifiers,
+                menu.Children,
+                menu.settingsContainer
+                    .GetComponentsInChildren<CategoryHeaderMasked>()
+                    .ToList());
         }
     }
 
@@ -217,12 +259,20 @@ internal static class GameOptionsMenuPatch
             return false;
         }
 
-        var filteredGroups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
-            .Where(x => x.OptionableType == null && !x.ShowInModifiersMenu && x.ParentMenu == MenuCategory.Roles) ?? [];
-
-        foreach (var group in filteredGroups)
+        var existing = GameSettingMenuPatches.CachedGameSettings.FirstOrDefault(x => x.ModId == GameSettingMenuPatches.SelectedModIdx && x.Category == MenuCategory.Game);
+        if (existing != null)
         {
-            CreateGroup(__instance, group);
+            GameSettingMenuPatches.ShowGameOptions(existing, __instance);
+        }
+        else
+        {
+            var filteredGroups = GameSettingMenuPatches.SelectedMod?.InternalOptionGroups
+                .Where(x => x.OptionableType == null && !x.ShowInModifiersMenu && x.ParentMenu == MenuCategory.Roles) ?? [];
+
+            foreach (var group in filteredGroups)
+            {
+                CreateGroup(__instance, group);
+            }
         }
 
         return false;

MiraAPI/Patches/Options/GamePresetsTabPatches.cs

@@ -262,7 +262,7 @@ internal static class GamePresetsTabPatches
             iconSpriteRend.sprite = MiraAssets.RefreshIcon.LoadAsset();
 
             Helpers.DivideSize(refreshButton.gameObject, 2f);
-            refreshButton.buttonText.gameObject.Destroy();
+            refreshButton.buttonText.gameObject.DeepDestroy();
 
             refreshButton.OnClick = new Button.ButtonClickedEvent();
             refreshButton.OnClick.AddListener((UnityAction)Refresh);

MiraAPI/Patches/Options/GameSettingMenuPatches.cs

@@ -6,6 +6,7 @@ using MiraAPI.GameOptions;
 using MiraAPI.Modifiers;
 using MiraAPI.PluginLoading;
 using MiraAPI.Presets;
+using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
 using Reactor.Utilities.Extensions;
 using TMPro;
@@ -40,6 +41,140 @@ internal static class GameSettingMenuPatches
     private static PassiveButton? _customTwoButton;
     private static GameObject? _nextModButton;
     private static GameObject? _previousModButton;
+    public static List<GameSettingsCache> CachedGameSettings { get; } = [];
+    public static List<RoleSettingsCache> CachedRoleSettings { get; } = [];
+
+    public sealed class GameSettingsCache
+    {
+        public int ModId { get; set; }
+        public MenuCategory Category { get; set; } = MenuCategory.Game;
+        public Il2CppSystem.Collections.Generic.List<OptionBehaviour> Options { get; set; }
+        public List<CategoryHeaderMasked> CategoryHeaders { get; set; }
+        public GameObject CacheHolder { get; set; }
+    }
+    public static GameSettingsCache GetCurrentSettings(MenuCategory category)
+    {
+        var existing = CachedGameSettings.FirstOrDefault(x => x.ModId == SelectedModIdx && x.Category == category);
+        if (existing != null)
+        {
+            return existing;
+        }
+
+        var menu = category switch
+        {
+            MenuCategory.Modifiers => _modifiersTab!,
+            MenuCategory.CustomOne => _customOneTab!,
+            MenuCategory.CustomTwo => _customTwoTab!,
+            _ => GameSettingMenu.Instance.GameSettingsTab,
+        };
+        return AddGameSettings(
+            category,
+            menu.Children,
+            menu.settingsContainer
+                .GetComponentsInChildren<CategoryHeaderMasked>()
+                .ToList());
+    }
+    public static GameSettingsCache AddGameSettings(MenuCategory category, Il2CppSystem.Collections.Generic.List<OptionBehaviour> options, List<CategoryHeaderMasked> categoryHeaders)
+    {
+        var modName = SelectedMod?.MiraPlugin.OptionsTitleText ?? "Vanilla";
+        var newHolder = new GameObject($"{modName} {category}");
+        newHolder.DontUnload().DontDestroy();
+        newHolder.SetActive(false);
+        var newCache = new GameSettingsCache
+        {
+            ModId = SelectedModIdx,
+            Category = category,
+            Options = options,
+            CategoryHeaders = categoryHeaders,
+            CacheHolder = newHolder,
+        };
+        CachedGameSettings.Add(newCache);
+        return newCache;
+    }
+    public static void HideGameOptions(GameSettingsCache cached, GameOptionsMenu gameOptMenu)
+    {
+        foreach (var obj in gameOptMenu.scrollBar.Inner.GetComponentsInChildren<Transform>())
+        {
+            if (obj.gameObject.name == "MapPicker" || !obj.gameObject)
+            {
+                continue;
+            }
+            obj.SetParent(cached.CacheHolder.transform);
+        }
+    }
+    public static void ShowGameOptions(GameSettingsCache cached, GameOptionsMenu gameOptMenu)
+    {
+        foreach (var obj in cached.CacheHolder.GetComponentsInChildren<Transform>())
+        {
+            if (!obj.gameObject)
+            {
+                continue;
+            }
+            obj.SetParent(gameOptMenu.scrollBar.Inner);
+        }
+    }
+    public sealed class RoleSettingsCache
+    {
+        public int ModId { get; set; }
+        public Il2CppSystem.Collections.Generic.List<OptionBehaviour> Options { get; set; }
+        public List<CategoryHeaderEditRole> RoleHeaders { get; set; }
+        public List<RoleOptionSetting> RoleOptions { get; set; }
+        public List<CategoryHeaderEditRole> CategoryHeaders { get; set; }
+        public GameObject CacheHolder { get; set; }
+    }
+    public static RoleSettingsCache GetCurrentRoleSettings()
+    {
+        var existing = CachedRoleSettings.FirstOrDefault(x => x.ModId == SelectedModIdx);
+        if (existing != null)
+        {
+            return existing;
+        }
+
+        var menu = GameSettingMenu.Instance.RoleSettingsTab;
+        return AddRoleSettings(
+            menu.advancedSettingChildren,
+            menu.RoleChancesSettings
+                .GetComponentsInChildren<CategoryHeaderEditRole>()
+                .ToList());
+    }
+    public static RoleSettingsCache AddRoleSettings(Il2CppSystem.Collections.Generic.List<OptionBehaviour> options, List<CategoryHeaderEditRole> categoryHeaders)
+    {
+        var modName = SelectedMod?.MiraPlugin.OptionsTitleText ?? "Vanilla";
+        var newHolder = new GameObject($"{modName} Roles");
+        newHolder.DontUnload().DontDestroy();
+        newHolder.SetActive(false);
+        var newCache = new RoleSettingsCache
+        {
+            ModId = SelectedModIdx,
+            Options = options,
+            CategoryHeaders = categoryHeaders,
+            CacheHolder = newHolder,
+        };
+        CachedRoleSettings.Add(newCache);
+        return newCache;
+    }
+    public static void HideRoleOptions(RoleSettingsCache cached, RolesSettingsMenu gameOptMenu)
+    {
+        foreach (var obj in gameOptMenu.scrollBar.Inner.GetComponentsInChildren<Transform>())
+        {
+            if (obj.gameObject.name == "MapPicker" || !obj.gameObject)
+            {
+                continue;
+            }
+            obj.SetParent(cached.CacheHolder.transform);
+        }
+    }
+    public static void ShowRoleOptions(RoleSettingsCache cached, RolesSettingsMenu gameOptMenu)
+    {
+        foreach (var obj in cached.CacheHolder.GetComponentsInChildren<Transform>())
+        {
+            if (!obj.gameObject)
+            {
+                continue;
+            }
+            obj.SetParent(gameOptMenu.scrollBar.Inner);
+        }
+    }
 
     private static Dictionary<int, Vector3> OptionsPositions { get; } = [];
     private static Dictionary<int, Vector3> ModifiersPositions { get; } = [];
@@ -564,21 +699,6 @@ internal static class GameSettingMenuPatches
         CleanupTab(settings, roles);
     }
 
-    private static void ClearOptions(Il2CppSystem.Collections.Generic.List<OptionBehaviour> options)
-    {
-        foreach (var child in options)
-        {
-            if (child.TryCast<GameOptionsMapPicker>() || !child.gameObject)
-            {
-                continue;
-            }
-
-            child.gameObject.DestroyImmediate();
-        }
-
-        options.Clear();
-    }
-
     private static void CleanupTab(GameOptionsMenu settings, RolesSettingsMenu roles)
     {
         if (roles.roleChances != null)
@@ -608,24 +728,10 @@ internal static class GameSettingMenuPatches
 
         void CleanupRoleSettings(RolesSettingsMenu rolesMenu)
         {
-            if (rolesMenu.advancedSettingChildren != null)
-            {
-                ClearOptions(rolesMenu.advancedSettingChildren);
-                rolesMenu.advancedSettingChildren = null;
-            }
+            HideRoleOptions(GetCurrentRoleSettings(), rolesMenu);
+            rolesMenu.advancedSettingChildren = null;
 
-            rolesMenu.RoleChancesSettings
-                .transform
-                .GetComponentsInChildren<CategoryHeaderEditRole>()
-                .ToList()
-                .ForEach(header => header.gameObject.DestroyImmediate());
-
-            foreach (var role in rolesMenu.roleChances)
-            {
-                role.gameObject.DestroyImmediate();
-            }
-
-            rolesMenu.roleChances?.Clear();
+            rolesMenu.roleChances.Clear();
 
             rolesMenu.AdvancedRolesSettings.gameObject.SetActive(false);
             rolesMenu.RoleChancesSettings.gameObject.SetActive(true);
@@ -643,14 +749,16 @@ internal static class GameSettingMenuPatches
 
         void CleanupSettings(GameOptionsMenu gameOptMenu, MenuCategory menuCategory = MenuCategory.Roles)
         {
-            ClearOptions(gameOptMenu.Children);
+            if (menuCategory is MenuCategory.Roles)
+            {
+                HideRoleOptions(GetCurrentRoleSettings(), gameOptMenu.RolesMenu);
+            }
+            else
+            {
+                HideGameOptions(GetCurrentSettings(menuCategory), gameOptMenu);
+            }
             gameOptMenu.Children = null;
 
-            gameOptMenu.settingsContainer
-                .GetComponentsInChildren<CategoryHeaderMasked>()
-                .ToList()
-                .ForEach(header => header.gameObject.DestroyImmediate());
-
             gameOptMenu.Initialize();
             var positions = OptionsPositions;
             switch (menuCategory)

MiraAPI/Patches/Options/RoleSettingMenuPatches.cs

@@ -41,12 +41,6 @@ public static class RoleSettingMenuPatches
     {
         HudManager.Instance.PlayerCam.OverrideScreenShakeEnabled = false;
     }
-    [HarmonyPostfix]
-    [HarmonyPatch(nameof(RolesSettingsMenu.OnDisable))]
-    public static void ClosePatch(RolesSettingsMenu __instance)
-    {
-        HudManager.Instance.PlayerCam.OverrideScreenShakeEnabled = true;
-    }
 
     [HarmonyPostfix]
     [HarmonyPatch(nameof(RolesSettingsMenu.SetQuotaTab))]
@@ -59,9 +53,11 @@ public static class RoleSettingMenuPatches
     [HarmonyPatch(nameof(RolesSettingsMenu.SetQuotaTab))]
     public static bool SetQuotaTabPatch(RolesSettingsMenu __instance)
     {
-        Headers.ForEach(Object.Destroy);
-        RoleOptionSettings.ForEach(Object.Destroy);
+        GameSettingMenuPatches.HideRoleOptions(GameSettingMenuPatches.GetCurrentRoleSettings(), __instance);
+        __instance.advancedSettingChildren = null;
+
         Headers.Clear();
+        __instance.roleChances.Clear();
         RoleOptionSettings.Clear();
         CurrentRole = null;
         CurrentRoleOptions = null;
@@ -139,6 +135,7 @@ public static class RoleSettingMenuPatches
                 num3++;
             }
 
+            Utilities.Extensions.ClearGarbageCollector();
             return false;
         }
 
@@ -160,6 +157,7 @@ public static class RoleSettingMenuPatches
 
         if (roleGroups is null)
         {
+            Utilities.Extensions.ClearGarbageCollector();
             return false;
         }
 
@@ -210,9 +208,9 @@ public static class RoleSettingMenuPatches
             var blankLabel = quotaInst.transform.FindChild("BlankLabel").gameObject;
             var chanceLabel = quotaInst.transform.FindChild("Chance Label").gameObject;
             var countLabel = quotaInst.transform.FindChild("# Label").gameObject;
-            blankLabel.Destroy();
-            chanceLabel.Destroy();
-            countLabel.Destroy();
+            blankLabel.DeepDestroy(false);
+            chanceLabel.DeepDestroy(false);
+            countLabel.DeepDestroy(false);
 
             categoryHeaderMasked.Background.sprite = MiraAssets.CategoryHeader.LoadAsset();
             categoryHeaderMasked.Background.sprite.texture.filterMode = FilterMode.Bilinear;
@@ -295,15 +293,10 @@ public static class RoleSettingMenuPatches
                     {
                         RoleGroupHidden[group] = !groupHidden;
                     }
-                    foreach (var header in Headers)
-                    {
-                        header.Destroy();
-                    }
+                    GameSettingMenuPatches.HideRoleOptions(GameSettingMenuPatches.GetCurrentRoleSettings(), __instance);
+                    __instance.advancedSettingChildren = null;
                     Headers.Clear();
-                    foreach (var option in RoleOptionSettings)
-                    {
-                        option.gameObject.Destroy();
-                    }
+                    __instance.roleChances.Clear();
                     RoleOptionSettings.Clear();
                     __instance.SetQuotaTab();
                 }));
@@ -314,6 +307,7 @@ public static class RoleSettingMenuPatches
                 ScrollerNum -= 0.4f;
             }
         }
+        Utilities.Extensions.ClearGarbageCollector();
 
         __instance.scrollBar.SetScrollBounds(__instance);
         return false;
@@ -428,8 +422,9 @@ public static class RoleSettingMenuPatches
     {
         foreach (var optBehaviour in __instance.AdvancedRolesSettings.GetComponentsInChildren<OptionBehaviour>())
         {
-            optBehaviour.gameObject.DestroyImmediate();
+            optBehaviour.gameObject.DeepDestroy(false);
         }
+        Utilities.Extensions.ClearGarbageCollector();
 
         CurrentRole = role;
         __instance.advancedSettingChildren.Clear();
@@ -624,7 +619,7 @@ public static class RoleSettingMenuPatches
             var newButton = Object.Instantiate(roleOptionSetting.buttons[0], roleOptionSetting.transform);
             newButton.name = "ConfigButton";
             newButton.transform.localPosition = new Vector3(0.4473f, -0.3f, -2f);
-            newButton.transform.FindChild("Text_TMP").gameObject.DestroyImmediate();
+            newButton.transform.FindChild("Text_TMP").gameObject.DeepDestroy();
             newButton.activeSprites.Destroy();
 
             var btnRend = newButton.transform.FindChild("ButtonSprite").GetComponent<SpriteRenderer>();

MiraAPI/Patches/Roles/HowToPlayPatch.cs

@@ -22,22 +22,18 @@ internal static class HowToPlayPatch
         __instance.startPage.SetActive(false);
         if (__instance.roleButtonsParent.childCount == 0)
         {
-            using (IEnumerator<RoleBehaviour> enumerator = RoleManager.Instance.AllRoles.ToArray().Where(x => !x.IsCustomRole()).GetEnumerator())
+            foreach (var role in RoleManager.Instance.AllRoles.ToArray().Where(x => !x.IsCustomRole()))
             {
-                while (enumerator.MoveNext())
+                if (!role.IsSimpleRole && role.Role != RoleTypes.CrewmateGhost && role.Role != RoleTypes.ImpostorGhost)
                 {
-                    RoleBehaviour role = enumerator.Current;
-                    if (!role.IsSimpleRole && role.Role != RoleTypes.CrewmateGhost && role.Role != RoleTypes.ImpostorGhost)
+                    HowToPlayRoleButton component = Object.Instantiate(__instance.roleButtonPrefab, __instance.roleButtonsParent).GetComponent<HowToPlayRoleButton>();
+                    Sprite roleIcon = __instance.rolesScenes.ToArray().First(r => r.role == role.Role).roleIcon;
+                    component.SetRoleInfo(role, roleIcon);
+                    component.SetButtonAction((Il2CppSystem.Action)(() =>
                     {
-                        HowToPlayRoleButton component = Object.Instantiate(__instance.roleButtonPrefab, __instance.roleButtonsParent).GetComponent<HowToPlayRoleButton>();
-                        Sprite roleIcon = __instance.rolesScenes.ToArray().First(r => r.role == role.Role).roleIcon;
-                        component.SetRoleInfo(role, roleIcon);
-                        component.SetButtonAction((Il2CppSystem.Action)(() =>
-                        {
-                            __instance.OpenRolePage(role.Role);
-                        }));
-                        __instance.controllerSelectables.Add(component.GetComponent<PassiveButton>());
-                    }
+                        OpenRolePage(__instance, role.Role);
+                    }));
+                    __instance.controllerSelectables.Add(component.GetComponent<PassiveButton>());
                 }
             }
             foreach (UiElement uiElement in __instance.controllerSelectables)
@@ -50,4 +46,23 @@ internal static class HowToPlayPatch
         __instance.roleSelectionScene.SetActive(true);
         ControllerManager.Instance.SetDefaultSelection(__instance.defaultButtonSelected, null);
     }
+    public static void OpenRolePage(HowToPlayScene instance, RoleTypes roleType)
+    {
+        instance.category = HowToPlayScene.HowToPlayCategory.Roles;
+        var newList = instance.rolesScenes.ToArray().ToList();
+        var buttonList = instance.roleButtons;
+        instance.sceneIndex = newList.FindIndex(r => r.role == roleType);
+        if (roleType != RoleTypes.Crewmate)
+        {
+            foreach (var button in buttonList)
+            {
+                if (button.GetRole().Role == roleType)
+                {
+                    instance.previouslySelectedRoleButton = button.GetComponent<PassiveButton>();
+                }
+            }
+        }
+        instance.SetupDots(instance.rolesScenes[instance.sceneIndex].rolePages.Count);
+        instance.ChangeScene(0);
+    }
 }

MiraAPI/Patches/Roles/HudManagerPatches.cs

@@ -1,7 +1,9 @@
 using HarmonyLib;
 using InnerNet;
 using MiraAPI.Roles;
+using MiraAPI.Utilities;
 using Reactor.Utilities.Extensions;
+using UnityEngine;
 
 namespace MiraAPI.Patches.Roles;
 
@@ -69,9 +71,9 @@ public static class HudManagerPatches
 
             CustomRoleManager.UpdateRoleTab(RoleTab, customRole);
         }
-        else if (RoleTab)
+        else if (RoleTab != null)
         {
-            RoleTab?.gameObject.Destroy();
+            RoleTab.gameObject.DeepDestroy();
         }
     }
 }

MiraAPI/Patches/Roles/RoleManagerPatches.cs

@@ -6,6 +6,7 @@ using MiraAPI.Events;
 using MiraAPI.Events.Vanilla.Gameplay;
 using MiraAPI.Modifiers;
 using MiraAPI.Roles;
+using MiraAPI.Utilities;
 using UnityEngine;
 
 namespace MiraAPI.Patches.Roles;
@@ -32,7 +33,7 @@ public static class RoleManagerPatches
         if (data.Role)
         {
             data.Role.Deinitialize(targetPlayer);
-            Object.Destroy(data.Role.gameObject);
+            data.Role.gameObject.DeepDestroy();
         }
         var roleBehaviour = Object.Instantiate<RoleBehaviour>(__instance.AllRoles.ToArray().First(r => r.Role == roleType), data.gameObject.transform);
         roleBehaviour.Initialize(targetPlayer);

MiraAPI/Patches/VentCanUsePatch.cs

@@ -28,7 +28,7 @@ internal static class VentCanUsePatch
         var @object = pc.Object;
         var role = @object.Data.Role;
 
-        var canVent = role is ICustomRole customRole ? customRole.Configuration.CanUseVent : role.CanVent;
+        var canVent = role is ICustomRole customRole ? customRole.Configuration.CanUseVent || customRole.Configuration.GetsVentData : role.CanVent;
         couldUse = canVent;
 
         var modifiers = @object.GetModifierComponent().ActiveModifiers;

MiraAPI/Presets/PresetManager.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using BepInEx.Configuration;
 using MiraAPI.PluginLoading;
 using MiraAPI.Roles;
+using MiraAPI.Utilities;
 using Reactor.Utilities;
 using UnityEngine;
 
@@ -61,9 +62,10 @@ public static class PresetManager
         {
             if (btn != null)
             {
-                Object.DestroyImmediate(btn);
+                btn.DeepDestroy(false);
             }
         }
+        Utilities.Extensions.ClearGarbageCollector();
 
         plugin.InternalPresets.Clear();
         if (!Directory.Exists(PresetDirectory))

MiraAPI/Presets/SavePresetPopup.cs

@@ -26,7 +26,7 @@ public class SavePresetPopup(nint cppPtr) : Minigame(cppPtr)
     // Cleanup holder object
     public void OnDestroy()
     {
-        transform.parent.gameObject.Destroy();
+        transform.parent.gameObject.DeepDestroy();
     }
 
     public override void Close()

MiraAPI/Roles/CustomRoleConfiguration.cs

@@ -109,10 +109,15 @@ public record struct CustomRoleConfiguration
     public bool UseVanillaKillButton { get; set; }
 
     /// <summary>
-    /// Gets or sets a value indicating whether the role can use vents.
+    /// Gets or sets a value indicating whether the role can use vents. Also sends vanilla vent data.
     /// </summary>
     public bool CanUseVent { get; set; }
 
+    /// <summary>
+    /// Gets or sets a value indicating whether the role can receive vanilla vent data.
+    /// </summary>
+    public bool GetsVentData { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether the role can use the sabotage button.
     /// </summary>

MiraAPI/Roles/CustomRoleManager.cs

@@ -123,7 +123,7 @@ public static class CustomRoleManager
 
         if (roleBehaviour is not ICustomRole customRole)
         {
-            roleBehaviour.gameObject.Destroy();
+            roleBehaviour.gameObject.DeepDestroy();
             return null;
         }
 
@@ -139,7 +139,7 @@ public static class CustomRoleManager
         roleBehaviour.CanBeKilled = customRole.Configuration.CanGetKilled;
         roleBehaviour.CanUseKillButton = customRole.Configuration.UseVanillaKillButton;
         roleBehaviour.TasksCountTowardProgress = customRole.Configuration.TasksCountForProgress;
-        roleBehaviour.CanVent = customRole.Configuration.CanUseVent;
+        roleBehaviour.CanVent = customRole.Configuration.CanUseVent || customRole.Configuration.GetsVentData;
         roleBehaviour.DefaultGhostRole = customRole.Configuration.GhostRole;
         roleBehaviour.MaxCount = customRole.Configuration.MaxRoleCount;
         roleBehaviour.RoleScreenshot = customRole.Configuration.OptionsScreenshot?.LoadAsset();

MiraAPI/Utilities/Assets/AddressablesLoader.cs

@@ -10,10 +10,40 @@ using UnityEngine.ResourceManagement.AsyncOperations;
 namespace MiraAPI.Utilities.Assets;
 
 /// <summary>
-/// The component for loading Addressables, and cosmetics. This is deprecated in favor of Corsac Cosmetics.
+/// The component for loading Addressables, and cosmetics.
 /// </summary>
 public static class AddressablesLoader
 {
+    private static bool _isInitialized;
+
+    private static readonly List<(string Location, string ProviderSuffix)> CatalogLocations = [];
+    private static readonly List<string> LoadedLocations = [];
+
+    private static readonly List<string> RegisteredHatKeys = [];
+    private static readonly List<(string, string)> RegisteredVisorKeys = [];
+    private static readonly List<(string, string)> RegisteredNameplateKeys = [];
+    private static readonly List<string> RegisteredSkinKeys = [];
+
+    /// <summary>
+    /// Gets a value indicating whether hats have been loaded by the addressables system.
+    /// </summary>
+    public static bool AddressableHatsExist { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether visors have been loaded by the addressables system.
+    /// </summary>
+    public static bool AddressableVisorsExist { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether nameplates have been loaded by the addressables system.
+    /// </summary>
+    public static bool AddressableNameplatesExist { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether skins have been loaded by the addressables system.
+    /// </summary>
+    public static bool AddressableSkinsExist { get; private set; }
+
     /// <summary>
     /// Registers a specific addressables package to load asynchronously at the start of the game, when possible.
     /// </summary>
@@ -21,7 +51,13 @@ public static class AddressablesLoader
     /// <param name="providerSuffix">The suffix of the provider for an addressables package.</param>
     public static void RegisterCatalog(string location, string providerSuffix = "")
     {
-        Error("Catalogs are no longer possible to load in MiraAPI! Please use Corsac Cosmetics instead.");
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized, cannot register more catalogs.");
+            return;
+        }
+
+        CatalogLocations.Add((location, providerSuffix));
     }
 
     /// <summary>
@@ -30,7 +66,14 @@ public static class AddressablesLoader
     /// <param name="addressablesKey">The key/label/group for a List <see cref="HatData"/>.</param>
     public static void RegisterHats(string addressablesKey)
     {
-        Error("Hats are no longer possible to load in MiraAPI! Please use Corsac Cosmetics instead.");
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized, cannot register more keys for hats.");
+            return;
+        }
+
+        AddressableHatsExist = true;
+        RegisteredHatKeys.Add(addressablesKey);
     }
 
     /// <summary>
@@ -39,7 +82,14 @@ public static class AddressablesLoader
     /// <param name="addressablesKey">The key/label/group for a List <see cref="SkinData"/>.</param>
     public static void RegisterSkins(string addressablesKey)
     {
-        Error("Skins are no longer possible to load in MiraAPI! Please use Corsac Cosmetics instead.");
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized, cannot register more keys for skins.");
+            return;
+        }
+
+        AddressableSkinsExist = true;
+        RegisteredSkinKeys.Add(addressablesKey);
     }
 
     /// <summary>
@@ -49,7 +99,14 @@ public static class AddressablesLoader
     /// /// <param name="groupTitle">The title of the group for visors.</param>
     public static void RegisterNameplates(string addressablesKey, string groupTitle)
     {
-        Error("Nameplates are no longer possible to load in MiraAPI! Please use Corsac Cosmetics instead.");
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized, cannot register more keys for nameplates.");
+            return;
+        }
+
+        AddressableNameplatesExist = true;
+        RegisteredNameplateKeys.Add((addressablesKey, groupTitle));
     }
 
     /// <summary>
@@ -59,6 +116,131 @@ public static class AddressablesLoader
     /// <param name="groupTitle">The title of the group for visors.</param>
     public static void RegisterVisors(string addressablesKey, string groupTitle)
     {
-        Error("Visors are no longer possible to load in MiraAPI! Please use Corsac Cosmetics instead.");
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized, cannot register more keys for visors.");
+            return;
+        }
+
+        AddressableVisorsExist = true;
+        RegisteredVisorKeys.Add((addressablesKey, groupTitle));
+    }
+
+    internal static void LoadAll()
+    {
+        if (_isInitialized)
+        {
+            Error("AddressablesLoader has already been initialized.");
+            return;
+        }
+
+        _isInitialized = true;
+        foreach (var (location, providerSuffix) in CatalogLocations)
+        {
+            Coroutines.Start(CoLoadAddressables(location, providerSuffix));
+        }
+
+        Coroutines.Start(LoadCosmetics());
+    }
+
+    internal static IEnumerator CoLoadAddressables(string location, string suffix = "")
+    {
+        while (!AmongUsClient.Instance) yield return null;
+        // Load the local/remote content catalog
+        var catalogOperation = Addressables.LoadContentCatalog(location, suffix);
+        yield return catalogOperation;
+
+        // Check for errors
+        if (catalogOperation.Status != AsyncOperationStatus.Succeeded)
+        {
+            Error($"Failed to load catalog {location}.");
+        }
+
+        Info($"Loaded addressables {location}.");
+        LoadedLocations.Add(location);
+    }
+
+    [HideFromIl2Cpp]
+    internal static IEnumerator LoadCosmetics()
+    {
+        while (!AmongUsClient.Instance || CatalogLocations.Select(x=>x.Location).Any(x=>!LoadedLocations.Contains(x))) yield return null;
+
+        var hatBehaviours = DiscoverData<HatData>(RegisteredHatKeys);
+        var skinBehaviours = DiscoverData<SkinData>(RegisteredSkinKeys);
+        var namePlateBehaviours = DiscoverAndReportData<NamePlateData>(RegisteredNameplateKeys);
+        var visorBehaviours = DiscoverAndReportData<VisorData>(RegisteredVisorKeys);
+
+        var hatData = new List<HatData>();
+        hatData.AddRange(DestroyableSingleton<HatManager>.Instance.allHats);
+        hatData.ForEach(x => x.StoreName = "Vanilla");
+        DestroyableSingleton<HatManager>.Instance.allHats = PrepareArray(hatData, hatBehaviours);
+
+        var skinData = new List<SkinData>();
+        skinData.AddRange(DestroyableSingleton<HatManager>.Instance.allSkins);
+        skinData.ForEach(x => x.StoreName = "Vanilla");
+        DestroyableSingleton<HatManager>.Instance.allSkins = PrepareArray(skinData, skinBehaviours);
+
+        var visorData = new List<VisorData>();
+        visorData.AddRange(DestroyableSingleton<HatManager>.Instance.allVisors);
+        VisorsTabPatches.AddRange(visorBehaviours);
+        DestroyableSingleton<HatManager>.Instance.allVisors = PrepareArray(visorData, visorBehaviours.Select(x=>x.Data).ToList());
+
+        var namePlateData = new List<NamePlateData>();
+        namePlateData.AddRange(DestroyableSingleton<HatManager>.Instance.allNamePlates);
+        NameplatesTabPatches.AddRange(namePlateBehaviours);
+        DestroyableSingleton<HatManager>.Instance.allNamePlates = PrepareArray(namePlateData, namePlateBehaviours.Select(x => x.Data).ToList());
+    }
+
+    private static T[] PrepareArray<T>(List<T> data, List<T> behaviours) where T : CosmeticData
+    {
+        var count = data.Count;
+        for (int i = 0; i < behaviours.Count; i++)
+        {
+            behaviours[i].displayOrder = count + i;
+            data.Add(behaviours[i]);
+        }
+        return data.ToArray();
+    }
+
+    private static List<T> DiscoverData<T>(List<string> tags)
+    {
+        var behaviours = new List<T>();
+
+        foreach (var tag in tags)
+        {
+            try
+            {
+                var allLocations = Addressables.LoadResourceLocationsAsync(tag).WaitForCompletion();
+                var assets = Addressables.LoadAssetsAsync<T>(allLocations, null, false).WaitForCompletion();
+                var array = new Il2CppSystem.Collections.Generic.List<T>(assets.Pointer);
+                behaviours.AddRange(array.ToArray());
+            }
+            catch
+            {
+                Error($"Failed to find tag {tag}");
+            }
+        }
+        return behaviours;
+    }
+
+    private static List<(string Category, T Data)> DiscoverAndReportData<T>(List<(string Tag, string Category)> tags)
+    {
+        var behaviours = new List<(string, T)>();
+
+        foreach (var tag in tags)
+        {
+            try
+            {
+                var allLocations = Addressables.LoadResourceLocationsAsync(tag.Tag).WaitForCompletion();
+                var assets = Addressables.LoadAssetsAsync<T>(allLocations, null, false).WaitForCompletion();
+                var array = new Il2CppSystem.Collections.Generic.List<T>(assets.Pointer);
+                behaviours.AddRange(array.ToArray().Select(x => (tag.Category, x)));
+            }
+            catch
+            {
+                Error($"Failed to find tag {tag}");
+            }
+        }
+        return behaviours;
     }
 }

MiraAPI/Utilities/Extensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -53,7 +54,7 @@ public static class Extensions
         bool isComplete;
         if (self.amClosing == Minigame.CloseState.Closing)
         {
-            UnityEngine.Object.Destroy(self.gameObject);
+            self.gameObject.DeepDestroy();
             return;
         }
         if (self.CloseSound && Constants.ShouldPlaySfx())
@@ -219,6 +220,121 @@ public static class Extensions
         return Mathf.Approximately(number, Mathf.Round(number));
     }
 
+    /// <summary>
+    /// Destroys the object properly.
+    /// </summary>
+    /// <param name="obj">The object to destroy.</param>
+    /// <param name="clearGc">Whether to run the garbage collector immediately.</param>
+    public static void DeepDestroy(this GameObject? obj, bool clearGc = true)
+    {
+        Coroutines.Start(Nuke(obj, clearGc));
+    }
+
+    private static IEnumerator Nuke(GameObject? go, bool clearGc)
+    {
+        if (go == null)
+            yield break;
+
+        try
+        {
+            go.transform.SetParent(null, false);
+        }
+        catch
+        {
+            // ignored
+        }
+
+        try
+        {
+            go.SetActive(false);
+        }
+        catch
+        {
+            // ignored
+        }
+
+        foreach (var mb in go.GetComponentsInChildren<MonoBehaviour>(true))
+        {
+            if (mb == null)
+                continue;
+
+            try
+            {
+                mb.StopAllCoroutines();
+            }
+            catch
+            {
+                // ignored
+            }
+
+            try
+            {
+                mb.enabled = false;
+            }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        foreach (var renderer in go.GetComponentsInChildren<Renderer>(true))
+        {
+            if (renderer == null)
+                continue;
+
+            try
+            {
+                foreach (var mat in renderer.materials)
+                {
+                    if (mat != null)
+                        UnityEngine.Object.Destroy(mat);
+                }
+            }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        foreach (var filter in go.GetComponentsInChildren<MeshFilter>(true))
+        {
+            if (filter == null)
+                continue;
+
+            try
+            {
+                var mesh = filter.mesh;
+                if (mesh != null)
+                    UnityEngine.Object.Destroy(mesh);
+            }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        UnityEngine.Object.Destroy(go);
+        yield return null;
+        if (clearGc)
+        {
+            yield return CoFreeResources();
+        }
+    }
+
+    public static void ClearGarbageCollector()
+    {
+        Coroutines.Start(CoFreeResources());
+    }
+
+    private static IEnumerator CoFreeResources()
+    {
+        yield return Resources.UnloadUnusedAssets();
+
+        GC.Collect(0, GCCollectionMode.Forced, blocking: true);
+        GC.WaitForPendingFinalizers();
+        GC.Collect(0, GCCollectionMode.Forced, blocking: true);
+    }
+
     /// <summary>
     /// Gets a cache of player's vote data components to improve performance.
     /// </summary>

MiraAPI/Utilities/Helpers.cs

@@ -539,7 +539,7 @@ public static class Helpers
     }
 
     /// <summary>
-    /// Returns whether the role is blacklisted from appearing and spawning. (Only applicable to vanilla roles)
+    /// Returns whether the role is blacklisted from appearing and spawning. Only applicable to vanilla roles.
     /// </summary>
     /// <param name="role">The role to check.</param>
     /// <returns>The role's blacklist status.</returns>