Merge branch 'dev' into android

# Conflicts:
#	AmongUs.props

MiraAPI.Example/Buttons/Freezer/FreezeButton.cs

@@ -3,10 +3,10 @@ using MiraAPI.Example.Options.Roles;
 using MiraAPI.Example.Roles;
 using MiraAPI.GameOptions;
 using MiraAPI.Hud;
+using MiraAPI.Keybinds;
 using MiraAPI.Modifiers;
 using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
-using Rewired;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons.Freezer;
@@ -16,12 +16,10 @@ public class FreezeButton : CustomActionButton<PlayerControl>
     public override string Name => "Freeze";
 
     public override float Cooldown => OptionGroupSingleton<FreezerRoleSettings>.Instance.FreezeDuration;
-
-    public override int MaxUses => (int)OptionGroupSingleton<FreezerRoleSettings>.Instance.FreezeUses;
+    public override bool PauseTimerInVent => true;
 
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
-    public override KeyboardKeyCode Defaultkeybind => KeyboardKeyCode.T;
-    public override ModifierKey Modifier1 => ModifierKey.Control;
+    public override MiraKeybind? Keybind => MiraGlobalKeybinds.PrimaryAbility;
 
     protected override void OnClick()
     {

MiraAPI.Example/Buttons/MeetingButton.cs

@@ -1,8 +1,8 @@
 using MiraAPI.Example.Modifiers;
 using MiraAPI.Hud;
+using MiraAPI.Keybinds;
 using MiraAPI.Modifiers;
 using MiraAPI.Utilities.Assets;
-using Rewired;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons;
@@ -16,9 +16,7 @@ public class MeetingButton : CustomActionButton
     public override int MaxUses => 3;
 
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
-    public override KeyboardKeyCode Defaultkeybind => KeyboardKeyCode.P;
-    public override ModifierKey Modifier1 => ModifierKey.Control;
-    public override ModifierKey Modifier2 => ModifierKey.Shift;
+    public override MiraKeybind? Keybind => MiraGlobalKeybinds.ModifierPrimaryAbility;
 
     public override bool Enabled(RoleBehaviour? role)
     {

MiraAPI.Example/Buttons/NeutralKillerButton.cs

@@ -2,8 +2,8 @@
 using MiraAPI.Example.Roles;
 using MiraAPI.GameEnd;
 using MiraAPI.Hud;
+using MiraAPI.Keybinds;
 using MiraAPI.Utilities.Assets;
-using Rewired;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons;
@@ -13,7 +13,8 @@ public class NeutralKillerButton : CustomActionButton
     public override string Name => "Win Game";
     public override float Cooldown => 0f;
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
-    public override KeyboardKeyCode Defaultkeybind => KeyboardKeyCode.K;
+    public override MiraKeybind Keybind => ExampleKeybinds.NeutralWinKeybind;
+
     protected override void OnClick()
     {
         CustomGameOver.Trigger<NeutralKillerGameOver>([PlayerControl.LocalPlayer.Data]);

MiraAPI.Example/Buttons/Teleporter/TeleportButton.cs

@@ -3,9 +3,9 @@ using MiraAPI.Example.Options.Roles;
 using MiraAPI.Example.Roles;
 using MiraAPI.GameOptions;
 using MiraAPI.Hud;
+using MiraAPI.Keybinds;
 using MiraAPI.Utilities.Assets;
 using Reactor.Utilities;
-using Rewired;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons.Teleporter;
@@ -22,7 +22,8 @@ public class TeleportButton : CustomActionButton
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.TeleportButton;
     public override Color TextOutlineColor => new Color32(221, 176, 152, 255);
     public static bool IsZoom { get; private set; }
-    public override KeyboardKeyCode Defaultkeybind => KeyboardKeyCode.M;
+    public override MiraKeybind? Keybind => MiraGlobalKeybinds.PrimaryAbility;
+
     public override bool Enabled(RoleBehaviour? role)
     {
         return role is TeleporterRole;

MiraAPI.Example/Buttons/ThinkButton.cs

@@ -0,0 +1,35 @@
+using MiraAPI.Hud;
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.Example.Buttons;
+
+public class ThinkButton : CustomActionButton
+{
+    public override string Name => "Think";
+    public override float Cooldown => 15f;
+    public override float EffectDuration => 10f;
+    public override int MaxUses => 1;
+    public override ButtonUsesMode UsesMode => ButtonUsesMode.PerRound;
+    public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
+    protected override void OnClick()
+    {
+        // This button does absolutely nothing besides changing its text
+        Button!.OverrideText("Thinking...");
+    }
+
+    public override void OnEffectEnd()
+    {
+        Button!.OverrideText("Think");
+    }
+
+    public override bool IsEffectCancellable()
+    {
+        return true;
+    }
+
+    public override bool Enabled(RoleBehaviour? role)
+    {
+        return role != null && role.IsImpostor;
+    }
+}

MiraAPI.Example/ExampleKeybinds.cs

@@ -0,0 +1,10 @@
+using MiraAPI.Keybinds;
+using Rewired;
+
+namespace MiraAPI.Example;
+
+[RegisterCustomKeybinds]
+public static class ExampleKeybinds
+{
+    public static MiraKeybind NeutralWinKeybind { get; } = new("Neutral Win", KeyboardKeyCode.C, [ModifierKey.Shift]);
+}

MiraAPI.Example/ExampleLocalSetings.cs

@@ -0,0 +1,53 @@
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings;
+using MiraAPI.LocalSettings.Attributes;
+using MiraAPI.Utilities;
+using UnityEngine;
+
+namespace MiraAPI.Example;
+
+public class ExampleLocalSettings(ConfigFile config) : LocalSettingsTab(config)
+{
+    public override string TabName => "Mira Example";
+    protected override bool ShouldCreateLabels => false;
+
+    public override LocalSettingTabAppearance TabAppearance => new()
+    {
+        ToggleActiveColor = Color.blue,
+        ToggleInactiveColor = Color.red,
+    };
+
+    [LocalSettingsButton]
+    public LocalSettingsButton ExampleButton { get; private set; } = new("Example Button", OnExampleButtonClick);
+
+    [LocalToggleSetting]
+    public ConfigEntry<bool> ExampleToggle { get; private set; } = config.Bind("General", "Example Bool", true);
+
+    [LocalToggleSetting]
+    public ConfigEntry<bool> ExampleToggle2 { get; private set; } = config.Bind("General", "Example Bool 2", false);
+
+    [LocalSliderSetting(suffixType: MiraNumberSuffixes.Percent, formatString: "0", roundValue: true)]
+    public ConfigEntry<float> ExampleSlider { get; private set; } = config.Bind("General", "Slider", 50f);
+
+    [LocalNumberSetting]
+    public ConfigEntry<float> ExampleNumber { get; private set; } = config.Bind("General", "Example Number", 4f);
+
+    [LocalNumberSetting(min: 0.1f, max: 2.5f, increment: 0.1f, formatString: "0.0", suffixType: MiraNumberSuffixes.Multiplier)]
+    public ConfigEntry<float> ExampleFloatNumber { get; private set; } = config.Bind("General", "Example Multplier", 1f);
+
+    [LocalEnumSetting]
+    public ConfigEntry<ExampleEnumSetting> ExampleEnum { get; private set; } = config.Bind("General", "Example Enum", ExampleEnumSetting.Fries);
+
+    private static void OnExampleButtonClick()
+    {
+        LocalSettingsTabSingleton<MiraApiSettings>.Instance.Open();
+    }
+}
+
+public enum ExampleEnumSetting
+{
+    Cheeseburger,
+    Sandwich,
+    Fries,
+    ChickenNuggets,
+}

MiraAPI.Example/ExamplePlugin.cs

@@ -1,4 +1,5 @@
-using BepInEx;
+using System.Linq;
+using BepInEx;
 using BepInEx.Configuration;
 using BepInEx.Unity.IL2CPP;
 using HarmonyLib;

MiraAPI/Events/Vanilla/Gameplay/IntroRoleRevealEvent.cs

@@ -0,0 +1,21 @@
+namespace MiraAPI.Events.Vanilla.Gameplay;
+
+/// <summary>
+/// The event that is invoked when the player's role is shown on the intro cutscene. Non cancelable.
+/// </summary>
+public class IntroRoleRevealEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the IntroCutscene.
+    /// </summary>
+    public IntroCutscene IntroCutscene { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="IntroRoleRevealEvent"/> class.
+    /// </summary>
+    /// <param name="introCutscene">The intro cutscene.</param>
+    public IntroRoleRevealEvent(IntroCutscene introCutscene)
+    {
+        IntroCutscene = introCutscene;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/Voting/AfterVoteEvent.cs

@@ -0,0 +1,30 @@
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// Event that is invoked after the local player successfully votes a player or skips. This event is not cancelable.
+/// </summary>
+public class AfterVoteEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the voter's vote data.
+    /// </summary>
+    public PlayerVoteArea VoteArea { get; }
+
+    /// <summary>
+    /// Gets the player who voted.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AfterVoteEvent"/> class.
+    /// </summary>
+    /// <param name="playerVoteArea">The player vote area that was voted on.</param>
+    /// <param name="voter">The player who voted.</param>
+    public AfterVoteEvent(PlayerVoteArea playerVoteArea, PlayerControl voter)
+    {
+        VoteArea = playerVoteArea;
+        Player = voter;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/Voting/BeforeVoteEvent.cs

@@ -0,0 +1,30 @@
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// Event that is invoked before the local player confirms a vote on a player or when skipping. This event is cancelable.
+/// </summary>
+public class BeforeVoteEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the instance of the voter's vote data.
+    /// </summary>
+    public PlayerVoteArea VoteArea { get; }
+
+    /// <summary>
+    /// Gets the player who voted.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BeforeVoteEvent"/> class.
+    /// </summary>
+    /// <param name="playerVoteArea">The player vote area that was voted on.</param>
+    /// <param name="voter">The player who voted.</param>
+    public BeforeVoteEvent(PlayerVoteArea playerVoteArea, PlayerControl voter)
+    {
+        VoteArea = playerVoteArea;
+        Player = voter;
+    }
+}

MiraAPI/Hud/ButtonUsesMode.cs

@@ -0,0 +1,17 @@
+namespace MiraAPI.Hud;
+
+/// <summary>
+/// The uses mode for custom buttons.
+/// </summary>
+public enum ButtonUsesMode
+{
+    /// <summary>
+    /// Uses per game.
+    /// </summary>
+    PerGame,
+
+    /// <summary>
+    /// Uses per round.
+    /// </summary>
+    PerRound,
+}

MiraAPI/Hud/CustomActionButton.cs

@@ -2,10 +2,14 @@
 using System.Globalization;
 using MiraAPI.Events;
 using MiraAPI.Events.Mira;
+using MiraAPI.Keybinds;
+using MiraAPI.LocalSettings;
 using MiraAPI.Patches;
 using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
+using Reactor.Utilities;
 using Rewired;
+using TMPro;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
@@ -33,6 +37,12 @@ public abstract class CustomActionButton
     /// </summary>
     public abstract float Cooldown { get; }
 
+    /// <summary>
+    /// Gets a value indicating whether the timer should stop decreasing when the player is venting.
+    /// Note that both cooldown decrease and effect timer decrease is disabled.
+    /// </summary>
+    public virtual bool PauseTimerInVent => false;
+
     /// <summary>
     /// Gets the sprite of the button. Use <see cref="LoadableResourceAsset"/> to load a sprite from a resource path. Use <see cref="LoadableBundleAsset{T}"/> to load a sprite from an asset bundle.
     /// </summary>
@@ -44,7 +54,12 @@ public abstract class CustomActionButton
     public virtual string CooldownTimerFormatString => "0";
 
     /// <summary>
-    /// Gets the button's effect duration in seconds. If the button has no effect, set to 0.
+    /// Gets a value indicating whether the button has an effect ability. By default true if <see cref="EffectDuration"/> is greater than 0.
+    /// </summary>
+    public virtual bool HasEffect => EffectDuration > 0;
+
+    /// <summary>
+    /// Gets the button's effect duration in seconds. If 0, the effect needs to be ended manually.
     /// </summary>
     public virtual float EffectDuration => 0;
 
@@ -54,26 +69,14 @@ public abstract class CustomActionButton
     public virtual int MaxUses => 0;
 
     /// <summary>
-    /// Gets or sets the current key binding for this button.
+    /// Gets the value indicating uses mode.
     /// </summary>
-    public abstract KeyboardKeyCode Defaultkeybind { get; }
+    public virtual ButtonUsesMode UsesMode => ButtonUsesMode.PerGame;
 
     /// <summary>
-    /// The first optional modifier key (e.g., Control, Shift, Alt) that must be held with the main key to activate the button.
+    /// Gets the keybind for this button. If null, no keybind will be added.
     /// </summary>
-    public virtual ModifierKey Modifier1 => ModifierKey.None;
-
-    /// <summary>
-    /// The second optional modifier key.
-    /// Set to <see cref="ModifierKey.None"/> if unused.
-    /// </summary>
-    public virtual ModifierKey Modifier2 => ModifierKey.None;
-
-    /// <summary>
-    /// The third optional modifier key.
-    /// Set to <see cref="ModifierKey.None"/> if unused.
-    /// </summary>
-    public virtual ModifierKey Modifier3 => ModifierKey.None;
+    public virtual BaseKeybind? Keybind => null;
 
     /// <summary>
     /// Gets the button's text outline color.
@@ -85,11 +88,6 @@ public abstract class CustomActionButton
     /// </summary>
     public virtual ButtonLocation Location { get; set; } = ButtonLocation.BottomLeft;
 
-    /// <summary>
-    /// Gets a value indicating whether the button has an effect ability.
-    /// </summary>
-    public bool HasEffect => EffectDuration > 0;
-
     /// <summary>
     /// Gets a value indicating whether the button has limited uses.
     /// </summary>
@@ -120,6 +118,16 @@ public abstract class CustomActionButton
     /// </summary>
     public ActionButton? Button { get; set; }
 
+    /// <summary>
+    /// Gets the gameObject used for the keybind icon.
+    /// </summary>
+    public GameObject? KeybindIcon { get; private set; }
+
+    /// <summary>
+    /// Gets or sets the keybind icon text.
+    /// </summary>
+    private TextMeshPro? KeybindText { get; set; }
+
     /// <summary>
     /// The method used to create the button.
     /// </summary>
@@ -191,6 +199,26 @@ public abstract class CustomActionButton
                 }
             }
         }));
+
+        if (Keybind != null)
+        {
+            Keybind.OnActivate(() =>
+            {
+                if (Enabled(PlayerControl.LocalPlayer.Data.Role))
+                {
+                    ClickHandler();
+                }
+            });
+
+            KeybindIcon =
+                Helpers.CreateKeybindIcon(
+                    Button.gameObject,
+                    Keybind.CurrentKey,
+                    new Vector3(MaxUses <= 0 ? -0.4f : 0.4f, 0.45f, -9f)
+                );
+            KeybindText = KeybindIcon.transform.GetChild(0).GetComponent<TextMeshPro>();
+            Button.usesRemainingSprite.transform.localPosition = new(-0.341f, 0.45f, -0.1f);
+        }
     }
 
     /// <summary>
@@ -377,6 +405,13 @@ public abstract class CustomActionButton
     {
     }
 
+    /// <summary>
+    /// Returns a value indicating whether the effect can be ended early by the player.
+    /// Always false by default.
+    /// </summary>
+    /// <returns>Can the effect be canceled.</returns>
+    public virtual bool IsEffectCancellable() => false;
+
     /// <summary>
     /// When the button is usable, this method is called to determine if the button can be clicked.
     /// By default, it takes into account the timer, effect, and uses.
@@ -385,7 +420,7 @@ public abstract class CustomActionButton
     /// <returns>A value that represents whether the button can be clicked or not.</returns>
     public virtual bool CanClick()
     {
-        return Timer <= 0 && !EffectActive && CanUse();
+        return (EffectActive ? IsEffectCancellable() : Timer <= 0) && CanUse();
     }
 
     /// <summary>
@@ -395,7 +430,8 @@ public abstract class CustomActionButton
     /// <returns>A value that represents whether the button should light up or not.</returns>
     public virtual bool CanUse()
     {
-        return PlayerControl.LocalPlayer.moveable && (!LimitedUses || UsesLeft > 0);
+        return PlayerControl.LocalPlayer.moveable &&
+               ((EffectActive && IsEffectCancellable()) || (!EffectActive && (!LimitedUses || UsesLeft > 0)));
     }
 
     /// <summary>
@@ -417,6 +453,12 @@ public abstract class CustomActionButton
     /// </summary>
     public virtual void ClickHandler()
     {
+        if (EffectActive && IsEffectCancellable())
+        {
+            ResetCooldownAndOrEffect();
+            return;
+        }
+
         if (!CanClick())
         {
             return;
@@ -449,14 +491,22 @@ public abstract class CustomActionButton
     /// <param name="playerControl">The local PlayerControl.</param>
     public virtual void FixedUpdateHandler(PlayerControl playerControl)
     {
+        if (Keybind != null && KeybindText != null)
+        {
+            KeybindText.text = Keybind.CurrentKey.ToString();
+            KeybindIcon?.SetActive(ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard &&
+                                   LocalSettingsTabSingleton<MiraApiSettings>.Instance.ShowKeybinds.Value &&
+                                   Keybind.CurrentKey != KeyboardKeyCode.None);
+        }
+
         if (Timer >= 0)
         {
-            if (!TimerPaused)
+            if (!TimerPaused && (!PauseTimerInVent || !playerControl.inVent))
             {
                 Timer -= Time.deltaTime;
             }
         }
-        else if (HasEffect && EffectActive)
+        else if (HasEffect && EffectActive && EffectDuration > 0)
         {
             EffectActive = false;
             Timer = Cooldown;
@@ -474,7 +524,7 @@ public abstract class CustomActionButton
                 Button!.SetDisabled();
             }
 
-            if (EffectActive)
+            if (EffectActive && EffectDuration > 0)
             {
                 Button.SetFillUp(Timer, EffectDuration);
 

MiraAPI/Hud/CustomButtonManager.cs

@@ -4,6 +4,7 @@ using System.Collections.ObjectModel;
 using System.Reflection;
 using MiraAPI.Events.Mira;
 using MiraAPI.PluginLoading;
+using UnityEngine;
 
 namespace MiraAPI.Hud;
 

MiraAPI/Hud/MultiTargetButton.cs

@@ -0,0 +1,78 @@
+using System.Linq;
+using HarmonyLib;
+using Reactor.Utilities.Extensions;
+using UnityEngine;
+
+namespace MiraAPI.Hud;
+
+/// <summary>
+/// Custom action button that has multiple target objects.
+/// </summary>
+/// <typeparam name="T">The type of the target objects.</typeparam>
+public abstract class MultiTargetButton<T> : CustomActionButton where T : MonoBehaviour
+{
+    /// <summary>
+    /// Gets or sets the list of targets of the button.
+    /// </summary>
+    public T[] Targets { get; protected set; } = [];
+
+    /// <inheritdoc cref="CustomActionButton{T}.Distance"/>
+    public virtual float Distance => PlayerControl.LocalPlayer.Data.Role.GetAbilityDistance();
+
+    /// <summary>
+    /// Gets the maximum amount of targets the button can have.
+    /// </summary>
+    public virtual int MaxTargets { get; } = int.MaxValue;
+
+    /// <inheritdoc cref="CustomActionButton{T}.IsTargetValid"/>
+    public virtual bool IsTargetValid(T target)
+    {
+        return target != null;
+    }
+
+    /// <summary>
+    /// The method used to get the target objects.
+    /// </summary>
+    /// <returns>The list of target objects.</returns>
+    public abstract T[] GetTargets();
+
+    /// <inheritdoc cref="CustomActionButton{T}.SetOutline"/>
+    /// <param name="target">The target object to set the oultine.</param>
+    public abstract void SetOutline(T target, bool active);
+
+    /// <inheritdoc cref="CustomActionButton{T}.CanUse"/>
+    public override bool CanUse()
+    {
+        var newTargets = GetTargets();
+        foreach (var target in Targets)
+        {
+            if (!newTargets.Contains(target))
+            {
+                SetOutline(target, false);
+            }
+        }
+
+        Targets = newTargets
+            .Where(IsTargetValid)
+            .Take(MaxTargets)
+            .ToArray();
+        Targets.Do(t => SetOutline(t, true));
+
+        return base.CanUse() && Targets.Length > 0;
+    }
+
+    /// <inheritdoc cref="CustomActionButton{T}.CanClick"/>
+    public override bool CanClick()
+    {
+        return base.CanClick() && Targets.Length > 0;
+    }
+
+    /// <summary>
+    /// Use this to reset the button's targets after used.
+    /// </summary>
+    public virtual void ResetTarget()
+    {
+        Targets.Do(t => SetOutline(t, false));
+        Targets = [];
+    }
+}

MiraAPI/Keybinds/BaseKeybind.cs

@@ -0,0 +1,72 @@
+using System;
+using Rewired;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Base keybind class.
+/// </summary>
+public class BaseKeybind
+{
+    /// <summary>
+    /// Gets the Rewired <see cref="InputAction"/> assinged for this keybind.
+    /// </summary>
+    public InputAction? RewiredInputAction { get; internal set; }
+
+    /// <summary>
+    /// Gets the unique identifier for this keybind. Used in Rewired.
+    /// </summary>
+    public string Id { get; protected set; }
+
+    /// <summary>
+    /// Gets the currently assigned keycode.
+    /// </summary>
+    public KeyboardKeyCode CurrentKey => KeybindUtils.GetKeycodeByKeybind(this);
+
+    /// <summary>
+    /// Gets or sets the handler of the keybind. Invoked when the keybind is activated.
+    /// </summary>
+    protected Action Handler { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BaseKeybind"/> class.
+    /// </summary>
+    /// <param name="id">The unique identifier for this keybind.</param>
+    public BaseKeybind(string id)
+    {
+        Id = id;
+        Handler = () => { };
+    }
+
+    public BaseKeybind()
+    {
+        Handler = () => { };
+    }
+
+    /// <summary>
+    /// Triggers the keybind, invoking its handler.
+    /// </summary>
+    public void Invoke()
+    {
+        Handler.Invoke();
+    }
+
+    /// <summary>
+    /// Adds an <see cref="Action"/> that will be invoked when the keybind is used.
+    /// </summary>
+    /// <param name="action">The <see cref="Action"/> to add.</param>
+    public void OnActivate(Action action)
+    {
+        Handler += action;
+    }
+
+    /// <summary>
+    /// Removes an <see cref="Action"/> that would be invoked when the keybind is used.
+    /// Not recommended to use - add checks in the method added in <see cref="OnActivate"/> itself rather than removing it from the keybind.
+    /// </summary>
+    /// <param name="action">The <see cref="Action"/> to remove.</param>
+    public void RemoveOnActivate(Action action)
+    {
+        Handler -= action;
+    }
+}

MiraAPI/Keybinds/KeybindManager.cs

@@ -1,116 +1,98 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using Il2CppInterop.Runtime.Attributes;
+using MiraAPI.Utilities;
+using Reactor.Utilities;
 using Rewired;
 
-namespace MiraAPI.Keybinds
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Lets you register and manage mod keybinds with conflict checks and rebinding support.
+/// </summary>
+public static class KeybindManager
 {
     /// <summary>
-    /// Lets you register and manage mod keybinds with conflict checks and rebinding support.
+    /// Gets a list of all registered keybinds.
     /// </summary>
-    public static class KeybindManager
+    public static List<MiraKeybind> Keybinds { get; } = new();
+
+    [HideFromIl2Cpp]
+    internal static Dictionary<Type, VanillaKeybind> VanillaKeybinds { get; set; } = [];
+
+    internal static void RewiredInit()
     {
-        /// <summary>
-        /// Stores all info for a registered keybind.
-        /// </summary>
-        public class KeybindEntry
+        try
         {
-            /// <summary>Unique identifier for this keybind.</summary>
-            public string Id;
-
-            /// <summary>Text shown in the Among Us rebinding menu to describe this keybind.</summary>
-            public string Description;
-
-            /// <summary>
-            /// The method that runs when this keybind is pressed.
-            /// </summary>
-            public Action Handler;
-
-            /// <summary>
-            /// The key currently assigned to this keybind.
-            /// </summary>
-            public KeyboardKeyCode Key;
-
-            /// <summary>
-            /// If true, this keybind will be checked for conflicts with other exclusive keybinds using the same key.
-            /// </summary>
-            public bool Exclusive;
-
-            /// <summary>
-            /// The first optional modifier key (e.g., Control, Shift, Alt) that must be held with the main key.
-            /// </summary>
-            public ModifierKey Modifier1 = ModifierKey.None;
-
-            /// <summary>
-            /// The second optional modifier key, if needed. Set to <c>ModifierKey.None</c> if unused.
-            /// </summary>
-            public ModifierKey Modifier2 = ModifierKey.None;
-
-            /// <summary>
-            /// The third optional modifier key, if needed. Set to <c>ModifierKey.None</c> if unused.
-            /// </summary>
-            public ModifierKey Modifier3 = ModifierKey.None;
-        }
-
-        private static readonly List<KeybindEntry> Registered = new();
-
-        /// <summary>
-        /// Registers a new mod keybind.
-        /// </summary>
-        /// <param name="id">Unique identifier for the keybind.</param>
-        /// <param name="description">Description to display in UI.</param>
-        /// <param name="key">Default key to use if no rebind exists.</param>
-        /// <param name="handler">Method to invoke when the keybind is pressed.</param>
-        /// <param name="exclusive">If true, conflicts with other exclusive keybinds on the same key.</param>
-        /// <param name="modifier1">Optional first modifier key (e.g., <c>Control</c>, <c>Shift</c>, <c>Alt</c>) that must be held with the main key.</param>
-        /// <param name="modifier2">Optional second modifier key. Use <c>ModifierKey.None</c> if unused.</param>
-        /// <param name="modifier3">Optional third modifier key. Use <c>ModifierKey.None</c> if unused.</param>
-        /// <returns> Returns the key that was registered for this keybind. </returns>
-        public static KeyboardKeyCode Register(string id, string description, KeyboardKeyCode key, Action handler, bool exclusive = true, ModifierKey modifier1 = ModifierKey.None, ModifierKey modifier2 = ModifierKey.None, ModifierKey modifier3 = ModifierKey.None)
-        {
-            Registered.Add(new KeybindEntry
+            var instance = KeybindUtils.RewiredInputManager!;
+            foreach (var keybind in KeybindManager.Keybinds)
             {
-                Id = id,
-                Description = description,
-                Key = key,
-                Handler = handler,
-                Exclusive = exclusive,
-                Modifier1 = modifier1,
-                Modifier2 = modifier2,
-                Modifier3 = modifier3,
-            });
-
-            return key;
-        }
-
-        /// <summary>
-        /// Returns all conflicts where exclusive keybinds use the same key.
-        /// </summary>
-        /// <returns>A list of pairs of keybinds that conflict.</returns>
-        public static List<(KeybindEntry, KeybindEntry)> GetConflicts()
-        {
-            var conflicts = new List<(KeybindEntry, KeybindEntry)>();
-            for (int i = 0; i < Registered.Count; i++)
-            {
-                for (int j = i + 1; j < Registered.Count; j++)
+                if (instance.userData.actions.ToArray().Any(x => x.name == keybind.Id))
                 {
-                    var a = Registered[i];
-                    var b = Registered[j];
-                    if (a.Key == b.Key && a.Exclusive && b.Exclusive)
-                    {
-                        conflicts.Add((a, b));
-                    }
+                    Logger<MiraApiPlugin>.Warning($"Keybind of id {keybind.Id} already exists. Skipping it");
+                    continue;
                 }
-            }
-            return conflicts;
-        }
 
-        /// <summary>
-        /// Returns all currently registered keybind entries.
-        /// </summary>
-        /// <returns>A list of all registered keybind entries.</returns>
-        public static List<KeybindEntry> GetEntries()
+                keybind.RewiredInputAction = instance.userData.RegisterModBind(
+                    keybind.Id,
+                    keybind.Name,
+                    keybind.SourcePluginName,
+                    keybind.DefaultKey,
+                    modifiers: keybind.ModifierKeys);
+            }
+        }
+        catch (Exception e)
         {
-            return Registered;
+            Logger<MiraApiPlugin>.Error($"Error while registering keybinds in Rewired: {e}");
         }
     }
+
+    /// <summary>
+    /// Returns all conflicts where keybinds use the same key.
+    /// </summary>
+    /// <returns>A list of pairs of keybinds that conflict.</returns>
+    public static Dictionary<KeyboardKeyCode, List<MiraKeybind>> GetConflicts()
+    {
+        var conflicts = new Dictionary<KeyboardKeyCode, List<MiraKeybind>>();
+        foreach (var keybind in Keybinds)
+        {
+            var all = GetKeybindsForKey(keybind.CurrentKey, true);
+            if (all.Length > 1)
+            {
+                if (!conflicts.TryGetValue(keybind.CurrentKey, out var group))
+                {
+                    conflicts.Add(keybind.CurrentKey, new List<MiraKeybind>());
+                    group = conflicts[keybind.CurrentKey];
+                }
+
+                if (!group.Contains(keybind))
+                {
+                    group.Add(keybind);
+                }
+            }
+        }
+
+        return conflicts;
+    }
+
+    /// <summary>
+    /// Returns all keybinds for a specified keycode.
+    /// </summary>
+    /// <param name="keyCode">The key to look for.</param>
+    /// /// <param name="exclusiveCheck">Should only exlusive keybinds be present.</param>
+    /// <returns>The list of keybinds.</returns>
+    public static MiraKeybind[] GetKeybindsForKey(KeyboardKeyCode keyCode, bool exclusiveCheck = false)
+    {
+        var all = new List<MiraKeybind>();
+        foreach (var keybind in Keybinds)
+        {
+            if (keybind.CurrentKey == keyCode && (keybind.Exclusive || !exclusiveCheck))
+            {
+                all.Add(keybind);
+            }
+        }
+
+        return all.ToArray();
+    }
 }

MiraAPI/Keybinds/KeybindUtils.cs

@@ -0,0 +1,80 @@
+using System;
+using Rewired;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Collection of keybind-related utility classes.
+/// </summary>
+public static class KeybindUtils
+{
+    /// <summary>
+    /// Gets the Rewired <see cref="InputManager_Base"/> instance.
+    /// </summary>
+    public static InputManager_Base? RewiredInputManager { get; internal set; }
+
+    /// <summary>
+    /// Returns the currently assigned keycode of a keybind.
+    /// </summary>
+    /// <param name="keybind">The keybind to get the keycode from.</param>
+    /// <returns>The currently assigned keycode.</returns>
+    public static KeyboardKeyCode GetKeycodeByKeybind(BaseKeybind keybind)
+    {
+        if (keybind.RewiredInputAction == null)
+        {
+            return KeyboardKeyCode.None;
+        }
+
+        return GetKeycodeByActionId(keybind.RewiredInputAction.id);
+    }
+
+    /// <summary>
+    /// Gets the keycode for an action with ReInput.
+    /// </summary>
+    /// <param name="actionId">The action ID.</param>
+    /// <returns>The keyboard keycode.</returns>
+    public static KeyboardKeyCode GetKeycodeByActionId(int actionId)
+    {
+        return GetActionElementMap(actionId)?.keyboardKeyCode ?? KeyboardKeyCode.None;
+    }
+
+    /// <summary>
+    /// Gets a <see cref="ActionElementMap"/> by id with ReInput.
+    /// </summary>
+    /// <param name="actionId">The action ID.</param>
+    /// <returns>The keyboard keycode.</returns>
+    public static ActionElementMap? GetActionElementMap(int actionId)
+    {
+        var player = ReInput.players.GetPlayer(0);
+        return player.controllers.maps.GetFirstElementMapWithAction(ControllerType.Keyboard, actionId, false);
+    }
+
+    /// <summary>
+    /// Gets an <see cref="InputAction"/> by id.
+    /// </summary>
+    /// <param name="id">The action identifier name.</param>
+    /// <returns>The keyboard keycode.</returns>
+    public static InputAction? GetInputActionById(int id)
+    {
+        return RewiredInputManager?.userData?.GetActionById(id);
+    }
+
+    /// <summary>
+    /// Finds and returns an unused KeyCode that is not equal to the excluded key.
+    /// </summary>
+    /// <param name="exclude">The KeyCode to skip during the search.</param>
+    /// <returns>
+    /// The first available KeyCode not currently used by any registered keybind,
+    /// or KeyCode.None if none are available.
+    /// </returns>
+    public static KeyboardKeyCode FindAvailableKey(KeyboardKeyCode exclude)
+    {
+        foreach (KeyboardKeyCode key in Enum.GetValues<KeyboardKeyCode>())
+        {
+            if (key == exclude) continue;
+            bool used = KeybindManager.Keybinds.Exists(e => e.DefaultKey == key);
+            if (!used) return key;
+        }
+        return KeyboardKeyCode.None;
+    }
+}

MiraAPI/Keybinds/MiraGlobalKeybinds.cs

@@ -0,0 +1,41 @@
+using Rewired;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Class containing all default keybinds.
+/// Recommended for cross-mod compatibility.
+/// </summary>
+[RegisterCustomKeybinds]
+public static class MiraGlobalKeybinds
+{
+    /// <summary>
+    /// Gets the keybind for primary abilities.
+    /// </summary>
+    public static MiraKeybind PrimaryAbility { get; } = new("Primary Ability", KeyboardKeyCode.T);
+
+    /// <summary>
+    /// Gets the keybind for secondary abilities.
+    /// </summary>
+    public static MiraKeybind SecondaryAbility { get; } = new("Secondary Ability", KeyboardKeyCode.Y);
+
+    /// <summary>
+    /// Gets the keybind for Tetiary abilities.
+    /// </summary>
+    public static MiraKeybind TertiaryAbility { get; } = new("Tertiary Ability", KeyboardKeyCode.U);
+
+    /// <summary>
+    /// Gets the keybind for primary modifier abilities.
+    /// </summary>
+    public static MiraKeybind ModifierPrimaryAbility { get; } = new("Modifier Primary Ability", KeyboardKeyCode.I);
+
+    /// <summary>
+    /// Gets the keybind for secondary modifier abilities.
+    /// </summary>
+    public static MiraKeybind ModifierSecondaryAbility { get; } = new("Modifier Secondary Ability", KeyboardKeyCode.O);
+
+    /// <summary>
+    /// Gets the keybind for Tetiary modifier abilities.
+    /// </summary>
+    public static MiraKeybind ModifierTertiaryAbility { get; } = new("Modifier Tertiary Ability", KeyboardKeyCode.P);
+}

MiraAPI/Keybinds/MiraKeybind.cs

@@ -0,0 +1,58 @@
+using System.Globalization;
+using Rewired;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Represents a registered keybind.
+/// </summary>
+public class MiraKeybind : BaseKeybind
+{
+    /// <summary>
+    /// Gets name of the keybind
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Gets the default keycode of this keybind.
+    /// </summary>
+    public KeyboardKeyCode DefaultKey { get; }
+
+    /// <summary>
+    /// Gets the modifier keys assigned to this keybind.
+    /// Due to Rewired limitations, there can only be 3 modifier keys.
+    /// </summary>
+    public ModifierKey[] ModifierKeys { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether this keybind should be checked for conflicts with other exclusive keybinds using the same key.
+    /// </summary>
+    public bool Exclusive { get; }
+
+    internal string? SourcePluginName { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraKeybind"/> class.
+    /// </summary>
+    /// <param name="name">The name of the keybind.</param>
+    /// <param name="defaultKeycode">The default keycode.</param>
+    /// <param name="modifierKeys">Up to 3 optional modifier keys.</param>
+    /// <param name="exclusive">Is exclusive.</param>
+    public MiraKeybind(
+        string name,
+        KeyboardKeyCode? defaultKeycode,
+        ModifierKey[]? modifierKeys = null,
+        bool exclusive = true) : base(name.ToLower(CultureInfo.InvariantCulture).Replace(' ', '_'))
+    {
+        Name = name;
+        DefaultKey = defaultKeycode ?? KeyboardKeyCode.None;
+        ModifierKeys = modifierKeys ?? [];
+        Exclusive = exclusive;
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return $"{Name} ({Id})";
+    }
+}

MiraAPI/Keybinds/RegisterCustomKeybindsAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Used to mark a class for custom keybinds registration.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class)]
+public class RegisterCustomKeybindsAttribute : Attribute;

MiraAPI/Keybinds/VanillaKeybind.cs

@@ -0,0 +1,24 @@
+using Rewired;
+
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Represents a vanilla keybind.
+/// </summary>
+public class VanillaKeybind : BaseKeybind
+{
+    /// <summary>
+    /// Gets the <see cref="ActionButton"/> this keybind is binded to.
+    /// </summary>
+    public ActionButton? Button { get; internal set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="VanillaKeybind"/> class.
+    /// </summary>
+    /// <param name="id">The keybind id.</param>
+    public VanillaKeybind(int id)
+    {
+        RewiredInputAction = KeybindUtils.GetInputActionById(id);
+        Id = RewiredInputAction?.name;
+    }
+}

MiraAPI/Keybinds/VanillaKeybindSingleton.cs

@@ -0,0 +1,17 @@
+namespace MiraAPI.Keybinds;
+
+/// <summary>
+/// Singleton for getting a vanilla keybind by <see cref="ActionButton"/>.
+/// </summary>
+/// <typeparam name="T">ActionButton type.</typeparam>
+public static class VanillaKeybinding<T> where T : ActionButton
+{
+    private static VanillaKeybind? _instance;
+
+    /// <summary>
+    /// Gets the instance of the option group.
+    /// </summary>
+#pragma warning disable CA1000
+    public static VanillaKeybind Instance => _instance ??= KeybindManager.VanillaKeybinds[typeof(T)];
+#pragma warning restore CA1000
+}

MiraAPI/LocalSettings/Attributes/LocalEnumSettingAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings.SettingTypes;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Creates an enum setting for the <see cref="ConfigEntry{T}"/>.
+/// </summary>
+/// <param name="names">Optional custom enum names.</param>
+/// <inheritdoc/>
+[AttributeUsage(AttributeTargets.Property)]
+public class LocalEnumSettingAttribute(
+    string? name = null,
+    string? description = null,
+    string[]? names = null
+    ) : LocalSettingAttribute(name, description)
+{
+    private readonly string? _name = name;
+    private readonly string? _description = description;
+
+    /// <inheritdoc/>
+    internal override LocalEnumSetting CreateSetting(Type tab, ConfigEntryBase configEntryBase)
+    {
+        return new LocalEnumSetting(tab, configEntryBase, configEntryBase.SettingType, _name, _description, names);
+    }
+}

MiraAPI/LocalSettings/Attributes/LocalNumberSettingAttribute.cs

@@ -0,0 +1,36 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings.SettingTypes;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Creates a number setting for the <see cref="ConfigEntry{T}"/>.
+/// </summary>
+/// <param name="min">Minimum range.</param>
+/// <param name="max">Maximum range.</param>
+/// <param name="increment">Increment per use.</param>
+/// <param name="suffixType">Suffix for the value.</param>
+/// <param name="formatString">Format string used when formating.</param>
+/// <inheritdoc/>
+[AttributeUsage(AttributeTargets.Property)]
+public class LocalNumberSettingAttribute(
+    string? name = null,
+    string? description = null,
+    float min = 1,
+    float max = 5,
+    float increment = 1,
+    MiraNumberSuffixes suffixType = MiraNumberSuffixes.None,
+    string? formatString = null
+    ) : LocalSettingAttribute(name, description)
+{
+    private readonly string? _name = name;
+    private readonly string? _description = description;
+
+    /// <inheritdoc/>
+    internal override LocalNumberSetting CreateSetting(Type tab, ConfigEntryBase configEntryBase)
+    {
+        return new LocalNumberSetting(tab, configEntryBase, _name, _description, new FloatRange(min, max), increment, suffixType, formatString);
+    }
+}

MiraAPI/LocalSettings/Attributes/LocalSettingAttribute.cs

@@ -0,0 +1,24 @@
+using System;
+using BepInEx.Configuration;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Base class for all local settings attributes.
+/// </summary>
+/// <param name="name">The name of the setting. Defaults to entry key.</param>
+/// <param name="description">The description of the setting. Defalts to entry description.</param>
+[AttributeUsage(AttributeTargets.Property)]
+public abstract class LocalSettingAttribute(
+    string? name = null,
+    string? description = null
+    ) : Attribute
+{
+    /// <summary>
+    /// Returns the created setting object.
+    /// </summary>
+    /// <param name="tab">Gets the tab where the setting is located.</param>
+    /// <param name="configEntryBase">Gets the config entry the setting is attached to.</param>
+    /// <returns>The created class.</returns>
+    internal abstract ILocalSetting CreateSetting(Type tab, ConfigEntryBase configEntryBase);
+}

MiraAPI/LocalSettings/Attributes/LocalSettingsButtonAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+using BepInEx.Configuration;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Attribute for local setting buttons.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
+public class LocalSettingsButtonAttribute : Attribute
+{
+}

MiraAPI/LocalSettings/Attributes/LocalSliderSettingAttribute.cs

@@ -0,0 +1,36 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings.SettingTypes;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Creates a slider setting for the <see cref="ConfigEntry{T}"/>.
+/// </summary>
+/// <inheritdoc/>
+/// <param name="min">Minimum range.</param>
+/// <param name="max">Maximum range.</param>
+/// <param name="roundValue">Should the value be rounded.</param>
+/// <param name="suffixType">Suffix for the value.</param>
+[AttributeUsage(AttributeTargets.Property)]
+public class LocalSliderSettingAttribute(
+    string? name = null,
+    float min = 0,
+    float max = 100,
+    string? description = null,
+    bool displayValue = false,
+    string? formatString = null,
+    bool roundValue = false,
+    MiraNumberSuffixes suffixType = MiraNumberSuffixes.None
+    ) : LocalSettingAttribute(name, description)
+{
+    private readonly string? _name = name;
+    private readonly string? _description = description;
+
+    /// <inheritdoc/>
+    internal override LocalSliderSetting CreateSetting(Type tab, ConfigEntryBase configEntryBase)
+    {
+        return new LocalSliderSetting(tab, configEntryBase, _name, _description, new FloatRange(min, max), displayValue, suffixType, formatString, roundValue);
+    }
+}

MiraAPI/LocalSettings/Attributes/LocalToggleSettingAttribute.cs

@@ -0,0 +1,25 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings.SettingTypes;
+
+namespace MiraAPI.LocalSettings.Attributes;
+
+/// <summary>
+/// Creates a toggle setting for the <see cref="ConfigEntry{T}"/>.
+/// </summary>
+/// <inheritdoc/>
+[AttributeUsage(AttributeTargets.Property)]
+public class LocalToggleSettingAttribute(
+    string? name = null,
+    string? description = null
+    ) : LocalSettingAttribute(name, description)
+{
+    private readonly string? _name = name;
+    private readonly string? _description = description;
+
+    /// <inheritdoc/>
+    internal override LocalToggleSetting CreateSetting(Type tab, ConfigEntryBase configEntryBase)
+    {
+        return new LocalToggleSetting(tab, configEntryBase, _name, _description);
+    }
+}

MiraAPI/LocalSettings/ILocalSetting.cs

@@ -0,0 +1,42 @@
+using BepInEx.Configuration;
+using UnityEngine;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Interface for all local settings.
+/// </summary>
+public interface ILocalSetting
+{
+    /// <summary>
+    /// Gets the preferred name of a setting.
+    /// </summary>
+    string Name { get; }
+
+    /// <summary>
+    /// Gets the description of a setting.
+    /// </summary>
+    string Description { get; }
+
+    /// <summary>
+    /// Gets the setting's gameobject.
+    /// </summary>
+    GameObject? Setting { get; }
+
+    /// <summary>
+    /// Gets the setting's config entry.
+    /// </summary>
+    ConfigEntryBase ConfigEntry { get; }
+
+    /// <summary>
+    /// Used to create the setting.
+    /// </summary>
+    /// <param name="toggle">Toggle template.</param>
+    /// <param name="slider">Slider template.</param>
+    /// <param name="parent">The parent of the setting.</param>
+    /// <param name="offset">The offset.</param>
+    /// <param name="order">The order.</param>
+    /// <param name="last">Whether it's the last on the row.</param>
+    /// <returns>The created setting.</returns>
+    GameObject? CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last);
+}

MiraAPI/LocalSettings/LocalSettingsButton.cs

@@ -0,0 +1,78 @@
+using System;
+using MiraAPI.Utilities;
+using Reactor.Localization.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Represents a local settings button.
+/// </summary>
+public class LocalSettingsButton(string text, Action onClick)
+{
+    /// <summary>
+    /// Gets or sets the button text.
+    /// </summary>
+    public string Text { get; set; } = text;
+
+    /// <summary>
+    /// Gets or sets the button on-click action.
+    /// </summary>
+    public Action OnClick { get; set; } = onClick;
+
+    /// <summary>
+    /// Gets the tab instance this button belongs to.
+    /// </summary>
+    public LocalSettingsTab? Tab { get; internal set; }
+
+    internal GameObject CreateButton(ToggleButtonBehaviour toggle, Transform parent, ref float offset, ref int order, bool last)
+    {
+        var button = Object.Instantiate(toggle, parent).GetComponent<PassiveButton>();
+        var tmp = button.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>();
+        var rollover = button.GetComponent<ButtonRolloverHandler>();
+        tmp.GetComponent<TextTranslatorTMP>().Destroy();
+        button.gameObject.SetActive(true);
+
+        var toggleComp = button.GetComponent<ToggleButtonBehaviour>();
+        var background = toggleComp.Background;
+        button.transform.FindChild("ButtonHighlight")?.gameObject.DestroyImmediate();
+        toggleComp.Destroy();
+
+        if (last && order == 1)
+        {
+            // Button in the middle
+            button.transform.localPosition = new Vector3(0, 1.85f - offset, -7);
+        }
+        else
+        {
+            button.transform.localPosition = new Vector3(order == 1 ? -1.185f : 1.185f, 1.85f - offset, -7);
+        }
+
+        tmp.text = Text;
+        button.name = Text;
+        button.OnClick = new UnityEngine.UI.Button.ButtonClickedEvent();
+        rollover.OutColor = Tab!.TabAppearance.ButtonColor;
+        rollover.OverColor = Tab!.TabAppearance.ButtonHoverColor;
+        rollover.Target = background;
+        background.color = Tab!.TabAppearance.ButtonColor;
+        button.OnClick.AddListener((UnityAction)OnClick);
+
+        background.transform.localScale = new Vector3(1, 1.25f, 1);
+        Helpers.DivideSize(button.gameObject, 1.1f);
+
+        order++;
+        if (order > 2 && !last)
+        {
+            offset += 0.5f;
+            order = 1;
+        }
+        if (last)
+            offset += 0.6f;
+
+        return button.gameObject;
+    }
+}

MiraAPI/LocalSettings/LocalSettingsManager.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using BepInEx.Unity.IL2CPP;
+using MiraAPI.GameOptions;
+using Reactor.Utilities;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Manages local settings.
+/// </summary>
+public static class LocalSettingsManager
+{
+    internal static readonly Dictionary<Type, LocalSettingsTab> TypeToTab = [];
+    internal static readonly List<LocalSettingsTab> Tabs = [];
+
+    internal static bool RegisterTab(Type type, BasePlugin pluginInfo)
+    {
+        if (Activator.CreateInstance(type, pluginInfo.Config) is not LocalSettingsTab tab)
+        {
+            return false;
+        }
+
+        if (TypeToTab.ContainsKey(type))
+        {
+            Logger<MiraApiPlugin>.Error($"Local settings tab {type.Name} already exists.");
+            return false;
+        }
+
+        Tabs.Add(tab);
+        TypeToTab.Add(type, tab);
+
+        typeof(LocalSettingsTabSingleton<>).MakeGenericType(type)
+#pragma warning disable S3011
+            .GetField("_instance", BindingFlags.Static | BindingFlags.NonPublic)!
+#pragma warning restore S3011
+            .SetValue(null, tab);
+
+        return true;
+    }
+}

MiraAPI/LocalSettings/LocalSettingsTab.cs

@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using BepInEx.Configuration;
+using HarmonyLib;
+using MiraAPI.Patches.LocalSettings;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Represents a local settings tab. Gets a button by default.
+/// </summary>
+public abstract class LocalSettingsTab(ConfigFile config)
+{
+    /// <summary>
+    /// Gets the name of the tab.
+    /// </summary>
+    public abstract string TabName { get; }
+
+    /// <summary>
+    /// Gets the tab appearance.
+    /// </summary>
+    public virtual LocalSettingTabAppearance TabAppearance { get; } = new();
+
+    /// <summary>
+    /// Gets a value indicating whether a button should be created for the tab.
+    /// </summary>
+    public virtual bool ShouldCreateButton => true;
+
+    /// <summary>
+    /// Gets a value indicating whether the tab should have category labels.
+    /// </summary>
+    protected virtual bool ShouldCreateLabels => true;
+
+    /// <summary>
+    /// Gets the mod's config file. Automatically found in the plugin loader.
+    /// </summary>
+    public ConfigFile Config { get; } = config ?? throw new ArgumentNullException(nameof(config));
+
+    /// <summary>
+    /// Gets the tab button instance.
+    /// </summary>
+    public TabGroup? TabButton { get; internal set; }
+
+    /// <summary>
+    /// Gets the list of settings.
+    /// </summary>
+    public List<ILocalSetting> Settings { get; } = [];
+
+    /// <summary>
+    /// Gets the list of buttons.
+    /// </summary>
+    public List<LocalSettingsButton> Buttons { get; } = [];
+
+    /// <summary>
+    /// Gets the index of this tab.
+    /// </summary>
+    protected int TabIndex => LocalSettingsManager.Tabs.IndexOf(this) + 10;
+
+    private Scroller? Scroller { get; set; }
+
+    /// <summary>
+    /// Invoked when an option value is changed.
+    /// </summary>
+    /// <param name="configEntry">The config entry which was changed.</param>
+    public virtual void OnOptionChanged(ConfigEntryBase configEntry)
+    {
+    }
+
+    /// <summary>
+    /// Attempts to open the tab.
+    /// Override for custom behavior.
+    /// </summary>
+    public virtual void Open()
+    {
+        OptionsMenuPatches.Instance?.OpenTabGroup(TabIndex);
+    }
+
+    /// <summary>
+    /// Creates the tab <see cref="GameObject"/> and it's content.
+    /// </summary>
+    /// <param name="instance">The <see cref="OptionsMenuBehaviour"/> instace.</param>
+    /// <returns>The created tab <see cref="GameObject"/>.</returns>
+    public virtual GameObject CreateTab(OptionsMenuBehaviour instance)
+    {
+         var tab = Object.Instantiate(instance.transform.FindChild("GeneralTab").gameObject, instance.transform);
+         tab.name = $"{TabName}Tab";
+         tab.transform.DestroyChildren();
+         tab.gameObject.SetActive(false);
+
+         if (Scroller == null)
+         {
+             Scroller = Helpers.CreateScroller(tab.transform, OptionsMenuPatches.MaskCollider);
+         }
+
+         if (TabButton != null)
+         {
+             TabButton.Content = tab.gameObject;
+         }
+
+         var generalLabel = instance.transform.FindChild("GeneralTab").FindChild("ControlGroup")
+             .FindChild("ControlText_TMP").gameObject;
+         var toggle = instance.transform.FindChild("GeneralTab").FindChild("ChatGroup").FindChild("CensorChatButton").GetComponent<ToggleButtonBehaviour>();
+         var slider = instance.transform.FindChild("GeneralTab").FindChild("SoundGroup").FindChild("SFXSlider").GetComponent<SlideBar>();
+
+         Dictionary<string, List<ILocalSetting>> entriesByGroup = new();
+         foreach (var entry in Settings)
+         {
+             var group = entry.ConfigEntry.Definition.Section;
+             if (!entriesByGroup.ContainsKey(group))
+                 entriesByGroup.Add(group, []);
+
+             entriesByGroup[group].Add(entry);
+         }
+
+         float contentOffset = 0;
+         var contentOrder = 1;
+         var contentIndex = 1;
+
+         foreach (var pair in entriesByGroup)
+         {
+             if (ShouldCreateLabels)
+             {
+                 CreateLabel(generalLabel, Scroller.Inner, pair.Key, ref contentOffset);
+                 contentOrder = 1;
+                 contentIndex = 1;
+             }
+
+             foreach (var setting in pair.Value)
+             {
+                 var obj = setting.CreateOption(
+                     toggle,
+                     slider,
+                     Scroller.Inner,
+                     ref contentOffset,
+                     ref contentOrder,
+                     contentIndex == pair.Value.Count);
+
+                 obj!.GetComponentsInChildren<SpriteRenderer>(true).Do(x =>
+                 {
+                     x.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
+                     x.sortingOrder = 150;
+                     x.sortingLayerName = "Default";
+                 });
+
+                 obj.GetComponentsInChildren<MeshRenderer>(true).Do(x =>
+                 {
+                     x.sortingOrder = 151;
+                     x.sortingLayerName = "Default";
+                 });
+
+                 obj.GetComponentsInChildren<PassiveButton>().Do(x => { x.ClickMask = OptionsMenuPatches.MaskCollider; });
+
+                 contentIndex++;
+             }
+
+             contentOrder = 1;
+         }
+
+         contentIndex = 1;
+         contentOrder = 1;
+         foreach (var button in Buttons)
+         {
+             var obj = button.CreateButton(
+                 toggle,
+                 Scroller.Inner,
+                 ref contentOffset,
+                 ref contentOrder,
+                 contentIndex == Buttons.Count);
+
+             obj!.GetComponentsInChildren<SpriteRenderer>(true).Do(x =>
+             {
+                 x.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
+                 x.sortingOrder = 150;
+                 x.sortingLayerName = "Default";
+             });
+
+             obj.GetComponentsInChildren<MeshRenderer>(true).Do(x =>
+             {
+                 x.sortingOrder = 151;
+                 x.sortingLayerName = "Default";
+             });
+
+             obj.GetComponentsInChildren<PassiveButton>().Do(x => { x.ClickMask = OptionsMenuPatches.MaskCollider; });
+
+             contentIndex++;
+         }
+
+         Scroller.SetBounds(new FloatRange(0, (Settings.Count + Buttons.Count) * 0.5f - 5f), new FloatRange(0, 0));
+         return tab;
+    }
+
+    /// <summary>
+    /// Creates the tab button.
+    /// </summary>
+    /// <param name="instance">The <see cref="OptionsMenuBehaviour"/> instance.</param>
+    /// <param name="tabIdx">The tab index.</param>
+    /// <param name="offset">The current button offset.</param>
+    /// <returns>The created button <see cref="GameObject"/>.</returns>
+    public virtual GameObject CreateTabButton(OptionsMenuBehaviour instance, ref int tabIdx, ref float offset)
+    {
+        var tabButtonObject = Object.Instantiate(instance.Tabs[0], instance.transform);
+        tabButtonObject.name = $"{TabName} Button";
+        tabButtonObject.transform.localPosition = new Vector3(2.4f, 2.1f - offset, 5.5f);
+        tabButtonObject.transform.localScale = new Vector3(1.25f, 1.25f, 1);
+        tabButtonObject.Button.color = TabAppearance.TabButtonColor;
+        TabButton = tabButtonObject;
+
+        var tabButtonText = tabButtonObject.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>();
+        tabButtonText.GetComponent<TextTranslatorTMP>().Destroy(); // i hate text translators
+        tabButtonText.transform.localPosition = new Vector3(0.078f, 0, 0);
+        tabButtonText.transform.localScale = new Vector3(0.9f, 0.9f);
+        tabButtonText.alignment = TextAlignmentOptions.Right;
+        tabButtonText.text = $"<b>{GetShortName(TabName)}</b>";
+
+        var tabButton = tabButtonObject.GetComponent<PassiveButton>();
+        var rollover = tabButtonObject.Rollover;
+        rollover.OverColor = TabAppearance.TabButtonHoverColor;
+        rollover.OutColor = TabAppearance.TabButtonColor;
+
+        SpriteRenderer? tabButtonRend = null;
+        if (TabAppearance.TabIcon != null)
+        {
+            tabButtonRend = new GameObject("sprite").AddComponent<SpriteRenderer>();
+            tabButtonRend.gameObject.layer = 5; // ui layer
+            tabButtonRend.transform.SetParent(tabButtonObject.transform);
+            tabButtonRend.transform.localPosition = new Vector3(0.5f, 0, -2);
+            tabButtonRend.transform.localScale = new Vector3(0.2f, 0.2f, 1);
+            tabButtonRend.sprite = TabAppearance.TabIcon.LoadAsset();
+            tabButtonText.gameObject.SetActive(false);
+        }
+
+        var tabIndex = tabIdx; // Local copies of the tab variables so we can use them in the lambdas
+        var tabOffset = offset;
+        tabButton.OnClick.AddListener((UnityAction)(() => { instance.OpenTabGroup(tabIndex + 10); }));
+        tabButton.OnMouseOver.AddListener((UnityAction)(() =>
+        {
+            tabButton.transform.localPosition = new Vector3(3.55f, 2.1f - tabOffset, 5.5f);
+            tabButtonText.gameObject.SetActive(true);
+            tabButtonText.transform.localPosition = new Vector3(-0.024f, 0, 0);
+            tabButtonText.maxVisibleCharacters = int.MaxValue;
+            tabButtonText.text = TabName;
+            tabButtonText.alignment = TextAlignmentOptions.Left;
+        }));
+        tabButton.OnMouseOut.AddListener((UnityAction)(() =>
+        {
+            if (!tabButtonObject.Content.gameObject.activeSelf)
+            {
+                //tabButtonObject.Button.color = TabColor;
+                //tabButtonObject.Rollover.OutColor = TabColor;
+            }
+
+            tabButton.transform.localPosition = new Vector3(2.4f, 2.1f - tabOffset, 5.5f);
+            tabButtonText.alignment = TextAlignmentOptions.Right;
+            if (tabButtonRend != null)
+            {
+                tabButtonRend.gameObject.SetActive(true);
+                tabButtonText.gameObject.SetActive(false);
+            }
+
+            tabButtonText.transform.localPosition = new Vector3(0.1f, 0, 0);
+            tabButtonText.maxVisibleCharacters = 4;
+            tabButtonText.text = $"<b>{GetShortName(TabName)}</b>";
+        }));
+
+        return tabButtonObject.gameObject;
+    }
+
+    private static void CreateLabel(GameObject template, Transform parent, string text, ref float offset)
+    {
+        var label = Object.Instantiate(template, parent);
+        label.transform.localPosition = new Vector3(0, 1.85f - offset);
+        label.GetComponent<TextTranslatorTMP>().Destroy();
+        label.name = text;
+
+        var tmp = label.GetComponent<TextMeshPro>();
+        tmp.text = $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\"><b>{text}</b></font>";
+        tmp.alignment = TextAlignmentOptions.Center;
+
+        var meshRend = label.GetComponent<MeshRenderer>();
+        meshRend.sortingLayerName = "Default";
+        meshRend.sortingOrder = 151;
+
+        offset += 0.5f;
+    }
+
+    private static string GetShortName(string name)
+    {
+        var shortName = string.Empty;
+        name.Split(' ').Do(x => shortName += x[0]);
+        return shortName;
+    }
+}

MiraAPI/LocalSettings/LocalSettingsTabAppearance.cs

@@ -0,0 +1,91 @@
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Struct for modyfing tab apparance.
+/// Defines how the settings look.
+/// </summary>
+public record struct LocalSettingTabAppearance()
+{
+    /// <summary>
+    /// Gets or sets main color of the tab.
+    /// </summary>
+    public Color TabColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets tab button icon. No icon by default.
+    /// </summary>
+    public LoadableAsset<Sprite>? TabIcon { get; set; }
+
+    /// <summary>
+    /// Gets or sets color of the tab button.
+    /// </summary>
+    public Color TabButtonColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets hover color of the tab button.
+    /// </summary>
+    public Color TabButtonHoverColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets active color of the tab button.
+    /// </summary>
+    public Color TabButtonActiveColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets hover color of toggles.
+    /// </summary>
+    public Color ToggleHoverColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets active color of toggles.
+    /// </summary>
+    public Color ToggleActiveColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets inactive color of toggles.
+    /// </summary>
+    public Color ToggleInactiveColor { get; set; } = Color.red;
+
+    /// <summary>
+    /// Gets or sets color of number buttons.
+    /// </summary>
+    public Color NumberColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets hover color of number buttons.
+    /// </summary>
+    public Color NumberHoverColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets color of sliders.
+    /// </summary>
+    public Color SliderColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets hover color of sliders.
+    /// </summary>
+    public Color SliderHoverColor { get; set; } = Palette.AcceptedGreen;
+
+    /// <summary>
+    /// Gets or sets color of enum buttons.
+    /// </summary>
+    public Color EnumColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets hover color of enum buttons.
+    /// </summary>
+    public Color EnumHoverColor { get; set; } = Palette.AcceptedGreen;
+    
+    /// <summary>
+    /// Gets or sets color of buttons.
+    /// </summary>
+    public Color ButtonColor { get; set; } = Color.white;
+
+    /// <summary>
+    /// Gets or sets hover color of buttons.
+    /// </summary>
+    public Color ButtonHoverColor { get; set; } = Palette.AcceptedGreen;
+}

MiraAPI/LocalSettings/LocalSettingsTabSingleton.cs

@@ -0,0 +1,19 @@
+using System.Linq;
+
+namespace MiraAPI.LocalSettings;
+
+/// <summary>
+/// Singleton for local settings tabs.
+/// </summary>
+/// <typeparam name="T">The settings tab type.</typeparam>
+public static class LocalSettingsTabSingleton<T> where T : LocalSettingsTab
+{
+    private static T? _instance;
+
+    /// <summary>
+    /// Gets the instance of the setting tab.
+    /// </summary>
+#pragma warning disable CA1000
+    public static T Instance => _instance ??= LocalSettingsManager.Tabs.OfType<T>().Single();
+#pragma warning restore CA1000
+}

MiraAPI/LocalSettings/SettingTypes/LocalEnumSetting.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Linq;
+using BepInEx.Configuration;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings.SettingTypes;
+
+/// <summary>
+/// Local setting class for enums.
+/// </summary>
+public class LocalEnumSetting : LocalSettingBase<int>
+{
+    /// <summary>
+    /// Gets the enum type of the setting.
+    /// </summary>
+    public Type EnumType { get; }
+
+    /// <summary>
+    /// Gets the enum values.
+    /// </summary>
+    public string[] Values { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalEnumSetting"/> class.
+    /// </summary>
+    /// <inheritdoc/>
+    /// <param name="enumType">The enum type.</param>
+    /// <param name="values">The optional values array to replace the enum names.</param>
+    public LocalEnumSetting(
+        Type tab,
+        ConfigEntryBase configEntry,
+        Type enumType,
+        string? name = null,
+        string? description = null,
+        string[]? values = null)
+        : base(tab, configEntry, name, description)
+    {
+        EnumType = enumType;
+        Values = values ?? Enum
+            .GetValues(configEntry.SettingType)
+            .Cast<Enum>()
+            .Select(x => x.ToDisplayString())
+            .ToArray();
+    }
+
+    /// <inheritdoc />
+    public override GameObject CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last)
+    {
+        var button = Object.Instantiate(toggle, parent).GetComponent<PassiveButton>();
+        var tmp = button.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>();
+        var rollover = button.GetComponent<ButtonRolloverHandler>();
+        tmp.GetComponent<TextTranslatorTMP>().Destroy();
+        button.gameObject.SetActive(true);
+
+        var toggleComp = button.GetComponent<ToggleButtonBehaviour>();
+        var background = toggleComp.Background;
+        var highlight = button.transform.FindChild("ButtonHighlight")?.GetComponent<SpriteRenderer>();
+        if (highlight != null)
+        {
+            highlight.color = Tab!.TabAppearance.EnumHoverColor;
+            highlight.gameObject.SetActive(false);
+        }
+        toggleComp.Destroy();
+
+        if (last && order == 1)
+        {
+            // Button in the middle
+            button.transform.localPosition = new Vector3(0, 1.85f - offset, -7);
+        }
+        else
+        {
+            button.transform.localPosition = new Vector3(order == 1 ? -1.185f : 1.185f, 1.85f - offset, -7);
+        }
+
+        tmp.text = GetValueText();
+        button.name = Name;
+        button.OnClick = new UnityEngine.UI.Button.ButtonClickedEvent();
+        rollover.OutColor = Tab!.TabAppearance.EnumColor;
+        rollover.OverColor = Tab!.TabAppearance.EnumHoverColor;
+        background.color = Tab!.TabAppearance.EnumColor;
+
+        button.OnClick.AddListener((UnityAction)(() =>
+        {
+            int value = GetValue();
+            value++;
+            if (value >= Values.Length)
+            {
+                value = 0;
+            }
+
+            SetValue(value);
+            tmp.text = GetValueText();
+        }));
+        button.OnMouseOver.AddListener((UnityAction)(() =>
+        {
+            if (!Description.IsNullOrWhiteSpace())
+            {
+                tmp.text = Description;
+            }
+            highlight?.gameObject.SetActive(true);
+        }));
+        button.OnMouseOut.AddListener((UnityAction)(() =>
+        {
+            tmp.text = GetValueText();
+            highlight?.gameObject.SetActive(false);
+        }));
+
+        Helpers.DivideSize(button.gameObject, 1.1f);
+
+        order++;
+        if (order > 2 && !last)
+        {
+            offset += 0.5f;
+            order = 1;
+        }
+        if (last)
+            offset += 0.6f;
+
+        return button.gameObject;
+    }
+
+    /// <inheritdoc/>
+    protected override string GetValueText()
+    {
+        return $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\">{Name}: <b>{Values[GetValue()]}</font></b>";
+    }
+}

MiraAPI/LocalSettings/SettingTypes/LocalNumberSetting.cs

@@ -0,0 +1,145 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings.SettingTypes;
+
+/// <summary>
+/// Local setting class for numbers.
+/// </summary>
+public class LocalNumberSetting : LocalSettingBase<float>
+{
+    /// <summary>
+    /// Gets the range of the button.
+    /// </summary>
+    public FloatRange NumberRange { get; }
+
+    /// <summary>
+    /// Gets the increment of the value when button is pressed.
+    /// </summary>
+    public float Increment { get; }
+
+    /// <summary>
+    /// Gets a format for the text to use to format the number.
+    /// </summary>
+    public string FormatString { get; }
+
+    /// <summary>
+    /// Gets the suffix for the number value.
+    /// </summary>
+    public MiraNumberSuffixes SuffixType { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalNumberSetting"/> class.
+    /// </summary>
+    /// <inheritdoc/>
+    /// <param name="numberRange">The value range.</param>
+    /// <param name="increment">The increment per click.</param>
+    /// <param name="suffixType">The suffix used for formating.</param>
+    /// <param name="formatString">The format string used for formating.</param>
+    public LocalNumberSetting(
+        Type tab,
+        ConfigEntryBase configEntry,
+        string? name = null,
+        string? description = null,
+        FloatRange? numberRange = null,
+        float? increment = null,
+        MiraNumberSuffixes? suffixType = null,
+        string? formatString = null)
+        : base(tab, configEntry, name, description)
+    {
+        SuffixType = suffixType ?? MiraNumberSuffixes.None;
+        NumberRange = numberRange ?? new FloatRange(1, 5);
+        Increment = increment ?? 1;
+        FormatString = formatString ?? "0";
+    }
+
+    /// <inheritdoc />
+    public override GameObject CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last)
+    {
+        var button = Object.Instantiate(toggle, parent).GetComponent<PassiveButton>();
+        var tmp = button.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>();
+        var rollover = button.GetComponent<ButtonRolloverHandler>();
+        tmp.GetComponent<TextTranslatorTMP>().Destroy();
+        button.gameObject.SetActive(true);
+
+        var toggleComp = button.GetComponent<ToggleButtonBehaviour>();
+        var background = toggleComp.Background;
+        var highlight = button.transform.FindChild("ButtonHighlight")?.GetComponent<SpriteRenderer>();
+        if (highlight != null)
+        {
+            highlight.color = Tab!.TabAppearance.NumberHoverColor;
+            highlight.gameObject.SetActive(false);
+        }
+        toggleComp.Destroy();
+
+        if (last && order == 1)
+        {
+            // Button in the middle
+            button.transform.localPosition = new Vector3(0, 1.85f - offset, -7);
+        }
+        else
+        {
+            button.transform.localPosition = new Vector3(order == 1 ? -1.185f : 1.185f, 1.85f - offset, -7);
+        }
+
+        tmp.text = GetValueText();
+        button.name = Name;
+        button.OnClick = new UnityEngine.UI.Button.ButtonClickedEvent();
+        rollover.OutColor = Tab!.TabAppearance.NumberColor;
+        rollover.OverColor = Tab!.TabAppearance.NumberHoverColor;
+        background.color = Tab!.TabAppearance.NumberColor;
+
+        button.OnClick.AddListener((UnityAction)(() =>
+        {
+            float value = GetValue();
+            value += Increment;
+            if (value > NumberRange.max)
+            {
+                value = NumberRange.min;
+            }
+
+            SetValue(value);
+            tmp.text = GetValueText();
+        }));
+        button.OnMouseOver.AddListener((UnityAction)(() =>
+        {
+            if (!Description.IsNullOrWhiteSpace())
+            {
+                tmp.text = Description;
+            }
+            highlight?.gameObject.SetActive(true);
+        }));
+        button.OnMouseOut.AddListener((UnityAction)(() =>
+        {
+            tmp.text = GetValueText();
+            highlight?.gameObject.SetActive(false);
+        }));
+
+        Helpers.DivideSize(button.gameObject, 1.1f);
+
+        order++;
+        if (order > 2 && !last)
+        {
+            offset += 0.5f;
+            order = 1;
+        }
+        if (last)
+            offset += 0.6f;
+
+        return button.gameObject;
+    }
+
+    /// <inheritdoc/>
+    protected override string GetValueText()
+    {
+        var value = GetValue();
+        var formated = Helpers.FormatValue(value, SuffixType, FormatString);
+        return $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\">{Name}: <b>{formated}</font></b>";
+    }
+}

MiraAPI/LocalSettings/SettingTypes/LocalSettingBase.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Linq;
+using BepInEx.Configuration;
+using UnityEngine;
+
+namespace MiraAPI.LocalSettings.SettingTypes;
+
+/// <inheritdoc />
+public abstract class LocalSettingBase<T> : ILocalSetting
+{
+    /// <inheritdoc />
+    public string Name { get; }
+
+    /// <inheritdoc />
+    public string Description { get; }
+
+    /// <inheritdoc />
+    public GameObject? Setting { get; } = null!;
+
+    /// <inheritdoc />
+    public ConfigEntryBase ConfigEntry { get; }
+
+    internal LocalSettingsTab? Tab => LocalSettingsManager.Tabs.FirstOrDefault(x => x.Settings.Contains(this));
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalSettingBase{T}"/> class.
+    /// </summary>
+    /// <param name="tab">The tab to create the setting in.</param>
+    /// <param name="configEntry">The config entry.</param>
+    /// <param name="name">The name of the setting.</param>
+    /// <param name="description">The description of the setting.</param>
+    protected LocalSettingBase(Type tab, ConfigEntryBase configEntry, string? name = null, string? description = null)
+    {
+        ConfigEntry = configEntry;
+        Name = name ?? ConfigEntry.Definition.Key;
+        Description = description ?? ConfigEntry.Description.Description;
+        LocalSettingsManager.TypeToTab[tab].Settings.Add(this);
+    }
+
+    /// <summary>
+    /// Creates an instance of the setting.
+    /// </summary>
+    /// <returns>The created setting.</returns>
+    public abstract GameObject CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last);
+
+    /// <summary>
+    /// Returns the formated string to use in the text of the setting.
+    /// </summary>
+    /// <returns>The value text.</returns>
+    protected virtual string GetValueText()
+    {
+        return string.Empty;
+    }
+
+    /// <summary>
+    /// Gets the value of the config entry, casted to the setting type.
+    /// </summary>
+    /// <returns>The value.</returns>
+    public virtual T GetValue()
+    {
+        return (T)ConfigEntry.BoxedValue;
+    }
+
+    /// <summary>
+    /// Sets the value of the config entry.
+    /// </summary>
+    /// <param name="value">The value to set to.</param>
+    public virtual void SetValue(T value)
+    {
+        ConfigEntry.BoxedValue = value;
+        Tab?.OnOptionChanged(ConfigEntry);
+    }
+}

MiraAPI/LocalSettings/SettingTypes/LocalSliderSetting.cs

@@ -0,0 +1,120 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.Utilities;
+using Reactor.Utilities.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings.SettingTypes;
+
+/// <summary>
+/// Local setting class for sliders.
+/// </summary>
+public class LocalSliderSetting : LocalSettingBase<float>
+{
+    /// <summary>
+    /// Gets the range of the slider.
+    /// </summary>
+    public FloatRange SliderRange { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the value should be displayed next to name.
+    /// </summary>
+    public bool DisplayValue { get; }
+
+    /// <summary>
+    /// Gets a format for the text to use to format the number.
+    /// </summary>
+    public string FormatString { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the value should be rounded.
+    /// </summary>
+    public bool RoundValue { get; }
+
+    /// <summary>
+    /// Gets the suffix for the number value.
+    /// </summary>
+    public MiraNumberSuffixes SuffixType { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalSliderSetting"/> class.
+    /// </summary>
+    /// <inheritdoc/>
+    /// <param name="sliderRange">The value range.</param>
+    /// <param name="suffixType">The suffix used for formating.</param>
+    /// <param name="formatString">The format string used for formating.</param>
+    /// <param name="roundValue">Should the value be rounded.</param>
+    public LocalSliderSetting(
+        Type tab,
+        ConfigEntryBase configEntry,
+        string? name = null,
+        string? description = null,
+        FloatRange? sliderRange = null,
+        bool displayValue = false,
+        MiraNumberSuffixes? suffixType = null,
+        string? formatString = null,
+        bool roundValue = false)
+        : base(tab, configEntry, name, description)
+    {
+        SliderRange = sliderRange ?? new FloatRange(0, 100);
+        DisplayValue = displayValue;
+        SuffixType = suffixType ?? MiraNumberSuffixes.None;
+        FormatString = formatString ?? "0.0";
+        RoundValue = roundValue;
+    }
+
+    /// <inheritdoc />
+    public override GameObject CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last)
+    {
+        var newSlider = Object.Instantiate(slider, parent).GetComponent<SlideBar>();
+        var rollover = newSlider.GetComponent<ButtonRolloverHandler>();
+        newSlider.Title = newSlider.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>(); // Why the hell slider has a title property that is not even assigned???
+        newSlider.Title.GetComponent<TextTranslatorTMP>().Destroy();
+        newSlider.gameObject.SetActive(true);
+        newSlider.Bar.color = Tab!.TabAppearance.SliderColor;
+
+        if (order == 2)
+            offset += 0.5f;
+
+        newSlider.Bar.transform.localPosition = new Vector3(2.85f, 0, 0);
+        newSlider.transform.localPosition = new Vector3(-2.12f, 1.85f - offset, -7);
+        newSlider.name = Name;
+        newSlider.Range = new FloatRange(-1.5f, 1.5f);
+        newSlider.SetValue(Mathf.InverseLerp(SliderRange.min, SliderRange.max, GetValue()));
+        rollover.OutColor = Tab!.TabAppearance.SliderColor;
+        rollover.OverColor = Tab!.TabAppearance.SliderHoverColor;
+        newSlider.Title.transform.localPosition = new Vector3(0.5f, 0, -1f);
+        newSlider.Title.horizontalAlignment = DisplayValue ? HorizontalAlignmentOptions.Left : HorizontalAlignmentOptions.Center;
+        newSlider.Title.text = GetValueText();
+
+        newSlider.OnValueChange.AddListener((UnityAction)(() =>
+        {
+            SetValue(RoundValue
+                ? Mathf.Round(Mathf.Lerp(SliderRange.min, SliderRange.max, newSlider.Value))
+                : Mathf.Lerp(SliderRange.min, SliderRange.max, newSlider.Value));
+
+            newSlider.Title.text = GetValueText();
+        }));
+
+        order = 1;
+        offset += 0.5f;
+        return newSlider.gameObject;
+    }
+
+    /// <inheritdoc/>
+    protected override string GetValueText()
+    {
+        if (DisplayValue)
+        {
+            var value = GetValue();
+            var formated = Helpers.FormatValue(value, SuffixType, FormatString);
+            var maxFormated = Helpers.FormatValue(SliderRange.max, SuffixType, FormatString);
+            return $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\">{Name}: <b>{formated} / {maxFormated}</font></b>";
+        }
+
+        return $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\">{Name}</font></b>";
+    }
+}

MiraAPI/LocalSettings/SettingTypes/LocalToggleSetting.cs

@@ -0,0 +1,88 @@
+using System;
+using BepInEx.Configuration;
+using MiraAPI.Utilities;
+using Reactor.Localization.Utilities;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
+
+namespace MiraAPI.LocalSettings.SettingTypes;
+
+/// <summary>
+/// Local setting class for toggles.
+/// </summary>
+public class LocalToggleSetting : LocalSettingBase<bool>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalToggleSetting"/> class.
+    /// </summary>
+    /// <inheritdoc/>
+    public LocalToggleSetting(
+        Type tab,
+        ConfigEntryBase configEntry,
+        string? name = null,
+        string? description = null
+        ) : base(tab, configEntry, name, description)
+    {
+    }
+
+    /// <inheritdoc />
+    public override GameObject CreateOption(ToggleButtonBehaviour toggle, SlideBar slider, Transform parent, ref float offset, ref int order, bool last)
+    {
+        var toggleObject = Object.Instantiate(toggle, parent).GetComponent<ToggleButtonBehaviour>();
+        var tmp = toggleObject.transform.FindChild("Text_TMP").GetComponent<TextMeshPro>();
+        var passiveButton = toggleObject.GetComponent<PassiveButton>();
+        var rollover = toggleObject.GetComponent<ButtonRolloverHandler>();
+        toggleObject.gameObject.SetActive(true);
+
+        if (last && order == 1)
+        {
+            // Toggle in the middle
+            toggleObject.transform.localPosition = new Vector3(0, 1.85f - offset, -7);
+        }
+        else
+        {
+            toggleObject.transform.localPosition = new Vector3(order == 1 ? -1.185f : 1.185f, 1.85f - offset, -7);
+        }
+
+        toggleObject.BaseText = CustomStringName.CreateAndRegister(Name);
+        toggleObject.UpdateText(GetValue());
+        toggleObject.name = Name;
+        toggleObject.Background.color = GetValue() ? Tab!.TabAppearance.ToggleActiveColor : Tab!.TabAppearance.ToggleInactiveColor;
+        passiveButton.OnClick = new UnityEngine.UI.Button.ButtonClickedEvent();
+        rollover.OverColor = Tab!.TabAppearance.ToggleHoverColor;
+
+        passiveButton.OnClick.AddListener((UnityAction)(() =>
+        {
+            SetValue(!GetValue());
+            toggleObject.UpdateText(GetValue());
+            toggleObject.Background.color = GetValue() ? Tab!.TabAppearance.ToggleActiveColor : Tab!.TabAppearance.ToggleInactiveColor;
+        }));
+        passiveButton.OnMouseOver.AddListener((UnityAction)(() =>
+        {
+            if (!Description.IsNullOrWhiteSpace())
+            {
+                tmp.text = Description;
+            }
+        }));
+        passiveButton.OnMouseOut.AddListener((UnityAction)(() =>
+        {
+            toggleObject.UpdateText(GetValue());
+            toggleObject.Background.color = GetValue() ? Tab!.TabAppearance.ToggleActiveColor : Tab!.TabAppearance.ToggleInactiveColor;
+        }));
+
+        Helpers.DivideSize(toggleObject.gameObject, 1.1f);
+
+        order++;
+        if (order > 2 && !last)
+        {
+            offset += 0.5f;
+            order = 1;
+        }
+        if (last)
+            offset += 0.6f;
+
+        return toggleObject.gameObject;
+    }
+}

MiraAPI/MiraApiConfig.cs

@@ -1,23 +0,0 @@
-using BepInEx;
-using BepInEx.Configuration;
-using BepInEx.Unity.IL2CPP;
-using HarmonyLib;
-using MiraAPI.PluginLoading;
-using Reactor;
-using Reactor.Networking;
-using Reactor.Networking.Attributes;
-using Reactor.Utilities;
-using UnityEngine;
-
-namespace MiraAPI;
-
-/// <summary>
-/// Mira API Config File Handler
-/// </summary>
-public class MiraApiConfig(ConfigFile config)
-{
-    /// <summary>
-    /// Gets whether the modifiers hud should be on the left side of the screen (under roles/task tab). Recommended for streamers.
-    /// </summary>
-    public ConfigEntry<bool> ModifiersHudLeftSide { get; private set; } = config.Bind("Displays", "Show Modifiers HUD on Left Side", false);
-}

MiraAPI/MiraApiPlugin.cs

@@ -30,10 +30,6 @@ public partial class MiraApiPlugin : BasePlugin
     /// </summary>
     public static Color DefaultHeaderColor { get; } = new Color32(77, 77, 77, 255);
 
-    /// <summary>
-    /// Gets the Mira Api Config Handler.
-    /// </summary>
-    public MiraApiConfig? MiraConfig { get; private set; }
     private static MiraPluginManager? PluginManager { get; set; }
     internal Harmony Harmony { get; } = new(Id);
 
@@ -44,7 +40,6 @@ public partial class MiraApiPlugin : BasePlugin
 
         ReactorCredits.Register("Mira API", Version, true, ReactorCredits.AlwaysShow);
 
-        MiraConfig = new MiraApiConfig(Config);
         PluginManager = new MiraPluginManager();
         PluginManager.Initialize();
     }

MiraAPI/MiraApiSettings.cs

@@ -0,0 +1,39 @@
+using BepInEx.Configuration;
+using MiraAPI.LocalSettings;
+using MiraAPI.LocalSettings.Attributes;
+using MiraAPI.Utilities.Assets;
+
+namespace MiraAPI;
+
+/// <summary>
+/// Mira API Config File Handler
+/// </summary>
+public class MiraApiSettings(ConfigFile config) : LocalSettingsTab(config)
+{
+    /// <inheritdoc />
+    public override string TabName => "Mira API";
+
+    /// <inheritdoc />
+    public override LocalSettingTabAppearance TabAppearance => new()
+    {
+        TabButtonHoverColor = MiraApiPlugin.MiraColor,
+        TabIcon = MiraAssets.SettingsIcon,
+    };
+
+    /// <summary>
+    /// Gets whether the modifiers hud should be on the left side of the screen (under roles/task tab). Recommended for streamers.
+    /// </summary>
+    [LocalToggleSetting]
+    public ConfigEntry<bool> ModifiersHudLeftSide { get; private set; } = config.Bind("Displays", "Show Modifiers HUD on Left Side", false);
+
+    /// <summary>
+    /// Gets whether to show keybinds in the control mapper.
+    /// </summary>
+    public ConfigEntry<bool> ShowKeybinds { get; private set; } = config.Bind("Keybinds", "Show Keybinds in Control Mapper", true);
+
+    /// <summary>
+    /// Gets whether to apply cosmetic changes to the TaskAdder.
+    /// </summary>
+    [LocalToggleSetting]
+    public ConfigEntry<bool> PrettyTaskAdder { get; private set; } = config.Bind("Freeplay", "Pretty Task Laptop", true);
+}

MiraAPI/Modifiers/ModifierComponent.cs

@@ -4,6 +4,7 @@ using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Il2CppInterop.Runtime.Attributes;
+using MiraAPI.LocalSettings;
 using MiraAPI.Modifiers.ModifierDisplay;
 using MiraAPI.Modifiers.Types;
 using MiraAPI.Patches.Roles;
@@ -129,7 +130,7 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
         {
             var taskPanelOpen = HudManager.Instance.TaskPanel.open;
             var roleTabOpen = HudManagerPatches.RoleTab != null && HudManagerPatches.RoleTab.open;
-            var leftSideHud = PluginSingleton<MiraApiPlugin>.Instance.MiraConfig!.ModifiersHudLeftSide.Value;
+            var leftSideHud = LocalSettingsTabSingleton<MiraApiSettings>.Instance.ModifiersHudLeftSide.Value;
 
             if (leftSideHud && (taskPanelOpen || roleTabOpen))
             {

MiraAPI/Modifiers/ModifierDisplay/ModifierDisplayComponent.cs

@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using HarmonyLib;
 using Il2CppInterop.Runtime.Attributes;
-using MiraAPI.Patches.Roles;
+using MiraAPI.LocalSettings;
 using MiraAPI.Utilities.Assets;
-using Reactor.Utilities;
 using Reactor.Utilities.Attributes;
 using Reactor.Utilities.Extensions;
 using TMPro;
@@ -98,7 +96,7 @@ public class ModifierDisplayComponent(nint cppPtr) : MonoBehaviour(cppPtr)
         IsOpen = false;
         _children.gameObject.SetActive(false);
 
-        if (PluginSingleton<MiraApiPlugin>.Instance.MiraConfig!.ModifiersHudLeftSide.Value)
+        if (LocalSettingsTabSingleton<MiraApiSettings>.Instance.ModifiersHudLeftSide.Value)
         {
             var aspect = GetComponent<AspectPosition>();
             _toggleButton.transform.localPosition = new Vector3(-1f, 2.7f, 0f);

MiraAPI/Modifiers/ModifierExtensions.cs

@@ -63,7 +63,7 @@ public static class ModifierExtensions
     /// </summary>
     /// <param name="target">The player to remove the modifier from.</param>
     /// <param name="uniqueId">The unique ID of the modifier.</param>
-    [MethodRpc((uint)MiraRpc.RemoveModifier, SendImmediately = true)]
+    [MethodRpc((uint)MiraRpc.RemoveModifier)]
     public static void RpcRemoveModifier(this PlayerControl target, Guid uniqueId)
     {
         target.RemoveModifier(uniqueId);

MiraAPI/Networking/CustomMurderRpc.cs

@@ -29,7 +29,7 @@ public static class CustomMurderRpc
     /// <param name="teleportMurderer">Should the killer be snapped to the dead player.</param>
     /// <param name="showKillAnim">Should the kill animation be shown.</param>
     /// <param name="playKillSound">Should the kill sound be played.</param>
-    [MethodRpc((uint)MiraRpc.CustomMurder, LocalHandling = RpcLocalHandling.Before, SendImmediately = true)]
+    [MethodRpc((uint)MiraRpc.CustomMurder, LocalHandling = RpcLocalHandling.Before)]
     public static void RpcCustomMurder(
         this PlayerControl source,
         PlayerControl target,
@@ -222,7 +222,7 @@ public static class CustomMurderRpc
 
         if (createDeadBody)
         {
-            deadBody = Object.Instantiate(GameManager.Instance.DeadBodyPrefab);
+            deadBody = Object.Instantiate(GameManager.Instance.deadBodyPrefab[0]);
             deadBody.enabled = false;
             deadBody.ParentId = target.PlayerId;
             deadBody.bodyRenderers.ToList().ForEach(target.SetPlayerMaterialColors);

MiraAPI/Patches/Freeplay/TaskAddButtonPatches.cs

@@ -1,7 +1,5 @@
 using HarmonyLib;
 using MiraAPI.Modifiers;
-using MiraAPI.Roles;
-using UnityEngine;
 
 namespace MiraAPI.Patches.Freeplay;
 

MiraAPI/Patches/Freeplay/TaskAdderPatches.cs

@@ -1,14 +1,19 @@
-using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Text;
 using AmongUs.GameOptions;
+using BepInEx.Unity.IL2CPP.Utils.Collections;
 using HarmonyLib;
+using Il2CppInterop.Runtime.InteropTypes.Arrays;
+using Il2CppSystem;
+using MiraAPI.LocalSettings;
 using MiraAPI.Modifiers;
+using MiraAPI.Modifiers.Types;
 using MiraAPI.PluginLoading;
 using MiraAPI.Roles;
-using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
-using TMPro;
+using Reactor.Utilities.Extensions;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
@@ -20,6 +25,8 @@ namespace MiraAPI.Patches.Freeplay;
 internal static class TaskAdderPatches
 {
     private static Scroller _scroller = null!;
+    private static Dictionary<string, TaskFolder> folders = new();
+
     [HarmonyPostfix]
     [HarmonyPatch(nameof(TaskAdderGame.Begin))]
     public static void AddRolesFolder(TaskAdderGame __instance)
@@ -59,46 +66,168 @@ internal static class TaskAdderPatches
         __instance.RoleButton.GetComponent<PassiveButton>().ClickMask = collider;
         __instance.RootFolderPrefab.GetComponent<PassiveButton>().ClickMask = collider;
         __instance.RootFolderPrefab.gameObject.SetActive(false);
-
         __instance.TaskParent = inner.transform;
 
-        var rolesFolder = Object.Instantiate(__instance.RootFolderPrefab, _scroller.Inner);
-        rolesFolder.gameObject.SetActive(false);
-        rolesFolder.FolderName = "Roles";
-        rolesFolder.name = "RolesFolder";
+        var crewmateFolder = __instance.Root.SubFolders.ToArray().FirstOrDefault(x => x.FolderName == "Crewmate")!;
+        var impostorFolder = __instance.Root.SubFolders.ToArray().FirstOrDefault(x => x.FolderName == "Impostor")!;
+        var neutralFolder = __instance.CreateFolder("Neutral", __instance.Root, 2, Color.gray);
+        var modifiersFolder = __instance.CreateFolder("Modifiers", __instance.Root, 0, Color.blue);
 
-        var modifiersFolder = Object.Instantiate(__instance.RootFolderPrefab, _scroller.Inner);
-        modifiersFolder.gameObject.SetActive(false);
-        modifiersFolder.FolderName = "Modifiers";
-        modifiersFolder.name = "ModifiersFolder";
+        folders.Clear();
+        folders.Add("Crewmate", crewmateFolder);
+        folders.Add("Impostor", impostorFolder);
+        folders.Add("Neutral", neutralFolder);
+        folders.Add("Modifiers", modifiersFolder);
 
+        int folderIdx = 3;
         foreach (var plugin in MiraPluginManager.Instance.RegisteredPlugins)
         {
-            if (plugin.InternalRoles.Any(x => x.Value is ICustomRole { Configuration.ShowInFreeplay: true }))
+            var pluginFolders = new Dictionary<string, TaskFolder>();
+
+            foreach (var role in plugin.InternalRoles
+                         .Where(x => x.Value is ICustomRole { Configuration.ShowInFreeplay: true })
+                         .Select(x => x.Value))
             {
-                var newFolder = Object.Instantiate(__instance.RootFolderPrefab, _scroller.Inner);
-                newFolder.name = plugin.PluginId+":Roles";
-                newFolder.FolderName = plugin.PluginInfo.Metadata.Name;
-                newFolder.gameObject.SetActive(false);
-                rolesFolder.SubFolders.Add(newFolder);
+                var customRole = role as ICustomRole;
+                var folderName = customRole!.Configuration.FreeplayFolder;
+                if (!folders.TryGetValue(folderName, out var teamFolder))
+                {
+                    teamFolder = __instance.CreateFolder(folderName, __instance.Root, folderIdx++, customRole.IntroConfiguration?.IntroTeamColor ?? Color.gray);
+                    folders.Add(folderName, teamFolder);
+                }
+
+                if (!pluginFolders.TryGetValue(folderName, out var pluginFolder))
+                {
+                    pluginFolder = __instance.CreateFolder(plugin.PluginInfo.Metadata.Name, teamFolder);
+                    pluginFolders.Add(folderName, teamFolder);
+                }
+
+                pluginFolder.RoleChildren.Add(role);
             }
 
             if (plugin.InternalModifiers.Exists(x => x.ShowInFreeplay))
             {
-                var newFolder = Object.Instantiate(__instance.RootFolderPrefab, _scroller.Inner);
-                newFolder.name = plugin.PluginId+":Modifiers";
-                newFolder.FolderName = plugin.PluginInfo.Metadata.Name;
-                newFolder.gameObject.SetActive(false);
-                modifiersFolder.SubFolders.Add(newFolder);
+                __instance.CreateFolder(plugin.PluginInfo.Metadata.Name, modifiersFolder)
+                    .gameObject.name = plugin.PluginId;
             }
         }
 
-        __instance.Root.SubFolders.Add(rolesFolder);
-        __instance.Root.SubFolders.Add(modifiersFolder);
+        // Modifier folder at the end
+        __instance.Root.SubFolders.Insert(folderIdx, modifiersFolder);
 
         __instance.GoToRoot();
     }
 
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(TaskAdderGame.PopulateRoot))]
+    private static bool PopulateRootPrefix(TaskAdderGame __instance, TaskAdderGame.FolderType folderType, TaskFolder rootFolder, Il2CppSystem.Collections.Generic.Dictionary<string, TaskFolder> folders, Il2CppReferenceArray<NormalPlayerTask> taskList)
+    {
+        if (folderType != TaskAdderGame.FolderType.Tasks)
+        {
+            if (folderType != TaskAdderGame.FolderType.Roles)
+            {
+                return false;
+            }
+
+            TaskFolder crewFolder = folders["Crewmates"] =
+                Object.Instantiate(__instance.RootFolderPrefab, __instance.transform);
+            crewFolder.gameObject.SetActive(false);
+            crewFolder.SetFolderColor(TaskFolder.FolderColor.Blue);
+            TaskFolder impFolder = folders["Impostors"] =
+                Object.Instantiate(__instance.RootFolderPrefab, __instance.transform);
+            impFolder.gameObject.SetActive(false);
+            impFolder.SetFolderColor(TaskFolder.FolderColor.Red);
+            crewFolder.FolderName = TranslationController.Instance.GetString(StringNames.Crewmate);
+            impFolder.FolderName = TranslationController.Instance.GetString(StringNames.Impostor);
+            rootFolder.SubFolders.Insert(0, crewFolder);
+            rootFolder.SubFolders.Insert(0, impFolder);
+            Il2CppSystem.Collections.Generic.List<RoleBehaviour> impRoles = new();
+            Il2CppSystem.Collections.Generic.List<RoleBehaviour> crewRoles = new();
+            foreach (var role in RoleManager.Instance.AllRoles)
+            {
+                if (role.Role != RoleTypes.ImpostorGhost && role.Role != RoleTypes.CrewmateGhost &&
+                    !role.IsCustomRole())
+                {
+                    if (role.TeamType == RoleTeamTypes.Crewmate)
+                    {
+                        crewRoles.Add(role);
+                    }
+                    else
+                    {
+                        impRoles.Add(role);
+                    }
+                }
+            }
+
+            crewFolder.RoleChildren = crewRoles;
+            impFolder.RoleChildren = impRoles;
+            return false;
+        }
+
+        if (taskList == null)
+        {
+            return false;
+        }
+
+        foreach (NormalPlayerTask normalPlayerTask in taskList)
+        {
+            SystemTypes systemTypes = normalPlayerTask.StartAt;
+            if (normalPlayerTask is DivertPowerTask task)
+            {
+                systemTypes = task.TargetSystem;
+            }
+
+            if (systemTypes == SystemTypes.LowerEngine)
+            {
+                systemTypes = SystemTypes.UpperEngine;
+            }
+
+            if (!folders.TryGetValue(systemTypes.ToString(), out var taskFolder3))
+            {
+                taskFolder3 = folders[systemTypes.ToString()] = Object.Instantiate(__instance.RootFolderPrefab, __instance.transform);
+                taskFolder3.SetFolderColor(TaskFolder.FolderColor.Tan);
+                taskFolder3.gameObject.SetActive(false);
+                if (systemTypes == SystemTypes.UpperEngine)
+                {
+                    taskFolder3.FolderName = TranslationController.Instance.GetString(StringNames.Engines);
+                }
+                else
+                {
+                    taskFolder3.FolderName = TranslationController.Instance.GetString(systemTypes);
+                }
+
+                rootFolder.SubFolders.Add(taskFolder3);
+            }
+
+            taskFolder3.TaskChildren.Add(normalPlayerTask);
+        }
+
+        return false;
+    }
+
+
+    private static TaskFolder CreateFolder(this TaskAdderGame instance, string name, TaskFolder parent, int idx = -1, Color? color = null)
+    {
+        var folder = Object.Instantiate(instance.RootFolderPrefab, instance.transform);
+        folder.gameObject.SetActive(false);
+        folder.FolderName = name;
+        folder.SetCustomColor(color ?? new Color(0.937f, 0.811f, 0.592f));
+        folder.name = name + "Folder";
+        if (idx == -1)
+            parent.SubFolders.Add(folder);
+        else if (idx > 0)
+            parent.SubFolders.Insert(idx, folder);
+        return folder;
+    }
+
+    private static void SetCustomColor(this TaskFolder folder, Color color)
+    {
+        folder.currentFolderColor = color;
+        folder.folderSpriteRenderer.color = color;
+        folder.buttonRolloverHandler.OutColor = color;
+        folder.buttonRolloverHandler.UnselectedColor = color;
+    }
+
     private static void AddFileAsChildCustom(
         this TaskAdderGame instance,
         TaskAddButton item,
@@ -121,40 +250,46 @@ internal static class TaskAdderPatches
         instance.ActiveItems.Add(item.transform);
     }
 
+    private static bool IsChildOf(this TaskFolder child, TaskFolder parent) => parent.SubFolders
+        .ToArray()
+        .Any(x => x.FolderName == child.FolderName);
+
     // yes it might be crazy patching the entire method, but i tried so many other methods and only this works :cry:
+    // true -chip
     [HarmonyPrefix]
     [HarmonyPatch(nameof(TaskAdderGame.ShowFolder))]
     public static bool ShowPatch(TaskAdderGame __instance, TaskFolder taskFolder)
     {
-        var stringBuilder = new Il2CppSystem.Text.StringBuilder(64);
+        StringBuilder stringBuilder = new StringBuilder(64);
         __instance.Hierarchy.Add(taskFolder);
-        for (var i = 0; i < __instance.Hierarchy.Count; i++)
+        foreach (var t in __instance.Hierarchy)
         {
-            stringBuilder.Append(__instance.Hierarchy.ToArray()[i].FolderName);
-            stringBuilder.Append("\\");
+            stringBuilder.Append(t.FolderName);
+            stringBuilder.Append('\\');
         }
-
         __instance.PathText.text = stringBuilder.ToString();
-        for (var j = 0; j < __instance.ActiveItems.Count; j++)
+        var prettyEnabled = LocalSettingsTabSingleton<MiraApiSettings>.Instance.PrettyTaskAdder.Value;
+        if (prettyEnabled)
         {
-            Object.Destroy(__instance.ActiveItems.ToArray()[j].gameObject);
+            __instance.PathText.fontSizeMin = 3;
+            __instance.PathText.fontSizeMax = 3;
+            __instance.transform.FindChild("TitleText_TMP")?.gameObject.DestroyImmediate();
         }
 
+        __instance.ActiveItems.ToArray().Do(x => x.gameObject.Destroy());
         __instance.ActiveItems.Clear();
-        var num = 0f;
-        var num2 = 0f;
-        var num3 = 0f;
-        for (var k = 0; k < taskFolder.SubFolders.Count; k++)
-        {
-            var taskFolder2 = Object.Instantiate(taskFolder.SubFolders.ToArray()[k], __instance.TaskParent);
-            var folderTransform = taskFolder2.transform;
 
+        float num = 0f;
+        float num2 = 0f;
+        float num3 = 0f;
+        foreach (var t in taskFolder.SubFolders)
+        {
+            TaskFolder taskFolder2 = Object.Instantiate(t, __instance.TaskParent);
             taskFolder2.gameObject.SetActive(true);
             taskFolder2.Parent = __instance;
-
-            folderTransform.localPosition = new Vector3(num, num2, 0f);
-            folderTransform.localScale = Vector3.one;
-            num3 = Mathf.Max(num3, taskFolder2.Text.bounds.size.y + 1.3f);
+            taskFolder2.transform.localPosition = new Vector3(num, num2, 0f);
+            taskFolder2.transform.localScale = Vector3.one;
+            num3 = Mathf.Max(num3, taskFolder2.Text.bounds.size.y + 1.1f);
             num += __instance.folderWidth;
             if (num > __instance.lineWidth)
             {
@@ -163,235 +298,74 @@ internal static class TaskAdderPatches
                 num3 = 0f;
             }
 
-            __instance.ActiveItems.Add(folderTransform);
-            if (!taskFolder2 || !taskFolder2.Button)
+            __instance.ActiveItems.Add(taskFolder2.transform);
+            if (taskFolder2 != null && taskFolder2.Button != null)
             {
-                continue;
-            }
-
-            ControllerManager.Instance.AddSelectableUiElement(taskFolder2.Button);
-            if (!string.IsNullOrEmpty(__instance.restorePreviousSelectionByFolderName) &&
-                taskFolder2.FolderName.Equals(__instance.restorePreviousSelectionByFolderName, StringComparison.Ordinal))
-            {
-                __instance.restorePreviousSelectionFound = taskFolder2.Button;
+                ControllerManager.Instance.AddSelectableUiElement(taskFolder2.Button);
             }
         }
 
-        var flag = false;
-        var list = taskFolder.Children.ToArray().OrderBy(t => t.TaskType).ToList();
-
-        for (var l = 0; l < list.Count; l++)
+        var list = taskFolder.TaskChildren
+            .ToArray()
+            .OrderBy(x => x.TaskType)
+            .ToArray();
+        foreach (var task in list)
         {
-            var taskAddButton = Object.Instantiate(__instance.TaskPrefab);
-            taskAddButton.MyTask = list.ToArray()[l];
-            switch (taskAddButton.MyTask.TaskType)
+            TaskAddButton taskAddButton = Object.Instantiate(__instance.TaskPrefab);
+            taskAddButton.MyTask = task;
+            switch (task.TaskType)
             {
                 case TaskTypes.DivertPower:
-                    {
-                        var targetSystem = taskAddButton.MyTask.Cast<DivertPowerTask>().TargetSystem;
-                        taskAddButton.Text.text = TranslationController.Instance.GetString(
-                            StringNames.DivertPowerTo,
-                            TranslationController.Instance.GetString(targetSystem));
-                        break;
-                    }
+                {
+                    var targetSystem = task.Cast<DivertPowerTask>().TargetSystem;
+                    taskAddButton.Text.text = TranslationController.Instance.GetString(
+                        StringNames.DivertPowerTo,
+                        TranslationController.Instance.GetString(targetSystem));
+                    break;
+                }
                 case TaskTypes.FixWeatherNode:
-                    {
-                        var nodeId = taskAddButton.MyTask.Cast<WeatherNodeTask>().NodeId;
-                        taskAddButton.Text.text =
-                            TranslationController.Instance.GetString(
-                                StringNames.FixWeatherNode) + " " +
-                            TranslationController.Instance.GetString(
-                                WeatherSwitchGame.ControlNames[nodeId]);
-                        break;
-                    }
+                {
+                    var nodeId = task.Cast<WeatherNodeTask>().NodeId;
+                    taskAddButton.Text.text =
+                        TranslationController.Instance.GetString(
+                            StringNames.FixWeatherNode) + " " +
+                        TranslationController.Instance.GetString(
+                            WeatherSwitchGame.ControlNames[nodeId]);
+                    break;
+                }
                 default:
                     taskAddButton.Text.text =
-                        TranslationController.Instance.GetString(taskAddButton.MyTask.TaskType);
+                        TranslationController.Instance.GetString(task.TaskType);
                     break;
             }
 
             __instance.AddFileAsChildCustom(taskAddButton, ref num, ref num2, ref num3);
-            if (taskAddButton.Button == null)
+            if (taskAddButton != null && taskAddButton.Button != null)
             {
-                continue;
-            }
-
-            ControllerManager.Instance.AddSelectableUiElement(taskAddButton.Button);
-            if (__instance.Hierarchy.Count == 1 || flag)
-            {
-                continue;
-            }
-
-            var component =
-                ControllerManager.Instance.CurrentUiState.CurrentSelection.GetComponent<TaskFolder>();
-            if (component != null)
-            {
-                __instance.restorePreviousSelectionByFolderName = component.FolderName;
-            }
-
-            ControllerManager.Instance.SetDefaultSelection(taskAddButton.Button);
-            flag = true;
-        }
-
-        if (taskFolder.FolderName == "Roles")
-        {
-            for (var m = 0; m < RoleManager.Instance.AllRoles.Length; m++)
-            {
-                var roleBehaviour = RoleManager.Instance.AllRoles[m];
-                if (roleBehaviour.Role == RoleTypes.ImpostorGhost || roleBehaviour.Role == RoleTypes.CrewmateGhost ||
-                    CustomRoleManager.CustomRoles.ContainsKey((ushort)roleBehaviour.Role))
-                {
-                    continue;
-                }
-
-                var taskAddButton2 = Object.Instantiate(__instance.RoleButton);
-                taskAddButton2.SafePositionWorld = __instance.SafePositionWorld;
-                taskAddButton2.Text.text = "Be_" + roleBehaviour.NiceName + ".exe";
-                __instance.AddFileAsChildCustom(taskAddButton2, ref num, ref num2, ref num3);
-                taskAddButton2.Role = roleBehaviour;
-
-                if (taskAddButton2.Button == null)
-                {
-                    continue;
-                }
-
-                ControllerManager.Instance.AddSelectableUiElement(taskAddButton2.Button);
-                switch (m)
-                {
-                    case 0 when __instance.restorePreviousSelectionFound != null:
-                        ControllerManager.Instance.SetDefaultSelection(__instance.restorePreviousSelectionFound);
-                        __instance.restorePreviousSelectionByFolderName = string.Empty;
-                        __instance.restorePreviousSelectionFound = null;
-                        break;
-                    case 0:
-                        ControllerManager.Instance.SetDefaultSelection(taskAddButton2.Button);
-                        break;
-                }
+                ControllerManager.Instance.AddSelectableUiElement(taskAddButton.Button, false);
             }
         }
 
-        if (taskFolder)
+        var roleChildren = taskFolder.RoleChildren
+            .ToArray()
+            .Where(x => !(taskFolder.IsChildOf(__instance.Root) && x is ICustomRole))
+            .ToArray();
+        foreach (var role in roleChildren)
         {
-            var split = taskFolder.name.Split(':');
-            if (split.Length == 2)
+            TaskAddButton roleAddButton = Object.Instantiate(__instance.RoleButton);
+            roleAddButton.SafePositionWorld = __instance.SafePositionWorld;
+            roleAddButton.Text.text = prettyEnabled ? role.NiceName : "Be_" + role.NiceName + ".exe";
+            roleAddButton.Role = role;
+            if (prettyEnabled)
             {
-                var pluginId = split[0];
-                var folderName = split[1];
-
-                if (MiraPluginManager.GetPluginByGuid(pluginId) is { } plugin)
-                {
-                    if (folderName == "Roles(Clone)")
-                    {
-                        PluginRoles(__instance, plugin, ref num, ref num2, ref num3);
-                    }
-                    else if (folderName == "Modifiers(Clone)")
-                    {
-                        PluginModifiers(__instance, plugin, ref num, ref num2, ref num3);
-                    }
-                }
+                roleAddButton.Text.fontSizeMin = 1;
+                roleAddButton.FileImage.sprite = role.IsImpostor
+                    ? MiraAssets.ImpostorFile.LoadAsset()
+                    : MiraAssets.CrewmateFile.LoadAsset();
             }
-        }
-
-        foreach (var chip in __instance.ActiveItems)
-        {
-            chip.GetComponentInChildren<TextMeshPro>().EnableStencilMasking();
-            chip.GetComponent<SpriteRenderer>().maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
-        }
-
-        if (_scroller)
-        {
-            _scroller.CalculateAndSetYBounds(__instance.ActiveItems.Count, 6, 4.5f, 1.65f);
-            _scroller.SetYBoundsMin(0.0f);
-            _scroller.ScrollToTop();
-        }
-
-        if (__instance.Hierarchy.Count == 1)
-        {
-            ControllerManager.Instance.SetBackButton(__instance.BackButton);
-            return false;
-        }
-
-        ControllerManager.Instance.SetBackButton(__instance.FolderBackButton);
-        return false;
-    }
-
-    private static void PluginModifiers(
-        TaskAdderGame instance,
-        MiraPluginInfo plugin,
-        ref float num,
-        ref float num2,
-        ref float num3)
-    {
-        for (var m = 0; m < plugin.InternalModifiers.Count; m++)
-        {
-            var modifier = plugin.InternalModifiers[m];
-            if (!modifier.ShowInFreeplay)
-            {
-                continue;
-            }
-
-            var taskAddButton = Object.Instantiate(instance.RoleButton);
-            taskAddButton.name = modifier.TypeId.ToString(NumberFormatInfo.InvariantInfo);
-            taskAddButton.role = null;
-            taskAddButton.MyTask = null;
-            taskAddButton.SafePositionWorld = instance.SafePositionWorld;
-            taskAddButton.Text.text = modifier.ModifierName;
-            taskAddButton.Text.EnableMasking();
-            taskAddButton.FileImage.color = modifier.FreeplayFileColor;
-            taskAddButton.RolloverHandler.OutColor = modifier.FreeplayFileColor;
-            taskAddButton.Button.OnClick = new Button.ButtonClickedEvent();
-            taskAddButton.Button.OnClick.AddListener((UnityEngine.Events.UnityAction)(() =>
-            {
-                var id = modifier.TypeId;
-                if (PlayerControl.LocalPlayer.HasModifier(id))
-                {
-                    PlayerControl.LocalPlayer.RemoveModifier(id);
-                    taskAddButton.Overlay.enabled = false;
-                }
-                else
-                {
-                    PlayerControl.LocalPlayer.AddModifier(id);
-                    taskAddButton.Overlay.enabled = true;
-                }
-            }));
-
-            instance.AddFileAsChildCustom(taskAddButton, ref num, ref num2, ref num3);
-
-            ControllerManager.Instance.AddSelectableUiElement(taskAddButton.Button);
-            switch (m)
-            {
-                case 0 when instance.restorePreviousSelectionFound != null:
-                    ControllerManager.Instance.SetDefaultSelection(instance.restorePreviousSelectionFound);
-                    instance.restorePreviousSelectionByFolderName = string.Empty;
-                    instance.restorePreviousSelectionFound = null;
-                    break;
-                case 0:
-                    ControllerManager.Instance.SetDefaultSelection(taskAddButton.Button);
-                    break;
-            }
-        }
-    }
-
-    private static void PluginRoles(TaskAdderGame instance, MiraPluginInfo plugin, ref float num, ref float num2, ref float num3)
-    {
-        for (var m = 0; m < plugin.InternalRoles.Count; m++)
-        {
-            var roleBehaviour = plugin.InternalRoles.ElementAt(m).Value;
-            if (roleBehaviour.Role == RoleTypes.ImpostorGhost || roleBehaviour.Role == RoleTypes.CrewmateGhost ||
-                roleBehaviour is ICustomRole { Configuration.ShowInFreeplay: false })
-            {
-                continue;
-            }
-
-            var taskAddButton2 = Object.Instantiate(instance.RoleButton);
-            taskAddButton2.SafePositionWorld = instance.SafePositionWorld;
-            taskAddButton2.Text.text = "Be_" + roleBehaviour.NiceName + ".exe";
-            taskAddButton2.Text.EnableMasking();
-
-            instance.AddFileAsChildCustom(taskAddButton2, ref num, ref num2, ref num3);
-            taskAddButton2.Role = roleBehaviour;
-            if (roleBehaviour is ICustomRole custom)
+            if (role is ICustomRole custom)
             {
+                if (prettyEnabled && custom.Team == ModdedRoleTeams.Custom) roleAddButton.FileImage.sprite = MiraAssets.CustomTeamFile.LoadAsset();
                 var customColor = custom.IntroConfiguration?.IntroTeamColor ?? Color.gray;
                 if (custom.Team is ModdedRoleTeams.Crewmate)
                 {
@@ -401,26 +375,84 @@ internal static class TaskAdderPatches
                 {
                     customColor = Palette.ImpostorRed;
                 }
-                taskAddButton2.FileImage.color = customColor;
-                taskAddButton2.RolloverHandler.OutColor = customColor;
+                roleAddButton.FileImage.color = customColor;
+                roleAddButton.RolloverHandler.OutColor = customColor;
             }
-            if (taskAddButton2.Button == null)
+            __instance.AddFileAsChildCustom(roleAddButton, ref num, ref num2, ref num3);
+            if (roleAddButton != null && roleAddButton.Button != null)
             {
-                continue;
-            }
-
-            ControllerManager.Instance.AddSelectableUiElement(taskAddButton2.Button);
-            switch (m)
-            {
-                case 0 when instance.restorePreviousSelectionFound != null:
-                    ControllerManager.Instance.SetDefaultSelection(instance.restorePreviousSelectionFound);
-                    instance.restorePreviousSelectionByFolderName = string.Empty;
-                    instance.restorePreviousSelectionFound = null;
-                    break;
-                case 0:
-                    ControllerManager.Instance.SetDefaultSelection(taskAddButton2.Button);
-                    break;
+                ControllerManager.Instance.AddSelectableUiElement(roleAddButton.Button);
             }
         }
+
+        if (folders.TryGetValue("Modifiers", out var modifiersFolder) && taskFolder.IsChildOf(modifiersFolder))
+        {
+            var plugin = MiraPluginManager.GetPluginByGuid(taskFolder.gameObject.name.Replace("(Clone)", string.Empty));
+            if (plugin != null)
+            {
+                foreach (var modifier in plugin.InternalModifiers)
+                {
+                    if (!modifier.ShowInFreeplay)
+                    {
+                        continue;
+                    }
+
+                    var taskAddButton = Object.Instantiate(__instance.RoleButton);
+                    taskAddButton.name = modifier.TypeId.ToString(NumberFormatInfo.InvariantInfo);
+                    taskAddButton.role = null;
+                    taskAddButton.MyTask = null;
+                    taskAddButton.SafePositionWorld = __instance.SafePositionWorld;
+                    taskAddButton.Text.text = modifier.ModifierName;
+                    taskAddButton.Text.fontSizeMin = 1;
+                    taskAddButton.Text.EnableMasking();
+                    taskAddButton.FileImage.color = modifier.FreeplayFileColor;
+                    taskAddButton.RolloverHandler.OutColor = modifier.FreeplayFileColor;
+                    if (modifier is TimedModifier timed)
+                    {
+                        taskAddButton.FileImage.sprite = MiraAssets.TimedModifierFile.LoadAsset();
+                        taskAddButton.Text.text += $" ({timed.Duration}s)";
+                    }
+                    else
+                    {
+                        taskAddButton.FileImage.sprite = MiraAssets.ModifierFile.LoadAsset();
+                    }
+
+                    taskAddButton.Button.OnClick = new Button.ButtonClickedEvent();
+                    var m = modifier;
+                    taskAddButton.Button.OnClick.AddListener((UnityAction)(() =>
+                    {
+                        var id = m.TypeId;
+                        if (PlayerControl.LocalPlayer.HasModifier(id))
+                        {
+                            PlayerControl.LocalPlayer.RemoveModifier(id);
+                            taskAddButton.Overlay.enabled = false;
+                        }
+                        else
+                        {
+                            PlayerControl.LocalPlayer.AddModifier(id);
+                            taskAddButton.Overlay.enabled = true;
+                        }
+                    }));
+
+                    __instance.AddFileAsChildCustom(taskAddButton, ref num, ref num2, ref num3);
+
+                    ControllerManager.Instance.AddSelectableUiElement(taskAddButton.Button);
+                }
+            }
+        }
+
+        if (_scroller)
+        {
+            _scroller.CalculateAndSetYBounds(__instance.ActiveItems.Count, 6, 4.5f, 1.65f);
+            _scroller.SetYBoundsMin(0.0f);
+            _scroller.ScrollToTop();
+        }
+
+        ControllerManager.Instance.SetBackButton(__instance.Hierarchy.Count == 1
+            ? __instance.BackButton
+            : __instance.FolderBackButton);
+
+        __instance.SetPreviousControllerSelection(taskFolder.FolderName);
+        return false;
     }
 }

MiraAPI/Patches/GameStartManagerPatch.cs

@@ -1,36 +0,0 @@
-using HarmonyLib;
-using MiraAPI.Keybinds;
-using UnityEngine;
-
-namespace MiraAPI.Patches;
-
-/// <summary>
-/// Checks keybind conflicts in the lobby and disables secondary ones.
-/// </summary>
-[HarmonyPatch(typeof(GameStartManager))]
-public static class GameStartManagerPatch
-{
-    public static bool conflictShown = false;
-
-    [HarmonyPatch(nameof(GameStartManager.Start))]
-    [HarmonyPostfix]
-    public static void StartPostfix(GameStartManager __instance)
-    {
-        if (conflictShown) return;
-
-        var conflicts = KeybindManager.GetConflicts();
-        if (conflicts.Count == 0) return;
-
-        conflictShown = true;
-
-        var message = "The following keybinds are disabled due to conflicts:\n\n";
-
-        foreach (var (a, b) in conflicts)
-        {
-            message += $"• <color=#FF5555>{b.Description}</color> (conflicts with {a.Description})\n";
-            b.Handler = null;
-        }
-
-        HudManager.Instance.ShowPopUp(message.TrimEnd());
-    }
-}

MiraAPI/Patches/Hud/ButtonResetPatches.cs

@@ -20,6 +20,11 @@ public static class ButtonResetPatches
             {
                 Logger<MiraApiPlugin>.Error($"Error resetting cooldown and effect for button {customActionButton.GetType().Name}: {ex}");
             }
+
+            if (customActionButton.UsesMode == ButtonUsesMode.PerRound)
+            {
+                customActionButton.SetUses(customActionButton.MaxUses);
+            }
         }
     }
 }

MiraAPI/Patches/HudManagerPatches.cs

@@ -1,11 +1,14 @@
-using System;
-using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 using HarmonyLib;
 using MiraAPI.Hud;
 using MiraAPI.Keybinds;
+using MiraAPI.LocalSettings;
+using MiraAPI.Utilities;
 using Reactor.Utilities;
 using Reactor.Utilities.Extensions;
 using Rewired;
+using TMPro;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
@@ -22,6 +25,8 @@ public static class HudManagerPatches
     public static Transform? BottomRight { get; private set; }
     public static Transform? Buttons { get; private set; }
 
+    private static Dictionary<TextMeshPro, int> vanillaKeybindIcons = new();
+
     /*
     /// <summary>
     /// Trigger hudstart on current custom gamemode
@@ -106,8 +111,35 @@ public static class HudManagerPatches
 
         gridArrange.Start();
         gridArrange.ArrangeChilds();
-
         aspectPosition.AdjustPosition();
+
+        vanillaKeybindIcons = [];
+        var keybindIconPos = new Vector3(-0.4f, 0.4f, -9.5f);
+        var vanillaButtons = new Dictionary<GameObject, int>
+        {
+            { __instance.KillButton.gameObject, 8 },
+            { __instance.UseButton.gameObject, 6 },
+            { __instance.ReportButton.gameObject, 7 },
+            { __instance.ImpostorVentButton.gameObject, 50 },
+            { __instance.SabotageButton.gameObject, 4 },
+            { __instance.AbilityButton.gameObject, 49 },
+        };
+
+        foreach (var kvp in vanillaButtons)
+        {
+            var buttonObj = kvp.Key;
+            var actionId = kvp.Value;
+
+            var key = KeybindUtils.GetKeycodeByActionId(actionId);
+            if (key == KeyboardKeyCode.None)
+            {
+                continue;
+            }
+            var icon = Helpers.CreateKeybindIcon(buttonObj, key, keybindIconPos);
+            vanillaKeybindIcons.Add(icon.transform.GetChild(0).GetComponent<TextMeshPro>(), actionId);
+            var comp = buttonObj.GetComponent<ActionButton>();
+            KeybindManager.VanillaKeybinds[comp.GetType()].Button = comp;
+        }
     }
 
     /// <summary>
@@ -142,22 +174,31 @@ public static class HudManagerPatches
 
     [HarmonyPatch(nameof(HudManager.Update))]
     [HarmonyPostfix]
-    public static void StartPostfix()
+    public static void UpdatePostfix()
     {
-        if (AmongUsClient.Instance.GameState != InnerNet.InnerNetClient.GameStates.Started) return;
-        if (PlayerControl.LocalPlayer.Data.IsDead) return;
-
-        foreach (var entry in KeybindManager.GetEntries())
+        foreach (var btnIcon in vanillaKeybindIcons)
         {
-            var player = ReInput.players.GetPlayer(0);
-            var keyboard = player.controllers.Keyboard;
+            btnIcon.Key.text = KeybindUtils.GetKeycodeByActionId(btnIcon.Value).ToString();
+            btnIcon.Key.transform.parent.gameObject.SetActive(ActiveInputManager.currentControlType == ActiveInputManager.InputType.Keyboard &&
+                                                              LocalSettingsTabSingleton<MiraApiSettings>.Instance.ShowKeybinds.Value);
+        }
 
-            if (player.GetButtonDown(entry.Id) &&
-               (entry.Modifier1 == ModifierKey.None || keyboard.GetModifierKey(entry.Modifier1)) &&
-               (entry.Modifier2 == ModifierKey.None || keyboard.GetModifierKey(entry.Modifier2)) &&
-               (entry.Modifier3 == ModifierKey.None || keyboard.GetModifierKey(entry.Modifier3)))
+        var player = ReInput.players.GetPlayer(0);
+        foreach (var entry in KeybindManager.Keybinds)
+        {
+            var keyboard = player.controllers.Keyboard;
+            bool modifierKeysPressed = entry.ModifierKeys.All(k => keyboard.GetModifierKey(k)) ||
+                                       entry.ModifierKeys.Length <= 0;
+            if (player.GetButtonDown(entry.Id) && modifierKeysPressed)
             {
-                entry.Handler?.Invoke();
+                entry.Invoke();
+            }
+        }
+        foreach (var entry in KeybindManager.VanillaKeybinds.Values)
+        {
+            if (player.GetButtonDown(entry.Id))
+            {
+                entry.Invoke();
             }
         }
     }

MiraAPI/Patches/IntroCutscenePatches.cs

@@ -29,6 +29,16 @@ public static class IntroCutscenePatches
         MiraEventManager.InvokeEvent(@event);
     }
 
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(IntroCutscene._ShowRole_d__41), nameof(IntroCutscene._ShowRole_d__41.MoveNext))]
+    [HarmonyPriority(Priority.Last)]
+    public static void ShowRolePatch(IntroCutscene._ShowRole_d__41 __instance)
+    {
+        var realInstance = __instance.__4__this;
+        var @event = new IntroRoleRevealEvent(realInstance);
+        MiraEventManager.InvokeEvent(@event);
+    }
+
     [HarmonyPrefix]
     [HarmonyPatch(nameof(IntroCutscene.BeginImpostor))]
     [HarmonyPatch(nameof(IntroCutscene.BeginCrewmate))]

MiraAPI/Patches/Keybinds/ControlMapperPatches.cs

@@ -0,0 +1,67 @@
+using System.Linq;
+using HarmonyLib;
+using MiraAPI.Keybinds;
+using MiraAPI.LocalSettings;
+using Reactor.Utilities;
+using Reactor.Utilities.Extensions;
+using Rewired.UI.ControlMapper;
+using TMPro;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UI;
+
+namespace MiraAPI.Patches.Keybinds;
+
+[HarmonyPatch(typeof(ControlMapper))]
+public static class ControlMapperPatches
+{
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(ControlMapper.Start))]
+    private static void StartPrefix(ControlMapper __instance)
+    {
+        var doneButton = GameObject.Find("DoneButton")?.GetComponent<CustomButton>();
+        if (doneButton == null)
+        {
+            return;
+        }
+
+        var toggle = Object.Instantiate(doneButton, doneButton.transform.parent);
+        var text = toggle.GetComponentInChildren<TextMeshProUGUI>();
+        var entry = LocalSettingsTabSingleton<MiraApiSettings>.Instance.ShowKeybinds;
+        toggle.gameObject.name = "KeybindsVisibleToggle";
+        text.text = $"Show Keybinds: {(entry.Value ? "On" : "Off")}";
+        toggle.onClick.RemoveAllListeners();
+        toggle.GetComponent<ButtonInfo>().identifier = "KeybindsVisibleToggle";
+        toggle.onClick.AddListener((UnityAction)(() =>
+        {
+            entry.Value = !entry.Value;
+            text.text = $"Show Keybinds: {(entry.Value ? "On" : "Off")}";
+        }));
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(ControlMapper.Update))]
+    private static void UpdatePrefix(ControlMapper __instance)
+    {
+        foreach (var element in __instance.themedElements)
+        {
+            var info = element.GetComponent<InputFieldInfo>();
+            if (info == null)
+            {
+                continue;
+            }
+
+            var key = info.glyphOrText?.actionElementMap?.keyboardKeyCode;
+            if (key == null)
+            {
+                continue;
+            }
+
+            var conflicts = KeybindManager.GetConflicts();
+            if (conflicts.Any(x => x.Key.ToString() == key.ToString()))
+            {
+                element.GetComponent<Image>().color = Color.red;
+            }
+        }
+    }
+}

MiraAPI/Patches/Keybinds/KeybindsPatch.cs

@@ -1,20 +1,36 @@
 using HarmonyLib;
 using MiraAPI.Keybinds;
-using MiraAPI.Utilities;
+using MonoMod.Utils;
 using Rewired;
 
-namespace MiraAPI.Patches.Keybinds
+namespace MiraAPI.Patches.Keybinds;
+
+[HarmonyPatch(typeof(InputManager_Base), nameof(InputManager_Base.Awake))]
+public static class KeybindMenuPatch
 {
-    [HarmonyPatch(typeof(InputManager_Base), nameof(InputManager_Base.Awake))]
-    public static class KeybindMenuPatch
+    private static bool _registered;
+
+    [HarmonyPrefix]
+    private static void AwakePrefix(InputManager_Base __instance)
     {
-        [HarmonyPrefix]
-        private static void StartPrefix(InputManager_Base __instance)
+        if (_registered)
         {
-            foreach (var entry in KeybindManager.GetEntries())
-            {
-                __instance.userData.RegisterModBind(entry.Id, entry.Description, entry.Key, modifier1: entry.Modifier1, modifier2: entry.Modifier2, modifier3: entry.Modifier3);
-            }
+            return;
         }
+
+        KeybindUtils.RewiredInputManager = __instance;
+        KeybindManager.RewiredInit();
+        _registered = true;
+
+        // Set these here right after input manager initializes
+        KeybindManager.VanillaKeybinds = new()
+        {
+            { typeof(KillButton), new VanillaKeybind(8) },
+            { typeof(UseButton), new VanillaKeybind(6) },
+            { typeof(ReportButton), new VanillaKeybind(7) },
+            { typeof(VentButton), new VanillaKeybind(50) },
+            { typeof(SabotageButton), new VanillaKeybind(4) },
+            { typeof(AbilityButton), new VanillaKeybind(49) },
+        };
     }
 }

MiraAPI/Patches/Keybinds/OptionsMenuBehaviourPatch.cs

@@ -0,0 +1,40 @@
+using HarmonyLib;
+using MiraAPI.Keybinds;
+using UnityEngine;
+
+namespace MiraAPI.Patches.Keybinds;
+
+[HarmonyPatch(typeof(OptionsMenuBehaviour))]
+public static class OptionsMenuBehaviourPatch
+{
+    private static ButtonRolloverHandler? _remap_rollover;
+    private static SpriteRenderer? _remap_background;
+    private static bool _conflicts => KeybindManager.GetConflicts().Count > 0;
+
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(OptionsMenuBehaviour.Open))]
+    private static void OpenPostfix(OptionsMenuBehaviour __instance)
+    {
+        _remap_rollover = GameObject.Find("Remap Controls")?.GetComponent<ButtonRolloverHandler>()!;
+        _remap_background = _remap_rollover.transform.FindChild("Background").GetComponent<SpriteRenderer>();
+        _remap_background.color = _conflicts ? Color.red : Color.white;
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(OptionsMenuBehaviour.Update))]
+    private static void UpdatePostfix(OptionsMenuBehaviour __instance)
+    {
+        if (_remap_rollover == null)
+        {
+            return;
+        }
+        if (_remap_background == null)
+        {
+            return;
+        }
+
+        _remap_rollover.OutColor = _conflicts ? Color.red : Color.white;
+        _remap_rollover.UnselectedColor = _conflicts ? Color.red : Color.white;
+        _remap_rollover.OverColor = _conflicts ? new Color32(255, 55, 55, 255) : Palette.AcceptedGreen;
+    }
+}

MiraAPI/Patches/LocalSettings/OptionsMenuPatches.cs

@@ -0,0 +1,232 @@
+using System.Collections.Generic;
+using System.Linq;
+using HarmonyLib;
+using MiraAPI.LocalSettings;
+using MiraAPI.Utilities.Assets;
+using Reactor.Utilities;
+using Reactor.Utilities.Extensions;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UI;
+
+namespace MiraAPI.Patches.LocalSettings;
+
+[HarmonyPatch(typeof(OptionsMenuBehaviour))]
+public static class OptionsMenuPatches
+{
+    internal static OptionsMenuBehaviour? Instance { get; private set; }
+    internal static BoxCollider2D MaskCollider;
+    private static SpriteRenderer? background;
+
+    private static int currentPage = 1;
+    private static Dictionary<int, List<GameObject>> tabButtons = new();
+
+    /// <summary>
+    /// Creates the tabs and their content
+    /// </summary>
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(OptionsMenuBehaviour.Start))]
+    public static void StartPostfix(OptionsMenuBehaviour __instance)
+    {
+        Instance = __instance;
+        // Fix for tabs not being clickable in the main menu
+        if (!AmongUsClient.Instance.IsInGame)
+        {
+            __instance.Background.GetComponent<BoxCollider2D>().enabled = false;
+            __instance.transform.FindChild("Tint").SetLocalZ(5.6f);
+        }
+
+        background = __instance.Background;
+
+        var maskObj = new GameObject
+        {
+            layer = 5,
+            name = "SpriteMask",
+        };
+        maskObj.transform.SetParent(__instance.transform);
+        maskObj.transform.localPosition = new Vector3(0, -0.3f, 0);
+        maskObj.transform.localScale = new Vector3(500, 120, 1);
+
+        var blank = Sprite.Create(
+            Texture2D.whiteTexture,
+            new Rect(0, 0, Texture2D.whiteTexture.width, Texture2D.whiteTexture.height),
+            new Vector2(0.5f, 0.5f));
+
+        var mask = maskObj.AddComponent<SpriteMask>();
+        mask.sprite = blank;
+        mask.isCustomRangeActive = true;
+        mask.sortingLayerName = "Default";
+        mask.backSortingOrder = 100;
+        mask.frontSortingOrder = 500;
+
+        MaskCollider = maskObj.AddComponent<BoxCollider2D>();
+        MaskCollider.size = new Vector2(0.01f, 0.1f);
+        MaskCollider.isTrigger = true;
+        MaskCollider.enabled = true;
+
+        currentPage = 1;
+        tabButtons.Clear();
+        float yOffset = 0;
+        int i = 0;
+        int tabIdx = 0;
+        int page = 1;
+        foreach (var settings in LocalSettingsManager.Tabs)
+        {
+            var tab = settings.CreateTab(__instance);
+            if (settings.ShouldCreateButton)
+            {
+                var button = settings.CreateTabButton(__instance, ref tabIdx, ref yOffset);
+                button.GetComponent<TabGroup>().Content = tab;
+                button.SetActive(page == currentPage);
+
+                if (!tabButtons.TryGetValue(page, out var list))
+                {
+                    tabButtons.Add(page, new());
+                    list = tabButtons[page];
+                }
+                list.Add(button);
+                yOffset += 0.6f;
+                tabIdx++;
+                i++;
+            }
+            if (i > 7)
+            {
+                i = 0;
+                yOffset = 0;
+                page++;
+            }
+        }
+
+        void ChangePage(int increase)
+        {
+            currentPage += increase;
+            if (currentPage > tabButtons.Count)
+            {
+                currentPage = 1;
+            }
+            if (currentPage < 1)
+            {
+                currentPage = tabButtons.Count;
+            }
+        }
+
+        // Create page buttons
+        // TODO: In-game menu has no close button. I tried making one from scratch but failed. Add one later plz
+        if (tabButtons.Count <= 1)
+        {
+            return;
+        }
+
+        var nextButton = Object.Instantiate(__instance.BackButton, __instance.transform).GetComponent<PassiveButton>();
+        nextButton.transform.localPosition = new Vector3(3.2f, 2.6f, -10);
+        nextButton.transform.localScale = new Vector2(0.25f, 0.25f);
+        var nextRend = nextButton.GetComponent<SpriteRenderer>();
+        nextRend.sprite = MiraAssets.NextButton.LoadAsset();
+        nextButton.gameObject.GetComponent<CloseButtonConsoleBehaviour>().DestroyImmediate();
+
+        var nextRollover = nextButton.gameObject.AddComponent<ButtonRolloverHandler>();
+        nextRollover.Target = nextRend;
+        nextRollover.OverColor = Palette.AcceptedGreen;
+
+        nextButton.OnClick = new Button.ButtonClickedEvent();
+        nextButton.OnClick.AddListener(
+            (UnityAction)(() =>
+            {
+                ChangePage(1);
+                UpdatePages();
+            }));
+
+        var backButton = Object.Instantiate(__instance.BackButton, __instance.transform).GetComponent<PassiveButton>();
+        backButton.transform.localPosition = new Vector3(2.9f, 2.6f, -10);
+        backButton.transform.localScale = new Vector2(0.25f, 0.25f);
+        var backRend = backButton.GetComponent<SpriteRenderer>();
+        backRend.sprite = MiraAssets.NextButton.LoadAsset();
+        backRend.flipX = true;
+        backButton.gameObject.GetComponent<CloseButtonConsoleBehaviour>().DestroyImmediate();
+
+        var backRollover = backButton.gameObject.AddComponent<ButtonRolloverHandler>();
+        backRollover.Target = backRend;
+        backRollover.OverColor = Palette.AcceptedGreen;
+
+        backButton.OnClick = new Button.ButtonClickedEvent();
+        backButton.OnClick.AddListener(
+            (UnityAction)(() =>
+            {
+                ChangePage(-1);
+                UpdatePages();
+            }));
+    }
+
+    /// <summary>
+    /// Modifies how opening tabs is handled for the custom ones to work.
+    /// </summary>
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(OptionsMenuBehaviour.OpenTabGroup))]
+    public static bool OpenTabGroupPrefix(OptionsMenuBehaviour __instance, ref int index)
+    {
+        __instance.Tabs.ToList().ForEach(x => x.Close()); // Close all vanilla tabs
+        LocalSettingsManager.Tabs.ForEach(CustomClose); // Close all mod tabs
+
+        // Tabs with index 10 and above are the mod settings tabs
+        if (index >= 10)
+        {
+            CustomOpen(LocalSettingsManager.Tabs[index - 10]);
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Makes the custom tabs close when opening the options menu and resets pages.
+    /// </summary>
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(OptionsMenuBehaviour.Open))]
+    public static void OpenPostfix(OptionsMenuBehaviour __instance)
+    {
+        LocalSettingsManager.Tabs.ForEach(CustomClose);
+        currentPage = 1;
+        UpdatePages();
+    }
+
+    private static void UpdatePages()
+    {
+        foreach (var pages in tabButtons)
+        {
+            pages.Value?
+                .Where(x => x != null)
+                .Do(
+                   x => x?.SetActive(
+                       pages.Key == currentPage));
+        }
+    }
+
+    private static void CustomOpen(LocalSettingsTab tab)
+    {
+        if (tab.TabButton?.Button)
+            tab.TabButton!.Button.color = tab.TabAppearance.TabButtonHoverColor;
+
+        if (tab.TabButton?.Rollover)
+            tab.TabButton!.Rollover.OutColor = tab.TabAppearance.TabButtonHoverColor;
+
+        if (tab.TabButton?.Content)
+            tab.TabButton!.Content.SetActive(true);
+
+        if (background != null)
+            background.color = tab.TabAppearance.TabColor;
+    }
+    private static void CustomClose(LocalSettingsTab tab)
+    {
+        if (tab.TabButton?.Button)
+            tab.TabButton!.Button.color = tab.TabAppearance.TabButtonColor;
+
+        if (tab.TabButton?.Rollover)
+            tab.TabButton!.Rollover.OutColor = tab.TabAppearance.TabButtonColor;
+
+        if (tab.TabButton?.Content)
+            tab.TabButton!.Content.SetActive(false);
+
+        if (background != null)
+            background.color = Color.white;
+    }
+}

MiraAPI/Patches/LocalSettings/ToggleBehaviourPatch.cs

@@ -0,0 +1,37 @@
+using HarmonyLib;
+using UnityEngine;
+
+namespace MiraAPI.Patches.LocalSettings;
+
+[HarmonyPatch(typeof(ToggleButtonBehaviour))]
+public static class ToggleBehaviourPatch
+{
+    /// <summary>
+    /// ResetText was inlined ofc.
+    /// Skill issue
+    /// </summary>
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(ToggleButtonBehaviour.UpdateText))]
+    public static bool UpdateTextPrefix(ToggleButtonBehaviour __instance, bool on)
+    {
+        var color = on ? new Color(0f, 1f, 0.16470589f, 1f) : Color.white;
+        __instance.onState = on;
+        __instance.Background.color = color;
+
+        // Used to mask the text
+        __instance.Text.richText = true;
+        __instance.Text.text = $"<font=\"LiberationSans SDF\" material=\"LiberationSans SDF - Chat Message Masked\">" +
+                               $"{DestroyableSingleton<TranslationController>.Instance.GetString(__instance.BaseText)}: <b>" +
+                               $"{DestroyableSingleton<TranslationController>.Instance.GetString(__instance.onState ? StringNames.SettingsOn : StringNames.SettingsOff)}</b></font>";
+        __instance.Text.sortingOrder = 151;
+        __instance.Text.renderer.sortingLayerName = "Default";
+        __instance.Text.renderer.sortingOrder = 151;
+
+        if (__instance.Rollover)
+        {
+            __instance.Rollover.ChangeOutColor(color);
+        }
+
+        return false;
+    }
+}

MiraAPI/Patches/Options/GamePresetsTabPatches.cs

@@ -6,6 +6,7 @@ using HarmonyLib;
 using MiraAPI.PluginLoading;
 using MiraAPI.Presets;
 using MiraAPI.Roles;
+using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
 using Reactor.Utilities;
 using Reactor.Utilities.Extensions;
@@ -28,22 +29,6 @@ internal static class GamePresetsTabPatches
 
     private static readonly object Lock = new();
 
-    public static void DivideSize(GameObject obj, float amount)
-    {
-        foreach (var collider in obj.GetComponentsInChildren<Collider2D>(true))
-        {
-            if (collider.TryCast<BoxCollider2D>() is { } col)
-            {
-                col.size = new Vector2(col.size.x / amount, col.size.y);
-            }
-        }
-
-        foreach (var rend in obj.GetComponentsInChildren<SpriteRenderer>(true))
-        {
-            rend.size = new Vector2(rend.size.x / amount, rend.size.y);
-        }
-    }
-
     [HarmonyPatch(typeof(GamePresetsTab), nameof(GamePresetsTab.OnEnable))]
     public static class GamePresetsOnEnablePatch
     {
@@ -207,7 +192,7 @@ internal static class GamePresetsTabPatches
                 saveText.transform.parent.localPosition.y,
                 saveText.transform.parent.localPosition.z);
 
-            DivideSize(saveButton.gameObject, 2f);
+            Helpers.DivideSize(saveButton.gameObject, 2f);
 
             saveButton.OnClick = new Button.ButtonClickedEvent();
             saveButton.OnClick.AddListener(
@@ -276,7 +261,7 @@ internal static class GamePresetsTabPatches
             var iconSpriteRend = icon.AddComponent<SpriteRenderer>();
             iconSpriteRend.sprite = MiraAssets.RefreshIcon.LoadAsset();
 
-            DivideSize(refreshButton.gameObject, 2f);
+            Helpers.DivideSize(refreshButton.gameObject, 2f);
             refreshButton.buttonText.gameObject.Destroy();
 
             refreshButton.OnClick = new Button.ButtonClickedEvent();

MiraAPI/Patches/Options/RoleSettingMenuPatches.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using HarmonyLib;
@@ -528,10 +528,22 @@ public static class RoleSettingMenuPatches
         roleOptionSetting.CountPlusBtn.SetInteractable(true);
         __instance.roleChances.Add(roleOptionSetting);
 
-        roleOptionSetting.titleText.transform.localPosition = new Vector3(-0.5376f, -0.2923f, 0f);
+        roleOptionSetting.titleText.transform.localPosition = new Vector3(-0.25f, -0.2923f, 0f);
         roleOptionSetting.titleText.color = customRole.OptionsMenuColor.FindAlternateColor();
         roleOptionSetting.titleText.horizontalAlignment = HorizontalAlignmentOptions.Left;
 
+        if (customRole.Configuration.Icon != null)
+        {
+            var roleIcon = new GameObject("RoleIcon");
+            roleIcon.transform.parent = roleOptionSetting.transform;
+                roleIcon.transform.localScale = new(.25f, .25f, 1);
+                roleIcon.layer = LayerMask.NameToLayer("UI");
+                roleIcon.transform.localPosition = new Vector3(-1.3f, -0.3f, -2f);
+                var rend = roleIcon.AddComponent<SpriteRenderer>();
+                rend.sprite = customRole.Configuration.Icon.LoadAsset();
+                rend.maskInteraction = SpriteMaskInteraction.VisibleInsideMask;
+            }
+
         if (GameSettingMenuPatches.SelectedMod is null ||
             GameSettingMenuPatches.SelectedMod.InternalOptionGroups
                 .Exists(x => x.GroupVisible() && x.OptionableType == role.GetType() && x.Options.Any(y => y.Visible())))

MiraAPI/Patches/Roles/HowToPlayPatch.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using System.Linq;
+using AmongUs.GameOptions;
+using HarmonyLib;
+using MiraAPI.Roles;
+using UnityEngine;
+
+namespace MiraAPI.Patches.Roles;
+
+[HarmonyPatch(typeof(HowToPlayScene), nameof(HowToPlayScene.OpenRolesSelectionMenu))]
+internal static class HowToPlayPatch
+{
+    // yes i patched the entire method
+    private static void Prefix(HowToPlayScene __instance)
+    {
+        __instance.sceneIndex = 0;
+        __instance.category = HowToPlayScene.HowToPlayCategory.RolesSelection;
+        __instance.startPage.SetActive(false);
+        if (__instance.roleButtonsParent.childCount == 0)
+        {
+            using (IEnumerator<RoleBehaviour> enumerator = RoleManager.Instance.AllRoles.ToArray().Where(x => !x.IsCustomRole()).GetEnumerator())
+            {
+                while (enumerator.MoveNext())
+                {
+                    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)(() =>
+                        {
+                            __instance.OpenRolePage(role.Role);
+                        }));
+                        __instance.controllerSelectables.Add(component.GetComponent<PassiveButton>());
+                    }
+                }
+            }
+            foreach (UiElement uiElement in __instance.controllerSelectables)
+            {
+                uiElement.ReceiveMouseOut();
+            }
+            ControllerManager.Instance.NewScene(__instance.name, __instance.closeButton, __instance.defaultButtonSelected, __instance.controllerSelectables, false);
+        }
+        __instance.DisableAllScenes();
+        __instance.roleSelectionScene.SetActive(true);
+        ControllerManager.Instance.SetDefaultSelection(__instance.defaultButtonSelected, null);
+    }
+}

MiraAPI/Patches/Roles/RoleManagerPatches.cs

@@ -33,7 +33,7 @@ public static class RoleManagerPatches
             data.Role.Deinitialize(targetPlayer);
             Object.Destroy(data.Role.gameObject);
         }
-        var roleBehaviour = Object.Instantiate<RoleBehaviour>(__instance.AllRoles.First(r => r.Role == roleType), data.gameObject.transform);
+        var roleBehaviour = Object.Instantiate<RoleBehaviour>(__instance.AllRoles.ToArray().First(r => r.Role == roleType), data.gameObject.transform);
         roleBehaviour.Initialize(targetPlayer);
         targetPlayer.Data.Role = roleBehaviour;
         targetPlayer.Data.RoleType = roleType;

MiraAPI/Patches/Voting/DummyBehaviourPatch.cs

@@ -40,7 +40,6 @@ internal static class DummyBehaviourPatches
 
     private static IEnumerator CoDoVote(DummyBehaviour dummy)
     {
-        Logger<MiraApiPlugin>.Warning(dummy.voted);
         dummy.voted = true;
         yield return new WaitForSeconds(dummy.voteTime.Next());
 

MiraAPI/Patches/Voting/MeetingHudPatches.cs

@@ -15,6 +15,24 @@ namespace MiraAPI.Patches.Voting;
 [SuppressMessage("ReSharper", "InconsistentNaming", Justification = "Harmony Convention")]
 internal static class MeetingHudPatches
 {
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlayerVoteArea), nameof(PlayerVoteArea.VoteForMe))]
+    public static bool VotePatch(PlayerVoteArea __instance)
+    {
+        var beforeVoteEvent = new BeforeVoteEvent(__instance, PlayerControl.LocalPlayer);
+        MiraEventManager.InvokeEvent(beforeVoteEvent);
+
+        if (beforeVoteEvent.IsCancelled)
+        {
+            return false;
+        }
+
+        var afterVoteEvent = new AfterVoteEvent(__instance, PlayerControl.LocalPlayer);
+        MiraEventManager.InvokeEvent(afterVoteEvent);
+
+        return true;
+    }
+
     [HarmonyPostfix]
     [HarmonyPatch(nameof(MeetingHud.Start))]
     public static void MeetingHudStartPatch(MeetingHud __instance)

MiraAPI/PluginLoading/MiraPluginInfo.cs

@@ -5,6 +5,7 @@ using BepInEx.Configuration;
 using MiraAPI.GameModes;
 using MiraAPI.GameOptions;
 using MiraAPI.Hud;
+using MiraAPI.LocalSettings;
 using MiraAPI.Modifiers;
 using MiraAPI.Presets;
 

MiraAPI/PluginLoading/MiraPluginManager.cs

@@ -4,6 +4,7 @@ using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
+using BepInEx.Configuration;
 using BepInEx.Unity.IL2CPP;
 using MiraAPI.Colors;
 using MiraAPI.Events;
@@ -12,13 +13,15 @@ using MiraAPI.GameOptions;
 using MiraAPI.GameOptions.Attributes;
 using MiraAPI.Hud;
 using MiraAPI.Keybinds;
+using MiraAPI.LocalSettings;
+using MiraAPI.LocalSettings.Attributes;
 using MiraAPI.Modifiers;
 using MiraAPI.Presets;
 using MiraAPI.Roles;
 using MiraAPI.Utilities;
 using Reactor.Networking;
 using Reactor.Utilities;
-using UnityEngine;
+using Rewired;
 
 namespace MiraAPI.PluginLoading;
 
@@ -92,6 +95,11 @@ public sealed class MiraPluginManager
                     continue;
                 }
 
+                if (RegisterLocalTabs(type, plugin))
+                {
+                    continue;
+                }
+
                 if (RegisterRole(type, info, out var role))
                 {
                     roles.Add(role);
@@ -109,6 +117,7 @@ public sealed class MiraPluginManager
                 }
 
                 RegisterColorClasses(type);
+                RegisterKeybinds(type, plugin);
             }
 
             info.PluginConfig.Save();
@@ -134,14 +143,10 @@ public sealed class MiraPluginManager
             RegisteredPlugins = [.. _registeredPlugins.Values];
 
             ModifierManager.Modifiers = new ReadOnlyCollection<BaseModifier>(ModifierManager.InternalModifiers);
-
-            foreach (var button in CustomButtonManager.Buttons)
-            {
-                KeybindManager.Register($"{button.Name}_Keybind", $"Keybind for {button.Name}", button.Defaultkeybind, button.ClickHandler, modifier1: button.Modifier1, modifier2: button.Modifier2, modifier3: button.Modifier3);
-
-                Logger<MiraApiPlugin>.Info($"Registered keybind for button '{button.GetType().Name}' with default key {button.Defaultkeybind}.");
-            }
         };
+
+        RegisterKeybinds(typeof(MiraGlobalKeybinds), PluginSingleton<MiraApiPlugin>.Instance);
+        RegisterLocalTabs(typeof(MiraApiSettings), PluginSingleton<MiraApiPlugin>.Instance);
     }
 
     /// <summary>
@@ -312,4 +317,125 @@ public sealed class MiraPluginManager
 
         return false;
     }
+
+    private static bool RegisterLocalTabs(Type type, BasePlugin pluginInfo)
+    {
+        try
+        {
+            if (!type.IsAssignableTo(typeof(LocalSettingsTab)))
+            {
+                return false;
+            }
+
+            if (!LocalSettingsManager.RegisterTab(type, pluginInfo))
+            {
+                return false;
+            }
+
+            foreach (var property in type.GetProperties())
+            {
+                if (LocalSettingsManager.TypeToTab[type] is not { } tabInstance)
+                {
+                    continue;
+                }
+
+                if (property.GetCustomAttribute<LocalSettingsButtonAttribute>() != null &&
+                    property.PropertyType.IsAssignableTo(typeof(LocalSettingsButton)))
+                {
+                    var button = property.GetValue(tabInstance) as LocalSettingsButton;
+                    button!.Tab = tabInstance;
+                    tabInstance.Buttons.Add(button);
+                    continue;
+                }
+
+                if (!typeof(ConfigEntryBase).IsAssignableFrom(property.PropertyType))
+                {
+                    continue;
+                }
+
+                if (property.GetMethod?.IsStatic == true)
+                {
+                    Logger<MiraApiPlugin>.Error($"Option property {property.Name} in {type.Name} must not be static.");
+                    continue;
+                }
+
+                if (property.GetValue(tabInstance) is not ConfigEntryBase configEntry)
+                {
+                    Logger<MiraApiPlugin>.Error($"Option property {property.Name} in {type.Name} has to be a config entry.");
+                    continue;
+                }
+
+                var attribute = property.GetCustomAttribute<LocalSettingAttribute>();
+                if (attribute == null)
+                {
+                    continue;
+                }
+
+                attribute.CreateSetting(type, configEntry);
+            }
+
+            foreach (var field in type.GetFields().Where(f => f.FieldType.IsAssignableTo(typeof(ConfigEntryBase)) && f.GetCustomAttribute<LocalSettingAttribute>() != null))
+            {
+                Logger<MiraApiPlugin>.Error($"{field.Name} is a field, not a property. Use properties for local settings.");
+            }
+
+            return true;
+        }
+        catch (Exception e)
+        {
+            Logger<MiraApiPlugin>.Error($"Failed to register options for {type.Name}: {e.ToString()}");
+        }
+
+        return false;
+    }
+
+    private static void RegisterKeybinds(Type type, BasePlugin source)
+    {
+        try
+        {
+            if (type.GetCustomAttribute<RegisterCustomKeybindsAttribute>() == null)
+            {
+                return;
+            }
+
+            if (!type.IsStatic())
+            {
+                Logger<MiraApiPlugin>.Error($"Keybinds class {type.Name} must be static.");
+                return;
+            }
+
+            foreach (var property in type.GetProperties())
+            {
+                if (property.PropertyType != typeof(MiraKeybind))
+                {
+                    continue;
+                }
+
+                if (property.GetValue(null) is not MiraKeybind keybind)
+                {
+                    Logger<MiraApiPlugin>.Error($"Keybind property {property.Name} in {type.Name} is not a MiraKeybind.");
+                    continue;
+                }
+
+                KeybindManager.Keybinds.Add(keybind);
+                if (source is IMiraPlugin miraPlugin)
+                {
+                    keybind.SourcePluginName = miraPlugin.OptionsTitleText;
+                }
+                else if (source is MiraApiPlugin)
+                {
+                    keybind.SourcePluginName = "MiraAPI";
+                }
+            }
+
+            foreach (var field in type.GetFields().Where(f => f.FieldType.IsAssignableTo(typeof(MiraKeybind))))
+            {
+                Logger<MiraApiPlugin>.Error($"{field.Name} is a field, not a property. Use properties for keybinds.");
+            }
+        }
+        catch (Exception e)
+        {
+            Logger<MiraApiPlugin>.Error($"Failed to register keybind class {type.Name}: {e}");
+        }
+    }
 }

MiraAPI/Roles/CustomRoleConfiguration.cs

@@ -32,6 +32,12 @@ public record struct CustomRoleConfiguration
         TasksCountForProgress = role.Team is ModdedRoleTeams.Crewmate;
         HideSettings = roleBehaviour?.IsDead == true;
         ShowInFreeplay = roleBehaviour?.IsDead == false;
+        FreeplayFolder = role.Team switch
+        {
+            ModdedRoleTeams.Crewmate => "Crewmate",
+            ModdedRoleTeams.Impostor => "Impostor",
+            _ => "Neutral",
+        };
         IntroSound = role.Team is ModdedRoleTeams.Crewmate
             ? CustomRoleManager.CrewmateIntroSound
             : CustomRoleManager.ImpostorIntroSound;
@@ -112,6 +118,11 @@ public record struct CustomRoleConfiguration
     /// </summary>
     public bool ShowInFreeplay { get; set; }
 
+    /// <summary>
+    /// Gets or sets a freeplay folder this role belongs to. Defaults to team folder.
+    /// </summary>
+    public string FreeplayFolder { get; set; }
+
     /// <summary>
     /// Gets or sets the outline color for the KillButton if <see cref="UseVanillaKillButton"/> is true.
     /// </summary>

MiraAPI/Roles/CustomRoleManager.cs

@@ -35,6 +35,11 @@ public static class CustomRoleManager
     public static readonly LoadableAsset<AudioClip> ImpostorIntroSound =
         CustomRoleUtils.GetIntroSound(RoleTypes.Impostor)!;
 
+    /// <summary>
+    /// Gets the list of all roles from vanilla RoleManager.
+    /// </summary>
+    public static RoleBehaviour[] AllRoles => RoleManager.Instance.AllRoles.ToArray();
+
     /// <summary>
     /// Gets the list of custom roles as RoleBehaviour objects.
     /// </summary>
@@ -57,7 +62,10 @@ public static class CustomRoleManager
 
     internal static void RegisterInRoleManager()
     {
-        RoleManager.Instance.AllRoles = RoleManager.Instance.AllRoles.Concat(CustomRoles.Values).ToArray();
+        foreach (var role in CustomRoles.Values)
+        {
+            RoleManager.Instance.AllRoles.Add(role);
+        }
 
         foreach (var role in CustomRoles.Values.Where(x => x.IsDead))
         {

MiraAPI/Roles/CustomRoleUtils.cs

@@ -4,7 +4,6 @@ using System.Linq;
 using System.Text;
 using AmongUs.GameOptions;
 using MiraAPI.Utilities.Assets;
-using Reactor.Utilities;
 using UnityEngine;
 
 namespace MiraAPI.Roles;
@@ -56,7 +55,7 @@ public static class CustomRoleUtils
     /// <returns>The intro sound.</returns>
     public static LoadableAsset<AudioClip>? GetIntroSound(RoleTypes roleType)
     {
-        var role = RoleManager.Instance.AllRoles.FirstOrDefault(role => role.Role == roleType);
+        var role = CustomRoleManager.AllRoles.FirstOrDefault(role => role.Role == roleType);
         if (role is ICustomRole customRole)
         {
             return customRole.Configuration.IntroSound;

MiraAPI/Utilities/Assets/MiraAssets.cs

@@ -70,6 +70,11 @@ public static class MiraAssets
     /// </summary>
     public static LoadableResourceAsset NextButton { get; } = new("MiraAPI.Resources.NextButton.png");
 
+    /// <summary>
+    /// Gets the Mira settings icon..
+    /// </summary>
+    public static LoadableResourceAsset SettingsIcon { get; } = new("MiraAPI.Resources.Settings.png");
+
     /// <summary>
     /// Gets the highlighted Next Button sprite.
     /// </summary>
@@ -94,4 +99,34 @@ public static class MiraAssets
     /// Gets the white CategoryHeader used in the Settings Menu.
     /// </summary>
     public static LoadableResourceAsset CategoryHeader { get; } = new("MiraAPI.Resources.CategoryHeader.png");
+
+    /// <summary>
+    /// Gets the sprite used for the Keybind icons.
+    /// </summary>
+    public static LoadableResourceAsset KeybindButton { get; } = new("MiraAPI.Resources.KeybindButton.png");
+
+    /// <summary>
+    /// Gets the sprite used for crewmate role files in TaskAdderGame.
+    /// </summary>
+    public static LoadableResourceAsset CrewmateFile { get; } = new("MiraAPI.Resources.CrewmateFile.png");
+    
+    /// <summary>
+    /// Gets the sprite used for impostor role files in TaskAdderGame.
+    /// </summary>
+    public static LoadableResourceAsset ImpostorFile { get; } = new("MiraAPI.Resources.ImpostorFile.png");
+    
+    /// <summary>
+    /// Gets the sprite used for custom team role files in TaskAdderGame.
+    /// </summary>
+    public static LoadableResourceAsset CustomTeamFile { get; } = new("MiraAPI.Resources.CustomFile.png");
+
+    /// <summary>
+    /// Gets the sprite used for modifier file in TaskAdderGame.
+    /// </summary>
+    public static LoadableResourceAsset ModifierFile { get; } = new("MiraAPI.Resources.ModifierFile.png");
+
+    /// <summary>
+    /// Gets the sprite used for timed modifier file in TaskAdderGame.
+    /// </summary>
+    public static LoadableResourceAsset TimedModifierFile { get; } = new("MiraAPI.Resources.TimedModifierFile.png");
 }

MiraAPI/Utilities/Extensions.cs

@@ -94,7 +94,7 @@ public static class Extensions
     /// <param name="timer">The current timer value.</param>
     /// <param name="maxTimer">The maximum timer value.</param>
     /// <param name="format">The format string to use for the timer text.</param>
-    public static void SetCooldownFormat(this ActionButton button, float timer, float maxTimer, string format = "0")
+    public static void SetCooldownFormat(this ActionButton? button, float timer, float maxTimer, string format = "0")
     {
         var num = Mathf.Clamp(timer / maxTimer, 0f, 1f);
         button.isCoolingDown = num > 0f;
@@ -554,24 +554,24 @@ public static class Extensions
     /// Registers a new mod keybind as a user-assignable button action in Rewired.
     /// </summary>
     /// <param name="userData">The Rewired user data to add the action to.</param>
-    /// <param name="actionName">The internal name of the action.</param>
-    /// <param name="description">Text shown in the rebinding UI.</param>
+    /// <param name="id">The internal name of the action.</param>
+    /// <param name="name">Text shown in the rebinding UI.</param>
+    /// /// <param name="group">Group shown above the label.</param>
     /// <param name="key">The default key to assign to this action.</param>
     /// <param name="category">Category ID to group actions in Rewired (default is 0).</param>
     /// <param name="elementIdentifierId">The element identifier ID (default is -1, meaning none specified).</param>
     /// <param name="type">The <see cref="InputActionType"/> for this action (default is Button).</param>
-    /// <param name="modifier1">The first optional modifier key (e.g., <c>Control</c>, <c>Shift</c>, <c>Alt</c>) that must be held together with the main key.</param>
-    /// <param name="modifier2">The second optional modifier key. Set to <see cref="ModifierKey.None"/> if not used.</param>
-    /// <param name="modifier3">The third optional modifier key. Set to <see cref="ModifierKey.None"/> if not used.</param>
+    /// <param name="modifiers">Optional modifier keys (e.g., <c>Control</c>, <c>Shift</c>, <c>Alt</c>) that must be held together with the main key.</param>
     /// <returns>The action ID of the newly registered action.</returns>
-    public static int RegisterModBind(this UserData userData, string actionName, string description, KeyboardKeyCode key, int category = 0, int elementIdentifierId = -1, InputActionType type = InputActionType.Button, ModifierKey modifier1 = ModifierKey.None, ModifierKey modifier2 = ModifierKey.None, ModifierKey modifier3 = ModifierKey.None)
+    public static InputAction RegisterModBind(this UserData userData, string id, string name, string? group, KeyboardKeyCode key, int category = 0, int elementIdentifierId = -1, InputActionType type = InputActionType.Button, ModifierKey[]? modifiers = null)
     {
         userData.AddAction(category);
-
         var action = userData.GetAction(userData.actions.Count - 1)!;
 
-        action.name = actionName;
-        action.descriptiveName = description;
+        action.name = id;
+        action.descriptiveName = group != null
+            ? $"<b><size=70%>{Palette.CrewmateRoleHeaderDarkBlue.ToTextColor()}{group.ReplaceLineEndings(" ")}</color></size></b>\n{name}"
+            : name;
         action.categoryId = category;
         action.type = type;
         action.userAssignable = true;
@@ -583,13 +583,17 @@ public static class Extensions
             _elementType = ControllerElementType.Button,
             _axisContribution = Pole.Positive,
             _keyboardKeyCode = key,
-            _modifierKey1 = modifier1,
-            _modifierKey2 = modifier2,
-            _modifierKey3 = modifier3,
         };
+
+        if (modifiers != null)
+        {
+            if (modifiers.Length > 0) map._modifierKey1 = modifiers[0];
+            if (modifiers.Length > 1) map._modifierKey2 = modifiers[1];
+            if (modifiers.Length > 2) map._modifierKey3 = modifiers[2];
+        }
+
         userData.keyboardMaps[0].actionElementMaps.Add(map);
         userData.joystickMaps[0].actionElementMaps.Add(map);
-
-        return action.id;
+        return action;
     }
 }

MiraAPI/Utilities/Helpers.cs

@@ -3,8 +3,9 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using Il2CppSystem.IO;
+using Il2CppInterop.Runtime.InteropTypes.Arrays;
 using MiraAPI.Keybinds;
+using MiraAPI.Utilities.Assets;
 using Rewired;
 using TMPro;
 using UnityEngine;
@@ -26,6 +27,76 @@ public static class Helpers
         return [.. GameData.Instance.AllPlayers.ToArray().Where(x => !x.IsDead && !x.Disconnected && x.Object).Select(x => x.Object)];
     }
 
+    internal static GameObject CreateKeybindIcon(GameObject button, KeyboardKeyCode keyCode, Vector3 localPos)
+    {
+        var keybindIcon = Object.Instantiate(HudManager.Instance.AbilityButton.usesRemainingSprite.gameObject, button.transform);
+        keybindIcon.GetComponent<SpriteRenderer>().sprite = MiraAssets.KeybindButton.LoadAsset();
+        keybindIcon.transform.GetComponentInChildren<TextMeshPro>().text = keyCode.ToString();
+        keybindIcon.name = "KeybindIcon";
+        keybindIcon.transform.localPosition = localPos;
+        return keybindIcon;
+    }
+
+    /// <summary>
+    /// Creates a draggable scroller. Add items into the scroller.Inner transform. This does not automatically position children.
+    /// </summary>
+    /// <param name="parent">Where the scroller should be parented to.</param>
+    /// <param name="hitBoxCollider">The collider of the scroller. Used to drag.</param>
+    /// <returns>The created scroller object.</returns>
+    public static Scroller CreateScroller(Transform parent, BoxCollider2D hitBoxCollider)
+    {
+        var scrollObj = new GameObject("Scroller");
+        scrollObj.transform.SetParent(parent);
+        scrollObj.transform.localScale = new Vector3(1, 1, 1);
+
+        var inner = new GameObject("Inner");
+        inner.transform.SetParent(scrollObj.transform);
+        inner.transform.localScale = new Vector3(1, 1, 1);
+        inner.transform.localPosition = new Vector3(0, 0, 2);
+
+        var scroller = scrollObj.AddComponent<Scroller>();
+        scroller.allowX = false;
+        scroller.allowY = true;
+        scroller.DragScrollSpeed = 1f;
+        scroller.Colliders = new Il2CppReferenceArray<Collider2D>([hitBoxCollider]);
+        scroller.Inner = inner.transform;
+
+        return scroller;
+    }
+
+    /// <summary>
+    /// Divides a button/etc by a certain amount by resizing colliders and renderer sizes.
+    /// </summary>
+    /// <param name="obj">The object you want to divide.</param>
+    /// <param name="amount">How much you want to divide by.</param>
+    public static void DivideSize(GameObject obj, float amount)
+    {
+        foreach (var collider in obj.GetComponentsInChildren<Collider2D>(true))
+        {
+            if (collider.TryCast<BoxCollider2D>() is { } col)
+            {
+                col.size = new Vector2(col.size.x / amount, col.size.y);
+            }
+        }
+
+        foreach (var rend in obj.GetComponentsInChildren<SpriteRenderer>(true))
+        {
+            rend.size = new Vector2(rend.size.x / amount, rend.size.y);
+        }
+    }
+
+    /// <summary>
+    /// Gets the keybind for an action with ReInput.
+    /// </summary>
+    /// <param name="actionId">The action ID.</param>
+    /// <returns>The keyboard key code.</returns>
+    public static KeyboardKeyCode GetKeybindByActionId(int actionId)
+    {
+        var player = ReInput.players.GetPlayer(0);
+        return player.controllers.maps.GetFirstElementMapWithAction(ControllerType.Keyboard, actionId, false)
+            .keyboardKeyCode;
+    }
+
     /// <summary>
     /// Determines whether a given probability check succeeds.
     /// </summary>
@@ -406,21 +477,22 @@ public static class Helpers
     }
 
     /// <summary>
-    /// Finds and returns an unused KeyCode that is not equal to the excluded key.
+    /// Returns the formated value using the specified suffix and format string.
     /// </summary>
-    /// <param name="exclude">The KeyCode to skip during the search.</param>
-    /// <returns>
-    /// The first available KeyCode not currently used by any registered keybind,
-    /// or KeyCode.None if none are available.
-    /// </returns>
-    public static KeyboardKeyCode FindAvailableKey(KeyboardKeyCode exclude)
+    /// <param name="value">The value to format.</param>
+    /// <param name="suffix">The suffix to add.</param>
+    /// <param name="formatString">The format string to use to format.</param>
+    /// <returns>The formated value.</returns>
+    public static string FormatValue(float value, MiraNumberSuffixes suffix = MiraNumberSuffixes.None, string formatString = "0.0")
     {
-        foreach (KeyboardKeyCode key in Enum.GetValues(typeof(KeyboardKeyCode)))
+        return suffix switch
         {
-            if (key == exclude) continue;
-            bool used = KeybindManager.GetEntries().Exists(e => e.Key == key);
-            if (!used) return key;
-        }
-        return KeyboardKeyCode.None;
+            MiraNumberSuffixes.None => value.ToString(formatString, NumberFormatInfo.InvariantInfo),
+            MiraNumberSuffixes.Multiplier => value.ToString(formatString, NumberFormatInfo.InvariantInfo) + "x",
+            MiraNumberSuffixes.Percent => value.ToString(formatString, NumberFormatInfo.InvariantInfo) + "%",
+            _ => TranslationController.Instance.GetString(
+                StringNames.GameSecondsAbbrev,
+                (Il2CppSystem.Object[])[value.ToString(formatString, CultureInfo.InvariantCulture)]),
+        };
     }
 }

MiraAPI/Voting/VotingUtils.cs

@@ -71,7 +71,7 @@ public static class VotingUtils
     /// <param name="source">The player who is sending the RPC. Should be the host.</param>
     /// <param name="voterId">The player who voted.</param>
     /// <param name="votedFor">The player who the voter voted for.</param>
-    [MethodRpc((uint)MiraRpc.RemoveVote, SendImmediately = true)]
+    [MethodRpc((uint)MiraRpc.RemoveVote)]
     public static void RpcRemoveVote(PlayerControl source, byte voterId, byte votedFor)
     {
         if (!source.IsHost()) return;
@@ -107,7 +107,7 @@ public static class VotingUtils
     /// <param name="source">The player who sent this RPC.</param>
     /// <param name="srcPlayerId">The id of the player who casted the vote.</param>
     /// <param name="suspectPlayerId">The voted player's id.</param>
-    [MethodRpc((uint)MiraRpc.CastVote, SendImmediately = true)]
+    [MethodRpc((uint)MiraRpc.CastVote)]
     public static void RpcCastVote(PlayerControl source, byte srcPlayerId, byte suspectPlayerId)
     {
         CustomCastVote(srcPlayerId, suspectPlayerId);